Communitygithub.com

promo-video

Make a coin or product promo video (pre-launch, launch day, how-to or feature walkthrough, hype video, trailer, explainer) at the RIPPER standard (pre-launch v2, launch and claim films) in one session, with no multi-agent orchestration. Use when the user asks for a "promo video", "launch video", "hype video", "how-to video", "walkthrough", "trailer", "teaser", "make a video for the coin", "a video for X", or wants an existing promo re-cut, slowed down, refreshed or re-rendered. Fixed procedure on the coin-factory Remotion template - brief, proven structure per cut type, storyboard JSON with the pacing rules built in, frame-exact and real-time site captures, live figures, scenes checked against bar stills, synthesised music (hype or warm) on the beat, readability probe, automatic framing check, safe Windows renders with a chunked fallback, QA gates, delivery note. Handles dark and light brands.

Qu'est-ce que promo-video ?

promo-video is a Claude Code agent skill that make a coin or product promo video (pre-launch, launch day, how-to or feature walkthrough, hype video, trailer, explainer) at the RIPPER standard (pre-launch v2, launch and claim films) in one session, with no multi-agent orchestration. Use when the user asks for a "promo video", "launch video", "hype video", "how-to video", "walkthrough", "trailer", "teaser", "make a video for the coin", "a video for X", or wants an existing promo re-cut, slowed down, refreshed or re-rendered. Fixed procedure on the coin-factory Remotion template - brief, proven structure per cut type, storyboard JSON with the pacing rules built in, frame-exact and real-time site captures, live figures, scenes checked against bar stills, synthesised music (hype or warm) on the beat, readability probe, automatic framing check, safe Windows renders with a chunked fallback, QA gates, delivery note. Handles dark and light brands.

Compatible avec✓Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/kaylum54/promo-video-skill/tree/HEAD

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Promo video

The house standard is three RIPPER films, one per cut type (references/QUALITY-BAR.md "Reference set"): the pre-launch cut v2 (72 s, 90 bpm, chapter cut; the user: "genuinely incredible"), the launch cut after its framing fix (56 s, 90 bpm, BEFORE / LIVE / FIRE / VAULT / PROOF, a real rip filmed live) and the claim walkthrough (49 s, 112.5 bpm, warm music, a numbered how-to on a phone). The user, 13 Oct: use the revised videos as the standard. Their lessons are built in: the framing gate (cropped cards, crew sliding off plinths), films for one coin that differ in tempo, music and structure, and live figures plus a stale-facts list so a product change is a quick re-render. One agent at medium effort can follow this start to finish.

Paths

NamePath
SKILLThe folder this file is in, written <SKILL> in every command below. Claude Code prints it as "Base directory for this skill" when the skill loads; a default install is ~/.claude/skills/promo-video. Put the real absolute path in each command. Scripts are in SKILL/scripts/, references in SKILL/references/.
TEMPLATE<SKILL>/template (Remotion 4.0.528 project: brand kit, time map, music, captures, render and QA scripts)
REFThe three RIPPER reference films (<RIPPER repo>/design/promo/<prelaunch, launch or claim>). Their source is not in this repo. Wherever a step or reference points at a REF file, use what stands in for it: the bar stills (BAR), references/storyboard-example-ripper.json (the whole pre-launch v2 film, beat by beat), references/SCENE-PATTERNS.md (how each scene was built) and references/QUALITY-BAR.md. Once you have made a film with this skill, your own film's BRIEF.md and out/DELIVERY.md are the worked example.
BARSKILL/references/bar-stills/ (one RIPPER v2 frame per scene pattern, with a README on what to match)
PROJECT<coin repo>/design/promo/<cut> (your new film)

"The user" is whoever asked for the film. Quoted remarks are the owner's review notes on the RIPPER films.

Run every project command from PROJECT. Skill scripts are called by full path: node <SKILL>/scripts/<name>.mjs.

Ground rules (read before step 1)

  1. One agent, one render at a time. No workflows, no parallel builders. 16 GB RAM: two render tabs at most, and only one Remotion process on the machine. render, readability and framing stop with exit 3 while another agent's job runs: wait and poll, never kill it. Run it on Opus at medium effort. Visual work never goes to Sonnet (the user's rule).
  2. Look at stills with the Read tool on the PNG or JPG. Never the Browser pane: four RIPPER agents hung 2-4 h on its zoom call.
  3. The brief is the only source of facts. No number or claim on screen that is not in BRIEF.md or a live-data check dated this week.
  4. The film must play on mute. Pace for a newcomer who has never seen the product: one must-read line per beat, key lines held at least 1.5 s.
  5. Match the bar by looking at it. Code pointers tell you how RIPPER was built. The bar stills show what it looked like. Read the bar still before you build a scene and compare your stills with it after.
  6. Time-box polish. Each scene gets one build pass and at most two fix passes against its checklist. What is left goes on the polish list in DELIVERY.md. Assemble and render the whole film early.
  7. Safety. Never read ~/.<coin>/ or any key or wallet folder. Never start a coin's worker or backend with real secrets. No deploys, no X posting, no wallet actions. Read live sites GET-only, with no clicks or sign-in.
  8. Writing. Plain and short in the film and in every note. No "not X but Y", no em dashes, no hype adjectives. Hype comes from rhythm, motion and real numbers.
  9. Write JSON and scripts with the Write tool. Bash heredocs drop backslashes (capture regexes broke this way) and mangle quotes.
  10. Load remotion-best-practices only for the rule file you need (~/.claude/skills/remotion-best-practices/rules/<topic>.md). The template already follows them.

When to stop and use a bigger run instead: references/WHEN-TO-ESCALATE.md.

Two modes

  • Full film (the default): steps 1-16.
  • Pilot: for a brand that differs from RIPPER, build the hook and the first chapter, render them, and send them to the user before the other scenes. Use it when any of these is true: the site is light (theme: "light"), there is no crew or cast, the site has fewer than three pages worth capturing, or the user asked for a new look. The pilot runs steps 1-10 in full, then step 11 for Hook and the first chapter only, then 11.6. Say in BRIEF.md open decisions that this is a pilot. After the user's yes, carry on from step 11 with the other scenes.

The procedure

Sixteen steps. Each one ends on a check. Do not start a step until the check before it passes.

1. Intake

Find out for yourself first. Look in the coin's repo docs, code, config, the live API and the site. Ask the user only for decisions and things only the user knows, all in one message:

  • Which cut: pre-launch, launch day, or a feature cut. Ask for the must-hit points in the user's words and quote them in the brief. List the coin's earlier films yourself (<repo>/design/promo/*: tempo, music style, structure) for step 5.
  • Platforms. Default: X 16:9 only. Add 9:16 or 1:1 only if the user names a use (references/PLATFORMS.md).
  • Any rule the docs leave open: whether the launchpad can be named, whether a tag stays on, whether a contract address or date may appear (pre-launch: never), whether devnet or testnet footage may appear.
  • Whether the user wants to see the animatic (step 9) before scenes are built. The default is to send it and keep going.

Collect yourself, with a source for each item:

ItemWhere it usually is
Every mechanic with its numbersdocs (README, LAUNCH.md), config (deploy/*.vars), code (fees, crew, claims), the live /api/state
What is true before launch and what starts at launchconfig flags (RIPPER: MANUAL_ONLY=true made "LIVE" false)
Proof that exists todayreceipts, transactions and posts from the live API; quote the exact wording the brief allows
Verbatim poststhe live feed API; re-check them on render day
Site URL, how to serve the sample page, its statesweb/fixture.ts or similar; npx vite --port 53xx
Every page or view the storyboard may show, and how each renders with no wallet and no secretsthe router (src/pages/*, web/routes*) and each page's API calls. A page that needs the backend is served with vite and its API stubbed from fixtures (step 8).
Theme and brand tokensthe site CSS (web/styles/*.css, src/styles.css :root), brand.ts, and the coin-factory brand.json if one exists. Note whether the site is dark or light, and its hairline and accent-tint colours.
Fonts with their axes, the wordmark@fontsource-variable/* in the coin's node_modules (each package lists its axis files: wdth, wght or opsz), the wordmark's SVG or clip paths, a logo mark beside the name in the header. A system font stack has no package: pick the nearest open @fontsource-variable face and record the swap.
Signature movethe site's own transition or gesture code (RIPPER: the tear in web/stage/pack.ts). If the site has none, derive one from its chapter device (Handoff: the step bar's segment filling and then wiping the frame).
Chapter devicethe site's step bar, tabs, keycaps or nav chips
Graphics to matchexplainer, flywheel and fee graphics in design/announce/
Avatars and marksdesign/announce/x-accounts/final/ or the brand pack

Check: every row has a value and a file or URL. Any gap becomes an open decision in BRIEF.md.

2. Scaffold

node <SKILL>/scripts/new-promo.mjs <PROJECT>
cd <PROJECT>
npm ci

This copies TEMPLATE without node_modules, out or caches, and writes BRIEF.md from references/BRIEF-TEMPLATE.md and capture/jobs.json from the example. If the coin has Playwright in its own repo, set PLAYWRIGHT_FROM=<repo>/package.json. Otherwise run npm i -D [email protected] and npx playwright install chromium. The first kit or stills render downloads Chrome Headless Shell (about 113 MB) once; let it finish.

Check: npm run check passes, and public/fonts/ holds the woff2 files.

3. BRIEF.md

Fill every <...> in PROJECT/BRIEF.md. Use REF/BRIEF.md as the worked example. Copy mechanic wording from the docs and code. Mark everything that only runs after launch. List the live-data lines to re-check on render day, and fill "Facts that go stale" (every timing, count and site wording the product could change, with the frames that show it).

Check: about 6 KB. Every fact names its source. The hard rules list the launchpad and rival names to ban. The Signature move field names the move, where it comes from and where it is used (the hook exit, the drop, the end card); the check fails while it is empty. Any font swap is recorded. Open decisions are listed.

4. Brand kit

  1. If the coin has a coin-factory brand.json, run node scripts/from-brand.mjs <path>/brand.json. It also sets theme from the palette.
  2. Edit brand/tokens.json against the site CSS. Where the two disagree, the site wins. Set:
    • theme: dark or light, as the site is. A white or pale site is light.
    • the palette roles: bg, surface, surface2, fg, fg2, muted, mutedDim, one accent, accent2, highlight (set it to the accent if the site has no second colour), line (the site's hairline) and tint (the site's accent tint), all as hex;
    • the fonts, each with its axis (wdth by default; wght or opsz for a face with no width axis, with stretch: "100%"). npm ci warns with the axes a package has if the file is missing;
    • the wordmark: svg, or text with the site header's weight and tracking, plus mark (a square SVG under public/) if the header shows a logo mark beside the name;
    • the glyphs, and assets for avatars and marks.
  3. Run npm run kit. Read out/kit/Kit-f0000.png next to a screenshot of the live site.

Check (tick all):

  • The background and type colours match the site.
  • The display font, weight and tracking match the site's headings (a width axis only if the site uses one).
  • The accent is used only where the site uses it (RIPPER: lamp red for burn and LIVE only).
  • The wordmark matches the site header, mark included.
  • Light theme only: no dark cone, no grey vignette at the edges, no glow halo around type, keycaps look like the site's buttons.
  • Nothing reads as a different brand.

Fix and re-run until every box is ticked, at most three rounds. RIPPER needed four.

5. Choose the structure

Read references/STRUCTURES.md and pick by cut type: chapter cut (pre-launch, explainer; the default), launch cut (launch day: before / live / the event / the user action / proof), walkthrough (a how-to or feature cut: numbered steps on the site's own step device, warm music, 105-120 bpm), live-floor or crew-led. Fill in its beat sheet.

Vary the next film. The user found two RIPPER films that matched "feel the same". If the coin has earlier films, this one changes at least two of tempo, music style and structure, and uses the chapter device and signature move differently. Write the choice in BRIEF.md.

Whatever the structure, apply the grafts in STRUCTURES.md: each character carries one mechanic, set up in the hook and paid off later, money splits drawn to scale, a real receipt for proof, a recap line after the mechanics. A site step or progress device is both the chapter key and the HUD rail, shown once per frame.

Check: a beat sheet with one row per scene (role, beats, key line, mechanic, capture). Every BRIEF mechanic appears in exactly one chapter or step. The total is in BRIEF's length range. The signature move is placed where STRUCTURES.md says for that structure.

6. Storyboard

Write storyboard.json to references/STORYBOARD-SCHEMA.md with the Write tool. Copy the shape of references/storyboard-example-ripper.json: the RIPPER v2 film in this schema, with exact copy, visuals, sources, motion, sound and SFX per beat.

Set structure (the step 5 choice). Pacing rules (the lint enforces them):

  • 30 fps. At 90 bpm a beat is 20 frames and a bar 80; at 112.5 a beat is 16 and a bar 64. Scenes start on beats; chapters start on bar downbeats where possible.
  • Frame 0 is the thumbnail: lit, settled, and saying what the product does in 4 words or fewer. The what-is-it sentence is complete by 2.0 s, and the product name lands by the end of the hook (about 5.3 s).
  • One must-read line lands per beat. Slam lines are 6 words or fewer.
  • Hook lines need reading time. Any hook must-read line of 3 words or more needs 0.25 s a word + 0.5 s, like every line, and the lint fails it when short. One- and two-word slams that build one sentence across beats (RIPPER: FIVE AIs. / RIP / REAL GRADED / CARD PACKS.) can sit on single beats.
  • Key lines are every money split, odds figure, trigger rule, proof line and the end card. List them in keyLines. Plan each one's beats from this table, counting from the frame it lands to the frame it leaves (until):
Words in the lineNeeds settledBeats at 90 bpmBeats at 112.5 bpm
1-41.5 s34
51.75 s34
6-72.0-2.25 s45
8-102.5-3.0 s56
  • Scene sizes: hook 8 beats, character intro at least 3 beats each, mechanic chapter 10-15 beats, recap 5, proof 8, end card 6. The chapter key slam takes one beat.
  • Every beat of a mechanic or proof scene says what it shows in source: capture:<job>#<selector> when the site has that view, or code: <why the site has no such view> (code: chapter key slam, code: split drawn to scale, code: no burn happens before launch). A drawn card where the site has the page is a fail (QUALITY-BAR rubric 8). Name every capture in the scene's captures too.
  • Live figures (counts, a pot, the newest receipt) are written {{live.<name>}}, never typed in: copy live.config.example.json to live.config.json, list them, run node scripts/live-data.mjs (STORYBOARD-SCHEMA.md "Live figures").
  • music on every scene, plus a drop frame (35-65% in, on a bar downbeat) and an impact frame before the end card.
  • sfx on beats: one accent per visual hit. Every sound has a visual on the same frame.
  • The banned word list sometimes catches the site's own copy (Handoff's headline says "pump.fun coins"). Keep the ban. Rephrase on screen, or show the site's text only inside footage as (UI) ..., and record the choice in facts.
node <SKILL>/scripts/lint-storyboard.mjs --verbose

Check: 0 errors. Read the warnings and the list of short non-key lines. Fix anything you can, apart from one- and two-word slams under the per-word bar (RIPPER v2 shipped about 110 of those).

7. Fact and rules pass

This replaces the three adversarial checkers. It cost 1% of the RIPPER tokens and caught 49 issues. Go through every on-screen string with three lenses, flag when unsure, and fix or move the string to open decisions:

  1. Facts, against the code and live data, not only the brief. Is it true before launch? Does a config flag make it false (RIPPER: "LIVE." and "30 MIN NOW")? Do the odds or steps differ per machine? Is the claim conditional? Is a handle ours (RIPPER: "@rookie" was a stranger's real handle)?
  2. Hard rules. The lint covers the word list. You check the visuals: no "BUY" chip, no rising staircase or diagonal, no ascending pitch on tiers, no other logos, nothing AI-generated that shows licensed art, no "LIVE" on sample footage.
  3. Newcomer misreadings. Could a viewer read it as a promise of money, a reward for holding, or a wrong mechanic? The RIPPER catches show the pattern: "THE PRICE FALLS AS MARKET CAP GROWS" reads as the token price falling, "100% TO THE HOUSE" as devs keeping fees, "ANYONE CAN CLAIM ONE" alone as a free airdrop, a flared 20th tick as "every 20th pull hits", "the big one" as jackpot talk, a post showing $38.25 back on a $25 pack as profit. Jargon a newcomer will not know (devnet, escrow) gets a short gloss in a mono caption.

Write the results into storyboard.json: facts (claim plus source), preRenderChecks (live data to re-read on render day), openDecisions.

Check: every on-screen string traces to a facts entry. The lint still shows 0 errors.

8. Captures

Real footage of our own site is the edge. Capture it frame-exact, with masks applied at capture time.

  1. Serve the site locally (npx vite --port 53xx in the coin's repo). Use the live site GET-only.
    • A page that needs the backend, a wallet or secrets: serve the app with vite anyway and stub its API with the job's routes field, from fixture JSON in capture/fixtures/ written from the values BRIEF.md allows. Never start the worker with real secrets, and never read a secrets file to make a page render.
  2. Write one job per capture in capture/jobs.json with the Write tool (fields in capture/jobs.example.json): the desktop at 1920x1080 dpr 2, the phone at 375x812 dpr 3 for 9:16. Add a win60 window for slow-motion moments. Use css masks with visibility:hidden for sample dollar figures, feed columns and running counts. Add a leak pattern for figures that must never show, and rects for every selector a beat names (capture:<job>#<selector>) or that you will crop or match-cut to.
    • Masked areas must not read as empty boxes at hero size. Crop past them, put the film's type over them, or use replace to set a brief-backed value. A light UI shows a hidden figure as a white hole.
    • Hide the site's own sample or demo labels ("Example trade, not live data") when the film's corner tag is on, so the two never stack.
    • The capture browser reports the brand theme as its colour scheme. A job's scheme overrides it.
  3. node capture/record.cjs for all jobs, or node capture/record.cjs <name> for one.
  4. node capture/index.cjs, then paste its rows into public/captures/INDEX.md with one line per capture on what it shows and its tag. Allowed tags: SAMPLE PAGE, LIVE · MAINNET, MAINNET · BEFORE LAUNCH, FROM LAUNCH, DEVNET PREVIEW (or TESTNET), and AFTER for a staged feature (AFTER THE BETA). Devnet or testnet footage needs the user's yes: list it as an open decision until then.
  5. Any footage that did not come from record.cjs goes through node capture/reencode.mjs <file> (-g 15 -bf 0).
  6. A real event on the live site (a scheduled rip, a burn): a jobs.json entry with "realtime": true, then node capture/realtime.cjs <job> --at <ISO UTC>, started a few minutes early. Masks go in the job's css; anything left (a clock column) gets Footage hide or blurCols in the edit.
  7. UI states the sample page cannot reach (a flow behind a wallet): a states job and node capture/states.cjs <job>, every edit copied from the component's own words, tagged SAMPLE PAGE, listed in BRIEF.md as staged.
  8. Cut every capture to what the film uses once the storyboard is set: node capture/reencode.mjs <in> <out> --frames a-b for long or real-time takes, --crop w:h:x:y for bands of 4K captures, --scale 960 for blurred plates. A long take played from its middle made every whole-film probe die with "No frame found".

Check: every capture named in storyboard.json (scene captures and beat source) is recorded, and the lint shows no missing job. Each public/captures/<name>.json lists no problems and no leaked frames. Read three key-frame PNGs per job: no sample figure legible at hero size, no empty mask box, no doubled sample label, no third-party logo sharp, no real person's photo, no scrollbar or cursor. Stop the vite server.

9. Animatic (render the whole film now)

node <SKILL>/scripts/sync-scenes.mjs
npm run check
node scripts/stills.mjs Main16x9 out/animatic 1

sync-scenes.mjs maps every unbuilt scene to the Placeholder animatic: its beats slammed on their frames. Re-run it after each scene is built. Read the contact sheet out/animatic/Main16x9-sheet.png. If the user asked to see pace before the build, also render node scripts/render.mjs Main16x9 out/animatic-16x9.mp4 after step 10 and send it.

Check: the stills render with no error, and each chapter's text sits where the beat sheet says.

10. Music and mix

node <SKILL>/scripts/plan-music.mjs
node scripts/music.mjs && node scripts/mix.mjs

Pass --style warm for a walkthrough (steady groove, electric piano, a bell motif on the payoff) or keep the default hype (stabs, risers, the drop); the coin's last film's style counts against variety (step 5). plan-music.mjs writes audio/music.json sections from the scenes' music, a 16th of silence before drop and impact, and cues from the beats' sfx. Progression, motif and master stay as they are; change progression (4 chords) and motif per coin if you want a different key or hook. The RIPPER arrangement is in references/storyboard-example-ripper.json (music per scene) and in REF/public/audio/INDEX.md; the warm walkthrough used D Bm G A (claim/audio/music.json).

Check: music.mjs prints every one on its exact frame sample, about -14 LUFS, peak -1.4 dBFS or lower. If it warns that the limiter is working over 3 dB, lower the loudest cues by 2-3 dB. mix.mjs reports -14 ± 1 LUFS and -1.5 dBTP or lower. Re-run both after any change to timing, holds or cues.

11. Build scenes, one at a time

Order: Hook, End, then story order. The hook and end card carry the thumbnail and the loop. (Pilot: Hook, then the first chapter, then stop at 11.6.) For each scene:

  1. Read the bar still for its pattern first (references/bar-stills/README.md maps patterns to files). Then read its storyboard entry, its pattern in references/SCENE-PATTERNS.md (and "Light brands" there if the theme is light) and the RIPPER file the pattern points to.
  2. Write src/scenes/<Id>.tsx (and src/scenes/<Id>/ for parts). Export export const <Id>: React.FC<SceneProps>. Build every size and position with pick(layout, {...}) or LAYOUTS. Start from the brand kit components (src/brand/), and model the scene on src/scenes/Example.tsx. Must-read lines go through Line (never free-wrapping text), footage through Footage with its subjects in marks; put data-subject on every card, slab, phone or avatar you draw, and follow "Framing rules" in SCENE-PATTERNS.md. Play the footage each beat's source names; draw only what the source says is code:.
  3. node <SKILL>/scripts/sync-scenes.mjs && npm run check && node <SKILL>/scripts/lint-scenes.mjs <Id>
  4. Render the self-check stills: every 8th frame of the scene plus every beat's settled frame (local beat frame + 6), in one call:
    node scripts/stills.mjs Scene-<Id> out/s-<Id> 0 --check
    
    --check reads the beats from storyboard.json. Each call pays up to 45 s to bundle, so put every frame you need in one call (--at a,b,c adds frames). Read the contact sheet out/s-<Id>/Scene-<Id>-sheet.png for in-between artefacts, then the single beat + 6 stills. Only for the formats in BRIEF Platforms, also render the two busiest beats: node scripts/stills.mjs Scene-<Id>-9x16 out/s-<Id>-9x16 0 --at <two local frames>, and the same for -1x1.
  5. Read every beat still and tick the scene self-check below. Fix, re-render only the frames you changed, and tick again. Two fix passes at most. Anything left goes on the polish list.
  6. Pilot only: after Hook and the first chapter pass, run steps 12 and 13 on that stretch, adding --frames 0-<f> to the stills and the probe. f is the first chapter scene's endFrame - 1, plus 20 for every hold beat before it. Then render it: node scripts/render.mjs Main16x9 out/<coin>-pilot-16x9.mp4 --frames 0-<f>. Run G4 and G5 on it, send the user the mp4 and its stills, and wait for a yes before building the rest.

Scene self-check. This is what 21 critic reviews and the Handoff trial flagged most, in order. Every box must be ticked to ship the scene.

  • Bar match: put your settled still next to the bar still for the same pattern. Count depth planes (ground, footage or plate, subject, type, HUD). Yours has at least as many, and the subject is as large. If not, add a plane or scale up before ticking anything else. A frame that is mostly empty with one small subject in the middle fails.
  • Footage: every UI shown is the captured site. A drawn card is allowed only where the beat's source says code: and gives a reason.
  • Hygiene: no sample figure, page heading or half-cut page text legible; no copy that contradicts a fact (RIPPER: a "BUYBACK 85%" chip one beat before "80% OF THE SALE"); licensed art and grading labels small and soft; no empty mask box; no site sample label under our tag.
  • Tags: the right corner tag (28 px or more, top right) on every footage frame, covering every frame the mechanic shows.
  • No line mid-word: no still shows a typed line part-way. Captions and sub-labels type at 6 characters a frame or appear whole; a typed line is complete by beat + 6.
  • 9:16 and 1:1 (only if in Platforms): subjects re-composed for that frame; nothing must-read below y 1540 or above y 160 in 9:16; 54-64 px margins; no empty band over a quarter of the frame; nothing crosses the HUD rail.
  • Dwell: each line is sharp for its planned beats, and no hold ends a few frames after the line settles.
  • Framing: every subject (card, slab, card photo in footage, avatar, plinth, coin, pot) whole and inside a 5% margin for the whole shot, not just the beat frame: work out the crop from the subject's source box and the push's end scale. Overlays on a pushed plate (plates on plinths, labels) push with it (LampsStage in the RIPPER launch cut). 9:16 and 1:1 get their own crop or a second plate, never the 16:9 crop centred.
  • Clipping: no hero word cut by the frame edge on its settled frame (the slam frame itself may overshoot for up to 4 f). Clamp the slam start scale: min(1.28, (W - 64) / lineWidth).
  • Downbeats: the subject is visible and sharp on every beat frame; no white flash or blur on the first frame after a cut.
  • Motion on every hold: each shot held 0.5 s or more has a push of 1.00 to 1.10 or a sheen. Grain does not count (on a light theme it is nearly invisible, and freezedetect fails the hold).
  • Overlaps: never two must-read lines at once or the same words twice in a frame; no band through a numeral; no overlay on card art; the chapter device shown once per frame (in the rail or in the scene, not both).
  • Sizes: must-read lines 84 px (16:9), 64 px (1:1), 56 px (9:16); mono bonus lines 28-48 px.
  • Artefacts: no motion-blur ghost copies (check the 8-frame sheet), no clip-path seams, no posterised gradients.
  • Honesty: a selection or highlight moves once, to its final state, and never visits an option it does not keep (a highlight roaming 30, 45, 30 min reads as selected); no rising trajectory; direction matches the words.
  • Brand: colours from C/RGB, fonts from T, shadows through shadow(), the signature move where BRIEF.md places it (three uses at most), hard cuts on the beat, no cross-fades. Light theme: no dark halos or heavy keycap shadows.

Delete src/scenes/Example.tsx once the first real scene is built. After every third scene, run node scripts/stills.mjs Main16x9 out/film 1 and read the contact sheet. Seams and crashes only show in the assembled film (RIPPER's f720 crash did).

12. Full-film check (pilot: on the built stretch)

node <SKILL>/scripts/lint-scenes.mjs
node scripts/stills.mjs Main16x9 out/check 0.5
node scripts/stills.mjs Main9x16 out/check-9x16 1     # only if 9:16 is in Platforms
node scripts/stills.mjs Main1x1 out/check-1x1 1       # only if 1:1 is in Platforms

Read the contact sheets, then open single stills wherever a tile looks wrong. Run the scene self-check across scene boundaries. Frame 0 must be lit, settled and say what the product does.

Check: lint-scenes shows 0 errors, and no still shows a black, blank, broken or placeholder frame.

13. Readability probe and holds (pilot: on the built stretch)

node scripts/readability.mjs Main16x9 --concurrency 1

This takes about 12 minutes for 72 s. It reports every rendered line's longest settled run against its bar and exits 1 if a key line or a hook line (3 words or more) is short.

For each short line, add a hold in storyboard.json retime.holds: { "at": <frame the line leaves>, "beats": <ceil((need - sec) / 0.667)>, "window": 10, "music": "repeat", "why": "<line> was <sec> s" }. Use "music": "pulse" for a long hold (4 beats or more) so no stab plays without its slam.

  • Round a hold up to whole bars (4 beats) when a chapter key, the drop or the impact comes within the next scene. A 1-beat hold pushes every later chapter off its bar downbeat.
  • Re-run lint-storyboard.mjs after adding holds. It applies the holds before it checks the downbeats of chapter keys, the drop and the impact.
  • Then run node scripts/music.mjs && node scripts/mix.mjs and probe again. For just the changed stretch: node scripts/readability.mjs Main16x9 --frames a-b --concurrency 1. Lines planned outside the range are listed as "not probed", and lines the range cuts as "cut by the range"; widen the range to judge them. To re-read a saved run without rendering: node scripts/readability.mjs --from out/probe-Main16x9.json (the probe- file, not the readability- report).

Check: a whole-film run ends key and hook lines: all pass. Never speed anything up to fix pace. Holds add whole beats only.

Framing check (G8, the automatic half), before any master:

node scripts/framing.mjs Main16x9 --every 2       # and Main9x16, Main1x1 for each layout in Platforms

About 4.5 min per 48 s layout. Fix every problem it lists (re-centre the crop on the subject, a smaller push, overlays inside the plate, an own crop per layout) and rerun until each layout reports 0. Once per film, self-test it: push one marked plate to 1.25, see it fail, revert. It knows only marked subjects; the sheets in step 15 cover the rest. A project scaffolded before 13 Oct 2026 lacks it: copy src/framing.tsx, scripts/framing.mjs and the framing prop in src/Main.tsx from TEMPLATE.

14. Render the masters

Re-read preRenderChecks and BRIEF.md's Facts that go stale first, on every render and re-render: timings (RIPPER: "AN HOUR IN" became 30 min), the site's wording in copy and footage ("insured" became "market value"), live figures (node scripts/live-data.mjs, then the lint). Update what changed, keep the old masters in out/prev-<why>/, and re-probe and re-run framing on the changed frames (--frames a-b).

node scripts/render.mjs Main16x9 out/<coin>-<cut>-16x9.mp4 --concurrency 2
node scripts/render.mjs Main9x16 out/<coin>-<cut>-9x16.mp4 --concurrency 2     # only if asked
node scripts/render.mjs Main1x1  out/<coin>-<cut>-1x1.mp4  --concurrency 2     # only if asked

One at a time, never in parallel. render.mjs stops if another Remotion job is running, sets the bitrate cap for the length (5M at 72 s), shifts the audio to cancel AAC priming and retries at concurrency 1 when a render fails. If that fails too it renders muted 240-frame chunks at concurrency 1, joins them and muxes mix.wav (--chunk 240 asks for this up front; chunks on disk are kept, so a rerun resumes). Then it runs qa.mjs; after a chunked render also run avsync (G4). Expect 3-10 minutes per master. Skip the silent master unless the user asks, because X mutes by default anyway.

Check: each render ends with qa.mjs reporting no problems.

15. QA gates

Run on every master. Any failure blocks delivery.

GateCommandPass
G1 ruleslint-storyboard.mjs + the step 7 lenses on the final stills0 errors, nothing flagged
G2 key linesstep 13 report, whole filmall pass
G3 hooknode scripts/stills.mjs Main16x9 out/hook 0 --at 0,30,60,150frame 0 lit and settled, says what it does in 4 words or fewer; sentence done by 2.0 s; the product name lands by the end of the hook (about 5.3 s)
G4 A/V syncnode scripts/avsync.mjs out/<master>.mp40 samples at every point
G5 black/freezeffmpeg -i out/<m>.mp4 -vf blackdetect=d=0.1:pix_th=0.10 -an -f null - 2>&1 | grep black_ and the same with freezedetect=n=-60dB:d=0.5 and grep freeze_, on every master (narrow layouts freeze where 16:9 does not)no black; freezes only on the end card or a listed hold
G6 specnode scripts/qa.mjs out/*.mp4 and ffmpeg -i out/<m>.mp4 -af ebur128=peak=true -f null - 2>&1 | tail -12H.264 High, yuv420p, 30 fps, AAC 192k, +faststart, under 50 MB, frame count as planned; about -14 LUFS, -1.0 dBTP or lower
G7 factsfacts and preRenderChecks in storyboard.jsonevery claim traced, live data re-read today
G8 framingframing.mjs 0 problems on every layout (step 13); then node scripts/frame-sheets.mjs out/<master>.mp4 out/frames/<layout> --every 6 on each master, read every sheet and compare with the reference film's sheets (QUALITY-BAR "Reference set")every card, slab, card photo in footage, avatar, plinth, coin, pot and key line sits whole inside the yellow 5% box whenever it is on screen, except a deliberate entry or exit

G8 by eye. The user on the launch cut: "you can't see a card ... the agents on their podiums slide off". framing.mjs knows only marked subjects, so read the D8 sheets of every master (--dense a-b:2 around pans and punch-ins, --at f1,f2 --width 800 for close-ups) next to the reference film's, list each cut subject as time, layout, what; fix, re-render, repeat until the list is empty. Keep before and after sheets for DELIVERY.md. Details: QUALITY-BAR D8 and D9.

Then score the rubric in references/QUALITY-BAR.md section B, 0-2 on each of 16 criteria. Ship at 26 or more with no 0. Put the scores in DELIVERY.md.

16. Delivery note and record

Write out/DELIVERY.md. Copy the structure of the reference film's out/DELIVERY.md (launch or claim):

  • the files table: name, size, resolution, length, audio;
  • what the film does, scene by scene, in one line each;
  • holds;
  • the key-line readability table;
  • the QA table, with the G8 result (framing.mjs per layout, sheet paths);
  • the facts that go stale, with the frames that show each, so a change is a quick re-render;
  • rubric scores;
  • what nobody has checked. Always: "No one has listened to the music on speakers yet."
  • the polish list;
  • open decisions;
  • the re-render commands.

Send the user the 16:9 master and DELIVERY.md. Then add a row to <SKILL>/RUNS.md: date, coin, cut, length, scenes, holds, wall time per step, render times, failures and what fixed them. If something new broke, add it to references/GOTCHAS.md in this skill.

Re-cuts of an existing film

  • Slower or faster with no graphics change: set retime.bpm, keeping srcBpm. Then rerun steps 10, 13, 14 and 15. This is what RIPPER v2 did in under an hour.
  • One line too short: add a hold (step 13).
  • Copy change: edit the scene and its storyboard beat, then run the lint, the scene stills, music if cues moved, and steps 13-15.
  • A fact changed (a timing, the site's wording, a live figure): find it on BRIEF.md's stale-facts list, change only those lines ({{live.<name>}} refreshes with live-data.mjs), probe and frame-check the changed range (--frames a-b), re-render every master, and add an "Update" section to DELIVERY.md naming each change and its frames (RIPPER launch and claim, 12 Oct).
  • Another film for the same coin is a new film, not a re-cut: vary tempo, music style and structure (step 5).

References

FileRead it at
references/BRIEF-TEMPLATE.mdstep 3
references/STRUCTURES.mdstep 5: structure per cut type (chapter, launch, walkthrough, live-floor, crew) with beat sheets, the variety rule, the grafts
references/STORYBOARD-SCHEMA.mdstep 6
references/storyboard-example-ripper.jsonsteps 6, 10, 11: the whole RIPPER v2 film in the schema
references/bar-stills/step 11: one RIPPER v2 frame per pattern, and the depth-plane count to match
references/SCENE-PATTERNS.mdstep 11: how each RIPPER scene type was built, with code pointers; light brands
references/QUALITY-BAR.mdsteps 11, 13 and 15: the reference set and its contact sheets, gates, rubric, tests
references/GOTCHAS.mdwhen anything fails: every machine, Remotion, footage and audio lesson with its fix
references/PLATFORMS.mdsteps 1 and 14: X, 9:16 and 1:1 targets and safe zones
references/WHEN-TO-ESCALATE.mdbefore step 1 if the job is unusual, and whenever a check fails twice

Skills associés