Skip to content
Back to search

stick-figure-film-skill

A Claude skill for making animated short films where every frame is drawn in code: stick figures, ink hatching, a cinematic camera and synced sound, rendered to MP4.

Safety scan

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

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/lauroguedes--stick-figure-film-skill/badge.svg)](/listings/lauroguedes--stick-figure-film-skill)

HTML

<a href="/listings/lauroguedes--stick-figure-film-skill"><img src="/api/listings/lauroguedes--stick-figure-film-skill/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.

npx skills add lauroguedes/stick-figure-film-skill

This uses the [`skills`](https://github.com/vercel-labs/skills) CLI (Node.js 22.20 or later). It installs the skill into the current project for the coding agents it detects; add `-g` to make it available in every project, or `-a claude-code` to choose the agent:

npx skills add lauroguedes/stick-figure-film-skill -g -a claude-code

The skill was written and tested with Claude Code. Other agents the CLI supports can load it, but its review workflow assumes an agent that can read images and run shell commands.

<details> <summary>Manual install</summary>

Copy the `skills/stick-figure-film/` folder into a skills directory Claude reads:

git clone https://github.com/lauroguedes/stick-figure-film-skill.git
cp -R stick-figure-film-skill/skills/stick-figure-film ~/.claude/skills/

For the Claude apps, zip the `skills/stick-figure-film/` folder and upload it as a custom skill.

</details>

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.

README.md · README · 230 lines
  1. <div align="center">
  2. # stick-figure-film
  3. **A Claude skill for making animated short films where every frame is drawn in code.**
  4. Stick-figure characters · ink-and-hatching look · choreographed action · cinematic camera ·
  5. synced sound and music · rendered to MP4 · no video-generation model involved.
  6. [![License: MIT](https://img.shields.io/badge/license-MIT-black.svg)](LICENSE)
  7. [![Claude Skill](https://img.shields.io/badge/Claude-skill-black.svg)](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview)
  8. [![Node](https://img.shields.io/badge/node-%E2%89%A520-black.svg)](https://nodejs.org)
  9. [![ffmpeg](https://img.shields.io/badge/requires-ffmpeg-black.svg)](https://ffmpeg.org)
  10. <img src="docs/paper-fight-poster.png" alt="PAPER FIGHT: two stick figures clash with a giant sword and hammer in an ink storm" width="760">
  11. </div>
  12. ---
  13. ## What it is
  14. `stick-figure-film` turns Claude into a small animation studio. Describe a film, for example *"a 20-second
  15. rooftop sword fight, black ink on notebook paper, with sound"*, and Claude writes it the way a
  16. studio would make it: characters on a rig, pose keys, a keyframed camera, effects and a sound cue
  17. sheet. A script then draws every frame on a canvas and encodes the result with ffmpeg.
  18. Because the film is code, everything is editable and deterministic: change a pose, a camera move
  19. or a timing and re-render. Nothing is generated by a video model.
  20. The skill was extracted from the production of **PAPER FIGHT**, a three-minute, seven-scene
  21. stick-figure action film. It bundles the engine that film was made with and the working method
  22. that got it there, including the mistakes, written down so they are not repeated.
  23. <div align="center">
  24. <img src="docs/demo.gif" alt="A few seconds of PAPER FIGHT: a bullet deflected in slow motion, then the opening clash" width="720">
  25. <br>
  26. <sub>A few seconds of PAPER FIGHT (silent preview; the film has a full soundtrack).</sub>
  27. </div>
  28. ## Features
  29. - **A complete film pipeline.** Project template, story bible, one file per scene, review on
  30. contact sheets, sound mix, MP4 render, end credits and social cuts.
  31. - **A character rig that moves well.** Two-bone IK limbs, a flexible spine, follow-through, smear
  32. frames, ballistic jumps on true parabolas, hands and feet pinned to the world for grabs and
  33. wall-runs.
  34. - **Weapons and props.** Thirteen weapon types, from a pencil staff to an ink-forged greatsword,
  35. a revolver and a rifle, that can be held, thrown, planted, morphed and broken. Shots come with muzzle
  36. flash, tracers, casings, ricochets and persistent bullet holes.
  37. - **A cinematic camera.** Keyframed pan, zoom and roll; fighter tracking; shake; impact frames;
  38. slow motion; bullet-time close-ups.
  39. - **A notebook world kit.** Ruled pages, hatched floors, breakable brick walls, debris, cracks,
  40. tears, parallax layers, page-turn transitions.
  41. - **Sound with no assets required.** A built-in synthesizer renders effects and a scene-by-scene
  42. score from the cue sheet, loudness-normalised and frame-accurate. Optionally, generate the
  43. effects and score with [ElevenLabs](https://elevenlabs.io) using your own API key.
  44. - **Review tools for an AI that cannot watch video.** Contact sheets, a joint/weapon probe, a
  45. blade-crossing finder and an animation lint (teleporting joints, limbs through the floor,
  46. characters out of frame).
  47. - **Honest delivery.** The skill makes Claude say what it checked and how (on still frames and
  48. by measurement) and that the film was never watched in motion or heard.
  49. <div align="center">
  50. <img src="docs/paper-fight-frames.png" alt="Twelve frames from PAPER FIGHT across its seven scenes" width="900">
  51. <br>
  52. <sub>Frames from PAPER FIGHT: bare hands, a city of pencils, a geometry zone, a graph-paper gunfight, a torn-paper battlefield, an ink storm.</sub>
  53. </div>
  54. ## Install
  55. ```bash
  56. npx skills add lauroguedes/stick-figure-film-skill
  57. ```
  58. This uses the [`skills`](https://github.com/vercel-labs/skills) CLI (Node.js 22.20 or later). It
  59. installs the skill into the current project for the coding agents it detects; add `-g` to make it
  60. available in every project, or `-a claude-code` to choose the agent:
  61. ```bash
  62. npx skills add lauroguedes/stick-figure-film-skill -g -a claude-code
  63. ```
  64. The skill was written and tested with Claude Code. Other agents the CLI supports can load it,
  65. but its review workflow assumes an agent that can read images and run shell commands.
  66. <details>
  67. <summary>Manual install</summary>
  68. Copy the `skills/stick-figure-film/` folder into a skills directory Claude reads:
  69. ```bash
  70. git clone https://github.com/lauroguedes/stick-figure-film-skill.git
  71. ```
  72. ```bash
  73. cp -R stick-figure-film-skill/skills/stick-figure-film ~/.claude/skills/
  74. ```
  75. For the Claude apps, zip the `skills/stick-figure-film/` folder and upload it as a custom skill.
  76. </details>
  77. ## Usage
  78. Ask for a film in plain words. The skill triggers on requests for animated shorts, fight scenes,
  79. stick-figure or doodle animation, or code-drawn video:
  80. > Make a 20-second stick figure sword fight on a rooftop, black ink on notebook paper, one quick
  81. > fighter and one heavy one, two real clashes, and one gets knocked off the roof. With sound.
  82. > I teach primary school. Make a 12-second animation where a stick figure throws a paper plane,
  83. > chases it, trips over a pencil and catches it with a jump. Friendly, with some sound.
  84. > Add a new scene to my film where they fight with spears on a floating ruler.
  85. > Make a 30-second teaser, three vertical clips and a thumbnail from my film.
  86. For short films Claude builds the whole thing and tells you every choice it made. For long films
  87. it delivers a 15-second prototype first and waits for your approval, then writes a story bible
  88. and builds the scenes, in parallel with one agent per scene when subagents are available.
  89. ## How it works
  90. ```
  91. brief ─▶ prototype ─▶ story bible ─▶ scenes (one file each) ─▶ review on contact sheets
  92. │ │
  93. ▼ ▼
  94. sound cue sheet ─▶ soundtrack ─▶ render MP4 ─▶ credits & social cuts
  95. ```
  96. A scene is one JavaScript file with its own clock. It declares pose keys for the characters,
  97. weapon tracks, camera keys, contacts and drawing hooks for its set:
  98. ```js
  99. const S = createScene({ id: 'rooftop', title: 'Rooftop', duration: 10, score: 'duel' });
  100. S.fighters({ A: [ /* pose keys */ ], B: [ /* pose keys */ ] });
  101. S.weapon('sword', [ /* held / thrown / planted keys */ ]);
  102. S.camera([ /* pan, zoom, roll, tracking */ ]);
  103. S.hit({ t: 3.4, x: 1180, h: 160, sound: 'clang', weight: 0.9, impact: true });
  104. S.env({ stage(ctx, t, E) { /* draw the rooftop */ } });
  105. export default S.build();
  106. ```
  107. `S.hit` places the burst, the sound and the camera shake on the same frame, so picture and sound
  108. cannot drift. Every frame is a pure function of time, so any frame can be rendered on its own.
  109. ## What's in this repository
  110. ```
  111. skills/stick-figure-film/ the skill
  112. ├── SKILL.md workflow and the craft rules learned the hard way
  113. ├── references/
  114. │ ├── engine.md scene authoring API: poses, weapons, camera, effects, set kit
  115. │ ├── production.md story bible, scene and polish briefs for subagents, checklists
  116. │ └── sound.md cue sheet, synthesizer, score styles, optional ElevenLabs
  117. └── assets/template/ the project scaffold Claude copies for each new film
  118. ├── src/engine/ rig, weapons, camera, effects, ink, set kit, scene runtime
  119. ├── src/scenes/ a minimal example, the full 15-second fight example, a weapon gallery
  120. └── tools/ render, contact sheets, probe, lint, sound, social cuts, preview
  121. examples/paper-fight/ the scene files, credits and story bible of the original film
  122. evals/ test prompts and graders for the skill
  123. docs/ images for this README
  124. ```
  125. ## Requirements
  126. | | |
  127. |---|---|
  128. | **Node.js** | 20 or newer. The only npm dependency is [`@napi-rs/canvas`](https://github.com/Brooooooklyn/canvas). |
  129. | **ffmpeg** | On the `PATH`, for encoding and audio checks. |
  130. | **Fonts** | The handwriting fonts `Bradley Hand` / `Noteworthy` (macOS) are used for doodles and credits; on other systems set a font you have in `kit.js` and `credits.js`. |
  131. | **ElevenLabs** (optional) | Your own API key in `ELEVEN_LABS_API_KEY`, only if you want generated effects and score. |
  132. ## Try the engine without Claude
  133. ```bash
  134. cp -R skills/stick-figure-film/assets/template my-film && cd my-film && npm install
  135. ```
  136. ```bash
  137. npm run build # soundtrack + film → out/film.mp4 (the minimal example scene)
  138. ```
  139. ```bash
  140. npm run preview # scrubbable player at http://localhost:4173/preview.html
  141. ```
  142. ```bash
  143. node tools/sheet.mjs --scene ref --from 3 --to 6 --n 12 --out out/sheet.png # contact sheet of the fight example
  144. ```
  145. ## Sound and generated audio
  146. Sound works out of the box with the built-in synthesizer: no network, no assets, no cost. Each
  147. scene picks a score style: `duel`, `chase`, `clockwork`, `heavy`, `climax`, `aftermath`,
  148. `playful` or `none`.
  149. ElevenLabs generation is optional. It spends **your** credits, so the skill reads the current
  150. API docs, estimates the cost, and asks you for an explicit credit cap before generating anything.
  151. Generated files are cached and never regenerated without `--force`. Check your ElevenLabs plan's
  152. licence terms before publishing generated audio.
  153. ## Limitations
  154. - **Claude cannot watch or hear the film.** It reviews still frames and measurements. Timing in
  155. motion, music and the mix are yours to judge, and the skill says so every time.
  156. - **It is 2D.** Simulated 3D camera moves around flat figures did not work and are deliberately
  157. not offered; dramatic moments use moving close-ups instead.
  158. - **The engine's vocabulary is a fighter's** (`S.fighters`, `S.hit`, weapons). Non-fight stories
  159. work (chases, props, falls, comic beats), but some props are drawn by hand in scene hooks.
  160. - **Long films are long jobs.** A three-minute film is many agent-hours of work and can run into
  161. usage limits; scene files are saved as they go so interrupted work can resume.
  162. ## Evaluations
  163. `evals/` holds two test cases, a rooftop sword duel and a classroom paper-plane chase, with
  164. graders, in the format read by `claude plugin eval`. In a first trial, runs with the skill passed
  165. 12 of 12 checks against 10 of 12 without it; the difference was honest reporting of what was and
  166. was not verified. The trial's findings shaped the current version.
  167. ## Credits
  168. - **PAPER FIGHT**: directed by Lauro Guedes, animated by Claude.
  169. - Sound effects and score of the original film generated with ElevenLabs; the skill's default
  170. sound is synthesized.
  171. ## License
  172. [MIT](LICENSE) © 2026 Lauro Guedes

Ratings and comments

Sign in to rate this skill.

Sign in

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