Automated Video Editing with Claude Code: Full Workflow

A four-minute recording can become a polished intro without dragging clips across a timeline by hand—but only if the automation knows what “good” editing means. Most guides skip this part: I spent time mapping the workflow, and the real breakthrough is not one clever prompt but a reusable system of folders, skills, transcripts, and connected editing tools.

What Automated Video Editing with Claude Code Actually Means

Automated video editing isn’t one magical command that turns raw footage into a finished video. It’s a coordinated pipeline: footage comes in, several tools process it, Claude Code makes decisions along the way, and a final render comes out.

In practice, a project folder might contain raw recordings, transcripts, graphics scripts, music, captions, intermediate files, and exports. Think of it like a sous chef who preps everything in sequence—Claude Code coordinates the kitchen, but it doesn’t personally cook every dish.

Claude Code as the editing orchestrator

Claude Code acts as the project manager and decision layer. It can inspect files, check video metadata, read transcripts, run scripts, decide which sections to cut, and trigger connected tools or renders.

That division matters. FFmpeg handles media processing, Whisper or WhisperX handles transcription, graphics scripts generate visual elements, and services such as Tella can provide recordings, transcripts, and editing workflows.[1]

Claude Code can also save these instructions as reusable skills. Project skills typically live in `.claude/skills/`, where a `SKILL.md` file and supporting scripts define how a particular kind of edit should work.[2]

Why AI cannot edit video files by itself

A language model can understand “remove long pauses and add captions,” but it cannot physically rewrite a video file without tools, permissions, and a rendering environment.

Claude Code bridges that gap by running local commands and connected services. Still, access must be configured correctly: the project folder needs permission, integrations must be connected, and the relevant models or scripts must be available. This is where most tutorials get it wrong—they make the workflow sound more automatic than it really is.

The difference between a prompt and a reusable editing system

A prompt gives Claude one instruction. A reusable editing system gives it known stages: intake, transcription, rough cut, graphics, captions, music, review, and export.

That repeatability is the real advantage. Put new footage into the expected folder, and the same rules can produce a draft through predictable stages—though human review still matters. AI can spot silence; you decide whether that silence carries meaning.

Build the Project Folder Before You Edit

A reliable automated edit starts before the first cut. Treat the project folder like a GPS that recalculates: every file has a known destination, so Claude Code can move through the workflow without guessing.

A practical folder structure

Here’s a structure that works well for a Claude Code–orchestrated video pipeline:

“`text

video-project/

├── raw/

│ ├── camera/

│ ├── screen-recordings/

│ └── audio/

├── transcripts/

├── project-files/

├── graphics/

├── music/

├── sound-effects/

├── renders/

├── exports/

├── config/

├── workflows/

└── .claude/

└── skills/

└── youtube-edit/

├── SKILL.md

└── scripts/

“`

The important distinction is between raw footage and everything generated afterward. Keep untouched camera files in `raw/`; transcripts, proxies, graphics, and intermediate renders belong elsewhere. I’ve found this single rule prevents accidental overwrites and makes it much easier to rebuild an edit.

Where skills, instructions, and brand rules belong

Project-specific skills live in `.claude/skills/`, where they can be shared with collaborators through the repository.[1][2] A `SKILL.md` should define when the skill applies, its required inputs, editing rules, commands, output standards, and quality checks. Claude Code uses the file’s YAML frontmatter to understand when to activate it, then follows the Markdown instructions.[2]

Put brand presets in `config/brand.yaml` or a similar file. Define fonts, colors, caption styles, intro and outro behavior, aspect ratios, and loudness targets—such as a 16:9 master, a 9:16 short, and a specified integrated loudness target. This is where most tutorials get it wrong: “make it match the brand” is not an instruction unless the brand is written down.

Separating source files, working files, and exports

Use consistent filenames such as `episode-014-camera-a.mov`, `episode-014-transcript.json`, and `episode-014-final-1080p.mp4`. Predictable names and directories reduce broken paths, make scripts reusable, and let a collaborator understand the project in seconds.

As a concrete example, a 20-minute recording might produce one transcript, three rough renders, several caption files, and two final exports. Keeping those assets separated means the untouched source remains dependable while the workflow iterates safely.

The End-to-End Automated Video Editing Workflow

A reliable automated edit starts before anyone cuts a frame. The goal is to turn raw footage into a finished video through a repeatable project folder, with Claude Code coordinating scripts, media analysis, graphics, captions, and renders rather than acting as the renderer itself.

1. Intake and media inspection

Begin by checking filenames, formats, duration, resolution, frame rate, audio tracks, and supporting assets such as logos, screenshots, music, and B-roll. I’ve found this step prevents a surprising number of downstream errors—especially when a “final” recording turns out to be 30 fps with a missing audio channel.

For webcam and screen footage, Tella or a similar recorder can keep source clips, layouts, transcripts, and visual material organized. Tella supports screen-and-camera capture, transcript-based trimming, automatic captions, and media layouts.[4]

2. Transcription and word-level timestamps

Next, use WhisperX or an equivalent speech model to create a transcript with word-level timestamps. That timing connects a spoken phrase to its exact position in the video, like a GPS that recalculates whenever the edit changes.

The transcript becomes structured editing data, not just a block of text. It can reveal filler words, long pauses, false starts, repeated sentences, bad takes, and off-topic sections.

3. Transcript-based rough cuts

Use those markers to create an automated first pass. But don’t delete every pause automatically: breaths, reactions, and small hesitations often make a speaker sound human. This is where most tutorials get it wrong—cleaner is not always clearer.

4. Graphics, captions, music, and sound

Generate captions from the same transcript used for cutting, so caption timing and edit timing stay aligned. Build titles, overlays, and lower thirds with reusable templates or code instead of recreating them for every project.

Music and sound effects also need explicit rules: when they enter, how loud they are, when dialogue triggers ducking, and how fades behave. A reusable skill can store these instructions, scripts, and assets in `.claude/skills/` for future projects.[1][3]

5. Rendering and quality control

Render a preview before the final export, then have the system inspect its own output for missing media, broken captions, timing errors, clipping, and incorrect aspect ratios. A ten-second preview can expose a misplaced title or silent audio track before a 20-minute export wastes your evening.

Connect Claude Code to the Editing Tools You Already Use

Claude Code works best as the coordinator of your editing setup—not as the renderer itself. The right connection lets it inspect footage, make decisions, run commands, and hand the final render to the tool that actually performs the work.

Using Tella through an MCP connection

An MCP connection can give Claude access to a Tella workspace, where it can find videos, read transcripts, apply cuts, change layouts, add zooms, and start exports.[1][2] Tella supports screen recordings, webcam footage, combined screen-and-camera layouts, transcript-driven edits, captions, overlays, and visual enhancements.

A useful request is specific: “Find the latest product demo, remove filler words, switch to a side-by-side layout during the walkthrough, add zooms when I click, and export a captioned 16:9 version.” That gives Claude three things it can act on: a clear asset, an editing rule, and a desired output. In my experience, vague prompts create vague edits.

Before connecting, check workspace permissions and decide whether footage or transcripts may leave your organization. A transcript can contain customer names, internal URLs, or unreleased product details, so privacy settings matter just as much as editing features.

Running local workflows with FFmpeg and Whisper

For files stored in your project folder, local Claude Code skills can run tools such as FFmpeg for media inspection, cutting, audio mixing, and rendering, alongside Whisper for transcription. The folder might contain raw footage, scripts, transcripts, graphics, presets, and final exports.

This is like having a sous chef who preps everything: Claude decides what should happen, while local tools execute repeatable steps. Local processing also keeps sensitive footage closer to your machine, although downloaded models, logs, and shared project folders still deserve a privacy review.

Choosing between cloud editing and local files

The practical division is simple: Tella manages media in its connected workspace, while local skills handle files, scripts, renders, and custom pipelines. Start with one dependable connection—perhaps Tella or a local workflow—rather than combining several integrations before the basic process is stable. One reliable path beats three half-configured ones.

Real Examples, Reusable Skills, and Human Review

The best way to understand this workflow is to follow one ordinary project from start to finish. Put the talking-head footage in the raw directory, inspect the files, generate a transcript, remove rambling sections, add captions and graphics, render a preview, review it, then export the approved version. In practice, that turns editing into a repeatable pipeline rather than a guessing game.

Example: turning a raw talking-head recording into a short intro

A useful request might be, “tighten this recording,” followed by “restore the pause before the key point.” Those are controlled workflow instructions: specific enough to repeat, unlike a vague prompt such as “make it better.” I’ve found the pause matters because removing every gap can make a speaker sound like a machine.

Example: editing a screen-recorded tutorial

For a screen tutorial, match transcript phrases with visual events. When the narration says “open the settings panel,” the system can align a zoom, cursor emphasis, highlight, or chapter graphic with that moment. It works like a GPS that recalculates when the route changes, but a person still needs to check whether the emphasis feels natural.

Example: repurposing one video for multiple formats

Create separate skills for long-form YouTube videos, shorts, captions, graphics, audio cleanup, and platform exports. Claude Code skills are reusable instruction files, typically built around a `SKILL.md` file and stored in a project’s `.claude/skills/` directory.[1][2]

A request such as “create a vertical cut from the strongest explanation” can produce a focused short, while the same project generates captions and platform-specific exports. One source video might become a 10-minute tutorial, three 45-second clips, and a captioned square version.

How to improve the system after every project

Keep an edit decision log recording what changed, why it changed, and which version contains the fix. Measure time saved, manual corrections, caption accuracy, export consistency, and viewer retention; for example, compare whether a new caption rule reduces corrections from 20 per video to 5.

Human approval should remain mandatory for narrative choices, emotional timing, factual accuracy, brand-sensitive moments, and final publishing. Automate repeatable mechanics while keeping creative judgment in the loop.