claude-youtube-editor: a Claude Code pipeline for cutting and packaging YouTube videos

The problem: screen moments are the expensive part of a talking-head video

Recording yourself is cheap. Everything around the recording is not. A full-screen statement, a diagram, a browser walkthrough, a terminal mockup and a title card all have to be produced, and the usual route is to capture them on screen and cut them in. That route couples the visual to whatever the machine happened to display at capture time, and it makes a one-word change in the narration a re-record.

claude-youtube-editor takes the opposite position. The README's framing is blunt: you record the talking head, and "Claude Code does the rest." The shot list you actually film is yourself. Every screen moment is built as Remotion TSX and composited over your cut, so a visual is a file you can edit rather than a clip you have to recapture. The audience is a solo creator who already works in Claude Code and is willing to treat a video as a small software project.

Six steps, eight skills, and where the state lives

The pipeline is organised as skills under `.claude/skills/`, which the README calls where the editor actually lives. The cut runs through `/clean-cut`: AssemblyAI transcribes with tone and talking style, you author `cuts.json` from the transcript, and the output is a clean master plus a word-level `edited-transcript.json`. That transcript is the spine of everything after it, because the later skills sync to word times rather than to a timeline.

`/make-tsx` and `/fake-screencast` build Remotion shots over the master, including generated UI clones that simulate a screen recording without capturing one. `/clean-audio` handles voice isolation, with an ElevenLabs method and a local RNNoise method. `/suggest-sfx` places sound effects on an exact word. `/packaging` produces one title and three thumbnail bets for YouTube's A/B test. `tools/yt_upload.py` checks for ghost speech and A/V drift and uploads as a private draft. `/brand-setup` rewrites `brand.md`, `remotion/src/brand.ts` and `remotion/src/fonts.ts` together, and `/vidtsx-2d-generator` holds the low-level rules that keep a shot from crashing.

The data flow is worth stating plainly: audio in, transcript out, transcript plus authored `cuts.json` in, master out, master plus word times in, TSX shots out. Each stage leaves a file the next stage reads, which is why the pipeline can be resumed at any step.

Installing claude-youtube-editor and rendering the first shot

The README lists the prerequisites as Claude Code, Python 3.10+, Node 18+, and `ffmpeg` plus `ffprobe` on PATH. `requirements.txt` repeats the ffmpeg and Node requirement in a comment, and notes that the tools are meant to be run as `python tools/<tool>.py ...` with the venv active.

Clone the repository and create the virtual environment, then install the Python dependencies. The Windows and macOS/Linux commands differ, and the README gives both.

git clone https://github.com/hassancs91/claude-youtube-editor
cd claude-youtube-editor

python -m venv venv
venv/Scripts/python -m pip install -r requirements.txt   # Windows

The Remotion side needs its own install and a registry generation step before any shot will render.

cd remotion && npm install && npm run gen && cd ..

Keys go into a `.env` copied from `.env.example`. The file states that the cut, clean, TSX and SFX core needs `ASSEMBLYAI_API_KEY` and `ELEVENLABS_API_KEY`, that `GEMINI_API_KEY` is only for thumbnails, and that `FAL_KEY` is only for generated video clips.

cp .env.example .env
claude

The fastest first use does not require any footage at all. The repository ships 37 real shots from a published video, and the README says they render standalone.

cd remotion && npm run studio

What you should see is the shipped example's shots in the Remotion studio, with no raw recording involved. Reading a few of them is the README's suggested way to learn `remotion/src/lib/`, which holds the browser frame, the screencast engine, the VS Code shell and the motion kit. Once you have footage, the entry point is a directory under `videos/`, and the README's example prompts are `clean cut videos/video-1`, `add TSX beats to video-1`, `suggest sfx for video-1` and `package this video`.

The brand contract is a real constraint, not a cosmetic step

The repository ships with what the README calls a house brand: a calm, premium indigo look. It is real and you can keep it, but the README is direct that if you change nothing, your videos will look like someone else's channel. That is an unusually honest thing to put in a quickstart, and it is also a genuine cost. `/brand-setup` interviews you and rewrites three files together: `brand.md`, `remotion/src/brand.ts` and `remotion/src/fonts.ts`. It checks that your fonts exist and that your palette is readable, then renders a proof card.

The reason this matters more than it would in a template pack is that the brand is a contract the other skills read. The roadmap lists filters as "grade/look presets that respect the brand contract," which tells you the later visual passes are expected to defer to those files. If you skip `/brand-setup` and then hand-edit `brand.ts`, you are changing the contract without the font and readability checks.

What the repository does not include

The README's "What's NOT in here" section is the most useful page for a decision. There is no script writer, so this edits video and does not write it. There is no footage: the example's shots ship, its raw recording does not, and `videos/` starts empty. There is no face kit, and thumbnails need reference photos of your face in `media/library/faces/`, which you supply.

There is also no CTR data. The `/packaging` rules ship calibrated on a real channel's numbers, but the numbers themselves do not. The README points to `references/channel-calibration.md` for building your own once you have roughly ten videos, and states that your data then beats the defaults. Until you have that, the packaging step is running someone else's calibration on your channel.

Two more boundaries are worth naming. The bundled SFX and music clips have their own licensing terms, and the README's licence section is truncated at "Bundled SFX/music clips w", so the MIT licence on the code does not automatically settle the audio. And the repository has no releases: the "Recent releases" list is empty, so there is no versioned artefact to pin. The last push was on 2026-08-18.

Where this sits against a conventional editor or a Descript-style tool

The obvious alternative is a timeline editor such as DaVinci Resolve or Premiere, or a transcript-driven editor in the Descript mould. The difference is not quality, it is where the artefact lives. In a timeline editor the finished video is the artefact and the project file is an implementation detail. Here the TSX shots and `cuts.json` are the artefact, and the rendered video is a build output.

That has a concrete consequence. Changing a word in a diagram is an edit to a file, and the shot re-renders against the same word times. In a captured-screen workflow the same change means re-recording. The cost is the inverse: you cannot nudge a clip with a mouse, and a visual idea that is not expressible in Remotion TSX is not expressible at all. The README's decision to make `/vidtsx-2d-generator` a skill of its own, dedicated to keeping a shot from crashing, is a signal about how much of the work is programming rather than editing.

A second alternative is doing nothing beyond manual cutting. That is fine if your videos are mostly you talking to camera with no screen moments. This pipeline exists to build the screen moments, and if you do not have any, most of the repository is dead weight.

Maintenance, upgrades and what the MIT licence does not cover

The repository is not archived, and the last push was on 2026-08-18, so it is roughly a month old by the calendar. That is recent enough to treat the code as current, but with no releases there is no changelog to read and no tag to pin against. The upgrade path is `git pull` plus re-running the two install steps, because the Remotion registry is generated by `npm run gen` and will not pick up new shots on its own.

The roadmap is a list of unchecked items: transitions between beats, zoom and punch-in effects, filters, and a `cuts.json` time-remapper so that `edited-transcript.json` does not need a second transcription pass. That last item tells you something about the current design: today, a change to the cut can force another transcription pass, which costs AssemblyAI credit and time. Budget for that until the remapper lands.

On licensing, the code is MIT. The README's licence section is cut off mid-sentence at the bundled SFX and music clips, so check `LICENSE` and the clip catalogue in `media/library/` before shipping anything with the bundled audio. This is not legal advice; it is a pointer to the file that would answer the question.

Editorial conclusion

Adopt it if you already record talking-head videos, are comfortable in a terminal and a TSX codebase, and want your screen moments to be reproducible code rather than captured footage. Skip it if you need a script writer, a face kit, or a GUI timeline, or if you are unwilling to pay for AssemblyAI, ElevenLabs and Gemini keys. Before committing, run `cd remotion && npm run studio` to render the 37 shipped shots without any footage, and read `references/channel-calibration.md` to see how much of the packaging logic depends on data the repository does not include.

Frequently asked questions

Official sources

1. hassancs91/claude-youtube-editor on GitHub
2. Issues
3. License: MIT
4. Project website
5. README