Edit your reels with Claude
Give Claude your raw video and one sentence. It cuts the mistakes, fixes the sound and colour, adds subtitles and graphics, and shows you every shot before it makes the video.
- Clean cuts
- Eyes on the lens, every shot
- Natural skin colour
- Word-timed subtitles
- Big titles and logos
- Screenshots before the render
How to use it
- Open Claude Code. You need a Claude Pro plan or higher. In the Claude desktop app it is the Code tab.
- Copy the prompt below and paste it into Claude Code.
- Say yes to each step. Claude checks your computer, shows you a short list of what it will set up, and asks before every install. Then it tests itself on a short sample video.
Then send it your video and say Edit this reel
. Claude asks if it is your full raw video or your chosen takes, asks for screenshots of a reel style you like, and always shows you preview screenshots before it makes the video.
What you need
- A Claude Pro plan or higher
- The Claude desktop app (Code tab)
- A Windows or Mac computer
Everything else, Claude installs for you after asking.
The prompt
Long on purpose: it holds the whole skill (677 lines). Copy all of it.
Set up the "reel-edit" skill on this computer for me, then show me how to use it.
I am not a developer. Explain every step in one simple sentence, with no technical words.
ABOUT THIS SKILL (credits)
- The skill's instructions, editing rules and helper scripts were written by the author of this skill. Everything else it uses is third-party: free tools made by other people (HyperFrames, GSAP, faster-whisper and the Whisper model, FFmpeg, Node.js, Python packages, Google Fonts), which you install or which load on your computer under their own licences. This skill does not include or redistribute their code and does not claim their work.
- The full list with each maker and licence is in the "Credits and third-party components" section at the end of the skill. Before you install anything, tell me in one or two plain sentences which outside tools this uses and that each one has its own licence.
RULES FOR THE SETUP
- Before you install, download or create anything, check what is already on this computer, then show me ONE short numbered list of everything you plan to do. Wait for my yes.
- Ask me again right before each install or download, and say what it is, where it comes from and roughly how big it is.
- Never delete or move any of my files.
- If something fails, tell me in one plain sentence and suggest the fix.
WHAT TO SET UP
1. Check these tools and install only the missing ones (ask first): ffmpeg, Python 3 with the "faster-whisper" and "numpy" packages, Node.js, and on Windows Git for Windows (for Git Bash). HyperFrames needs no install: it runs with "npx hyperframes".
2. Create the skill folder: ~/.claude/skills/reel-edit/ (on Windows: C:\Users\<my user>\.claude\skills\reel-edit\).
3. Save everything between the two SKILL.md markers below, exactly as written, as SKILL.md in that folder.
4. Write every script in the skill's "Appendix" into a scripts/ folder inside the skill folder, exactly as written.
5. Make the sound effects in assets/sfx/ inside the skill folder. Make them with ffmpeg, no download needed:
ffmpeg -f lavfi -i "sine=f=900:d=0.08" -af "afade=t=out:st=0.02:d=0.06,volume=0.6" pop.wav
ffmpeg -f lavfi -i "anoisesrc=d=0.6:c=pink" -af "highpass=f=400,lowpass=f=3000,afade=t=in:d=0.25,afade=t=out:st=0.3:d=0.3,volume=0.5" whoosh.wav
6. Create assets/logos/ inside the skill folder. Ask me which AI tools or apps I usually talk about in my videos. For each one, offer to download its official SVG logo from the company's own brand or press page (ask me per file), or let me add them later.
7. Ask me for my brand colours (one dark colour, one accent colour). If I give them, set them as the default "theme" in scripts/build.mjs. If I skip, keep the defaults.
8. Test it: make a 20-second test video with ffmpeg, run make_clips.py, build.mjs and "npx --yes hyperframes@0.8.105 check" on it, and tell me in one line if everything works. Delete only the test files you made.
9. Finish with a short "how to use it" for me: open Claude Code in the folder with my video, say "edit this reel" and give the file name. Tell me you will first ask (a) whether it is my full raw video or my chosen takes already put together, and (b) for screenshots of a reel whose style I like, and that you will always send me preview screenshots before you make the video. Then I answer in plain words. Also give me 3 filming tips: eyes on the lens, a short pause between sentences, and good light on my face.
===== SKILL.md STARTS ON THE NEXT LINE =====
---
name: reel-edit
description: Turn a raw talking-head video into a finished vertical reel in one go - clean cuts with no clipped words, eyes on the lens in every shot, natural skin colour, word-timed subtitles, big wall titles, chat bubbles, crossed-out icons, logo pops, a raw-footage inset and an end card - with a screenshot storyboard sent for approval before the final render. Triggers: /reel-edit, edit this reel, edit this video, make this a reel, here's the raw video.
---
# Reel edit
**Contract:** the user hands you a video (and maybe a script or an idea note). You return the FINISHED 9:16
reel. You always stop at two points: the two questions at the start, and the preview stills before every render.
Otherwise only stop to ask when something cannot be decided from the footage, the script or the rules below (for
example two equally good takes of the key line). Everything else: decide, build, check yourself, deliver, and list
the choices you made so the user can change any of them in one sentence.
## Always ask these two questions first (one short message, before any work)
1. **"Is this the full raw video, or the takes you already chose, put together in one video?"**
- **Full raw video:** you pick the takes (step 2 in full): drop retakes, false starts and filler, keep the
cleanest take of each line.
- **Chosen takes:** do NOT re-pick or reorder anything. Keep every line in their order. Only tighten the cuts
(trim dead air, clean edges), check the eyes at every cut, and add the editing.
2. **"Do you have a reference for the style? Send me screenshots (or the link) of a reel whose look you like."**
- If yes: study the screenshots and match their look: caption font, size, colour and position, title style,
colours, kind of graphics, how often the picture changes. Write what you took from them into `plan.json`
(`theme`, `captionTop`, overlay choices) and tell the user in one line what you are copying.
- If no: use this skill's default style.
If the user already answered either question in their message, do not ask it again.
The user is not an editor. Report progress in one plain line per step. No jargon in messages.
`S` = the folder this SKILL.md lives in. If `S/scripts/` is missing, first write every script from the
**Appendix** into `S/scripts/` exactly as given.
## The editing rules (check every one before delivery)
1. **Eyes on the lens in every face shot.** Eyes up, down or to the side = not usable. A blink is fine.
2. **Clean cuts.** No stray syllable of the next word, no tail of the previous take, no clipped word ending.
3. **Short pauses.** Cut dead air inside sentences. Leave a short breath (under 1 s) where a word was removed
and before each new section. A hard jump straight into the next sentence sounds rushed.
4. **Natural skin.** Tone-map HDR properly. Show the user stills of two or three grade options once, let them
pick, then never change the grade without showing stills again.
5. **One framing per sentence.** Never zoom at a hidden join inside one sentence, and never on the last line.
Punch-ins are fine between separate sentences or shots.
6. **Face on screen often.** Graphics are for the payoff, not every line. Keep the natural speaking speed
(speeding the voice up makes it sound rushed).
7. **Captions follow the picture.** Readable on whatever is behind them, switching style at the exact frame the
picture changes. Spelled right. Never under the app's bottom buttons.
8. **Every note from the previous version is fixed** (when this is a new version). Go through them one by one.
9. **Sound:** one steady level (-14 LUFS), effects under the voice, music (if any) well under the voice.
## Steps
### 0. Set up
- Make a project folder `reels/<short-slug>/` with `src/`, `assets/clips/`, `sheets/`, `renders/`, and copy
`S/assets/sfx/` and `S/assets/logos/` into its `assets/` folder (add any new logo the video needs).
- Write `package.json` there: `{"name":"reel","private":true,"type":"module"}`.
- Leave the raw footage where the user put it; never move or delete originals.
- Check free disk space: a render needs a few GB for its frame cache.
### 1. Probe and transcribe
- `ffprobe` each source: length, fps, rotation, `color_transfer` (`arib-std-b67` = iPhone HLG HDR, `smpte2084` =
HDR10; `make_clips.py` detects both and tone-maps).
- Audio: `ffmpeg -i SRC -vn -ac 1 -ar 16000 src/p1_16k.wav`, then
`python -I S/scripts/transcribe.py src/p1_16k.wav src/p1_words.json --lang ar` (use the spoken language).
- Long dead air or off-camera chatter at the start? Whisper can loop on silence. Transcribe only the stretches
where someone speaks: `--ranges 88-332,400-450`.
- Read the whole transcript. If there is a script, line it up against it. Captions follow what was actually said,
not the script.
### 2. Choose the story and the takes
- **Chosen-takes video:** skip take-hunting. Keep every line in the user's order; only find where each line
starts and ends, then go to step 3. Still run the eye check below at every cut point.
- **Full raw video:** keep the full message; drop retakes, false starts, filler and repeated lines. Aim for 40 to 60 s.
- A repeated line: use the cleanest take where the speaker looks at the lens the whole time. Note the pick.
- Check EVERY candidate stretch for look-aways: `bash S/scripts/gaze.sh SRC <start> <end> sheets/gaze_<n>.jpg`
and look at the sheet (source time is printed on every frame). A nice line is not usable if the eyes are off.
### 3. Set cut points
- Start from word times. Then snap each edge to the quietest 10 ms nearby:
`python -I S/scripts/quiet.py src/p1_16k.wav <time> <time> ...`
- Keep about 0.15 s after the last word (soft word endings sit below -30 dB and get clipped otherwise). Cut tight
before the next word.
- Inside one sentence, remove pauses longer than about 0.2 s by splitting the shot into sub-shots that keep the
same framing (rule 5).
- Whisper word times can drift about 0.4 s. For very short cuts, confirm on the loudness, not the word times.
### 4. Write plan.json (the edit decision list)
```json
{
"title": "Example reel",
"language": "ar",
"grade": "natural",
"theme": { "dark": "#141414", "accent": "#6D28D9", "light": "#C4B5FD" },
"sources": { "p1": "C:/Videos/raw/IMG_0001.MOV" },
"shots": [
{ "src": "p1", "in": 12.30, "out": 14.10, "zoom": false },
{ "src": "p1", "in": 15.02, "out": 18.40, "zoom": true }
],
"captions": [
{ "shot": 0, "text": "I never *opened* an editing app" },
{ "shot": 1, "text": "عملتله edit كله بـ *Claude*" }
],
"overlays": [
{ "type": "wall", "shot": 0, "text": "ZERO<br>EDITING", "font": "sans" },
{ "type": "logos", "shot": 1, "items": ["claude.svg"] }
]
}
```
- `shots` in order. **Framing:** alternate wide and punch-in (`zoom: true` = slow push in) at sentence or shot
changes, never at a hidden join (rule 5). Full-body standing shots: never zoom (the push crops the head).
- `captions`: each lasts until the next starts (or `dur`). `from` = seconds into the shot. Mark ONE word per card
with `*word*` (highlighted in the accent colour).
- `overlays`, each `{type, shot, from?, shots?|dur?}`, lasting to the end of its shot unless `shots`/`dur`:
- `wall` `{text, font: "sans"|"serif"}` big title in the empty space above the head. Hook and key phrases.
- `chat` `{label, prompt}` a typed prompt bubble, when the speaker describes asking an AI something.
- `icons` `{items: [{emoji, label}], cross: true}` the old way, crossed out in red.
- `logos` `{items: ["file.svg", ...]}` tool logos popping in with arrows between them (files in `assets/logos`).
- `inset` `{label}` picture-in-picture of the same moment ungraded (the "raw footage" look).
- `end` `{title, serif}` dark end card with the last shot framed in a card. Once, on the last line.
- Optional: `music {file, volume: 0.12}`; `sfx: false` mutes effects; `cutWhoosh: true` adds a soft whoosh on
framing changes; `captionTop` (default 1300 px) to move captions; `theme` for the user's brand colours.
- Density: one overlay per one or two shots, face visible often (rule 6).
**Caption rules:**
- Write exactly what was said, in the speaker's own register (colloquial stays colloquial, never "corrected" into
formal language).
- Mixed languages (for example Arabic with English tech words): English words stay in Latin letters and go at the
END of a mixed card or on their own card, never buried in the middle. A pure-English card runs left to right.
- Short cards: 2 to 5 words, one line. Spell-check every card.
- Keep captions above the bottom ~300 px (Instagram's caption and buttons cover that area). If a caption covers
the face on a shot, move it lower, still above that line.
### 5. Cut, then verify the clips
- `python -I S/scripts/make_clips.py reels/<slug>` (cuts all; pass shot numbers to redo only some).
`grade`: `"natural"` (tone-map only) or `"less-red"` (slightly less saturation and red, for skin that looks too red).
- `python -I S/scripts/verify_clips.py reels/<slug>`: each clip's own transcript must start and end on the right
words. Look at every face sheet in `sheets/verify/`. Fix the plan and recut until clean.
- **Split-second look-away at the start or end of a needed line:** hold the first (or last) on-lens frame over it.
Sound stays untouched, so sync is kept. For a look-away in the first D seconds of clip `sNN.mp4`:
`ffmpeg -i sNN.mp4 -vf "trim=start=D,setpts=PTS-STARTPTS,tpad=start_mode=clone:start_duration=D" -c:a copy -c:v libx264 -crf 17 -g 30 -keyint_min 30 -pix_fmt yuv420p sNN_fixed.mp4`
(last D seconds: `trim=end=<length-D>,tpad=stop_mode=clone:stop_duration=D`). Redo this after every recut.
- If the eyes are off in every take of a line, drop the line or tell the user; do not hide a look-away.
- Voice muffled or noisy beyond the light cleanup in make_clips? Clean the source audio first, then remux it onto
the original picture (`ffmpeg -i orig.MOV -i clean.wav -map 0:v -map 1:a -c:v copy -c:a aac out.mov`).
### 6. Build and check
- `node S/scripts/build.mjs reels/<slug>` writes `index.html`. Then inside the project:
`npx --yes hyperframes@0.8.105 check`. Zero Lint, Runtime and Layout errors required. Contrast flags on white
titles over bright footage and the "nested structure" / sound-effect length warnings are expected: judge
contrast by eye in the stills instead.
- Never write Arabic (or any joined script) with ffmpeg `drawtext`: the letters break. Text lives only in the
composition.
- Every `<video>`/`<audio>` needs an `id` (build.mjs does it). Do not wrap a timed video inside a timed div (the
check fails); build.mjs uses untimed wrappers for the inset and end card.
- If overlays land on the face (common on standing shots, where the head sits high), patch their `top` lower in
a small post-build step for those shots.
### 7. Preview stills first (ALWAYS, before EVERY render)
Never start a render, not even a re-render for a small fix, until the user has seen the preview stills and said
yes. Before each render, send the user ONE message with:
- a still of every shot in order, with its time and the caption that sits on it (take stills from the cut clips,
or from HyperFrames' preview/snapshot command; see `npx --yes hyperframes@0.8.105 --help`),
- the titles and graphics planned for each shot,
- the takes you dropped and why (full raw video only),
- if they sent a reference: one line on what you matched from it.
Wait for a clear yes. The user answers in plain words ("tighter cut on shot 4", "bigger subtitles", "use the
other take"). Apply the changes and show stills again for what changed, then wait for the yes again.
### 8. Render
- `bash S/scripts/render.sh reels/<slug> <slug>-v1`, in the background (renders take minutes: on a modest 2-core
laptop a 60 s reel took about 12 minutes).
- If it fails with `VIDEO_SOURCE_UNRENDERABLE`, just rerun: the frame cache fills more each try.
- With music: render once WITHOUT music (`<slug>-v1-nomusic`) and mix the music on afterwards (below), so a
music-level change takes a minute instead of a full re-render.
### 9. Check the result yourself (before the user sees it)
- `bash S/scripts/stills.sh reels/<slug> reels/<slug>/renders/<slug>-v1.mp4` and look at `renders/check/sheet.jpg`
plus every still (one just after each picture change).
- Go through the 9 rules one by one and confirm each in a still or a transcript.
- `ffprobe` shows an audio stream and `color_primaries=bt709`.
### 10. Deliver
- Send the final file. Message: one line on what it is, the takes and overlays you chose, anything you could not
fix, and what the user can ask for next.
## Style notes (what makes it look edited, not cut)
- Opening hook: optionally cut the speaker out (a person-segmentation model such as `rembg` with the
`u2net_human_seg` model gives a black-and-white mask video) and place them on a solid brand colour with huge
words behind the head. Composite with ffmpeg:
`ffmpeg -i graded.mp4 -i mask.mp4 -f lavfi -i color=c=0x6D28D9:s=1080x1920:r=30 -filter_complex "[1:v]format=gray[m];[0:v][m]alphamerge[fg];[2:v][fg]overlay=shortest=1[v]" -map "[v]" -map 0:a? -c:v libx264 -crf 17 -g 30 -keyint_min 30 -pix_fmt yuv420p comp.mp4`
- Transitions: a light swish or a soft ting on every other framing change, alternating, never both at once.
- Music: a quiet royalty-free bed that dips under the voice ("ducking"). Starting values, tune by ear:
`ffmpeg -i reel-nomusic.mp4 -stream_loop -1 -i music.mp3 -filter_complex "[0:a]asplit=2[v1][v2];[1:a]volume=0.35[m];[m][v1]sidechaincompress=threshold=0.03:ratio=8:attack=20:release=400[d];[v2][d]amix=inputs=2:duration=first:normalize=0,loudnorm=I=-14:TP=-1.5:LRA=11[a]" -map 0:v -map "[a]" -c:v copy -c:a aac -b:a 192k -movflags +faststart reel.mp4`
- Brand colours live in the graphics (caption box, highlight, end card), never as a colour wash over the face.
## Appendix: helper scripts (write these into S/scripts/)
### transcribe.py
```python
"""Windowed faster-whisper transcription with word times (whole-file runs can skip stretches).
Usage: python -I transcribe.py <in16k.wav> <out.json> [--lang ar] [--win 24] [--model small] [--ranges 10-60,80-120]"""
import argparse, json, sys, wave
import numpy as np
from faster_whisper import WhisperModel
sys.stdout.reconfigure(encoding="utf-8")
ap = argparse.ArgumentParser()
ap.add_argument("src"); ap.add_argument("out")
ap.add_argument("--lang", default="en"); ap.add_argument("--win", type=float, default=24.0)
ap.add_argument("--model", default="small"); ap.add_argument("--ranges", default="")
a = ap.parse_args()
OVL = 2.0
w = wave.open(a.src, "rb")
sr = w.getframerate()
pcm = np.frombuffer(w.readframes(w.getnframes()), dtype=np.int16).astype(np.float32) / 32768
dur = len(pcm) / sr
model = WhisperModel(a.model, device="cpu", compute_type="int8")
spans = [tuple(map(float, r.split("-"))) for r in a.ranges.split(",") if r] or [(0.0, dur)]
words, wins = [], []
for lo, hi in spans:
t = lo
while t < hi:
s0, s1 = t, min(hi, t + a.win)
segs, _ = model.transcribe(pcm[int(s0 * sr):int(s1 * sr)], language=a.lang, word_timestamps=True,
vad_filter=False, condition_on_previous_text=False)
text = []
for s in segs:
text.append(s.text.strip())
for x in s.words or []:
st = round(s0 + x.start, 3)
if words and st < words[-1]["end"] - 0.05: # already covered by the window overlap
continue
words.append({"start": st, "end": round(s0 + x.end, 3), "word": x.word.strip()})
wins.append({"start": round(s0, 2), "end": round(s1, 2), "text": " ".join(text)})
print(f"[{s0:6.1f}-{s1:6.1f}] {' '.join(text)}", flush=True)
t = s1 - OVL if s1 < hi else hi
json.dump({"language": a.lang, "duration": dur, "words": words, "windows": wins},
open(a.out, "w", encoding="utf-8"), ensure_ascii=False, indent=1)
print("words", len(words))
```
### quiet.py
```python
"""Snap cut times to the quietest 10 ms within +-0.12 s. Usage: python -I quiet.py <in16k.wav> <t1> <t2> ..."""
import sys, wave
import numpy as np
w = wave.open(sys.argv[1], "rb")
sr = w.getframerate()
pcm = np.frombuffer(w.readframes(w.getnframes()), dtype=np.int16).astype(np.float32) / 32768
STEP, SPAN = 0.01, 0.12
for arg in sys.argv[2:]:
t, best = float(arg), None
for k in range(-int(SPAN / STEP), int(SPAN / STEP) + 1):
c = t + k * STEP
i, j = int(c * sr), int((c + STEP) * sr)
if i < 0 or j > len(pcm):
continue
db = 20 * np.log10(np.sqrt(np.mean(pcm[i:j] ** 2)) + 1e-9)
if best is None or db < best[1]:
best = (c, db)
print(f"{t:.3f} -> {best[0]:.3f} ({best[1]:.1f} dB)")
```
### gaze.sh
```bash
#!/bin/bash
# gaze.sh <src> <start> <end> <out.jpg> [fps] -> contact sheet, source time printed on every frame
SRC="$1"; A="$2"; B="$3"; OUT="$4"; FPS="${5:-4}"
if [ -z "$FONT" ]; then
if [ -f /c/Windows/Fonts/arial.ttf ]; then FONT='C\:/Windows/Fonts/arial.ttf'
elif [ -f /System/Library/Fonts/Supplemental/Arial.ttf ]; then FONT=/System/Library/Fonts/Supplemental/Arial.ttf
else FONT=/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf; fi
fi
D=$(awk "BEGIN{print $B-$A}")
N=$(awk "BEGIN{n=($B-$A)*$FPS; print (n==int(n))?n:int(n)+1}")
COLS=10; ROWS=$(( (N + COLS - 1) / COLS ))
ffmpeg -v error -y -ss "$A" -i "$SRC" -t "$D" -vf "fps=$FPS,scale=160:-2,drawtext=fontfile='$FONT':text='%{eif\:t+$A\:d}.%{eif\:mod((t+$A)*10\,10)\:d}':x=4:y=4:fontsize=20:fontcolor=yellow:box=1:boxcolor=black@0.7,tile=${COLS}x${ROWS}" -frames:v 1 "$OUT"
```
### make_clips.py
```python
"""Cuts every shot in plan.json into assets/clips/sNN.mp4: HDR -> SDR bt709, 1080x1920, 30 fps constant,
keyframe every 30 frames (HyperFrames seeks fail on sparse keyframes), light voice cleanup and 10/15 ms fades so
no cut clicks. Writes sNN_raw.mp4 (ungraded) for any shot an inset uses, and clips.json with real lengths.
Usage: python -I make_clips.py <project_dir> [shot numbers...]"""
import json, os, subprocess, sys
sys.stdout.reconfigure(encoding="utf-8")
ROOT = os.path.abspath(sys.argv[1])
only = set(sys.argv[2:])
plan = json.load(open(os.path.join(ROOT, "plan.json"), encoding="utf-8"))
OUT = os.path.join(ROOT, "assets", "clips")
os.makedirs(OUT, exist_ok=True)
TONEMAP = ("zscale=t=linear:npl=100,format=gbrpf32le,zscale=p=bt709,tonemap=tonemap=hable:desat=0,"
"zscale=t=bt709:m=bt709:r=tv,format=yuv420p,")
GRADES = {"natural": "", "less-red": "eq=saturation=0.88,colorbalance=rm=-0.03,"}
FRAME = "scale=1080:1920:force_original_aspect_ratio=increase,crop=1080:1920,setsar=1,fps=30"
VENC = ["-c:v", "libx264", "-preset", "medium", "-crf", "17", "-pix_fmt", "yuv420p", "-g", "30", "-keyint_min", "30",
"-sc_threshold", "0", "-colorspace", "bt709", "-color_primaries", "bt709", "-color_trc", "bt709"]
AENC = ["-c:a", "aac", "-b:a", "192k", "-ar", "48000", "-ac", "2"]
def probe(path, entry):
r = subprocess.run(["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries", entry,
"-of", "csv=p=0", path], capture_output=True, text=True)
return r.stdout.strip()
def length(path):
r = subprocess.run(["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", path],
capture_output=True, text=True)
return round(float(r.stdout.strip()), 3)
grade = GRADES[plan.get("grade", "natural")]
hdr = {k: probe(v, "stream=color_transfer") in ("arib-std-b67", "smpte2084") for k, v in plan["sources"].items()}
inset_shots = {o["shot"] for o in plan.get("overlays", []) if o["type"] == "inset"}
lens_path = os.path.join(ROOT, "clips.json")
lens = json.load(open(lens_path, encoding="utf-8")) if os.path.exists(lens_path) else {}
for i, s in enumerate(plan["shots"]):
if only and str(i) not in only:
continue
src = plan["sources"][s["src"]]
dur = round(s["out"] - s["in"], 3)
af = "highpass=f=80,afftdn=nf=-25,aresample=48000,afade=t=in:d=0.01,afade=t=out:st=%.3f:d=0.015" % max(0, dur - 0.015)
vf = (TONEMAP + grade if hdr[s["src"]] else "format=yuv420p," + grade) + FRAME
f = os.path.join(OUT, f"s{i:02d}.mp4")
subprocess.run(["ffmpeg", "-v", "error", "-y", "-ss", str(s["in"]), "-t", str(dur), "-i", src,
"-map", "0:v:0", "-map", "0:a:0", "-vf", vf, "-af", af] + VENC + AENC + [f], check=True)
lens[f"s{i:02d}"] = length(f)
if i in inset_shots:
raw = (TONEMAP if hdr[s["src"]] else "format=yuv420p,") + FRAME
subprocess.run(["ffmpeg", "-v", "error", "-y", "-ss", str(s["in"]), "-t", str(dur), "-i", src,
"-map", "0:v:0", "-an", "-vf", raw] + VENC + [os.path.join(OUT, f"s{i:02d}_raw.mp4")],
check=True)
print(f"s{i:02d} {s['src']} {s['in']:.2f}-{s['out']:.2f} -> {lens[f's{i:02d}']}s", flush=True)
json.dump(lens, open(lens_path, "w", encoding="utf-8"), indent=1)
print("clips:", len(lens), "total", round(sum(lens.values()), 2), "s")
```
### verify_clips.py
```python
"""Transcribes every cut clip on its own and prints it next to its captions, so a stray syllable or a clipped word
at either end shows up (rule 2). Writes an 8 fps face sheet per clip to sheets/verify/ (rule 1).
Usage: python -I verify_clips.py <project_dir> [shot numbers...]"""
import json, os, re, subprocess, sys
from faster_whisper import WhisperModel
sys.stdout.reconfigure(encoding="utf-8")
def font():
if os.environ.get("FONT"):
return os.environ["FONT"]
if os.name == "nt":
return "C\\:/Windows/Fonts/arial.ttf"
if sys.platform == "darwin":
return "/System/Library/Fonts/Supplemental/Arial.ttf"
return "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"
ROOT = os.path.abspath(sys.argv[1])
only = set(sys.argv[2:])
plan = json.load(open(os.path.join(ROOT, "plan.json"), encoding="utf-8"))
lens = json.load(open(os.path.join(ROOT, "clips.json"), encoding="utf-8"))
os.makedirs(os.path.join(ROOT, "sheets", "verify"), exist_ok=True)
m = WhisperModel("small", device="cpu", compute_type="int8")
lang = plan.get("language", "en")
for i, s in enumerate(plan["shots"]):
if only and str(i) not in only:
continue
name = f"s{i:02d}"
f = os.path.join(ROOT, "assets", "clips", name + ".mp4")
segs, _ = m.transcribe(f, language=lang, word_timestamps=True, vad_filter=False, condition_on_previous_text=False)
ws = [(round(w.start, 2), round(w.end, 2), w.word.strip()) for sg in segs for w in (sg.words or [])]
heard = " ".join(w[2] for w in ws)
edge = f"first word at {ws[0][0]:.2f}s, last ends {ws[-1][1]:.2f}s of {lens[name]:.2f}s" if ws else "NO SPEECH"
caps = " | ".join(re.sub(r"\*", "", c["text"]) for c in plan["captions"] if c["shot"] == i)
print(f"{name} heard: {heard}\n captions: {caps}\n [{edge}]", flush=True)
n = max(1, int(lens[name] * 8 + 0.999))
rows = (n + 11) // 12
subprocess.run(["ffmpeg", "-v", "error", "-y", "-i", f, "-vf",
f"fps=8,crop=1080:1100:0:300,scale=150:-2,drawtext=fontfile='{font()}':"
f"text='{name} %{{eif\\:t*8\\:d}}':x=3:y=3:fontsize=16:fontcolor=yellow:box=1:boxcolor=black@0.7,"
f"tile=12x{rows}", "-frames:v", "1", os.path.join(ROOT, "sheets", "verify", name + ".jpg")])
print("face sheets in", os.path.join(ROOT, "sheets", "verify"))
```
### build.mjs
```js
// Turns plan.json + clips.json into the HyperFrames index.html. The whole look lives here: jump cuts alternating
// wide and punch-in, a one-line caption in a small dark box with one highlighted word, big titles above the head,
// a typed chat-prompt bubble, crossed-out icons, logo pops, a raw-footage inset, and an end card.
// Usage: node build.mjs <project_dir>
import fs from "fs";
import path from "path";
const DIR = path.resolve(process.argv[2] || ".");
const plan = JSON.parse(fs.readFileSync(path.join(DIR, "plan.json"), "utf8"));
const lens = JSON.parse(fs.readFileSync(path.join(DIR, "clips.json"), "utf8"));
const C = { dark: "#141414", accent: "#6D28D9", light: "#C4B5FD", red: "#E0352B", ...(plan.theme || {}) };
const W = 1080, H = 1920, CAP_TOP = plan.captionTop || 1300;
const r = (n) => Math.round(n * 1000) / 1000;
const pad = (i) => String(i).padStart(2, "0");
let t = 0;
const shots = plan.shots.map((s, i) => { const d = lens[`s${pad(i)}`]; const o = { ...s, f: `s${pad(i)}`, d, at: t }; t += d; return o; });
const END = r(t);
const S = (i) => (i >= shots.length ? END : shots[i].at);
const win = (o) => { const a = S(o.shot) + (o.from || 0); const b = o.dur ? a + o.dur : S(o.shot + (o.shots || 1)); return [r(a), r(b)]; };
const RTL = /[\u0590-\u08FF]/;
const esc = (s) => s.replace(/&/g, "&").replace(/</g, "<");
const hi = (s) => esc(s).replace(/\*([^*]+)\*/g, "<em>$1</em>");
const dirOf = (s) => (RTL.test(s) ? "rtl" : "ltr");
const caps = plan.captions.map((c, i) => {
const a = S(c.shot) + (c.from || 0);
const next = plan.captions[i + 1];
const b = c.dur ? a + c.dur : next ? S(next.shot) + (next.from || 0) : END;
return { a: r(a), b: r(b), text: c.text };
});
const endO = (plan.overlays || []).find((o) => o.type === "end");
const endAt = endO ? win(endO)[0] : Infinity;
const body = [], a = [], sfx = [];
body.push(`<div id="vidBox" data-layout-allow-overflow>${shots.map((s, i) => `<video id="v${i}" class="clip shot${s.zoom ? " zoom" : ""}" src="assets/clips/${s.f}.mp4" data-start="${r(s.at)}" data-duration="${r(s.d)}" data-media-start="0" data-track-index="0" muted playsinline></video>`).join("")}</div>`);
shots.forEach((s, i) => { if (s.zoom) a.push(`tl.fromTo("#v${i}",{scale:1.32},{scale:1.4,duration:${r(s.d)},ease:"none"},${r(s.at)});`); });
(plan.overlays || []).forEach((o, k) => {
const [st, en] = win(o);
const id = `o${k}`;
const timed = `data-start="${st}" data-duration="${r(en - st)}" data-track-index="4"`;
if (o.type === "wall") {
const font = o.font === "serif" ? "serif" : "sans";
body.push(`<div id="${id}" class="clip wall" ${timed}><div class="big ${font}" dir="${dirOf(o.text)}">${o.text}</div></div>`);
a.push(font === "sans" ? `tl.fromTo("#${id} .big",{scale:1.25,opacity:0},{scale:1,opacity:1,duration:0.28,ease:"power3.out"},${st});`
: `tl.fromTo("#${id} .big",{y:30,opacity:0},{y:0,opacity:1,duration:0.3,ease:"power3.out"},${st});`);
sfx.push(["whoosh", st, 0.22]);
} else if (o.type === "icons") {
body.push(`<div id="${id}" class="clip icons" ${timed}>${o.items.map((it, j) => `<div class="ic" id="${id}i${j}"><span>${it.emoji}</span>${o.cross ? "<i></i>" : ""}<b dir="${dirOf(it.label)}">${esc(it.label)}</b></div>`).join("")}</div>`);
o.items.forEach((_, j) => { a.push(`tl.fromTo("#${id}i${j}",{scale:0},{scale:1,duration:0.25,ease:"back.out(2.4)"},${r(st + j * 0.25)});`); sfx.push(["pop", r(st + j * 0.25), 0.35]); });
if (o.cross) a.push(`tl.fromTo("#${id} i",{scaleX:0},{scaleX:1,duration:0.2,ease:"power2.out",stagger:0.1},${r(st + (o.crossAt ?? 0.9))});`);
} else if (o.type === "chat") {
body.push(`<div id="${id}" class="clip chat" ${timed}><div class="chatIn"><small>${esc(o.label || "CLAUDE")}</small><div class="row"><div class="typed" dir="${dirOf(o.prompt)}"><span id="${id}t"></span><u></u></div><div class="send">↑</div></div></div></div>`);
a.push(`tl.fromTo("#${id} .chatIn",{y:-40,opacity:0},{y:0,opacity:1,duration:0.25,ease:"power3.out"},${st});`);
const typeDur = r(Math.min(1.9, Math.max(0.6, en - st - 0.6)));
a.push(`(()=>{const p=${JSON.stringify(o.prompt)},c={n:0};tl.to(c,{n:p.length,duration:${typeDur},ease:"none",onUpdate:()=>{document.getElementById("${id}t").textContent=p.slice(0,Math.round(c.n));}},${r(st + 0.2)});})();`);
sfx.push(["pop", st, 0.3]);
} else if (o.type === "logos") {
const parts = [];
o.items.forEach((f, j) => { if (j) parts.push(`<div class="arrow" id="${id}a${j}">→</div>`); parts.push(`<div class="lg" id="${id}l${j}"><img src="assets/logos/${f}" alt=""/></div>`); });
body.push(`<div id="${id}" class="clip logos" ${timed}>${parts.join("")}</div>`);
o.items.forEach((_, j) => {
const at = r(st + 0.05 + j * 0.45);
if (j) a.push(`tl.fromTo("#${id}a${j}",{opacity:0,x:-30},{opacity:1,x:0,duration:0.25,ease:"power2.out"},${r(at - 0.2)});`);
a.push(`tl.fromTo("#${id}l${j}",{scale:0,rotation:${j % 2 ? 12 : -12}},{scale:1,rotation:0,duration:0.3,ease:"back.out(2.4)"},${at});`);
sfx.push(["pop", at, 0.35]);
});
} else if (o.type === "inset") {
// untimed wrapper (a timed wrapper around a timed video breaks the check); shown and hidden on the timeline
body.push(`<div id="${id}" class="pip" data-layout-allow-occlusion><video id="${id}v" class="clip" src="assets/clips/s${pad(o.shot)}_raw.mp4" data-start="${st}" data-duration="${r(en - st)}" data-media-start="${r(o.from || 0)}" data-track-index="1" muted playsinline></video>${o.label ? `<div class="pipTag" dir="${dirOf(o.label)}">${esc(o.label)}</div>` : ""}</div>`);
a.push(`tl.fromTo("#${id}",{scale:0.6,opacity:0},{scale:1,opacity:1,duration:0.28,ease:"power3.out",immediateRender:false},${st});`);
a.push(`tl.set("#${id}",{opacity:0},${en});`);
sfx.push(["pop", st, 0.3]);
} else if (o.type === "end") {
const sh = shots[o.shot];
body.push(`<div id="end"><div class="endTitle sans" dir="${dirOf(o.title)}">${o.title}</div>${o.serif ? `<div class="endSerif serif" dir="${dirOf(o.serif)}">${o.serif}</div>` : ""}<div class="card"><video id="endv" class="clip" src="assets/clips/${sh.f}.mp4" data-start="${st}" data-duration="${r(en - st)}" data-media-start="${r(o.from || 0)}" data-track-index="2" muted playsinline></video></div></div>`);
a.push(`tl.set("#end",{opacity:1},${st});`);
a.push(`tl.fromTo("#end .card",{scale:1.6},{scale:1,duration:0.45,ease:"power3.out"},${st});`);
a.push(`tl.fromTo("#end .endTitle, #end .endSerif",{y:24,opacity:0},{y:0,opacity:1,duration:0.3,ease:"power3.out",stagger:0.12},${r(st + 0.15)});`);
sfx.push(["whoosh", st, 0.3]);
}
});
// captions: dark box over the video; light box with dark text over the dark end card (rule 7)
caps.forEach((c, i) => {
if (!c.text) return;
const parts = c.a < endAt && c.b > endAt ? [[c.a, endAt, ""], [endAt, c.b, " light"]] : [[c.a, c.b, c.a >= endAt ? " light" : ""]];
parts.forEach(([p, q, cls], j) => {
body.push(`<div id="cap${i}_${j}" class="clip cap${cls}" data-start="${r(p)}" data-duration="${r(q - p)}" data-track-index="6"><div class="capIn" dir="${dirOf(c.text)}">${hi(c.text)}</div></div>`);
if (j === 0) a.push(`tl.fromTo("#cap${i}_0 .capIn",{y:10,opacity:0},{y:0,opacity:1,duration:0.14,ease:"power2.out"},${r(p)});`);
});
});
// sound: the voice from each clip, effects under it, optional music bed
const aud = (id, src, start, dur, track, vol) => `<audio id="${id}" src="${src}" data-start="${r(start)}" data-duration="${r(dur)}" data-media-start="0" data-track-index="${track}" data-volume="${vol}"></audio>`;
shots.forEach((s, i) => body.push(aud(`h${i}`, `assets/clips/${s.f}.mp4`, s.at, s.d, 10, 1)));
shots.forEach((s, i) => { if (i && !(plan.overlays || []).some((o) => Math.abs(win(o)[0] - s.at) < 0.3) && s.zoom !== shots[i - 1].zoom && plan.cutWhoosh) sfx.push(["whoosh", s.at, 0.15]); });
if (plan.sfx !== false) sfx.sort((x, y) => x[1] - y[1]).forEach(([n, at, v], i) => body.push(aud(`sfx${i}`, `assets/sfx/${n}.wav`, at, 0.9, 12 + (i % 3), v)));
if (plan.music) body.push(aud("music", plan.music.file, 0, END, 16, plan.music.volume ?? 0.12));
a.push(`tl.set({}, {}, ${END});`);
const html = `<!doctype html>
<html lang="${plan.language || "en"}">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=${W}, height=${H}" />
<link rel="preconnect" href="https://fonts.googleapis.com">
<link href="https://fonts.googleapis.com/css2?family=Amiri:ital,wght@0,400;0,700;1,400&family=Anton&family=Playfair+Display:ital,wght@1,500&display=swap" rel="stylesheet">
<script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>
<style>
*{margin:0;padding:0;box-sizing:border-box}
html,body{width:${W}px;height:${H}px;overflow:hidden;background:#000}
#root{width:100%;height:100%;position:relative;overflow:hidden;background:#000}
#vidBox{z-index:1;position:absolute;inset:0;overflow:hidden}
.shot{position:absolute;inset:0;width:${W}px;height:${H}px;object-fit:cover;transform-origin:50% 48%}
.sans{font-family:"Anton",sans-serif;letter-spacing:.01em}
.serif{font-family:"Playfair Display",Georgia,serif;font-style:italic}
.wall{z-index:4;position:absolute;left:0;top:0;width:${W}px;height:640px;display:grid;place-items:center;pointer-events:none}
.big{color:#fff;text-align:center;text-shadow:0 6px 30px rgba(0,0,0,.5)}
.big.sans{font-size:170px;line-height:.95}
.big.serif{font-size:150px}
.cap{z-index:8;position:absolute;left:0;top:${CAP_TOP}px;width:${W}px;display:flex;justify-content:center;pointer-events:none}
.capIn{background:${C.dark};color:#fff;font-family:"Amiri",Georgia,serif;font-size:50px;line-height:1.25;padding:6px 22px 10px;border-radius:4px;max-width:960px;text-align:center}
.capIn em{font-style:normal;background:${C.accent};color:#fff;padding:0 10px 2px;border-radius:4px}
.cap.light .capIn{background:#fff;color:${C.dark}}
.cap.light .capIn em{background:${C.accent};color:#fff}
.icons{z-index:4;position:absolute;left:0;top:150px;width:${W}px;display:flex;justify-content:center;gap:70px}
.ic{position:relative;width:230px;height:230px;border-radius:52px;background:#fff;display:flex;flex-direction:column;align-items:center;justify-content:center;box-shadow:0 14px 40px rgba(0,0,0,.25)}
.ic span{font-size:110px;line-height:1}
.ic b{font-family:"Amiri",serif;font-size:34px;color:${C.dark};margin-top:6px}
.ic i{position:absolute;left:-14px;top:50%;width:258px;height:16px;margin-top:-8px;background:${C.red};border-radius:8px;transform:rotate(-38deg) scaleX(0);transform-origin:50% 50%}
.chat{z-index:4;position:absolute;left:0;top:170px;width:${W}px;display:flex;justify-content:center}
.chatIn{width:900px;background:#fff;border-radius:26px;padding:18px 24px 22px;box-shadow:0 16px 46px rgba(0,0,0,.3)}
.chatIn small{display:block;font-family:Arial,sans-serif;font-size:20px;letter-spacing:.12em;color:#6b6b6b;margin-bottom:8px}
.chatIn .row{display:flex;align-items:center;gap:18px}
.typed{flex:1;font-family:"Amiri",serif;font-size:46px;color:#151515;min-height:64px}
.typed[dir=rtl]{text-align:right}
.typed u{display:inline-block;width:3px;height:44px;background:#151515;vertical-align:middle;margin:0 4px;text-decoration:none}
.send{width:64px;height:64px;border-radius:50%;background:${C.accent};color:#fff;font-size:36px;display:grid;place-items:center;font-family:Arial,sans-serif}
.logos{z-index:4;position:absolute;left:0;top:190px;width:${W}px;display:flex;justify-content:center;align-items:center;gap:40px}
.lg{width:250px;height:250px;border-radius:56px;background:#fff;display:grid;place-items:center;box-shadow:0 14px 40px rgba(0,0,0,.25)}
.lg img{width:160px;height:160px;object-fit:contain}
.arrow{font-family:"Anton",sans-serif;font-size:120px;color:#fff;text-shadow:0 6px 24px rgba(0,0,0,.5)}
.pip{opacity:0;z-index:5;position:absolute;left:345px;top:120px;width:390px;height:694px;border:5px solid #fff;border-radius:18px;overflow:hidden;box-shadow:0 18px 50px rgba(0,0,0,.4)}
.pip video{position:absolute;inset:0;width:100%;height:100%;object-fit:cover}
.pipTag{position:absolute;left:50%;bottom:16px;transform:translateX(-50%);white-space:nowrap;background:${C.accent};color:#fff;font-family:"Amiri",serif;font-size:30px;padding:2px 16px 6px;border-radius:6px}
#end{opacity:0;z-index:6;position:absolute;inset:0;background:${C.dark}}
.endTitle{position:absolute;left:0;top:150px;width:${W}px;text-align:center;color:#fff;font-size:120px;line-height:.95}
.endSerif{position:absolute;left:0;top:385px;width:${W}px;text-align:center;color:${C.light};font-size:120px}
.card{position:absolute;left:330px;top:540px;width:420px;height:746px;border-radius:22px;overflow:hidden;border:4px solid ${C.accent};box-shadow:0 24px 60px rgba(0,0,0,.45)}
.card video{position:absolute;inset:0;width:100%;height:100%;object-fit:cover}
</style>
</head>
<body>
<div id="root" data-composition-id="main" data-start="0" data-duration="${END}" data-width="${W}" data-height="${H}">
${body.join("\n")}
</div>
<script>
const tl = gsap.timeline({ paused: true });
${a.join("\n")}
window.__timelines["main"] = tl;
tl.seek(0);
</script>
</body>
</html>`;
fs.writeFileSync(path.join(DIR, "index.html"), html);
console.log("index.html written:", END, "s,", shots.length, "shots,", caps.length, "captions,", (plan.overlays || []).length, "overlays,", sfx.length, "sound effects");
```
### render.sh
```bash
#!/bin/bash
# render.sh <project_dir> <name> -> renders/<name>-raw.mp4, then renders/<name>.mp4 with the sound levelled.
# Settings that render reliably: one worker, jpg frames, SDR, fast capture OFF (it can silently drop clipped
# fills such as progress bars). Long renders: run this in the background.
set -e
P="$(cd "$1" && pwd)"; NAME="$2"
mkdir -p "$P/renders/fcache"
PW="$P"; command -v cygpath >/dev/null && PW=$(cygpath -w "$P")
FREE_GB=$(df -Pk "$P" | awk 'NR==2{print int($4/1048576)}')
echo "free space: ${FREE_GB} GB"
[ "$FREE_GB" -lt 2 ] && { echo "STOP: under 2 GB free for the frame cache."; exit 2; }
npx --yes hyperframes@0.8.105 render "$PW" --workers 1 --video-frame-format jpg --sdr --no-experimental-fast-capture \
--frames-cache-dir "$PW/renders/fcache" -o "$PW/renders/$NAME-raw.mp4" 2>&1 | tail -4
# level the sound to -14 LUFS (Instagram/TikTok loudness), picture copied untouched
ffmpeg -v error -y -i "$P/renders/$NAME-raw.mp4" -c:v copy -af loudnorm=I=-14:TP=-1.5:LRA=11 -c:a aac -b:a 192k -ar 48000 \
-movflags +faststart "$P/renders/$NAME.mp4"
ffprobe -v error -show_entries stream=codec_type,width,height,color_primaries -show_entries format=duration -of compact "$P/renders/$NAME.mp4"
echo "DONE $P/renders/$NAME.mp4"
```
### stills.sh
```bash
#!/bin/bash
# stills.sh <project_dir> <video.mp4> -> renders/check/: a sheet of the whole reel plus one still just after every
# picture change (cut, overlay in or out, end card), time printed, for the final check.
P="$1"; V="$2"; O="$P/renders/check"; mkdir -p "$O"; rm -f "$O"/*.jpg
if [ -z "$FONT" ]; then
if [ -f /c/Windows/Fonts/arial.ttf ]; then FONT='C\:/Windows/Fonts/arial.ttf'
elif [ -f /System/Library/Fonts/Supplemental/Arial.ttf ]; then FONT=/System/Library/Fonts/Supplemental/Arial.ttf
else FONT=/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf; fi
fi
D=$(ffprobe -v error -show_entries format=duration -of csv=p=0 "$V")
ROWS=$(awk "BEGIN{n=$D*2/8; print (n==int(n))?n:int(n)+1}")
ffmpeg -v error -y -i "$V" -vf "fps=2,scale=180:-1,tile=8x$ROWS" -frames:v 1 "$O/sheet.jpg"
for t in $(node -e '
const h=require("fs").readFileSync(process.argv[1],"utf8");const ts=new Set();
for(const m of h.matchAll(/data-start="([\d.]+)"/g))ts.add(+m[1]);
for(const m of h.matchAll(/\},([\d.]+)\);/g))ts.add(+m[1]);
console.log([...ts].filter(x=>x<+process.argv[2]).sort((a,b)=>a-b).map(x=>(x+0.35).toFixed(2)).join(" "))' "$P/index.html" "$D"); do
ffmpeg -v error -y -ss "$t" -i "$V" -frames:v 1 -vf "scale=540:-1,drawtext=fontfile='$FONT':text='$t s':x=8:y=8:fontsize=24:fontcolor=yellow:box=1:boxcolor=black@0.7" "$O/t$t.jpg"
done
ls "$O" | wc -l
```
## Lessons learned the hard way
- Whole-file Whisper runs skip stretches and loop on long silence: transcribe in windows, and only where people speak.
- HyperFrames seeks fail on sparse keyframes: clips must be constant 30 fps with a keyframe every 30 frames.
- Fast capture can silently drop clipped shapes: always render with `--no-experimental-fast-capture`.
- Many clips can make frame extraction fail: one worker, and just rerun.
- iPhone video is HDR: without tone-mapping, skin turns orange-red and highlights blow out.
- Check eyes on EVERY stretch before writing the plan, then again on every cut clip. Look-aways hide in the first
and last few frames.
- Small fixes do not need a full re-render: re-render only the changed part, or remix music on the no-music file.
## Credits and third-party components
**Original work in this skill:** these instructions, the editing rules, the `plan.json` format and the helper
scripts in the Appendix. The scripts call the tools below but contain none of their code. The sound effects are
generated with FFmpeg during setup. The skill holds no credentials, private data or company information.
**Third-party components** (not included in this skill; installed by the user or loaded at run time, each under
its own licence, all free to use):
| Component | Made by | Licence | How this skill uses it |
|---|---|---|---|
| HyperFrames 0.8.105 | HeyGen | Apache-2.0 | builds and renders the video (run with `npx`) |
| GSAP 3.14.2 | GreenSock | GSAP Standard "no charge" license (gsap.com/standard-license) | animations, loaded from the jsDelivr CDN inside the composition |
| faster-whisper | SYSTRAN | MIT | transcription with word times |
| Whisper "small" model (faster-whisper-small) | OpenAI, converted by SYSTRAN | MIT | downloaded by faster-whisper on first use |
| CTranslate2 | OpenNMT | MIT | installed with faster-whisper |
| NumPy | NumPy developers | BSD-3-Clause (plus bundled permissive licences) | audio maths |
| FFmpeg | FFmpeg developers | LGPL 2.1 or later (some builds GPL) | cutting, colour, sound, stills |
| Node.js | Node.js contributors | MIT (plus bundled licences) | runs HyperFrames and build.mjs |
| Anton, Amiri, Playfair Display fonts | their type designers, via Google Fonts | SIL Open Font License 1.1 | caption and title fonts |
| rembg + U²-Net human segmentation model (optional) | Daniel Gatis; Xuebin Qin et al. | MIT; Apache-2.0 | only for the optional cut-out effect |
| Claude and Claude Code | Anthropic | Anthropic's terms of service | runs this skill |
| Tool logos the user adds | each brand | trademarks of their owners | use only official logos, only to name the tool |
**When you share or change this skill:** keep this section and every licence notice, mark your own changes as
yours, and check that any new component's licence allows sharing and commercial use. If a component's source or
licence is unknown, flag it for review before adding it.
===== SKILL.md ENDS ON THE LINE ABOVE =====
After the setup: what to say
- Edit this reel
- Make it look more professional
- Tighter cut on shot 4
- Bigger subtitles
- Use the second take of the last line
- Looks good, render it
One sentence at a time, like talking to an editor.
Tips for cleaner cuts
- Keep your eyes on the lens while you talk.
- Leave a short pause between sentences.
- Want it faster? Send one video that already holds only the takes you like.