ButterCuts
An AI video editor for brands and creators who record on camera. One raw recording becomes a finished long-form video and Shorts, each with an editable project. Claude Code or Codex makes the creative calls, and the engine does the media work locally.
The problem
Recording is the easy part. Turning one recording into a polished long-form video and a set of Shorts takes hours of editing: cutting retakes, captions, graphics, reframing for vertical. Hiring that out is slow and expensive, and handing it to an AI tool is fast but unreliable.
ButterCuts lets the model make the creative calls and makes code prove every step before anything ships.
What a brand gets
- One recording, every format. A long-form video and Shorts from the same raw footage.
- Edits that are checked. Code and independent AI reviewers check the plan and the rendered video before anything is called finished.
- A project they can still touch. Every video comes with an editable Studio project for hand changes.
- Footage stays home. Transcription and rendering run on their own machine by default.
- No second AI bill. The editor runs on the Claude Code or Codex subscription they already have.
Pipeline
- Ingest. Each source is admitted through an OS sandbox.
- Transcribe. Local Whisper by default. Paid ASR runs only when the operator turns it on.
- Select. The agent picks the strongest moments and shows a paper edit.
- Plan. The agent writes
edit_plan.json: cuts, captions, graphics, transitions, audio. - Gate. Code checks the plan first. Then fresh critics review it.
- Render. ffmpeg and HyperFrames render into an isolated candidate folder, never straight to the final file.
- QC. An automated audit, then a composition critic and an editorial critic.
- Deliver. The video, mastered to −14 LUFS, plus a Studio project for hand edits.
Click any box for what it does, why it matters, how it works and what it cost. Filter by skill, or press a ▶ walkthrough.
Two layers of agents
Agents edit the videos, and a separate team of agents builds the engine itself. Both follow one rule: each job goes to the cheapest model that does it well, and code checks the result.
Editing agents
- The plan is the boundary. The model writes
edit_plan.json. Code renders it, and the same plan and inputs give the same output. - Code checks before critics. Intent, hook, claims and plan rules are checked by code. A 70-second checker caught all 7 material issues that had cost a long-form edit about 1 h 40 min of critic rounds, so critics are saved for taste.
- Authors don't approve their own work. Critics are fresh, read-only processes. Light edits need one clean review, produced edits need two, capped at four rounds.
- Media text is data. Transcripts, OCR, filenames and web text are never treated as instructions.
Build agents
| Job | Model |
|---|---|
| Watching for finished renders and new notes; running scripts and test suites | Haiku 5.5 |
| Small named fixes, well-specified builds, docs | Sonnet 5.5 |
| Designing and specifying critical work; auditing hash, persistence and capture code | Fable 5.2 |
| Builds and independent reviews | Codex |
| Editorial work on a real release | Opus 5.5 |
- Small, named units. Each piece of work names the model, the files, what done means and when to stop.
- No paying to wait. Shell watchers wake sessions on events. Long jobs run in the background and write a one-screen summary.
- Two independent reviews per engine change, from fresh context. Fixes are re-checked against the delta only.
- A quality ledger records the builder model, every review verdict and the real-footage result. If a cheaper tier's numbers slip for a kind of job, that job moves back up.
- Pick tiers by test. On a review page with planted problems, Sonnet missed them. Opus at high effort caught the same ones as extra-high in about half the time, so that became the review tier.
The full rule file is free: Token-efficient agents →
Stack
| Layer | What |
|---|---|
| Engine | Python, tested with stdlib unittest |
| App and Studio | TypeScript, Next.js 16, React 19 |
| Media | ffmpeg, HyperFrames compositions with GSAP, local Whisper |
| Runtime | Native macOS and Windows, OS sandbox per source, detached workers that survive restarts |
Key decisions
- Evidence is hash-bound. Reviews, audits and frame checks are tied to the exact inputs they saw. Change the plan and every downstream approval is invalid.
- Isolated candidates. Renders land in their own folder, so a failed render can't pass as finished.
- One engine for every format. Shorts-only code had grown to 7,981 lines, and 3,226 of them duplicated long-form work. A Short is becoming a format profile on the shared engine.
- Real footage is the proof. Unit tests aren't enough. Every change runs on real footage nightly.
Things I measured
- Revision reviews compared file bytes, so every change looked whole. Comparing content hashes instead cut a two-card recolor's review scope from 100% of frames to 11.8%.
- A fixed picture-in-picture inset kept as little as 37% of the face in frame. Insets now follow the measured face, with at least 70% on every frame.