Video analysis and evidence workflows: practice drills

Exercises for choosing video input, preserving and hashing source media, recording metadata, constructing analysis prompts and Oracle calls, separating evidence lanes, checking outputs, extracting visual evidence, reviewing omissions, and producing…

These exercises practice turning video into verified prompt material.

Use a short clip when possible. A 30-90 second bug reproduction or design feedback clip is enough.

Exercise 1: Decide Whether Video Is Useful

Choose video, text/log, or code context.

Scenario Best Input Why
checkout button disappears after a sequence of clicks
unit test failure points to one function
designer explains spacing problems while moving through UI
terminal command prints one clear stack trace
app feels slow after refresh but logs are clean
long tutorial should become exercises and references
auth/session architecture needs cross-file review

Fill out:

# Input Choice

- scenario:
- chosen input:
- why:
- what video would add:
- what text/logs would add:
- what code context would add:

Exercise 2: Create The Run Folder

Run:

RUN_ID="exercise-video-$(date +%Y%m%d-%H%M%S)"
RUN_DIR="runs/$RUN_ID"
mkdir -p "$RUN_DIR"/{inputs,receipts,analysis,final,keyframes,contact-sheets}
mkdir -p "$RUN_DIR/chunks/01"
find "$RUN_DIR" -maxdepth 3 -type d | sort

Fill out:

# Video Run Folder

- run id:
- run dir:
- inputs:
- receipts:
- chunks:
- analysis:
- final:
- keyframes:

Exercise 3: Preserve Source Media

For a local video:

cp /path/to/source-video.mp4 "$RUN_DIR/inputs/source-video.mp4"
shasum -a 256 "$RUN_DIR/inputs/source-video.mp4" \
  > "$RUN_DIR/inputs/source-video.sha256"
ffprobe -hide_banner -show_format -show_streams -of json \
  "$RUN_DIR/inputs/source-video.mp4" \
  > "$RUN_DIR/receipts/ffprobe.source.json"

For a URL:

yt-dlp --dump-single-json --skip-download --no-check-formats "$URL" \
  > "$RUN_DIR/receipts/source.metadata.json"
yt-dlp -f "bv*+ba/best" -o "$RUN_DIR/inputs/source-video.%(ext)s" "$URL"

Confirm:

test -s "$RUN_DIR/inputs/source-video.sha256" && echo "sha256:OK"
test -s "$RUN_DIR/receipts/ffprobe.source.json" && echo "ffprobe:OK"

Fill out:

# Source Media Notes

- source path or URL:
- local video path:
- sha256 path:
- ffprobe path:
- original duration:
- original timestamps preserved? yes/no

Exercise 4: Write The Gemini Prompt

Run:

cat > "$RUN_DIR/chunks/01/gemini-prompt.md" <<'EOF'
Analyze this video as prompt material for a software project.

Return:

1. short summary
2. timestamped workflow
3. transcript evidence
4. chat evidence
5. visual evidence
6. inferences, clearly labeled
7. likely downstream artifacts
8. omissions or uncertainty

Rules:

- Do not invent URLs, tools, commands, files, UI labels, or speakers.
- Preserve original timestamps.
- Separate visible facts from spoken claims and inferences.
- Include the exact sentinel below as the last line.

END_OF_VIDEO_ANALYSIS
EOF

printf 'END_OF_VIDEO_ANALYSIS\n' \
  > "$RUN_DIR/chunks/01/expected-sentinel.txt"

rg -n "END_OF_VIDEO_ANALYSIS" "$RUN_DIR/chunks/01/gemini-prompt.md"

Fill out:

# Gemini Prompt Notes

- prompt path:
- sentinel:
- required lanes:
- forbidden inventions:
- timestamp rule:
- uncertainty rule:

Exercise 5: Check Oracle Call Shape

Write the call shape with an absolute video path.

mcp__oracle__consult({
  prompt: "[exercise-video-analysis]\n\n{contents of chunks/01/gemini-prompt.md}",
  files: ["/absolute/path/to/runs/<run-id>/chunks/01/chunk.mp4"],
  engine: "browser",
  model: "gemini-3-pro",
  browserAttachments: "always",
  slug: "exercise-video-analysis"
})

Fill out:

# Oracle Video Call Shape

- engine:
- model:
- browserAttachments:
- file path absolute? yes/no
- slug:
- why API mode is wrong:

Exercise 6: Separate Evidence Lanes

Use a video analysis result or a short mock result. Fill the lanes separately.

# Evidence Lanes

## Transcript Evidence

- timestamp:
- quote or paraphrase:

## Chat Evidence

- timestamp:
- message:

## Visual Evidence

- timestamp:
- visible fact:
- keyframe:

## Inference

- inference:
- based on:
- confidence:
- what would confirm it:

Question:

Which claims are visible facts, and which are only spoken claims or inferences?

Exercise 7: Verify The Analysis

Run checks against the saved files.

test -s "$RUN_DIR/inputs/source-video.sha256" && echo "source-hash:OK"
test -s "$RUN_DIR/receipts/ffprobe.source.json" && echo "ffprobe:OK"
test -s "$RUN_DIR/chunks/01/gemini-prompt.md" && echo "prompt:OK"
test -s "$RUN_DIR/chunks/01/expected-sentinel.txt" && echo "sentinel-file:OK"

If Oracle output exists:

rg -n "END_OF_VIDEO_ANALYSIS" ~/.oracle/sessions/<slug>/output.log

Fill out:

# Analysis Verification

- source hash exists? yes/no
- ffprobe exists? yes/no
- prompt exists? yes/no
- sentinel required? yes/no
- sentinel found in output? yes/no
- timestamps preserved? yes/no
- unsupported URLs/tools/commands removed? yes/no
- visual claims have keyframes? yes/no

Exercise 8: Extract Keyframes

Run:

mkdir -p "$RUN_DIR/keyframes"
ffmpeg -i "$RUN_DIR/inputs/source-video.mp4" \
  -vf "fps=1/10" \
  "$RUN_DIR/keyframes/frame-%04d.jpg"
find "$RUN_DIR/keyframes" -type f | head

Optional contact sheet:

ffmpeg -pattern_type glob -i "$RUN_DIR/keyframes/*.jpg" \
  -vf "scale=320:-1,tile=4x4" \
  "$RUN_DIR/contact-sheets/source-contact-sheet.jpg"

Fill out:

# Keyframe Notes

- keyframe folder:
- contact sheet:
- visual claim checked:
- timestamp:
- confirmed? yes/no

Exercise 9: Write An Omissions Pass Prompt

Run:

cat > "$RUN_DIR/analysis/omissions-prompt.md" <<'EOF'
Review the prior video analysis for omissions.

Focus only on missing visible UI states, skipped timestamps, unsupported claims,
invented details, and uncertainty. Do not rewrite the whole analysis. Return a
patch-style list of corrections and end with END_OF_VIDEO_ANALYSIS.
EOF

Fill out:

# Omissions Pass

- why an omissions pass is needed:
- missing visual state:
- missing timestamp:
- unsupported claim:
- uncertainty:
- expected correction:

Exercise 10: Create A Bug Repro Prompt

Write:

# Implementation Prompt From Video

## Source

- video:
- source hash:
- ffprobe:
- analysis:
- keyframes:

## Observed Failure

- timestamp:
- visual evidence:
- transcript/chat evidence:
- expected behavior:
- actual behavior:

## Request

Implement the smallest safe fix.

## Constraints

- do not change:
- preserve:

## Verification

- command:
- what passing means:

Confirm:

test -s "$RUN_DIR/final/implementation-prompt.md" && echo "implementation-prompt:OK"

Exercise 11: Convert Video Evidence Into A Section 6 Matrix

Pick one variable from the video-derived work.

# Video-Derived Variation Matrix

## Goal

## Evidence From Video

- timestamp:
- observation:
- keyframe:
- why it matters:

## Invariants

- same repo state:
- same source evidence:
- same target flow:
- same verification command:
- same review criteria:

## Variable Under Test

- variable:
- why this variable matters:
- what is out of scope:

## Candidates

| ID | Variable setting | Output location | Verification command |
| --- | --- | --- | --- |
| v1 | | | |
| v2 | | | |
| v3 | | | |

Exercise 12: Section 8 Bridge

Write a marker that carries the evidence discipline forward.

mkdir -p "$RUN_DIR/final"
cat > "$RUN_DIR/final/section8-bridge-agent-marker.md" <<'EOF'
# Agent Marker Bridge

- previous section: Section 7
- evidence type: video prompt material
- source hash:
- ffprobe:
- analysis:
- output.log:
- sentinel:
- visual evidence:
- uncertainty:
- next marker:
- Section 8 target: Debugging with Agent Markers
EOF

test -s "$RUN_DIR/final/section8-bridge-agent-marker.md" \
  && echo "agent-marker-bridge:OK"

Fill out:

# Section 8 Bridge Notes

- what evidence was preserved:
- what uncertainty remains:
- what marker should the debugging agent leave next:
- what would be lost without the marker:

Final Check

Run:

test -s "$RUN_DIR/inputs/source-video.sha256" && echo "sha256:OK"
test -s "$RUN_DIR/receipts/ffprobe.source.json" && echo "ffprobe:OK"
test -s "$RUN_DIR/chunks/01/gemini-prompt.md" && echo "prompt:OK"
test -s "$RUN_DIR/chunks/01/expected-sentinel.txt" && echo "sentinel:OK"
find "$RUN_DIR/final" -type f | sort

Fill out:

# Final Video Prompt Run Check

- source preserved? yes/no
- source hash saved? yes/no
- ffprobe saved? yes/no
- original timestamps preserved? yes/no
- prompt saved? yes/no
- Oracle call shape correct? yes/no
- output.log checked? yes/no
- sentinel verified? yes/no
- evidence lanes separated? yes/no
- keyframes/contact sheet saved? yes/no
- unsupported claims removed? yes/no
- omissions pass considered? yes/no
- downstream artifact saved? yes/no
- ready to use as prompt material? yes/no

Source references