Skip to content
Back to search

what-if-animation

SkillWorks with Claude CodeGitHub

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.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/kelano86--what-if-animation/badge.svg)](/listings/kelano86--what-if-animation)

HTML

<a href="/listings/kelano86--what-if-animation"><img src="/api/listings/kelano86--what-if-animation/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Clone it into your skills folder, then set up the studio once:

git clone https://github.com/kelano86/what-if-animation ~/.claude/skills/what-if-animation
cp -r ~/.claude/skills/what-if-animation/studio ./what-if-studio
cd what-if-studio && npm install

Then, in Claude Code, from that folder:

> Make a What If episode: what if you could pause everyone but you?

Claude follows `SKILL.md`: script, voice, shot list, storyboard (you'll see it before anything is animated), self- check, animation, sound, master. You get `out/<slug>/<slug>-final.mp4` and `out/<slug>/storyboard.jpg`.

To see the examples first: `npx remotion studio src/index.ts` and open `Rewind` (the proof clip: three demos, each undone by playing the shot backwards) or `CopyPaste` (the skill's first full run). Both render straight away.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 176 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. ---
  2. name: what-if-animation
  3. description: 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.
  4. ---
  5. # What If animation
  6. One topic line in, a finished 15-25 second episode out. Every frame is SVG that Claude writes (rendered by
  7. Remotion); the voice and the sound come from ElevenLabs. Two examples ship in `studio/src/episodes/`, both ready to
  8. render: `rewind` ("What if you could rewind 10 seconds?", the proof clip: shots played backwards as the power) and
  9. `copy-paste` ("What if you could copy and paste anything?", the skill's first full run: a new kitchen set, a
  10. schematic for the science beat, a cliffhanger blackout). Read the one closest to your topic before you start.
  11. | File | What's in it |
  12. |---|---|
  13. | `references/formula.md` | The seven-beat What If formula, the 15-25 s shape, script rules, choosing a topic |
  14. | `references/look.md` | The measured look, pace, shot vocabulary, and the storyboard and motion checklists |
  15. | `references/kit.md` | The building blocks: engine, cast, sets, room kit, light, UI, looks, and how to add each |
  16. | `references/sound.md` | Writing sound events, prompts, levels, costs |
  17. | `references/traps.md` | Everything that cost time on the two example episodes |
  18. | `studio/` | The Remotion project: copy it once, then every episode lives in it |
  19. | `scripts/` | voice, plan, stills, board, sfx, mixcheck, motiongrid, master (Python 3.9+ and Node) |
  20. ## Rules
  21. - **Original characters only.** Pip (the hero, look B) and Mo (his friend) are ours, and so are the sister, mum and
  22. the suit on the rig. Never a channel's own hero, and nothing that resembles a famous cartoon character: check every
  23. new look on the cast sheet (Mo's first hat was dropped for drifting toward one).
  24. - **Original stories.** The formula is shared; the episode isn't anyone else's. Don't remake a channel's title.
  25. - **Never claim the viral channels are made with Claude** or any other tool. Nobody has said how they're made.
  26. - **Keys by name only.** `ELEVENLABS_API_KEY`, from the environment or a `.env`
  27. above the studio. Never print, paste or hardcode a key.
  28. - **Report the ElevenLabs credits** of every run: the scripts log them to `out/<slug>/costs.json` and `master.py`
  29. totals them in `report.json`. The voice's cost is read from the account's history (exact); sound clips don't show
  30. there, so their cost comes from the account counter, which can lag: re-read it before you report. Say the number
  31. when you hand the episode over. The copy-paste run cost 152 credits (78 for the voice, 74 for 12 new clips).
  32. - **Storyboard before animation.** No video render until the stills pass the self-check (step 5) and, when the person
  33. is in the loop, they've seen the board.
  34. - **Every fact is real.** A number in the script is worked out and sourced in the episode's `science` field first.
  35. ## Setup (once per machine)
  36. Needs Node 18+, ffmpeg and ffprobe on the PATH, Python 3.9+ with `numpy` and `Pillow`, and an ElevenLabs key.
  37. ```bash
  38. cp -r <skill>/studio ./what-if-studio && cd what-if-studio && npm install
  39. ```
  40. Everything below runs from that studio folder; `<skill>` is this skill's folder. To work offline or in your own
  41. brand face, put a display font in `public/fonts/` and set `titleFont` in `src/studio.config.ts` (the default title
  42. face, Bricolage Grotesque, and the UI faces load from Google Fonts at render time). To update an existing studio to
  43. a newer engine, copy `<skill>/studio/src/engine` over its `src/engine`.
  44. ## The pipeline
  45. Work through the steps in order. Each ends on something you look at before the next.
  46. ### 1. Script
  47. Read `references/formula.md`. Search YouTube for the premise first: if a What If channel already has that exact
  48. episode, change the power or the rule. From the topic line, decide the power's word, its rule, three escalating
  49. demos and the turn (one real fact with a number). Write `src/episodes/<slug>/episode.json` with `id` (PascalCase,
  50. the composition name), `slug`, `topic`, `title` (two lines), `script` (one entry per beat) and `science` (each fact:
  51. the claim, the working, the source). 45 to 65 words. Read it aloud at pace: every line must be a picture.
  52. ### 2. Voice
  53. ```bash
  54. python <skill>/scripts/voice.py <slug>
  55. ```
  56. One ElevenLabs take with character timestamps (the 356-character copy-paste take cost 78 credits), then the pauses
  57. cut to the genre's pace: `public/<slug>/voice.wav` and `src/episodes/<slug>/words.json`. Check the length (15-25 s)
  58. 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
  59. and it calls the API again.
  60. ### 3. Shot list
  61. Design one shot per picture in the script (usually 9 to 14), varying the size and angle every cut (wide, insert,
  62. medium, close-up, over the shoulder, high, low; see `references/look.md`). Add to `episode.json`:
  63. - `shots`: `{ "id": "S1", "size": "medium", "set": "kitchen", "key": 14, "note": "what we see" }` (`key` is the
  64. frame of the shot's own clock the storyboard shows)
  65. - `edit`: `{ "shot": "S1", "at": "cookie" }` per cut, cued on the word it lands on (`plan.py` lists the cue forms;
  66. `reverse`, `from`, `to` and `look` for powers that bend a shot's clock)
  67. - `fx`: one-frame flashes and shakes, `{ "at": "S3+2", "kind": "flash" }`
  68. ```bash
  69. python <skill>/scripts/plan.py <slug>
  70. ```
  71. It writes `timeline.json` and `out/<slug>/shotlist.md` and prints the pace. Aim for 27+ cuts a minute in the
  72. opening and no static shot over about 3 s; fix what it flags before drawing anything.
  73. ### 4. Storyboard
  74. Read `references/kit.md` for the building blocks. Write `src/episodes/<slug>/shots.tsx`, one component per shot,
  75. each a pure function of its clock `t` (copy the patterns in the two examples' `shots.tsx`), and `index.tsx` (the
  76. episode and its power look), then add the episode to `src/episodes/index.ts`. At this step each shot only needs to
  77. 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
  78. `src/engine/sets/` (and to the skill's copy) so the next episode has it, as the copy-paste run did with the kitchen
  79. and the schematic. A new character or costume: add the look, then check it on the cast sheet
  80. (`npx remotion still src/index.ts Cast out/cast.png`).
  81. ```bash
  82. npx tsc --noEmit
  83. node <skill>/scripts/stills.mjs <slug>
  84. python <skill>/scripts/board.py <slug>
  85. ```
  86. `out/<slug>/storyboard.jpg`: one captioned still per shot.
  87. ### 5. Self-check the stills
  88. Look at the storyboard, then open every still in `out/<slug>/board/` at full size, and run the storyboard checklist
  89. in `references/look.md` honestly, shot by shot. Write down what fails, fix it, re-render just those shots
  90. (`stills.mjs <slug> S3 S7`), rebuild the sheet and look again. Repeat until it passes. Check `references/traps.md`
  91. for the failure you're seeing before inventing a fix. If the person is in the loop, show them the board now and
  92. take their notes before animating.
  93. ### 6. Animate
  94. Bring each shot to life from its key pose: `poseAt` keys with anticipation, holds and overshoot, `faceAt` for
  95. expressions, camera moves with `kf`, the power's look, the `fx`. Then render a draft and check the motion:
  96. ```bash
  97. python <skill>/scripts/master.py <slug>
  98. python <skill>/scripts/motiongrid.py <slug> S2 S5
  99. node <skill>/scripts/stills.mjs <slug> --frames 120 240
  100. ```
  101. Read the grids like a flipbook against the motion checklist in `references/look.md`; fix and re-render until it
  102. reads.
  103. ### 7. Sound
  104. Read `references/sound.md`. Add `sound` to `episode.json`: the clips (prompt and length), one event per visible
  105. action cued to its shot, ambiences per location, the music bed and the levels. Check what the library already has,
  106. then generate:
  107. ```bash
  108. python <skill>/scripts/sfx.py <slug> --dry
  109. python <skill>/scripts/sfx.py <slug>
  110. ```
  111. It prints the credits it used and sets the stem volumes in `timeline.json`. Then check that every word stays clear:
  112. ```bash
  113. python <skill>/scripts/mixcheck.py <slug>
  114. ```
  115. It lists the moments, while a word is being spoken, where effects or music come within 3 dB of the voice. A hit that
  116. 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;
  117. if most of the stem crowds the voice, lower `sfx_lu`. Re-run sfx.py and the check until only deliberate overlaps
  118. remain (a title boom, a turn).
  119. ### 8. Master and hand over
  120. ```bash
  121. python <skill>/scripts/master.py <slug>
  122. ```
  123. Renders, brings the mix to -14 LUFS with peaks under -1 dBTP, and writes `out/<slug>/report.json` (length, loudness,
  124. pace, credits). Watch the final file once through with sound. Hand over `out/<slug>/<slug>-final.mp4` and
  125. `out/<slug>/storyboard.jpg`, with the length, the ElevenLabs credits used, and anything you'd still improve.
  126. ## Where an episode lives
  127. | Path | What |
  128. |---|---|
  129. | `src/episodes/<slug>/episode.json` | Everything you write: script, science, shots, edit, fx, sound |
  130. | `src/episodes/<slug>/shots.tsx`, `index.tsx` | The drawing: one component per shot, the power's look |
  131. | `src/episodes/<slug>/words.json`, `timeline.json` | Written by voice.py and plan.py (sfx.py adds the volumes) |
  132. | `public/<slug>/` | voice.wav, sfx.wav, music.wav |
  133. | `out/<slug>/` | board stills, storyboard.jpg, shotlist.md, motion grids, renders, costs.json, report.json |
  134. | `library/sfx/` | Every generated sound clip, shared by all episodes |
README.md · README · 133 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # What If animation: a free skill for Claude Code and OpenCode
  2. Type one line, "What if you could rewind 10 seconds?", and get a finished 15-25 second animated episode in the
  3. dusk-lit stick-figure style of the "What If" channels that took off on YouTube in October 2026.
  4. Every frame is drawn in code: the AI writes the scenes as SVG and Remotion renders them. The voice and the sound
  5. effects come from ElevenLabs. No image model, no video model, no drawing. It runs in Claude Code, or for free in
  6. OpenCode with a free model. Made by [FreshStack](https://freshstack.ai).
  7. ## What it does
  8. 1. **Writes the script** on the seven-beat What If formula (decoded from five scripts across four channels): a cold
  9. open of quick demos, the premise as a title card, the fun, and a turn built on one real, checked fact.
  10. 2. **Voices it** with ElevenLabs, with word timings, and tightens the pauses to the genre's pace.
  11. 3. **Lays out a shot list** on the words, at the genre's pace (about 27 cuts a minute in the opening and up).
  12. 4. **Renders a storyboard** of one still per shot, before any animation.
  13. 5. **Checks its own stills** against an 11-point checklist and fixes what reads wrong.
  14. 6. **Animates** an original cast on one rig, in rooms drawn in real perspective, lit by their own lamps and windows.
  15. 7. **Generates and syncs the sound:** an effect on every action, lined up by its attack, ambience per place, a
  16. music bed, levels set against the voice.
  17. 8. **Masters** the episode to -14 LUFS and reports what it cost.
  18. Why the character never changes: it isn't generated, it's a rig in code. The same function draws Pip in every
  19. shot, so there is nothing to drift.
  20. ## What you need
  21. - [Claude Code](https://claude.com/claude-code), or [OpenCode](https://opencode.ai) with a free model (see
  22. [Use it in OpenCode](#use-it-in-opencode-with-a-free-model))
  23. - Node 18 or newer, ffmpeg (with ffprobe), Python 3.9+ with `numpy` and `Pillow`
  24. - An [ElevenLabs](https://elevenlabs.io) API key in your environment or a `.env` file as `ELEVENLABS_API_KEY`.
  25. The copy-paste episode cost 152 credits: 78 for the voice and 74 for 12 new sound effects. It reused 9 clips from
  26. the starter library that ships in `studio/library/sfx/`, and every clip you generate joins it for the next
  27. episode. Later runs cost 170 to 242 credits. ElevenLabs' free plan (10,000 credits a month when we checked, in
  28. October 2026) covers about 40 episodes, but it's for non-commercial use and asks you to credit ElevenLabs, so
  29. check its terms before you monetise.
  30. ## Install in Claude Code
  31. Clone it into your skills folder, then set up the studio once:
  32. ```bash
  33. git clone https://github.com/kelano86/what-if-animation ~/.claude/skills/what-if-animation
  34. cp -r ~/.claude/skills/what-if-animation/studio ./what-if-studio
  35. cd what-if-studio && npm install
  36. ```
  37. Then, in Claude Code, from that folder:
  38. > Make a What If episode: what if you could pause everyone but you?
  39. Claude follows `SKILL.md`: script, voice, shot list, storyboard (you'll see it before anything is animated), self-
  40. check, animation, sound, master. You get `out/<slug>/<slug>-final.mp4` and `out/<slug>/storyboard.jpg`.
  41. To see the examples first: `npx remotion studio src/index.ts` and open `Rewind` (the proof clip: three demos, each
  42. undone by playing the shot backwards) or `CopyPaste` (the skill's first full run). Both render straight away.
  43. ## Use it in OpenCode, with a free model
  44. [OpenCode](https://opencode.ai) is a free, open-source coding agent. In October 2026 it offers GLM-5.3-Flash Free at
  45. no cost, for a limited time, with no account or key. With this skill, that model made a full episode from one line:
  46. 28 minutes, one render, nothing typed in between, and $0 for the model (the voice and sound still use your
  47. ElevenLabs credits).
  48. 1. Install the tools above, then OpenCode: `npm install -g opencode-ai`
  49. 2. Make a folder for your episodes, put the skill in it under `.claude/skills/`, and add the `/what-if` command
  50. (OpenCode doesn't list skills when you type `/`, so the command loads it for you).
  51. Windows (PowerShell):
  52. ```powershell
  53. mkdir what-if; cd what-if
  54. git clone https://github.com/kelano86/what-if-animation .claude/skills/what-if-animation
  55. mkdir .opencode/commands
  56. copy .claude/skills/what-if-animation/opencode/commands/what-if.md .opencode/commands/
  57. ```
  58. Mac or Linux:
  59. ```bash
  60. mkdir what-if && cd what-if
  61. git clone https://github.com/kelano86/what-if-animation .claude/skills/what-if-animation
  62. mkdir -p .opencode/commands && cp .claude/skills/what-if-animation/opencode/commands/what-if.md .opencode/commands/
  63. ```
  64. No git? Download the ZIP from GitHub and unzip it into `.claude/skills/` (the folder's name doesn't matter), then
  65. copy `opencode/commands/what-if.md` from it into `.opencode/commands/`.
  66. 3. Put your key in a file called `.env` in the same folder, one line: `ELEVENLABS_API_KEY=your-key`
  67. 4. Start OpenCode **from inside that folder**: `cd` into it (on Windows you can right-click the folder and choose
  68. Open in Terminal), then type `opencode`. Started anywhere else, it won't find the skill or the command.
  69. 5. Type `/models`, choose GLM-5.3-Flash Free, and press Ctrl+T until the reasoning level reads high.
  70. 6. Type `/what-if What if you could pause everyone but you?` and leave it running. The first run copies the studio
  71. into `what-if-studio/` and installs it, which adds a few minutes.
  72. Tips for the free model:
  73. - One session per episode. An episode can fill most of its 200K context; start fresh for the next one.
  74. - Search YouTube for your premise yourself. The free model's search can miss episodes that already exist, and the
  75. skill wants an original title.
  76. - Open the source of the episode's fact (`science` in its `episode.json`) before you post.
  77. ## What's in the folder
  78. | Path | What |
  79. |---|---|
  80. | `SKILL.md` | The pipeline the AI follows |
  81. | `references/` | The formula, the measured look and checklists, the building-block catalogue, sound, traps |
  82. | `studio/` | The Remotion project: the engine (rig, sets, light, UI, the episode engine) and two example episodes |
  83. | `scripts/` | voice, plan, stills, board, sfx, mixcheck, motiongrid, master |
  84. | `opencode/commands/what-if.md` | The `/what-if` command for OpenCode |
  85. ## The rules it follows
  86. - Original characters only: never a channel's hero, nothing that resembles a famous cartoon character.
  87. - Original stories: the formula is shared, the episodes aren't anyone's.
  88. - It never claims the viral channels are made with Claude or any other tool; nobody has said how they're made.
  89. - Every fact in a script is worked out and sourced before it's voiced.
  90. ## Honest limits
  91. - Walk cycles and acting are simple next to a hand-animated channel; the look carries it.
  92. - Painted, textured styles (the ink-and-paper explainers) aren't realistic in pure code; they need an image model.
  93. - It's not one prompt: the storyboard step is where the episode gets good. Look at it.
  94. ## Licences
  95. - Fonts load from Google Fonts at render time (Bricolage Grotesque, Fragment Mono, Kalam: SIL Open Font License).
  96. To use your own title face, put it in `studio/public/fonts/` and set `titleFont` in `src/studio.config.ts`.
  97. - [Remotion](https://www.remotion.dev/license) is free for individuals and for companies of up to three people;
  98. larger companies need a Remotion company licence.
  99. - Voices and sound effects are generated by your ElevenLabs account under its terms. The example episodes' audio
  100. and the starter clips in `studio/library/sfx/` were generated on a paid plan.
  101. - The code is free to use, change and share.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.