Turn recordings into video evidence packets

A long recording is not one prompt. It is a pile of evidence with a timeline.

A long recording is not one prompt. It is a pile of evidence with a timeline.

Do not reduce it to a transcript too early. Keep the video as prompt material, cut the recording into chunks, send each chunk through the video-watching lane, extract screen evidence while it is still visible, and carry prior summaries forward.

The artifact you want is not a summary. It is a video evidence packet.

The Failure

A five-hour workshop, app walkthrough, or bug reproduction contains too much visual detail for one tidy answer.

If one model response has to summarize the whole recording, it will usually flatten the exact details software work needs:

  • tooltip text
  • disabled button states
  • cursor actions
  • modal transitions
  • terminal output
  • code snippets
  • missing steps
  • retries and failed attempts
  • loading, error, and empty states

The problem is not only upload size. The problem is answer density. One huge answer cannot carry every useful screen fact.

It's very difficult to get good information out of it that way, because it's limited by the amount of tokens it can provide in one response.

— John Lindquist

The Move

Create video evidence packets.

A video evidence packet is a chunked, source-preserving record of what happened in a slice of video:

  • clip
  • transcript slice
  • chat slice
  • key frames
  • visible text
  • UI states
  • actions
  • code snippets or terminal output
  • omissions
  • model output
  • verification notes

The packet gives the next agent inspectable context without pretending it watched the whole recording.

Keep The Video

Video is not just a transcript with pictures nearby. For UI work, the screen matters.

A tooltip, hover state, selected tab, disabled button, cursor path, dialog, terminal frame, or loading spinner can be the evidence. Keep the clip attached as prompt material until the visual claims have been extracted and checked.

In the demonstrated workflow, the local agent owned the files, prompts, saved outputs, and verification. Oracle handled the browser handoff. Gemini was the video-watching lane for that run. The repo received the output as reviewable files.

Treat exact model behavior, limits, quotas, pricing, and account budget as current-product details that must be rechecked before relying on them in shared guidance.

Chunk By Evidence Density

Use chunks small enough that each answer can stay specific.

What you can do with an agent is split the video into, like, 15-minute chunks, and then in each of those chunks, you can say, what are the key frames, what are the key ideas, what are the key transcript points.

— John Lindquist

Fifteen minutes is a reasonable default for workshop or walkthrough material. Five minutes can be useful when the screen is dense, the bug is subtle, or the output needs frame-level detail.

Do not turn those numbers into doctrine. Choose chunk size by evidence density.

Before analysis, remove confirmed dead space when it is safe:

  • long silence
  • blank screens
  • motionless regions
  • breaks
  • inactive spans

Do not delete chat, links, questions, or setup context that explains the next spoken section. Carry that forward.

Ask For Screen Evidence

Use the same evidence lanes for each chunk.

For this video chunk, extract:

Visual evidence:
- key frames
- visible text
- UI states
- cursor actions
- modal/dialog states
- loading/error/empty states
- code snippets or terminal output
- colors, layout shifts, and visual changes

Transcript evidence:
- key spoken points
- claims made
- instructions given
- unanswered questions
- deferred follow-ups

Action evidence:
- user actions
- app responses
- navigation steps
- failed attempts
- retries
- omissions or confusing transitions

Verification:
- what is directly visible
- what is transcript-supported
- what is inferred
- what needs manual review

This is the difference between "the user clicked around" and "the tooltip text appeared next to the control, then the follow-up prompt asked what it said."

Carry Prior Chunks Forward

Chunking solves the density problem and creates a continuity problem.

Fix that by carrying a compact previous-summary ledger into every later prompt:

You are analyzing chunk 10 of 15 from a long software workshop.

Previous chunk summary:
- Chunk 01 introduced the repo and evidence boundary.
- Chunk 02 covered agent-ready repo setup.
- Chunk 03 covered narrow workspace agents.
- Chunk 04 covered generated variations.
- Chunk 05 covered visual review before implementation.

For this chunk:
- preserve original timestamps
- extract visible UI states, actions, text, code snippets, and omissions
- separate transcript evidence, visual evidence, and inference
- return a chunk summary that can be carried into the next prompt

Every later chunk should know what came before it: active concepts, unresolved questions, decisions already made, and what the current chunk must not re-explain.

Use It For Software Work

Good fits:

  • QA records a checkout regression and the packet extracts the disabled button state, selected shipping option, console error, and missing validation message.
  • A designer records a settings walkthrough and the packet extracts empty states, modal transitions, keyboard traps, contrast concerns, and confusing copy.
  • A product team records its own onboarding flow and the packet turns it into acceptance criteria.
  • A developer combines a debug marker packet with the video chunk around the marked moment.

Product research also fits, but keep the ethics boundary clear. Use public walkthroughs for UX critique, accessibility review, flow comparison, and internal design study. Do not present this as a way to copy proprietary UI, assets, copy, CSS, or product behavior.

Copyable Artifact: Video Evidence Packet

Source:
- recording:
- source hash:
- original timestamp range:
- transcript slice:
- chat slice:
- chunk id:
- prior summary included? yes/no

Preprocessing:
- silence reviewed:
- motionless/blank spans reviewed:
- removed spans:
- carried-forward chat/questions:

Ask the video model to extract:
- key frames:
- visible text:
- transcript points:
- user actions:
- UI states:
- code snippets or terminal output:
- colors/layout changes:
- loading/error/empty states:
- omissions:
- uncertainties:

Cumulative context:
- previous chunks summarized:
- unresolved questions:
- concepts already introduced:
- what this chunk must not re-explain:

Verification:
- claims supported by transcript:
- claims supported by visual evidence:
- claims supported by chat:
- claims that are inference only:
- private details removed:
- screenshots/keyframes sanitized:
- model/cost/limit claims removed or verified:

Example prompt:

Analyze this checkout bug recording as chunk 03 of 08.

Previous summary:
[paste compact prior-summary ledger]

Extract:
- visible UI states
- cursor actions
- selected fields
- loading/error/empty states
- visible text
- transcript claims
- omitted steps
- uncertainties

Separate visual evidence, transcript evidence, chat evidence, and inference.
Return a short carry-forward summary for the next chunk.

Claim Boundaries

This workflow does not prove model limits, pricing, quota behavior, speed, or model superiority.

It proves that a recording was processed through a chunked, source-preserving workflow and that shared claims can be checked against transcript, video evidence, key frames, chat, and saved outputs.

Before sharing screenshots or key frames, sanitize them, copy them into the shared asset tree, add alt text, and review for private browser/account state.

Source references