Communitygithub.com

executive-animator

Shows an agent how to plan, build, or cut "executive animator" so the concrete output is an edit with timed captions. The procedure moves through Executive Animator, 0. Which target — decide this first, it changes stages 5, 6 and 7, 1. Intake — no transcript, no plan. Use it when a new assignment calls for this craft.

What is executive-animator?

executive-animator is a Claude Code agent skill that shows an agent how to plan, build, or cut "executive animator" so the concrete output is an edit with timed captions. The procedure moves through Executive Animator, 0. Which target — decide this first, it changes stages 5, 6 and 7, 1. Intake — no transcript, no plan. Use it when a new assignment calls for this craft.

Works with✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/lucasaerb/workless-video-editor/tree/HEAD/skills/executive-animator

Ask in your favorite AI

Open a new chat with this agent skill pre-loaded.

Documentation

SCOPE: this skill BUILDS 16:9 long-form. Do not load it while cutting a short. Standing note, 2026-08-15, and it is about context budget rather than correctness. This file is 500 lines and every one of them is about a long-form cut. In a controlled A/B on the same 24-minute source, the run whose skill tree carried this plus youtube-longform produced no Stage 2 clip-candidate search and no CAPTION.md, and cut its short from the first 47 seconds of the recording. The run without them searched the whole source and shipped both. The guidance is not wrong; there is a lot of it, it is irrelevant to a 45-second vertical, and it crowds out the editorial step that had no gate protecting it. scripts/verify_story.py is now that gate.

Its METHOD is shared and that is not a contradiction. short-composer (Step 1) and graphics-only-short (Phase 4) both cite the one-pass-over-the-whole-recording planning method below, and they cite it in two paragraphs rather than loading this file. The 9:16 column in the comparison table exists to mark what the shorts path does differently, not to be followed here. Clarified 2026-08-27, when the audit read the scope note as contradicting the file's own body.

Shorts: skills/ultimate, which owns the 9:16 slot, and skills/shorts-multiplatform.

Executive Animator

skills/broll-scout decides what goes at a timestamp. skills/stat-overlay builds one graphic. This skill is the pass between them: read a whole recording, propose the 5-10 graphics that recording actually earns, prove each one against the transcript, then build and gate them in one batched browser session instead of ten.

Inherits skills/00-house-rules/SKILL.md and every rule in skills/stat-overlay/SKILL.md. Nothing here overrides the authoring contract. It only adds intake, proof, and batching.


0. Which target — decide this first, it changes stages 5, 6 and 7

Sections 1-4 are identical for both: intake, candidates, the accuracy gate, the count. Stages 5 onward are not, and running the vertical instructions against a 16:9 cut produces graphics that build_longform_composition.py cannot use at all.

9:16 vertical16:9 long-form
consumed bybuild_composition.pybuild_longform_composition.py
a graphic isan alpha .mov composited over the platea scene declared in composition.json
authored asa HyperFrames composition you writea kind + fields; the generator writes the HTML
vocabularythe 373-block registrythe 14 built-in kinds, a closed set
render--format mov at composition resolution, plus an mp4 twinnothing per graphic — one render at the end
safe areacontent above y=1400, clear of the caption band16:9 safe box, captions off
gate platform--platform instagram_reels--platform youtube_long
final resolutionportrait-4klandscape-4k
densityone insert per 8-12s (broll-scout)3-6 scenes + a stinger every 20-40s
contact sheeta separate reel project in overlays/probe_frames.py --plan --grid on the comp

The 16:9 path has no authoring step. You do not open the registry, you do not write HTML, and you do not render anything per candidate. You translate each candidate into one of these:

title · chapter · statement · compare · lower_third · endcard — scenes, 8-15s, they carry an argument the viewer reads. converge · overload · steps · swap · countup · beats · surround · photo/clip — stingers, 2-4s, one gesture each, cut TO not laid over.

skills/motion-language/SKILL.md owns that vocabulary and its per-kind fields. build_longform_composition.py exits with unknown scene kind on anything else, so a candidate that maps to no kind gets cut — which is usually correct, because it means the idea was decoration. Then follow skills/youtube-longform/SKILL.md from its Stage 4.

Everything below this line assumes 9:16 unless it says otherwise.


1. Intake — no transcript, no plan

bash scripts/transcribe.sh VIDEO_UPLOAD/raw/<file>.mov drops/drop-NNN-slug/working

Word-level JSON, not a summary. Every candidate is anchored to a word range, so a paragraph-level transcript makes the whole skill guesswork. If a transcript already exists in working/, use it — do not re-transcribe.

Then watch the footage. Not the whole file: python3 scripts/probe_frames.py is for compositions, so for source footage pull stills with ffmpeg every ~10s and look at them. You are checking one thing — what is already on screen. A graphic that duplicates a screen recording the speaker is already showing is a wasted slot and tier 1 beat you to it.

2. Candidate pass — 5-10, and every one carries a quote

Write working/motion/ANIMATION-PLAN.json:

{
  "source": "drops/drop-NNN-slug/working/transcript.json",
  "duration_ms": 184000,
  "candidates": [{
    "id": "01-three-jobs",
    "start_ms": 22400, "end_ms": 28100,
    "quote": "a skill does three jobs, it names the task, it holds the steps, it carries the files",
    "claim_on_screen": "3 jobs: name · steps · files",
    "shape": "list",
    "evidence": "spoken",
    "block": "grid-card-assemble",
    "mechanism": "three chips assemble out of scattered particles into a row",
    "layout": "centre-stack",
    "reason": "he enumerates three things and the viewer cannot hold three things by ear",
    "status": "build"
  }],
  "rejected": [{
    "quote": "it's been a wild year for agents",
    "proposed": "timeline of model releases",
    "reason_rejected": "he never names a date. the graphic would be inventing the content"
  }]
}

Shapes that earn a graphic, in the order they usually appear in speech: a number, a comparison, a list of three or more, a process with steps, a before/after, a timeline, an abstraction with no footage of it. Everything else is footage's job.

Log rejections. Same reason as broll-scout: the rejection log is what stops the next run re-proposing the same decorative timeline.

shape is checked for repeats at plan time, before anything is built. If four candidates are all stat, the recording did not give you four stat cards — it gave you one idea you kept re-cropping. Merge them into one graphic that holds all four numbers, or cut three. Rework the plan here; discovering it on the contact sheet means you built four graphics to throw away.

3. The accuracy gate — this is the whole point

A graphic is a claim rendered at 4K with brand fonts on it, which makes it read as verified whether or not it is. So, per candidate:

  • quote is verbatim from the transcript. Copy it, do not retype it from memory.
  • claim_on_screen may compress the quote. It may not extend it. Dropping words is editing; adding a number, a unit, a percentage, a date or a proper noun the speaker never said is fabrication. If the graphic needs a fact to work and the speaker did not say it, the graphic does not work.
  • evidence is one of spoken | cited | unconfirmed.
    • spoken — he says the number. The source line reads as him.
    • cited — he references something external and you resolved a real primary source. Put the source line on the frame. Load /verify-subagent-factual-claims before you accept a number a subagent handed you.
    • unconfirmed — the frame carries a visible ⚠ unconfirmed, or the candidate is cut. Those are the only two outcomes. Never quietly launder it into a clean stat card.
  • Do not animate a claim you had to steady. If making the sentence fit the graphic required rounding, re-scoping or "roughly", cut the candidate. That is the graphic disagreeing with the footage, and the footage is the one the human recorded.

4. Count — propose 5-10, ship what the runtime allows

5-10 is the size of the candidate set, never the number that lands in one cut. broll-scout's density rule is binding for 9:16: roughly one insert per 8-12 seconds, and tier 1 wins some of those slots outright. On 16:9 that rule is far too dense — budget 3-6 scenes plus a stinger every 20-40s, which lands near 20-25% of runtime carrying a graphic.

RuntimeGraphics that can actually land
30-60s short2-4
3-5 min long-form5-8
10 min+8-10, then stop proposing

So on a single short, expect to build 5-10 candidates and mark most of them status: "hold". That is the correct outcome, not a failure — a held candidate is a finished graphic waiting for the next cut of the same recording, which is exactly what plan_calendar.py spaces out. An empty shot plan still beats a decorated one.

Never place a graphic in the first 3 seconds (the hook is the face) or across the payoff line (emotional beats land on humans).

5. Build — one project, N sub-compositions

16:9 — skip this section entirely. There is nothing to author. Write the kinds and fields into composition.json and go to skills/youtube-longform/SKILL.md Stage 4. Everything from here to the end of §7 describes the vertical compositing model.

Author per skills/stat-overlay/SKILL.md — registry search first, real logos via /media-use, one paused timeline, fromTo, 8-10 elements in three layers, content above y=1400, 5-7 seconds. None of that changes here.

Two animation skills, and they answer different questions. Load both.

  • /hyperframes-animation — what the motion is. Load it before authoring any candidate and compose 2-4 atomic rules from its rules-index.md. Never start from a blank timeline. Reach for a blueprint only for genuinely multi-phase choreography, and for the shapes this skill produces most — a list assembling, a number counting up, a before/after swap — its 24 named text-animation effects usually already name the thing you were about to hand-roll. Across a set of 5-10, this is also what keeps the set coherent: pick the rule vocabulary once, at plan time, and reuse it. Ten graphics each inventing their own entrance read as ten unrelated videos.
  • /hyperframes-keyframes — how the tween is written. Load it the moment a candidate needs motion no registry block covers: seek-safe 2D/3D keyframes, a GSAP timeline authored by hand, SVG morph or dash-draw (getTotalLength() reveals on the inlined Lucide icons), path and mask work, FLIP, text trails, depth. This is the skill that keeps hand-written motion seek-safe, which matters more here than anywhere else in the repo: the capture engine seeks non-linearly, and a tween that only looks right when played start-to-finish will render wrong in a reel that is ten compositions long.

If a candidate can be built by composing rules alone, do not open the keyframes skill. If it cannot, do not improvise the tween — open it.

Variety: one system, ten different sentences

These two failures look nothing alike and both kill the set:

  • Ten unrelated videos. Different type scales, different eases, different colour weights. Reads as stock, because stock is the only place unrelated graphics arrive together.
  • The same card ten times. One layout, one entrance, only the words change. Reads as a template, and a viewer clocks it by the third one and stops reading the fourth.

So fix the system and vary the execution. Nothing in the left column may drift across the set; nothing in the right column may repeat.

Constant across all candidatesDistinct per candidate
Colour and type from brand/tokens.jsonmechanism — the one move that carries the idea
The type scale (headline / body / label sizes)Layout: centre-stack, left-anchored, split, edge-anchored, full-bleed
The easing family and timing signatureEntry direction and the axis motion travels on
Caption-band clearance, safe area, 5-7s bandRegistry block, and the 2-4 rules composed from /hyperframes-animation
The rule vocabulary — which rules are in playWhich of them lead, and in what order
Source-line treatmentDensity and pacing within the 5-7s

Enforce it mechanically, at plan time:

  • mechanism is unique across the set. One sentence, describing the move and not the content: "three chips assemble out of scattered particles" is a mechanism; "shows the three jobs" is a restatement of claim_on_screen. Two candidates whose mechanisms paraphrase each other are one candidate — merge or cut. This is the field that actually does the work, because two graphics can use different blocks and still move identically.
  • No registry block twice, unless it is a deliberate --batch family (see the caveat below). With 373 blocks in the catalogue, reaching for the same one twice means the second search was lazier than the first. Search per candidate, from the candidate's own shape.
  • layout is unique across the set, or as near as five slots allow. If every graphic centres its content, the reel has one composition repeated in different colours.
  • Vary the pacing. Per /hyperframes-creative a single scene wants 3+ eases and a slowest tween ~3x the fastest — that applies across the set too. If every candidate builds for 2s, holds for 3s and exits for 1s, they will feel identical no matter how different they look.
  • Alternate the register. A set of five wants roughly: one that lands hard and fast, two that build and resolve, one quiet lower-third that barely moves, one that earns real complexity. Five graphics all pitched at maximum intensity flatten into noise.

The --batch caveat, which is the trap this section exists for. Section 5 says same-shape candidates can share one composition and render as variable rows. That is a real efficiency and it also manufactures exactly the failure above: batch siblings are identical by construction. So batch is correct for a set that is meant to read as a family — a four-part series posted across four days, or four panels inside one carousel — and wrong when those rows are four of the five graphics in a single cut. If they land in one video, they are not a batch. Build them separately.

The contact sheet in §6 is the check. It is the one artifact that shows all candidates at once, which is the only way this failure is visible — every graphic passes every gate individually and the set still reads as a template. Look at the sheet and ask whether you can tell the graphics apart with the words unreadable. If not, the problem is in mechanism and layout, and it is cheaper to fix in the plan than in ten authored files.

What changes is the layout. Put every candidate in the shared overlays/ project as a sub-composition, and make index.html a contact reel that sequences them via data-composition-src (see /hyperframes-core):

overlays/
├── index.html                              ← the reel: every candidate, in order
└── compositions/drop-NNN/
    ├── 01-three-jobs.html
    └── 02-cost-per-run.html

This exists for one reason: hyperframes check takes a project directory, not a composition, so ten standalone projects means ten visible Chromium launches on the human's screen. The reel makes it one. render does take -c, so the reel costs nothing at output time.

If several candidates are the same shape with different content — four stat cards, three quote cards — build one composition with data-composition-variables and render the set with --batch rows.json. One authored file, one gate, N outputs.

6. Gate the whole set in one pass

cd overlays && npx hyperframes check --samples 60 --at-transitions --json
cd overlays && npx hyperframes keyframes compositions/drop-NNN/01-three-jobs.html --json
python3 scripts/graphics_check.py overlays --platform instagram_reels
python3 scripts/probe_frames.py overlays <t1> <t2> ... --grid working/motion/candidates.png

16:9 gates the whole video once, not the graphics separately — the scenes are already inside it. cd working/comp && npx hyperframes check, then graphics_check.py working/comp --platform youtube_long, then probe_frames.py working/comp --plan --grid sheet.png, which is the contact sheet: it probes every moment plan.json says matters, so every scene lands on it without a list of timestamps. Read it for variety exactly as below.

  • Raise --samples. The default 9 across a 60s reel samples roughly one frame per composition and will miss most of them. Budget ~6 samples per candidate.
  • --at-transitions catches the seams between candidates, which is where a reel of this shape actually fails.
  • Zero errors before any render. overlapping_gsap_tweens is the silent killer.
  • keyframes is the per-candidate diagnostic, and unlike check it takes a composition path — so it is how you isolate one graphic out of a ten-composition reel. --json reads the tweens statically. When a candidate's motion looks wrong and the JSON does not say why, --shot working/motion/<id>-onion.png --selector <el> draws the element's real path as an onion skin without rendering; --layout strip for in-place motion, --from/--to to scope one beat. Batch these — each --shot drives a browser, and CLAUDE.md forbids iterating visible Chromium runs on the human's screen.
  • Then graphics_check.py — the design half. It fires on defects that shipped past a clean hyperframes check.
  • Then the animation map, per /hyperframes-animation: node <ANIM_SKILL_DIR>/scripts/animation-map.mjs overlays --out .hyperframes/anim-map. deadZones empty, staggers consistent across the set, every collision / offscreen / paced-fast / paced-slow flag justified individually.
  • The contact sheet is the one image the human looks at to approve all of them. Probe each candidate's hero moment, not its first frame. Read it for variety as well as for defects — squint at it, or look at it with the type too small to read. If the graphics are indistinguishable as shapes, go back to mechanism and layout in the plan.

6.5 Fit and alignment — measured in the frame it actually ships in

Every gate in §6 is relative to a canvas, and nothing so far has proved which canvas. A graphic that passed every rule against the wrong frame is the most expensive kind of pass, because it reads as verified. So before the contact sheet goes to a human, prove fit (does the content sit inside the frame it will ship in, while it is moving) and alignment (do the graphics agree with each other about where the edges are).

Declare the canvas, then let the gate check it. hf_preview reads data-width / data-height off the main composition and falls back to 1080x1920 when it cannot find them, so a landscape project with its attributes in an unexpected order gets measured as a vertical one. graphics_check.py now refuses that pair outright: canvas aspect must match --platform's own resolution in config/platforms.yml, and it exits before probing rather than printing a pass it never performed. 4K multiples of the same aspect are fine.

python3 scripts/graphics_check.py overlays --platform instagram_reels     # 9:16 — every insert
python3 scripts/graphics_check.py working/comp --platform youtube_long    # 16:9 — the whole comp

One gate per aspect is enough, because one platform dominates each. instagram_reels (250/520/80/200) is at least as strict as tiktok (130/320/60/120) and youtube_shorts (170/400/50/120) on all four edges, so a vertical set that clears reels clears every vertical destination. On 16:9 there is only youtube_long (72/132/96/96), whose bottom is the end-screen reserve plus the player chrome that appears on hover.

The optical centre flips between the two targets, and this is the alignment rule people get wrong. Vertical safe insets are asymmetric — 80 left against a 200px right rail — so the usable box is x 80..880 and its centre is 480, not 540. Centring on the canvas (left:50%) puts every centred headline 60px into Instagram's like/comment/share column, which is exactly the defect outside_safe_area fires on. Landscape insets are symmetric (96/96), so on 16:9 the usable centre is the canvas centre, 960. Vertical content also stays above y=1400 to clear the karaoke caption band (x 80-880, y 1150-1400); 16:9 burns no captions and has no such band.

Fit is a property of the motion, not of the resting frame. Entrance tweens overshoot: a row laid out to the full 800px column and scaled 1.35 → 1 measures 826px mid-entrance, and a probe that lands there reports a real safe-area error on type that was never actually outside the frame. Probe deliberately inside the entrance (--at, plus --at-transitions on hyperframes check), and when it fires, budget for the overshoot in the layout — lay out to the column minus what the tween adds. Do not nudge the coordinate until that one probe goes quiet; that fix survives until the next take and no further. build_composition.py clamps display line sizes for this exact reason.

On 16:9, fit is also fit in time. build_longform_composition.py exits when a scene collapses under its own anchors or a beat is anchored past the scene's end, so run the generator before gating — a scene that cannot hold its beats is a fit failure that no frame will ever show you.

When the drop ships both cuts, the candidate is one idea and two artifacts. There is no rescale path between them: a 1080x1920 alpha insert dropped into a 16:9 cut arrives pillarboxed, and a landscape scene cropped to 9:16 loses the edges its layout hangs from. So build the insert and declare the kind, then run both gates above. A candidate that fits one target and not the other gets cut from the one it fails, never shrunk until it technically fits — a graphic scaled down to survive a crop is unreadable on a phone, which is where it was going.

Alignment is across the set, and only the contact sheet shows it. Pick one left edge (the target's SAFE_L — 80 vertical, 96 landscape) and hang every edge-anchored candidate off it; centred candidates share the one optical centre above. On the sheet, the graphics should line up with each other, not each find their own margin. That check costs a second and it is invisible in any per-composition gate, because ten differently-aligned graphics each pass on their own.

6.6 Three layout failures that 6.5's measurements will not catch

A device longer than its window never populates. Every shape in the motion pack declares a duration. If the anchors give it less time than that, it renders half-built and holds there, and hyperframes check, graphics_check and the census all pass, because a partly-drawn layout is a valid layout. drop-019's compare-2col is a 3.6s shape that was handed 2.72s and spent its whole window as an eyebrow above an empty outline. Compare each shape's declared duration against the window its anchors produce, and probe a frame from the END of the scene, not the start.

The corner PIP eats the top-right, so eyebrows have about twenty characters. On any swap shape the self-view sits over the upper right and a longer eyebrow runs underneath it. "Where the risk sat" cleared it; "What it actually was at the time" and "What he says sets you up" did not, and the layout check reported it as an info, not an error. Keep an eyebrow short enough to clear the corner, or move it.

A stack builds bottom-up, so its numbering inverts its meaning. stack-build renders the LAST array element on top and numbers it 01. Declared in causal order it numbers the outcome first and reads as though success came before the work. House rule is 01 at the top, so the causally-first item goes LAST in the array. Look at the finished frame and read the numbers in order.

And when you remove something, re-measure what was under it. Dropping the series card from drop-019's opening lifted the eyebrow by 166px, off the speaker's glasses, which is where it had wanted to be all along. Vertical position is a consequence of everything above it.

7. Preview, wait, then render

Show the contact sheet. Wait for approval. Checks passing is not approval — this is non-negotiable in CLAUDE.md and it applies to a batch exactly as it applies to one overlay. That sentence is the one part of this section that is true on both targets.

16:9 — nothing here applies below this line. No alpha master, no mp4 twin, no per-graphic render at all: the scenes are layers inside the video and they leave the project exactly once, as landscape-4k, when the whole cut renders. Alpha exists so an insert can composite over a plate the generator does not own; long-form owns the plate, so there is nothing to composite against. Approve the contact sheet and go render the video.

Every insert ships as two files: an alpha master and a playable mp4 twin. Not one or the other. They answer different questions and neither substitutes for the other.

# 1. the alpha master — what build_composition.py composites
cd overlays && npx hyperframes render -c compositions/drop-NNN/01-three-jobs.html \
  --format mov -o renders/drop-NNN-01.mov

# 2. the mp4 twin — what a human can actually open. Flatten over the brand navy.
ffmpeg -f lavfi -i color=c=0x091F2C:s=1080x1920:r=30 -i renders/drop-NNN-01.mov \
  -filter_complex "[0:v][1:v]overlay=format=auto:shortest=1,format=yuv420p" \
  -c:v libx264 -preset slow -crf 18 -movflags +faststart \
  <drop>/working/motion/preview/drop-NNN-01-preview.mp4

Why both, and why you cannot just render mp4. h264 has no alpha channel. An insert rendered straight to mp4 is a solid navy rectangle that covers the speaker's face, which defeats the entire point of an insert. So the master keeps its alpha.

Why the mp4 is mandatory rather than nice to have. The alpha master is ProRes 4444 (yuva444p12le), and ProRes does not decode on Windows without QuickTime, which is discontinued. Handing over only a .mov hands over a file the human cannot open, so the approval step silently becomes "trust the log" — exactly what 00-house-rules forbids. The mp4 twin is the reviewable artifact. Standing instruction from the human, 2026-08-13.

--resolution and alpha are mutually exclusive. HyperFrames 0.7.105 rejects --resolution portrait-4k --format mov|webm|png-sequence: its alpha screenshot path does not apply deviceScaleFactor and would silently emit composition-resolution frames while reporting 4K. Render alpha at composition resolution and let the composition's own portrait-4k pass raise DPR once, at composite time. Do not "fix" this by upscaling the insert.

--format mp4 only for a graphic that replaces the frame — a standalone silent explainer, which has no speaker to composite over. Those take --resolution portrait-4k normally.

Where the outputs go:

  • Inserts (composite over the speaker) stay in working/motion/ and are consumed by build_composition.py. They are not posts and never reach _FINAL/motion/.
  • Their mp4 twins go in working/motion/preview/, one folder, nothing else in it. The alpha masters sit beside it in working/motion/. Keeping them apart is the point: a folder holding both formats means the human opens a .mov by accident and concludes the render is broken. preview/ is the folder to point at whenever the ask is "let me see them".
  • Standalone silent explainers — a graphic that carries its own argument with no speaker — go to _FINAL/motion/*.mp4, which is the motion content type in config/content-types.yml. Then re-run python3 scripts/publish_outbox.py; the outbox uses hard links, so a rebuilt render is invisible to it until you do.
  • Held candidates stay authored in overlays/compositions/drop-NNN/ with status: "hold" in the plan. Do not delete them and do not render them.

Every rendered graphic gets a line in the drop README.md and, if any asset was tier 3, _FINAL/ATTRIBUTION.md.

Checklist

Both targets:

  • Target decided before stage 5 — vertical composites, 16:9 declares
  • Word-level transcript, not a summary
  • Source stills looked at; nothing proposed that tier 1 already shows
  • 5-10 candidates in ANIMATION-PLAN.json, rejections logged with reasons
  • Every candidate: verbatim quote, claim_on_screen that compresses but never extends
  • Every evidence: unconfirmed either carries a visible ⚠ on the frame or was cut
  • Count scaled to runtime and to the target's density rule; no graphic in the first 3s or over the payoff line
  • shape repeats resolved in the plan, not discovered on the sheet
  • mechanism unique across every candidate; no two paraphrase each other
  • layout varies; pacing and register vary across the set
  • Contact sheet read with the type unreadable — the graphics are still tellable apart
  • Canvas declared on main and matched to the target — graphics_check.py refuses a 9:16 project gated as 16:9, and a fallback canvas means every safe-area result was fiction
  • Fit probed mid-entrance, not only at rest; overshoot budgeted in the layout, not tuned away one coordinate at a time
  • Set shares one left edge and one optical centre; the edges line up on the contact sheet
  • Shipping both cuts? Two artifacts, both gated. Anything that fits only one target was cut from the other, not scaled down until it fit
  • Preview shown and approved before any render

16:9 only:

  • Every candidate maps to one of the 14 kinds; the ones that did not were cut, not forced
  • Scenes and stingers not confused — if the viewer must read it, it is a scene
  • Generator run before the gate — a scene that collapses under its anchors is a fit failure in time, and no frame will show it to you
  • Gated on the whole comp with --platform youtube_long; --plan --grid sheet read
  • Centred content on the canvas centre (960) — landscape insets are symmetric, so it is right here and wrong on vertical
  • Nothing rendered per graphic, and no alpha anywhere

9:16 only:

  • Built as sub-compositions of one reel; same-shape candidates share one composition + --batch
  • /hyperframes-animation loaded; one rule vocabulary picked at plan time and reused across the set
  • /hyperframes-keyframes loaded for every hand-written tween; nothing improvised, everything seek-safe
  • No registry block used twice
  • --batch used only for a family meant to read as siblings, never for graphics landing in one cut
  • hyperframes check run once, --samples scaled to the reel, zero errors
  • hyperframes keyframes clean per candidate; animation-map.json has no dead zones and every flag justified
  • graphics_check.py passes at --platform instagram_reels — strictest of the three vertical safe boxes on all four edges, so clearing it clears TikTok and Shorts too
  • Centred content on 480, not 540; nothing below y=1400
  • One contact sheet produced and read
  • Alpha rendered at composition resolution, never with --resolution (the CLI rejects the pair)
  • Every insert has an mp4 twin in working/motion/preview/ — a .mov alone is unopenable
  • Each rendered file checked as a still over grey: alpha real, brand fonts embedded not fallback
  • Inserts in working/motion/, standalone posts in _FINAL/motion/, outbox republished

Individual skills in this repo

This repo contains 2 individual skills — each has its own dedicated page.

Related Skills