I Taught Claude Code My Video Editing Style (Here's the Prompt)
I edit short vertical videos of myself talking about AI and dev tools. I found a style I liked: off-white cards, one accent colour, captions with small words around one huge word, thick lines that stop at the text, a quiet music bed. Doing that by hand for every video was slow. So I taught Claude Code the style and turned it into a skill. Now I drop in a raw clip, pick designs on a planning page, and my own PC renders the finished short.
This post covers how I built it, how it works and what I fixed along the way. You can also download the skill and use it yourself, or use the prompt at the end to build one for your own style.
What I gave Claude to start
- Reference videos. 9 shorts in the style I wanted, in one folder. I removed the off-style ones, because mixed references give you a mixed style.
- Screenshots. Frames of the exact moments I liked, each with a one-line note.
- A breakdown. A tutorial video of the style with its transcript and a design reference image.
- My machine. Windows, an RTX 3070 Ti, a Ryzen 5 5600X, ffmpeg, Python and Node.
Then one instruction: learn this style and make it a skill. Everything below came out of that and a few rounds of notes.
Step 1: measure the style, don't describe it
The most useful thing Claude did was measure instead of guess. Across the 9 references (about 420 shots) it:
- found every cut with ffmpeg scene detection and logged what each shot showed (face, card, diagram, B-roll)
- sampled exact hex colours and measured text sizes and positions in pixels at 1080×1920
- stepped through animations frame by frame for durations, blur and easing
- measured the audio: the music bed sits about 18 dB under the voice, and there are almost no sound effects (0–3 per minute, only where something moves)
- matched visuals to the transcript to learn why each graphic appears: the speaker announces a point on camera, then the description gets a visual
All of it went into four reference files the skill reads before every edit: style-guide.md, editing-logic.md, scene-library.md and refs.md. Numbers in those files are what stop the output drifting into a generic look.
Step 2: the engine
The design rule that made everything else easy: every frame is a pure function of time.
timeline.json ──► base video (ffmpeg: cuts, punch-ins, B-roll)
──► graphics page (HTML/CSS/JS, seek(t) sets the DOM for time t)
└─ Playwright screenshots transparent PNGs per frame
└─ ffmpeg overlays them on the base, NVENC encode
──► audio mix (voice + music bed + a few sound effects)
timeline.jsonis the single source of truth. Word timings, captions, punch-ins, B-roll, scenes and audio. Claude edits this file; it never touches pixels directly.- No CSS transitions, no
Math.random, noDate. Any frame can be rendered alone, in any order, so rendering splits into parallel chunks (one Chromium page per worker, each piping frames into its own ffmpeg) that get joined without re-encoding. - Scenes are reusable modules. Captions, colour cards, quote cards, the line-and-text arc, node diagrams, charts, paintings, treated photo illustrations, cards, a CTA. Each is a small JS file with
mountandupdate(t). - Transcription runs on the GPU. faster-whisper gives word timestamps, and captions, scene starts and element entrances all key off those times.
A small CLI wraps it: prep, plan, previews, stills, render, plus asset download (free-licensed stock with credits) and a sound-effects library.
Step 3: the workflow the skill follows
- Interview. Clip, project name, accent colour, how the intro title should look, music, sound-effects level, density.
- Prep. Normalise to 1080×1920 at 30 fps and transcribe. Pauses are kept by default, because my clips usually arrive already cut.
- Plan. Claude splits the script into beats and gives 2–3 scene options per beat, each with a reason and the reference timestamp it copies.
- Previews. Every option is rendered as a short clip with sound on my real footage.
- Pick. I choose per beat on a planning page, add notes, and press Send to Claude.
- Build, check, render. Claude writes the timeline from my picks, looks at real stills, then I render a half-res draft and the final.
What I fixed after the first version
"I can't judge a text description"
The first planning page listed options as text: "Line + text, contrast in two halves". I couldn't picture it. Now each option in plan.json carries its real scene JSON, and mpe.py previews renders it as a 5-second clip with voice and sound effects. The page shows each one looping, and a click plays it large with sound. Options render 4 at a time, which took a 12-option plan from 56 s to 28 s on my machine.
One colour isn't a style rule
The references were all electric blue, so the engine had blue hard-coded in about 25 places. Rather than edit every scene, the runtime now recolours: any saturated blue-family colour (hue 190–250) is shifted to the same shade of the chosen accent. Hue rotated, saturation and lightness offset. It runs through the shared element helpers and the stylesheet, so lines, cards, gradients and glows all follow one setting:
{ "accent": "red" } // or any hex, e.g. "#E3161D"
Blue stays the default, and the output with no accent set is unchanged.
A title that actually hooks
The intro was a small serif card in the corner. I wanted the magazine-cover look: one huge word across the top, with the speaker's head in front of the letters. The new headline scene fits each line to the frame width and has fonts, colours and animations to pick from. With behind: true the pipeline cuts the speaker out of every intro frame (rembg's person model, on the CPU) and the page draws that cut-out back over the text. The cut-outs come from the same base frames ffmpeg overlays onto, so they line up pixel for pixel. Masks are cached per project, and the model downloads once.
The line animation cut off the punchline
In the arc scene, the camera started moving to the next phrase 0.5 s early, so the big word of the current phrase ("not", "sued") left the screen while it was still being said, and a stub of the next line showed up under an unfinished phrase. Now the camera stays until the phrase is spoken, then the line and camera move together in under half a second, and the next phrase's words appear as the camera arrives.
My own sound effects
I dropped my sound files (pop, click, ding, notifications, typing, paper, a riser) into the skill folder. mpe.py sfx-lib turns them into a library:
- trims each file to where the sound starts. The originals had 60–250 ms of silence first, which makes a pop land late.
- levels them to the same peak, so a
dbvalue means the same for every sound - finds each sound's loudest point, so a riser is placed to peak exactly when the title lands
- records what each sound is for, which
sfx-suggestuses to place them by scene (pop on a card, typing over keyboard B-roll), capped by the level I chose
Download and install /minimal-premium-edit
If you like this style as it is, use my skill directly: download the skill (zip, 5.6 MB). The launchers are Windows .cmd files.
1. Install the tools
- Claude Code: the desktop app or the CLI
- ffmpeg: the "full" build from gyan.dev, on your PATH
- Node.js 22+ and Python 3 with pip (I use Python 3.13)
- Optional: an NVIDIA GPU. Transcription and video encoding use it when it's there and fall back to the CPU when it isn't.
2. Unzip it and add it to Claude Code
Unzip it anywhere, for example D:\Editing\minimal-premium-edit (the folder that contains SKILL.md). Then link that folder into your personal skills folder, so every Claude Code session can use it. In PowerShell:
New-Item -ItemType Junction -Path "$env:USERPROFILE\.claude\skills\minimal-premium-edit" -Target "D:\Editing\minimal-premium-edit"
Copying the folder into %USERPROFILE%\.claude\skills\ works too. The link just means any change to the folder applies straight away.
3. Run setup once
Double-click setup.cmd in the skill folder. It checks ffmpeg and Node, tests the NVIDIA encoder, installs Playwright with Chromium, installs faster-whisper, rembg and the CUDA libraries with pip, and generates the built-in sound effects.
4. Add a Pixabay key (only for stock video)
Photos come from Openverse and paintings from Wikimedia Commons without any key. Stock video needs a free Pixabay key:
- Create a free account at pixabay.com and copy your API key from pixabay.com/api/docs.
- Double-click
set-pixabay-key.cmdin the skill folder and paste the key. The input is hidden, and the key is stored in the skill'stoolsfolder on your machine only.
If you have a Pexels key, set-pexels-key.cmd adds it the same way. Don't paste keys into the Claude chat.
5. Add your own sound effects (optional)
Put your sound files (pop, click, whoosh, riser…) in the skill's assets folder and run mpe.cmd sfx-lib. Without them, the skill uses its built-in sounds.
6. Edit a video
Make a folder for your edits, open Claude Code in it, and type:
/minimal-premium-edit
Or just ask: "Edit D:\clips\my-take.mp4 in the minimal premium style." Claude asks a few questions (project name, accent colour, intro title, music, sound-effects level), runs or gives you the commands for each step, and builds the planning page with previews for you to pick from. Use royalty-free music, and keep the credits.md file it writes for the stock it downloads.
Or build one for your own style
Gather 5–10 reference videos in one style, screenshots with a note each, and one raw clip to test on. Then paste this into a Claude Code session opened in that folder, filling in the brackets:
I want you to build a Claude Code skill that edits my raw talking-head clips into short
vertical videos (1080x1920) in one visual style, rendered on my own computer. Learn the
style from the reference videos and screenshots I've collected. Ask me anything you need first.
## What I've prepared
- Reference videos: [path]. Ignore [off-style files].
- Screenshots of what I like: [path]. Notes: [01.png: the one huge word under small text] ...
- Optional breakdown: [tutorial video + transcript, or "none"]
- My computer: [Windows/macOS], GPU: [model or none]. Installed: [ffmpeg/Python/Node].
- Put the skill in [path]\my-style-skill\ and projects in [path]\projects\<name>\.
## Phase 1: study the style (measure, don't guess)
For every reference: find every cut with ffmpeg scene detection and list each shot; pull
frames of every graphic and measure exact hex colours, text sizes and positions at 1080x1920;
identify the fonts (closest free OFL match if needed); step through animations frame by frame;
measure music level under the voice and how often sound effects happen; transcribe with word
timestamps and work out which kind of line gets which visual.
Write style-guide.md, editing-logic.md, scene-library.md and refs.md in reference/.
Show me a summary with frames and wait for my OK.
## Phase 2: build the toolkit
- One timeline.json per video is the single source of truth.
- Graphics engine: HTML/CSS/JS where every frame is a pure function of time (no CSS
transitions, randomness or clock). Playwright screenshots transparent frames, ffmpeg
overlays them on the footage. Parallel chunks; GPU encoder with automatic CPU fallback.
- Commands: setup, prep (normalise, transcribe with word timestamps, optional silence cut,
proxy, contact sheet, draft timeline), plan, previews, stills, render (--draft), assets,
and a sound-effects library from my own files.
- Every scene type from the references, configurable. Colours are tokens (accent is a setting).
- Free fonts, music and stock only; record credits.
## Phase 3: the workflow (write it into SKILL.md)
1. Interview once: clip, project, accent colour, intro title, music, sound level, density.
2. Prep. 3. Plan beats with 2-3 options each (reason + reference timestamp), each carrying
its real scene settings. 4. Render every option as a short clip with sound and show them on
a planning page where I pick, add notes and press "Send to Claude". 5. Build the timeline
from my picks exactly. 6. Look at real stills before calling anything done.
7. Draft, then final. Turn my notes into rules in the reference docs.
## Rules
- Never put invented numbers, quotes, names or titles on screen.
- My choices beat yours. Every step leaves files so a new session can resume.
## Done means
Stills of every scene type next to the matching reference frames, then my test clip
[path] edited through to a final render I approve.
Two things matter most. Stop after phase 1 and correct the style guide, because fixing it there is far cheaper than fixing a finished engine. And expect the first cut to be 60–70% there. Timestamped notes ("0:12, the big word leaves too early") get it the rest of the way, and each note can become a permanent rule in the reference files.
Wrap-up
The parts that made this work weren't clever: measured references instead of adjectives, one JSON file as the source of truth, frames that are pure functions of time, and rendered previews instead of descriptions. Claude handles the planning and the timeline, and my GPU does the heavy lifting. If you build one for your own style, tell me what you change.
Related articles
Your Next Security Patch Could Help Hackers: What Google's AI Threat Report Means for Developers
Google's 2026 AI threat report warns of automated patch exploitation. Here's what developers should know and which tools can help secure their softwar…
Plan with Opus, Ship with Parallel Sonnet: My write-plan and run-plan Skills for Claude Code
Two free Claude Code skills that cut a feature into self-contained slices and run them in parallel with Sonnet/Haiku subagents. Install steps and prom…
Build 3D Floor Plans with Codex and Blender MCP
Connect Codex to Blender with MCP, turn a 2D floor plan into an editable 3D scene, and improve results with compact, testable prompts.