---
schema_version: 1
revision: "22ce5d34dbcb5a78"
id: "codex-video-workflows-practice"
title: "Video analysis and evidence workflows: practice drills"
---

# Video analysis and evidence workflows: practice drills

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:

```markdown
# 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:

```bash
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:

```markdown
# Video Run Folder

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

## Exercise 3: Preserve Source Media

For a local video:

```bash
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:

```bash
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:

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

Fill out:

```markdown
# 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:

```bash
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:

```markdown
# 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.

```js
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:

```markdown
# 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.

```markdown
# 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:

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

## Exercise 7: Verify The Analysis

Run checks against the saved files.

```bash
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:

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

Fill out:

```markdown
# 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:

```bash
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:

```bash
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:

```markdown
# Keyframe Notes

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

## Exercise 9: Write An Omissions Pass Prompt

Run:

```bash
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:

```markdown
# 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:

```markdown
# 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:

```bash
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.

```markdown
# 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.

```bash
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:

```markdown
# 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:

```bash
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:

```markdown
# 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
```

## Related resources

- [Companion reference](https://lapis-fossil-vsbc.here.now/downloads/codex-power-user-workshop-2026-06-27.bundle)
- [Resource directory and portable download](/topics/codex-resources/)

## Original references

- [Portable Codex workflow resources](https://lapis-fossil-vsbc.here.now/downloads/codex-power-user-workshop-2026-06-27.bundle)
