Build a Video to Shorts Pipeline
You already record an hour of real expertise every week and publish almost none of it. This is the whole pipeline that turns one recording into a longform episode and ten or more vertical shorts, every step, with the prompts and the code.
This guide documents a pipeline we built and run every week, not a concept. The scripts, the prompts, the scoring rubrics and the numbers are the ones in production.
It is written to be handed to Claude Code. Open a terminal in an empty folder, give Claude Code the link to a step, and follow what it asks for. You supply the recording, the API keys and the judgement calls. It writes the code.
Nine steps, in order. Each one produces a real artifact you can inspect before moving on. If a step fails its check, stop there. Every later step depends on the one before it.
What you have at the end
- One longform episode, lightly edited, with a cold open that holds viewers.
- Ten or more vertical shorts, each one a complete idea that stands alone.
- Two thumbnails, per platform copy, and a schedule file ready to publish.
Before you start
Before step 1, get these in place. All of it is free except the model subscription.
| What | Why | Notes |
|---|---|---|
| Claude Code | Writes and runs every script in this guide | A subscription plan, not per-call API billing. Building this way costs a few dollars of allowance rather than a few hundred in metered usage. |
| Python 3.10 or newer | The pipeline scripts | Check with python --version |
| ffmpeg | Every cut, render and frame grab | ffmpeg -version must return something |
| faster-whisper | Word level transcription | Installed in step 2 |
| A recording | The input | A screen recording of a real call, an hour or so, with your camera visible somewhere in frame |
Set up a video pipeline project for me.
Create this structure:
pipeline/ingest/ pipeline/transcribe/ pipeline/cut/
pipeline/shorts/ pipeline/thumbnails/ pipeline/longform/
work/ (gitignored scratch for video files)
episodes/ (finished output, one folder per recording)
skills/ (the prompt skills we will add as we go)
Then:
1. Create a Python virtual environment and a requirements.txt with:
faster-whisper, gdown, pillow
2. Verify ffmpeg is on my PATH and tell me how to install it if not.
3. Add a .gitignore that excludes work/, .env, and any mp4 or mov files.
4. Print my Python version, my ffmpeg version, and confirm the folders exist.
Do not write any pipeline code yet. Just the scaffold, then stop and tell me
what is missing.The nine steps
- Set the Weekly Output Contract Decide what one recording owes you before you touch a video file. Without a written contract you will ship whatever the week allows, which is usually nothing. 20 minutes, once
- Transcribe and Strip the Dead Air Get the recording onto your machine, transcribe it with word level timestamps, and cut the silence and filler. Those word timings are the source of truth for every cut in this pipeline. An afternoon to build, then about an hour of machine time per recording
- Mine the Transcript for Ideas Read the entire transcript and extract ideas, not timestamps. This is the step that separates a pipeline worth running from an automatic clipper. About 30 minutes per recording, most of it your review
- Assemble Each Idea Into a Clip Plan Turn every surviving idea into exact segment timestamps, with the strongest line moved to the front. This is where an idea becomes something you can render. About 10 minutes per idea
- Run the Coherence Gate Three tests that decide whether a clip survives. This is a pass or fail gate, not a score, and it is the reason our clips make sense to someone who was not on the call. About 2 minutes per clip
- Render Vertical With Word Pop Captions Build the 9:16 render with animated word level captions, then run the caption correction loop. This is the longest script in the pipeline and the one you will tune most. A day to build, then a few minutes per clip
- Build the Open Loop Cold Open The longform episode needs a first fifteen seconds that opens a loop and refuses to close it. This is the difference between an episode people watch and a recording people scrub. About 30 minutes per episode
- Score Every Asset Against an 85 Floor Two rubrics, one loop, one rule: 85 or it does not ship. Three fix passes maximum, then it is killed or flagged. This is what stops the pipeline quietly degrading. About 5 minutes per asset
- Render Two Thumbnails, Not Four One design, two crops, every platform covered. Then the per platform copy and the schedule file that turns a folder of renders into a published week. About 20 minutes per episode
Do them in order
Each step produces an artifact the next one reads. Step 4 cannot plan clips without the ideas from step 3, and step 6 cannot render without the plans from step 4. If a step fails its check, stop and fix it there. Carrying a broken transcript forward wastes every hour after it.
Talk it through
Want this built for you instead?
Free 30 minutes. If you would rather have the pipeline running than build it, that is a conversation worth having.