Can Claude Code actually edit video?

It edits the decisions, not the pixels. Claude Code reads a timestamped transcript, writes a cut list of in and out points, and drives ffmpeg or your editor's project format to render it. It cannot watch footage or judge whether a shot feels right, so anything requiring visual judgment stays with you.

What should the agent verify on its own?

Total duration within the expected range, cut count matching the cut list, no segment short enough to read as a jump, continuous audio, and loudness normalized to your target. Mechanical checks catch the failures that would otherwise waste your review pass, leaving your attention for whether the edit is actually good.

Why does the automated edit not match my style?

Because your style is a set of specific decisions the model cannot infer: how tight you cut, which verbal tics stay, when a pause carries weight, how you build a cold open. None of it is in the transcript. Correcting it in chat fixes one video, then the session ends and the agent starts over next week.

How do I make my editing conventions stick between sessions?

Write them down as you would brief a human editor, then index that file and your past cut lists with RDK as encrypted private chunks. The agent retrieves your actual rules and prior decisions before writing a cut list. Stacked retrieval also keeps long transcripts from being re-sent every turn, cutting token spend 80 to 90 percent.

How to Automate Video Editing With Claude Code

Claude Code automates editing decisions, not pixel work. Transcribe the footage with timestamps, have the agent read the transcript and produce a cut list, then render those cuts with ffmpeg or your editor's project format. The agent edits text and timecodes. The renderer touches the video.

What an agent can and cannot edit

Claude Code cannot watch your footage. It has no timeline, no scrubber, and no sense of whether a shot feels right. Automating video editing means routing around that limitation, not pretending it does not exist.

What an agent is genuinely good at is deciding things from text and then driving deterministic tools. Given a timestamped transcript, it can find where a sentence starts and ends, identify a filler-heavy passage, spot a repeated take, and write out the exact in and out points for each keeper. That is the bulk of a first assembly on talking-head, tutorial, podcast, and interview footage, and it is the part that eats hours.

The pixels stay with ffmpeg or your NLE. The agent produces instructions; the renderer executes them. Keep that line clear and the workflow becomes reliable. Blur it, and you get an agent guessing about content it cannot perceive.

The transcript-driven pipeline

The whole workflow is five stages, and each one hands a file to the next.

Ingest: collect the source files and probe them for duration, resolution, and audio layout so later stages are not guessing. Transcribe: run a transcription pass that produces word-level or segment-level timestamps, since a transcript without timecodes is useless for cutting. Decide: Claude Code reads the transcript and writes a cut list, a plain JSON array of segments with source file, start, end, and a one-line reason. Render: ffmpeg trims each segment and concatenates the result, or the cut list is converted to an EDL or project file you open in your editor. Verify: check the output mechanically before anyone watches it.

The cut list is the important artifact. Because it is data, you can review the agent's decisions in seconds without scrubbing a timeline, edit a boundary by hand, re-render deterministically, and diff two versions to see exactly what changed. If the agent went straight from footage to a rendered file, none of that is possible and your only feedback loop is watching the whole thing.

Cut on sentences, then adjust

Word-level timestamps tempt you to cut tightly around individual words, which produces clipped audio and choppy pacing. Have the agent cut on sentence or breath boundaries by default, with a small pre-roll and post-roll so speech is not truncated. Give it explicit rules for the cases it will hit constantly: how long a pause has to be before it gets trimmed, whether false starts are removed or kept, and what counts as a repeated take worth dropping.

Verify mechanically before you watch

Have the agent check its own output: total duration within the expected range, cut count matching the cut list, no segment shorter than a threshold that would read as a jump, audio present across the whole file, and loudness normalized to your target. These checks catch the failures that waste your review time. What they cannot catch, whether the edit is any good, is exactly what you should be spending that review time on.

The part that makes it feel automated or not

A generic agent produces a generic edit. It removes obvious filler, keeps most of the words, and hands you something roughly the right length. Then you spend the afternoon fixing it, because it did not cut the way you cut.

Editing style is a set of specific decisions: how tight you go, whether you keep the breath before a punchline, when a pause carries weight and when it is dead air, which verbal tics you always remove and which are part of the speaker's voice, how you handle the cold open, where the b-roll cues go. None of that is in the transcript, and none of it is in the model.

So the first automated pass usually disappoints, and the natural response is to correct it in chat. That works for one video, and then the session ends and the knowledge goes with it. Next week the agent proposes the same wrong pacing and you correct it the same way, at full token price, forever.

Encode your editing conventions so they persist

Write your editing rules down once, in the same plain language you would use to brief a human editor. Pause longer than this gets trimmed. These filler words always go, these stay. Cold open comes from the strongest thirty seconds in the back half. Never cut mid-clause. Keep the file short and specific.

RDK indexes that file, along with your past cut lists and show notes, as encrypted private chunks on the RDK network. Before the agent writes a cut list, it searches those chunks and retrieves your actual conventions and prior decisions, rather than inferring a house style from nothing.

The effect on output is immediate: the first pass looks like your edit, so review becomes approval instead of repair. The effect on cost is the same lever running underneath. With stacked retrieval, a private index answers 40 to 65 percent of queries, the public network adds 15 to 20 percent, and the LLM handles the remaining 5 to 10 percent as fallback, so token spend drops 80 to 90 percent. Long transcripts are expensive context, and retrieving the relevant passage beats re-sending the whole thing on every turn.

Past cut lists matter more than they sound. They are a record of judgment calls you already made on footage very like the footage in front of you now, which is exactly what a new session otherwise has to reinvent.

Where to keep a human in the loop

Full automation is the wrong target for anything anyone will actually watch. Aim for a first assembly you trust, delivered in minutes instead of hours.

Let the agent own the mechanical passes end to end: transcription, filler and pause removal, take selection, concatenation, loudness normalization, caption generation, and format variants for each platform. These are deterministic, checkable, and boring, which is precisely what you want automated.

Keep the judgment calls: which story you are telling, whether the cold open lands, when a silence should breathe, and the final watch-through. Those are the parts that make the video worth publishing, and they are the parts no cut list can encode.

The honest version of automated editing is not an agent that publishes for you. It is an agent that hands you a solid first cut, built from your own rules, so you spend your time on the decisions that actually need a person.

Frequently asked questions

Can Claude Code actually edit video?: It edits the decisions, not the pixels. Claude Code reads a timestamped transcript, writes a cut list of in and out points, and drives ffmpeg or your editor's project format to render it. It cannot watch footage or judge whether a shot feels right, so anything requiring visual judgment stays with you.
Why produce a cut list instead of rendering directly?: Because a cut list is data. You can review every decision in seconds without scrubbing a timeline, fix a boundary by hand, re-render deterministically, and diff two versions to see what changed. A rendered MP4 gives you none of that, and your only feedback loop becomes watching the entire file.
What should the agent verify on its own?: Total duration within the expected range, cut count matching the cut list, no segment short enough to read as a jump, continuous audio, and loudness normalized to your target. Mechanical checks catch the failures that would otherwise waste your review pass, leaving your attention for whether the edit is actually good.
Why does the automated edit not match my style?: Because your style is a set of specific decisions the model cannot infer: how tight you cut, which verbal tics stay, when a pause carries weight, how you build a cold open. None of it is in the transcript. Correcting it in chat fixes one video, then the session ends and the agent starts over next week.
How do I make my editing conventions stick between sessions?: Write them down as you would brief a human editor, then index that file and your past cut lists with RDK as encrypted private chunks. The agent retrieves your actual rules and prior decisions before writing a cut list. Stacked retrieval also keeps long transcripts from being re-sent every turn, cutting token spend 80 to 90 percent.

Key takeaways

The transcript is the interface. An agent cannot watch footage, but it can read timestamped text and decide precisely where a cut belongs.
Every edit should be a data artifact first. A cut list in JSON is reviewable, diffable, and re-renderable. A finished MP4 is none of those.
ffmpeg is the workhorse for mechanical passes. Trims, concatenation, normalization, and captions are deterministic operations an agent can chain reliably.
Verify with numbers, not vibes. Output duration, cut count, gap detection, and audio levels are checks the agent can run without your eyes.
Your editing conventions are the missing input. Pace, filler-word policy, and how tight you cut are decisions the model cannot infer, so index them and let it retrieve them.