The argument in one line.
Claude Code can drive DaVinci Resolve through an MCP server well enough to ingest footage, transcribe it, and assemble a rough first-pass cut, but deciding which cuts actually matter still has to come from the editor.
Read if. Skip if.
- A solo creator paying freelance editors weekly for a channel that isn't yet profitable and wants to cut that recurring cost.
- Someone comfortable cloning a GitHub repo and running terminal setup steps inside Claude Code without hand-holding.
- An editor curious whether an AI agent can operate a real NLE like DaVinci Resolve, not just generate captions or short clips.
- You want a fully polished edit handed back with zero manual cleanup — dead air and mistimed cuts still need a human pass.
- You have no script or reference doc to feed the agent; this workflow depends on a structured source document to cut against.
The full version, fast.
Paying $1,300/month for freelance editors on a channel making $0 forced a rethink, so the creator connected Claude Code to DaVinci Resolve using an open-source MCP server plus the Superpowers plugin's brainstorm skill. Given a footage folder and a script reference doc, Claude opens Resolve, transcribes each clip with WhisperX, and assembles a first-pass timeline on its own. Tests show it can follow relative marker instructions (move this pink clip to that marker) but its dead-space detection is inconsistent — it misses obvious gaps and flags irrelevant ones. The conclusion: let the agent handle repetitive assembly while you keep doing the judgment calls yourself, treating it like a junior editor you haven't fully trusted yet.
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →Where the time goes.

01 · The cost problem
States the problem that drove the build: paying about $350/week ($1,300/month) to three freelance editors on a channel earning $0, forcing a choice between finding an alternative or stopping uploads.

02 · What agent-editing means here
Defines the workflow as an editing assistant that produces a first-pass assembly cut while the human keeps final say, aimed at solo creators buried in repetitive timeline work.

03 · The DaVinci Resolve MCP repo
Introduces the open-source DaVinci Resolve MCP server (by Samuel Gursky) that lets a coding agent like Claude Code or Codex drive DaVinci Resolve directly.

04 · Running the setup plan
Creates a local project folder, pastes the MCP repo link into Claude Code, and runs it in plan mode at high reasoning so the agent scans the folder, drafts an install plan (clone, isolated venv, wire-up, verification), then executes it.

05 · Installing the Superpowers plugin
Adds obra's Superpowers plugin — either by pasting a GitHub prompt or through Claude's plugin browser — to unlock extra skills; the brainstorm skill is the one actually used later.

06 · Starting a session with a structured prompt
Opens the MCP folder as a fresh Claude Code session and hands it a template prompt: footage path, a script/reference doc (a Notion page), a scoped instruction ('just the first two minutes'), and an explicit call to the brainstorm skill in plan mode.

07 · Choosing Opus vs. Sonnet
Runs the brainstorm/plan step on Opus at high reasoning for quality, then switches to Sonnet for the execution pass to save tokens, noting high-reasoning Opus burns noticeably more.

08 · Watching the agent work autonomously
The agent opens Resolve, creates a new 29.97fps project timeline, and ingests three clips on its own — assembling beats 0 through 2 into a fully pre-cut sequence with no further prompting.

09 · The marker relocation test
Manually recolors a clip pink, places a cream-colored marker, and asks Claude to move the pink clip to the marker's position and delete the red markers — testing relative, color-coded references. It succeeds, but detaches adjacent clips as a side effect.

10 · How the pipeline actually works
Explains the mechanism: since AI can't 'watch' video like a human, the agent transcribes each clip with WhisperX, analyzes word-level timing, and builds per-clip alignment files it uses to assemble cuts — plus a warning to hand-hold it fully until you trust it, like onboarding a junior editor.

11 · The dead-space marking test
Asks the agent to mark every dead-space gap in the timeline with a red marker for review instead of cutting automatically, then finds the marks inconsistent — missing obvious gaps while flagging spots that don't matter.

12 · Doing the fine polish by hand
For small, fast fixes — trimming a lingering gap, nudging a clip to land on motion — doing it manually in Resolve is faster than prompting the agent; the two run in parallel while the agent works elsewhere.

13 · AI does the repetition, you keep the judgment
Closes on the thesis: the agent is good at specialist, repetitive work — cuts, assembly — but can't yet decide which pieces matter; that judgment call is the skill worth protecting and building.
Lines worth screenshotting.
- The creator was spending $350/week — about $1,300/month — on three freelance editors for a channel making $0 in revenue.
- The setup treats Claude as an editing assistant that handles first-pass assembly while the human retains final say over every cut.
- The DaVinci Resolve MCP server (built by Samuel Gursky) is what lets a coding agent like Claude Code or Codex actually operate DaVinci Resolve.
- AI agents can't watch video the way humans do — they transcribe audio into words and analyze frames separately, then reconstruct edits from that text layer.
- WhisperX is the tool Claude uses under the hood to transcribe footage and build word-level alignment for each clip.
- Running the initial brainstorm/plan step on Opus at high reasoning costs more tokens, so the creator switches to Sonnet for the execution pass to save budget.
- In a live test, the agent correctly moved a manually-recolored pink clip to a cream-colored marker's position, but it also detached the clip from its neighbors as a side effect.
- Asked to mark every dead-space gap in the timeline for review, the agent's markers were inconsistent — missing gaps the creator actually cared about and flagging spots that didn't need attention.
- The creator compares trusting an AI editor to trusting a brand-new junior editor: you don't hand over unsupervised first cuts until you've watched it work and built confidence.
- For small, obvious fixes — trimming a short gap, nudging a clip to land on motion — doing it manually in Resolve is faster than writing a prompt for it.
- The workflow runs in parallel, not sequentially: while the agent chews through repetitive assembly, the creator works on packaging, animations, and sound elsewhere.
- The core thesis: AI can only replace you if you're doing the exact same repetitive task it does — the judgment about which pieces matter is the skill worth protecting.
Let the agent do the repetitive assembly, keep the judgment calls yourself.
An AI agent wired into a real NLE can genuinely do first-pass assembly work, but its marker logic and dead-space detection are unreliable enough that you still have to review every cut it makes.
- Weigh the recurring cost of freelance editing against the setup cost of an agent-editing pipeline — $1,300/month on editors is a real number to compare against.
- An agent editor is only useful if you keep final review on every cut; treat its output as a first pass, not a delivery-ready edit.
- MCP servers are what let a coding agent operate real creative software (here, DaVinci Resolve) rather than just generate text or clips.
- Plan mode matters: seeing the agent's proposed steps before it executes catches problems before they're baked into your project file.
- Give the agent a scoped instruction (a time range, a chapter) instead of the whole video — smaller scope means fewer compounding errors to review.
- Running the planning/brainstorm pass on a stronger, more expensive model and the execution pass on a cheaper one is a reasonable way to control token cost.
- AI agents don't 'watch' video — they transcribe audio to text and analyze frames separately, so anything that depends on visual-only meaning may not translate cleanly.
- Test an agent's spatial/relative reasoning (move this to that marker) before trusting it with judgment calls like which silences to cut.
- Automatic dead-space detection is not yet reliable enough to run unsupervised — expect to manually re-check and often manually fix pacing gaps yourself.
- The efficiency gain isn't 'don't do anything' — it's working in parallel: let the agent grind through repetitive cuts while you do packaging, sound, or the next piece of content.
- The transferable principle beyond editing: AI replaces you only on tasks that are pure repetition; the skill worth building is the judgment about what actually matters.
Terms worth knowing.
- MCP (Model Context Protocol)
- A protocol that lets an AI agent like Claude Code call into external software — here, a DaVinci Resolve MCP server exposes editing actions (import, cut, marker, timeline moves) the agent can invoke directly.
- DaVinci Resolve
- A professional video editing application with a full timeline, color, and audio toolset, used here as the NLE the AI agent is being taught to operate.
- WhisperX
- A speech-to-text tool that transcribes audio into word-level timed text, which the agent uses to understand and align footage it otherwise can't 'watch' like a human.
- Superpowers plugin
- A community Claude Code plugin (by obra) that adds extra skills to the agent, including a 'brainstorm' skill used here to plan the edit before executing it.
- Beat
- In this workflow, a labeled chunk of the assembled timeline (e.g. beat 0, beat 1) representing one pre-cut segment of footage the agent has already assembled.
- Plan mode
- A Claude Code setting where the agent drafts and shows a proposed sequence of actions before executing anything, letting the user review the approach first.
Things they pointed at.
Lines you could clip.
“I only built this because I was spending about $350 a week on three freelance editors, roughly $1,300 a month, on a channel that was making $0.”
“Would you trust a junior editor or a brand new editor to your team with the first cut without giving them any directions at all?”
“AI empowers you. It can only replace you if you're doing the exact same thing it does.”
“Right now, it does the specialist work. The cuts, the assembly, the repetitive stuff. What it can't do yet is manage that whole thing. It doesn't know which pieces actually matter.”
Word for word.
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
The bait, then the rug-pull.
He was paying $350 a week — roughly $1,300 a month — to three freelance editors on a channel that was making zero dollars. So he set up Claude as his editor inside DaVinci Resolve instead, and this is the exact setup, start to finish.
Named ideas worth stealing.
The agent-editing kickoff prompt
- Footage file path (or drag in the folder)
- Script / reference doc (Notion page or wherever the script lives)
- A scoped instruction (e.g. 'just the first two minutes')
- Explicit skill call ('use the brainstorm skill')
- Plan mode before execution
The five-part prompt template used to kick off a new Claude Code editing session: point it at the footage, the script, a scoped chunk of the video, the brainstorm skill, and plan mode before it touches anything.
How they asked for the click.
“If you want proof this works, I edit a real video start to finish with this setup in my last video. Go watch that.”
Soft, single-ask CTA at the very end pointing to a companion video, followed by a comment-bait line ('drop agent editing in the comments') — no mid-roll pitch, no product sale.



































































