agentleFS
kelano86kelano86/what-if-animation/SKILL.md

what-if-animation

Skill75 starsChanged 27 days agoMITView on GitHub

Make a "What If" animated episode from one topic line ("What if you could rewind 10 seconds?"), in the dusk-lit stick-figure style of the What If channels that broke out on YouTube in October 2026. Writes the script on the seven-beat What If formula, voices it with ElevenLabs, lays out a shot list at the genre's pace, renders a storyboard of stills and self-checks it before animating, animates every frame in code (Remotion and SVG, with an original cast on one rig, rooms in perspective and light from lamps and windows), generates and syncs the sound, and masters a finished 15-25 s episode to -14 LUFS. Use when someone asks for a What If episode, animation or cartoon, "make a what if video about X", a stick-figure explainer in this style, or to run the free What If skill.

  • Reads credentials
  • Installs packages

1 other project uses a version of this, 1 of them edited.

Adopted by

Most recently taken up by

  • Other versions1 project uses a version of this.

    Word for word · 0

    None found.

    Edited · 1

    1. owlinthebarnai/video-studio-kit★ 41100% same

    Wrote their own version · 0

    None found.

    How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.

The file

We split this skill into the rules it gives an agent

6 rules. About 0 are common, 1 is distinctive, and 5 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈1

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 5

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Storyboard before animation: No video render until the stills pass the self-check (step 5) and, when the person is in the loop, they've …

    line 37
  2. Very specific:

    Read references/formula.md.

    line 60
  3. Very specific:

    Read references/kit.md for the building blocks.

    line 97
  4. Very specific:

    Look at the storyboard, then open every still in out/<slug>/board/ at full size, and run the storyboard checklist in references/look.md …

    line 115
  5. Very specific:

    Read the grids like a flipbook against the motion checklist in references/look.md.

    line 132
  6. Very specific:

    Read references/sound.md. Add sound to episode.json: the clips (prompt and length), one event per visible action cued to its shot, …

    line 137

≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

What If animation

One topic line in, a finished 15-25 second episode out. Every frame is SVG that Claude writes (rendered by Remotion); the voice and the sound come from ElevenLabs. Two examples ship in studio/src/episodes/, both ready to render: rewind ("What if you could rewind 10 seconds?", the proof clip: shots played backwards as the power) and copy-paste ("What if you could copy and paste anything?", the skill's first full run: a new kitchen set, a schematic for the science beat, a cliffhanger blackout). Read the one closest to your topic before you start.

FileWhat's in it
references/formula.mdThe seven-beat What If formula, the 15-25 s shape, script rules, choosing a topic
references/look.mdThe measured look, pace, shot vocabulary, and the storyboard and motion checklists
references/kit.mdThe building blocks: engine, cast, sets, room kit, light, UI, looks, and how to add each
references/sound.mdWriting sound events, prompts, levels, costs
references/traps.mdEverything that cost time on the two example episodes
studio/The Remotion project: copy it once, then every episode lives in it
scripts/voice, plan, stills, board, sfx, mixcheck, motiongrid, master (Python 3.9+ and Node)

Rules

  • Original characters only. Pip (the hero, look B) and Mo (his friend) are ours, and so are the sister, mum and the suit on the rig. Never a channel's own hero, and nothing that resembles a famous cartoon character: check every new look on the cast sheet (Mo's first hat was dropped for drifting toward one).
  • Original stories. The formula is shared; the episode isn't anyone else's. Don't remake a channel's title.
  • Never claim the viral channels are made with Claude or any other tool. Nobody has said how they're made.
  • Keys by name only. ELEVENLABS_API_KEY, from the environment or a .env above the studio. Never print, paste or hardcode a key.
  • Report the ElevenLabs credits of every run: the scripts log them to out/<slug>/costs.json and master.py totals them in report.json. The voice's cost is read from the account's history (exact); sound clips don't show there, so their cost comes from the account counter, which can lag: re-read it before you report. Say the number when you hand the episode over. The copy-paste run cost 152 credits (78 for the voice, 74 for 12 new clips).
  • Storyboard before animation. No video render until the stills pass the self-check (step 5) and, when the person is in the loop, they've seen the board.
  • Every fact is real. A number in the script is worked out and sourced in the episode's science field first.

Setup (once per machine)

Needs Node 18+, ffmpeg and ffprobe on the PATH, Python 3.9+ with numpy and Pillow, and an ElevenLabs key.

cp -r <skill>/studio ./what-if-studio && cd what-if-studio && npm install

Everything below runs from that studio folder; <skill> is this skill's folder. To work offline or in your own brand face, put a display font in public/fonts/ and set titleFont in src/studio.config.ts (the default title face, Bricolage Grotesque, and the UI faces load from Google Fonts at render time). To update an existing studio to a newer engine, copy <skill>/studio/src/engine over its src/engine.

The pipeline

Work through the steps in order. Each ends on something you look at before the next.

1. Script

Read references/formula.md. Search YouTube for the premise first: if a What If channel already has that exact episode, change the power or the rule. From the topic line, decide the power's word, its rule, three escalating demos and the turn (one real fact with a number). Write src/episodes/<slug>/episode.json with id (PascalCase, the composition name), slug, topic, title (two lines), script (one entry per beat) and science (each fact: the claim, the working, the source). 45 to 65 words. Read it aloud at pace: every line must be a picture.

2. Voice

python <skill>/scripts/voice.py <slug>

One ElevenLabs take with character timestamps (the 356-character copy-paste take cost 78 credits), then the pauses cut to the genre's pace: public/<slug>/voice.wav and src/episodes/<slug>/words.json. Check the length (15-25 s) and the word times it prints. Retune pauses with gaps in episode.json and re-run: the take is cached, so that's free. Change a word and it calls the API again.

3. Shot list

Design one shot per picture in the script (usually 9 to 14), varying the size and angle every cut (wide, insert, medium, close-up, over the shoulder, high, low; see references/look.md). Add to episode.json:

  • shots: { "id": "S1", "size": "medium", "set": "kitchen", "key": 14, "note": "what we see" } (key is the frame of the shot's own clock the storyboard shows)
  • edit: { "shot": "S1", "at": "cookie" } per cut, cued on the word it lands on (plan.py lists the cue forms; reverse, from, to and look for powers that bend a shot's clock)
  • fx: one-frame flashes and shakes, { "at": "S3+2", "kind": "flash" }
python <skill>/scripts/plan.py <slug>

It writes timeline.json and out/<slug>/shotlist.md and prints the pace. Aim for 27+ cuts a minute in the opening and no static shot over about 3 s; fix what it flags before drawing anything.

4. Storyboard

Read references/kit.md for the building blocks. Write src/episodes/<slug>/shots.tsx, one component per shot, each a pure function of its clock t (copy the patterns in the two examples' shots.tsx), and index.tsx (the episode and its power look), then add the episode to src/episodes/index.ts. At this step each shot only needs to be right at its key frame. When a topic needs a place the library lacks, build it with the room kit and add it to src/engine/sets/ (and to the skill's copy) so the next episode has it, as the copy-paste run did with the kitchen and the schematic. A new character or costume: add the look, then check it on the cast sheet (npx remotion still src/index.ts Cast out/cast.png).

npx tsc --noEmit
node <skill>/scripts/stills.mjs <slug>
python <skill>/scripts/board.py <slug>

out/<slug>/storyboard.jpg: one captioned still per shot.

5. Self-check the stills

Look at the storyboard, then open every still in out/<slug>/board/ at full size, and run the storyboard checklist in references/look.md honestly, shot by shot. Write down what fails, fix it, re-render just those shots (stills.mjs <slug> S3 S7), rebuild the sheet and look again. Repeat until it passes. Check references/traps.md for the failure you're seeing before inventing a fix. If the person is in the loop, show them the board now and take their notes before animating.

6. Animate

Bring each shot to life from its key pose: poseAt keys with anticipation, holds and overshoot, faceAt for expressions, camera moves with kf, the power's look, the fx. Then render a draft and check the motion:

python <skill>/scripts/master.py <slug>
python <skill>/scripts/motiongrid.py <slug> S2 S5
node <skill>/scripts/stills.mjs <slug> --frames 120 240

Read the grids like a flipbook against the motion checklist in references/look.md; fix and re-render until it reads.

7. Sound

Read references/sound.md. Add sound to episode.json: the clips (prompt and length), one event per visible action cued to its shot, ambiences per location, the music bed and the levels. Check what the library already has, then generate:

python <skill>/scripts/sfx.py <slug> --dry
python <skill>/scripts/sfx.py <slug>

It prints the credits it used and sets the stem volumes in timeline.json. Then check that every word stays clear:

python <skill>/scripts/mixcheck.py <slug>

It lists the moments, while a word is being spoken, where effects or music come within 3 dB of the voice. A hit that illustrates a word lands in the pause just after it, never on it; a bed (a hum, a drone) under a key line comes down; if most of the stem crowds the voice, lower sfx_lu. Re-run sfx.py and the check until only deliberate overlaps remain (a title boom, a turn).

8. Master and hand over

python <skill>/scripts/master.py <slug>

Renders, brings the mix to -14 LUFS with peaks under -1 dBTP, and writes out/<slug>/report.json (length, loudness, pace, credits). Watch the final file once through with sound. Hand over out/<slug>/<slug>-final.mp4 and out/<slug>/storyboard.jpg, with the length, the ElevenLabs credits used, and anything you'd still improve.

Where an episode lives

PathWhat
src/episodes/<slug>/episode.jsonEverything you write: script, science, shots, edit, fx, sound
src/episodes/<slug>/shots.tsx, index.tsxThe drawing: one component per shot, the power's look
src/episodes/<slug>/words.json, timeline.jsonWritten by voice.py and plan.py (sfx.py adds the volumes)
public/<slug>/voice.wav, sfx.wav, music.wav
out/<slug>/board stills, storyboard.jpg, shotlist.md, motion grids, renders, costs.json, report.json
library/sfx/Every generated sound clip, shared by all episodes

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.