The problem#
I shoot long-form: workshops, teaching videos, walkthroughs. The best 30 seconds is in there — but finding it means watching everything once, and cutting it by hand means watching it again to check the cut didn't break a sentence.
That workflow works. It just doesn't scale, and it stops the moment I stop. The shortcut version — a tool that spits out “highlights” — isn't much better, because I still end up fixing clips by hand afterwards.
I didn't want highlights. I wanted edit decisions: something a machine could reason about, check, and hand to a renderer.
An EDL is a machine-readable list of where each edit should happen. That's the whole idea: the machine writes the plan, the renderer films it.
How does it work?#
long-form video → word-level alignment → scoring model → EDL → render → QA layers → human ears → publish
Six parts, in order. Everything before the last step is machine.
- long_form
- The source video and the one transcript built from it.
- whisperx
- Forced word-level alignment. This transcript is the source of truth every cut is checked against.
- scoring_model
- Reads the transcript and scores which moments are worth keeping.
- edl
- The edit decision list — the cut plan, written as data instead of done by hand.
- render_qa
- Renders the edit list, then checks the render against the source before anyone looks at it.
- human_checkpoint
- My ears. The pipeline cannot mark its own work ready to post.
The last step is the important one. A system that can find a clean clip but can't tell when a clip taught nothing will ship clips that look fine and say nothing.
What did I build?#
- A transcript-first pipeline. Long-form video in, word-aligned transcript out — and every stage downstream points back at that one source of truth.
- A scoring stage. The model reads the transcript and scores the moments that stand on their own, with timestamps attached.
- An edit-list generator. Scored moments become a machine-readable list of edit decisions: a plan a renderer can execute and a person can read.
- A render chain with QA. Each render is checked against the source before it's allowed to be called done.
- A human gate the machine can't override. The pipeline can recommend. My ears decide what ships.
Keep the lesson. Keep the words. Cut the dead air.
Before and after#
| Step | By hand | Through the factory |
|---|---|---|
| Find the moments | Watch and scrub the whole video | Transcript scored for moments worth keeping, each pick tied to timestamps |
| Write the cut | Mark in and out points clip by clip | A machine-readable edit decision list generated from the picks |
| Make the clips | Export each version manually | A renderer executes the edit list — the cut is data, not muscle memory |
| Check the work | Watch it back and hope | QA layers check the render against the source; a human approves before publish |
Technical depth#
- WhisperX
- scoring model
- EDL generation
- render QA
- taste audit
- human gate
The stack is small on purpose. The transcript layer does the heavy lifting; everything after it is structured data and checks. Because the cut is data, the same edit decisions can be rendered again without re-deciding anything — which is what makes the QA worth having.
Production readiness#
Video pipelines fail quietly: a clipped word, a gap of dead air, a render that passes the file check and teaches nothing. The gates aim straight at that.
- Word-level provenance. Every cut maps back to the aligned transcript, so a timestamp can always be checked against what was actually said.
- QA on every render. The machine checks its own output before a human sees it — the render has to survive the checks, not just look plausible.
- A taste pass. Renders are audited for whether the lesson lands, not just whether the file is technically clean.
- A human terminal gate. Approval is not a status the automation is allowed to emit. That single rule is why the greens mean something.
The error analysis lists 300+ automated tests and 40+ named failure gates across four QA layers. The gates aren't decoration: each one exists because something got through first. What the machine got wrong goes through the receipts.
The result#
60+ shorts generated from existing content — no new filming required. Shorts that never existed, because nobody had the hours to cut them.
Run numbers taken from the receipts in What the machine got wrong.
What you're looking at
One finished short from the factory: vertical, captioned, cut from a long-form recording I'd already shot.
See one
30-second walkthrough#
Why this matters to an employer#
Media automation
Video in, structured edits out, rendered without an operator babysitting it.
Structured data generation
The valuable output isn't a file — it's the edit decision list, a plan that can be checked, versioned and re-run.
AI plus traditional software
Models for the judgement calls, ordinary deterministic code for the cut, the QA and the render.
Automation around existing tools
The pipeline works with the editing workflow instead of trying to replace it.
The honest tail: I still listen to every clip before it ships. The machine passes and I still pause — that pause is the job.