How Fable 5 Edited Its Own Launch Video: Thariq’s Claude Code Pipeline

On June 11, 2026, Thariq (@trq212)—on the Claude Code team at Anthropic—posted a walkthrough that hit 288K+ views in hours: Fable 5 edited its own launch video, and he never opened a traditional video editor.

The finished cut is the @ClaudeDevs Fable 5 launch video from June 9, 2026. The meta story—how that video was produced—is what Thariq documented in a 6:39 follow-up video and an interactive deck at thariqs.github.io/cc-video-editing-deck.

TL;DR: One /goal-driven prompt kicked off a pipeline: Whisper timestamps on 17 takes → subagents pick best shots into final-edit.json → ffmpeg cuts and concatenates → 7 hand-written LUTs for S-Log3 color grade → Remotion rebuilds 11 design PNGs as animated React → Figma MCP exports for design review and re-imports tweaks → 4K render at 24 fps. 0 video editors opened.

“We verify it’s doing the right work”

The launch video’s narrative hinges on a line from @ClaudeDevs:

We used to verify that Claude did the work right. Now we verify that it's doing the right work.

Thariq’s editing workflow is a literal demonstration. He supplied taste (script, which takes felt best, grade preference, design direction). Fable supplied orchestration—transcription, take selection with written rationale, frame-accurate cuts, LUT authoring, motion graphics as code, Figma handoff, and re-render loops.

That shift—from micromanaging each tool call to setting goals and reviewing artifacts—is the same loop engineering pattern Boris Cherny and Peter Steinberger describe for coding agents, applied to a creative pipeline.

The raw material: 17 takes, 4 scenes

Thariq shot 17 camera takes across four scenes for the Fable 5 story:

Footage: Sony masters, S-Log3, 4K, ~25 GB total. The deck marks ✓ on takes that made the final cut.

Step 1: One prompt, /goal, and workflows

The entire edit started from one prompt (abbreviated; full text in the deck):

I'm processing the recording of a bunch of videos in @Fable-Full-Recording/
the script for them is in @Fable-Full-Recording/fable5script.md.

Run the eleven labs transcription service on them. Stitch together the best shots
into one final clip.

Notes: multiple takes per scene; best takes usually last with fewest ums.
Re-shot the first scene at the end. Cut out "Hey [name]" warm-up openers.

Create a JSON file per scene showing clips and time ranges.
Create a final scene using ffmpeg.
Orchestrate this all using workflows.

/goal dont stop until you have a final video

Pattern: @ file references for footage and script, workflows for parallel subtasks, and /goal so Fable keeps going until a verifiable final video exists—not until the model thinks it’s done.

Step 2: Whisper hears every word

All 17 takes ran through Whisper locally on an M4 Max. Output: per-word JSON timestamps in work/transcripts/.

Whisper misheard “Thariq” as “Sark” in places—the deck notes timestamps still landed, which is what mattered for cuts and overlay cues.

// work/transcripts/A004C003.json (excerpt)
"words": [
  { "word": " Hey",    "start": 1.02, "end": 1.50 },
  { "word": " Sark",   "start": 2.04, "end": 2.24 },
  { "word": " Claude", "start": 2.54, "end": 2.86 }
]

Why text beats timelines: Every cut point and graphics cue was grepped from transcript JSON, not scrubbed on a timeline. That makes the edit diffable and re-promptable—core to agentic video.

Step 3: Subagents pick takes; the EDL is JSON

Fable spawned one subagent per scene, with verifiers double-checking selections. Rationale was written into final-edit.json:

{
  "scene": 1,
  "title": "Part 1: Intro",
  "candidate_takes": ["C001", "C002", "C003", "C004", "C017 (re-shoot)"],
  "selection_rationale": "C017 incomplete — 5.8s dead pause, disqualified. C003 cleanest: zero ums.",
  "clips": [{ "clip": "A004C003", "start": 1.89, "end": 60.81 }]
}

Result: 17 takes read → 4 scenes cast → 0 ums kept in the first assembly.

ffmpeg executed the EDL:

ffmpeg -ss 1.89 -to 60.81 -i A004C003.MP4 -c copy cuts/seg1.mp4
ffmpeg -f concat -i concat.txt -c copy fable5-final.mp4

7 minutes of raw folder → verified 2:50 cut within minutes. Claude then re-transcribed its own cut to confirm “zero ums.”

This is verifier-style loop design—environment feedback (transcript) beats self-critique.

Step 4: Color grade as code (.cube LUTs)

Flat S-Log3 off the sensor looked muted. Thariq prompted:

the color grading feels a bit too muted, can you fix that?
make some examples of how we might regrade and let me choose one

Fable generated 7 hand-written .cube LUTs (S-Log3 → Rec.709)—neutral709, warm_filmic, punchy, teal_orange, etc. No preset packs. Grade applied at ffmpeg encode time.

Thariq picked neutral_cool_desat for the final look. “Make it warmer” becomes a prompt; the LUT file is plain text the agent can edit and re-apply.

Step 5: Remotion—PNGs become parameterized React

Input: 11 static PNGs in fable5-assets/—5 cards + 6 overlays. No animation spec.

Prompt:

I've added design files for interludes in @Fable-Full-Recording/fable5-assets/
— use remotion to stitch these into a clip that smoothly animates the assets.
Please do a first pass.

Fable rebuilt each PNG as JSX—every word, color, and beat a parameter:

// KeypointLedger.tsx — beat lands on "right work"
const beat2 = interpolate(frame, [beat2At, beat2At + 12], [0, 1], {
  easing: EASE_OUT,
});

Global feel in six numbers (anim.tsx):

export const TIMING = {
  reveal: 13,
  stagger: 4,
  overlayIn: 10,
  overlayOut: 8,
  emphasisDelay: 3,
};
export const EASE_OUT = Easing.bezier(0.16, 1, 0.3, 1);

Cue sheet synced to transcript words—not a timeline:

const CUES = [
  { id: 'lower-third', at: 1.2,  dur: 4.5 },
  { id: 'keypoint',    at: 12.2, dur: 25.6 },
  { id: 'three-ways',  at: 43.0, dur: 15.8 },
];

Frame 295 = the word “right.” Overlays land on spoken beats because cues come from Whisper timestamps.

Step 6–8: Figma MCP round trip

Thariq wanted designers in the loop without abandoning code:

1. Export to Figma via MCP—real file: Fable 5 — Video Graphics (Design Review), with components, color-grading station, motion page with live-render GIFs.
2. Control room UI—sliders for grade, animation replay, “copy feedback as prompt” with exact numbers for paste-back into Claude Code.
3. Re-import: “the design has been updated in this Figma… can you update the video to match?” — minimal cream-card redesign rebuilt in Remotion.

2× code → Figma → code cycles. Design taste stays human; execution stays agentic.

Step 9: Final render

Claude screenshotted stills to review work before each full npx remotion render pass—~10 re-renders in one night.

The repo is the edit

Thariq’s deck closes with the artifact map:

No timeline, no project file — the edit is text, so Claude can read it, diff it, and re-render it.

That’s the technical thesis: video editing as a software repo, not a proprietary NLE project—ideal for Claude Fable 5 long-horizon agents.

What this means for creative workflows

1. Taste in, pipeline out. Thariq’s job was prompts, picks, and review—not ripple edits.

2. Verification moved up-stack. Re-transcribe the cut. Screenshot frames before full renders. Written selection_rationale in JSON. Same rubric thinking as Fable loop design.

3. MCP extends beyond code. Figma MCP turned motion graphics into a design-team interface without leaving the agent loop.

4. /goal for creative deliverables. “Don’t stop until you have a final video” is the same primitive as “tests pass” for engineering—different verifier, same loop shape.

5. Meta-marketing that proves the product. The video about Fable 5 was edited by Fable 5. The deck is open source. The pipeline is inspectable.

Primary sources

• Thariq’s deck: thariqs.github.io/cc-video-editing-deck
• Thariq’s thread: @trq212 on X — Jun 11, 2026 (~288K views)
• Launch video: @ClaudeDevs — Jun 9, 2026
• Fable 5 announcement: Claude Fable 5 and Mythos 5 launch

Related ExplainX guides

• Claude Fable 5 and Mythos 5 launch
• Code with Claude Tokyo: scheduled agents and vaults
• DiffusionGemma 4× faster text generation
• Fable 5 loop design and self-correction
• Claude Code /goal command
• Loop engineering guide
• Claude Code commands reference
• What is MCP?

Summary

Thariq’s Fable 5 launch video is a case study in agentic creative production: 17 takes, one /goal, JSON edit lists, ffmpeg, Remotion, Figma MCP, and zero NLE. The deck is the manual; the tweet is the proof that 288K people wanted to see how it worked.

If you’re building similar pipelines, start with verifiable artifacts (transcripts, EDL JSON, frame stills)—not timeline scrubbing—and let Fable 5 orchestrate the middle.

Pipeline details and metrics from Thariq’s deck and @trq212’s June 11, 2026 thread. View counts and availability of Fable 5 in Claude Code may change—verify against Anthropic docs before reproducing.