Skip to content
Skills Library
Marketing & content · Building & coding

animate

/animate

Make a finished short animation drawn entirely in code, with a synthesized soundtrack, from any number of reference images or videos plus a rough idea. Three jobs: animate a still image the user supplies, repaint a reference as a moving scene, or make a new film on a topic in the look of the references (explainers, animated stories, motion graphics, loops). Use whenever the user shares a reference image or video and says animate this, bring it to life, make it move, make something like this, in this style, or asks for an animated explainer or story "drawn with code" or without AI video models,

Licence
MIT
Last repository change
07.11.2026

Assessment and security

95/ 100Class: good
Format20 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
30
Scripts
13
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 07.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What to check before installing
  • 13 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: examples/moving-image/animate.py, examples/moving-image/layers.py, examples/seaside-scene/Seaside.tsx, examples/seaside-scene/clouds.ts, examples/seaside-scene/foliage.ts, examples/seaside-scene/people.ts, examples/seaside-scene/scene.ts, scripts/compare.py

What it does and when to use it

Make a finished short animation drawn entirely in code, with a synthesized soundtrack, from any number of reference images or videos plus a rough idea. Three jobs: animate a still image the user supplies, repaint a reference as a moving scene, or make a new film on a topic in the look of the references (explainers, animated stories, motion graphics, loops). Use whenever the user shares a reference image or video and says animate this, bring it to life, make it move, make something like this, in this style, or asks for an animated explainer or story "drawn with code" or without AI video models,

Triggers from the description

drawn with code
Original author description

Make a finished short animation drawn entirely in code, with a synthesized soundtrack, from any number of reference images or videos plus a rough idea. Three jobs: animate a still image the user supplies, repaint a reference as a moving scene, or make a new film on a topic in the look of the references (explainers, animated stories, motion graphics, loops). Use whenever the user shares a reference image or video and says animate this, bring it to life, make it move, make something like this, in this style, or asks for an animated explainer or story "drawn with code" or without AI video models,

How it works

  1. Pick the job
  2. Stage 1: Study every reference
  3. Stage 2: Beats
  4. Stage 3: Build the picture
  5. Stage 4: Sound
  6. Stage 5: Render, check, fix
  7. Hand over
Original SKILL.md headings · 161 lines, 1,351 words
SKILL.md preview
---
name: animate
description: >-
  Make a finished short animation drawn entirely in code, with a synthesized soundtrack, from any number of
  reference images or videos plus a rough idea. Three jobs: animate a still image the user supplies, repaint a
  reference as a moving scene, or make a new film on a topic in the look of the references (explainers, animated
  stories, motion graphics, loops). Use whenever the user shares a reference image or video and says animate this,
  bring it to life, make it move, make something like this, in this style, or asks for an animated explainer or
  story "drawn with code" or without AI video models, even if they never say "skill". Prefer this over video-studio
  when the look of the animation is the point rather than a narrated reel.
---

# animate

Turn references and a rough idea into an MP4 where every frame is drawn by code and the sound is synthesized.
The user brings taste; you do the directing. A rough brief is enough, so make the creative calls yourself and ask
only about what would change the whole piece.

Everything lives in `animations/<slug>/`:

```
refs/  study/  style.md  beats.md  piece.html  score.json  out/<slug>.mp4
```

Add helper scripts or notes there as needed. `examples/bee-dance/` in this skill's folder is a complete worked film.

In the commands below, `$SKILL` means this skill's folder. Run them from the user's project with `$SKILL/.venv/bin/python`
if that exists, otherwise `python3`. If a package is missing, see the setup in `README.md`. They need ffmpeg and Chrome.

## Pick the job

| The user wants | Job | How |
| --- | --- | --- |
| "Animate this image" | **Move the artwork** | Cut the image into layers and move those. Read `references/move-an-image.md`. Skip stages 3-4's piece.html; the render is a Python script. |
| "Paint this", "recreate this scene" | **Repaint** | Draw the whole scene in `piece.html`, matching the reference closely. |
| A topic or story "in this style" | **New film** | Full process below. References set the look; the subject is new. |

If they don't name a length or shape, use 15 seconds at 1080x1920 for a film and 5 seconds for a moving image.

Code is strong at shapes, lines, gradients and texture: flat vector, line art, paper-cut, risograph, watercolour,
anime backgrounds, botanical plates. It is weak at photorealism and at acting faces. If a reference is photoreal,
say so before building and propose an illustrated take on it.

## Stage 1: Study every reference

The user may hand you many references, so give each one a job rather than averaging them into mush.

```bash
python3 $SKILL/scripts/study.py animations/<slug>/study <files or folders...>
```

This gives you, per reference, a contact sheet, a palette, and for videos the cuts and the pacing curve. If only part
of a video matters, add its range in seconds, as in `"reel.mp4@0-12"`, or talking-head footage skews the results.
Then look at the sheets yourself, and crop in where texture matters. Numbers can't tell you why something feels good.

Write `style.md`:

- **What each reference gives us**, one line each: texture from this one, type from that one, pacing from another.
- **What we will not copy**: poses, characters, logos, signatures, exact compositions. Take the style, not the work;
  the exception is a Repaint or Move job on an image the user asked to animate.
- **Palette** as hex values, **type** (`assets/fonts/` has two to start with, or copy in any open font), **texture**, **motion feel**.
- **One device** that ties the piece together: a lens, a ripple, a line that never breaks. Films without one feel
  like a slideshow.

Add a short card for each new reference to `animations/library.md`, so its lessons outlive this project. Reuse
cards when the user points at a style they've used before, and extend one only when you learned something new.

**Gate:** you can say in one sentence what this piece looks like and why that serves the topic.

## Stage 2: Beats

If there are facts in the piece, check them first. A wrong claim drawn beautifully is still wrong, and popular
"facts" are often loose. Note anything you softened for the final report.

Write `beats.md` as one table. Picture and sound are planned together because that sync is what makes it feel
expensive:

| Time | Picture | Sound |
| --- | --- | --- |
| 0-1.5 s | An orange drop falls and spreads | Drip, wet bloom, pad comes in |
| 1.5-3 s | Title line, details pop on | Pluck per word, tiny ticks |

**Gate:** something moves in the first half second; the shape is hook, build, a breath, payoff; no stretch over
2 seconds without a new picture idea; the end holds about 1.5 seconds so it can be read. Let the picture carry the
new ideas rather than the words: each caption needs about 1.5 seconds on screen, so cut captions before shortening
them. Keep text out of the top 12% and bottom 18% of a vertical frame.

## Stage 3: Build the picture

Copy `assets/piece-template.html` to `piece.html` and draw in it. The contract is `window.PIECE` plus
`window.renderFrame(t)`.

`renderFrame(t)` must depend only on `t`, and may be async. Stills jump straight to any time, so anything remembered
between frames, or any unseeded `Math.random()`, breaks them. Paint expensive static layers once inside `window.ready`,
from a seeded generator, then composite per frame.

To show another film inside a piece, extract its frames to `clips/` as numbered JPEGs, load the one you need with an
`Image` inside an async `renderFrame`, and draw it to the canvas.

Read `references/styles.md` before drawing; it has working recipes (cel clouds, foliage, walking figures, water,
watercolour, paper) and the source files to copy from. Depth comes from layers moving at different speeds, life
comes from small secondary motion: sway, drift, shimmer, flicker.

Review stills early and often, long before a full render:

```bash
python3 $SKILL/scripts/render.py animations/<slug>/piece.html --stills 0.5 3 7 12
```

Look at them at full size, compare them side by side with the references, and fix what's off. Expect several rounds.
The first still is usually a rough draft, and this loop is where the quality comes from.

```bash
python3 $SKILL/scripts/compare.py animations/<slug>/out/compare.jpg <stills and reference images...>
```

**Gate:** a still from the middle looks like it was made with the same materials as the references: same paper, paint,
line and colour. The subject can be new. Clip-art versions of the reference don't pass.

## Stage 4: Sound

Write `score.json` against the same times as `beats.md`. See the header of `scripts/synth.py` for the sounds
available: plucks, bells, pads, drips, ticks, swells, whooshes, impacts, kicks and noise beds.

```bash
python3 $SKILL/scripts/synth.py animations/<slug>/score.json animations/<slug>/out/score.wav
```

Stay in one key. Land the hits on picture events, not on a grid. Leave real quiet before the payoff, because the
contrast is what makes it land. Generate long runs of notes with a few lines of Python rather than typing them out.

You can't hear it, so read the level report `synth.py` prints: look for dips you didn't plan, and for the signature
sound being buried under the rest.

### If the piece is narrated

Narration comes before the picture, because word timings set every beat. Record it with whatever voice tool the user
has, transcribe it with word timings (faster-whisper works), then build the beats and captions from those times.
Whisper can start a word early in the silence before it, so check the waveform before cutting in a pause.

Mix the voice over the score, then render with the result as `--audio`. The score ducks under the voice, so music rises
in the pauses:

```bash
python3 $SKILL/scripts/mix.py animations/<slug>/out/voice.wav animations/<slug>/out/score.wav animations/<slug>/out/mix.wav
```

## Stage 5: Render, check, fix

```bash
python3 $SKILL/scripts/render.py animations/<slug>/piece.html --audio animations/<slug>/out/score.wav
python3 $SKILL/scripts/qc.py animations/<slug>/out/<slug>.mp4
```

`render.py` writes `out/<slug>.mp4`, mastered to -14 LUFS. It prints progress, and takes about 1-2 minutes for 15
seconds of a typical piece; run it in the background if a piece is heavy. After a sound-only change, add `--remux`
to swap the audio in seconds without redrawing.

`qc.py` flags dead stretches, one-frame glitches and loudness, and writes a contact sheet. It can't judge whether
motion looks good, so read the sheet too, then step through the risky moments frame by frame in close-up crops:
transitions, text on and off, where layers overlap, and a full cycle of any repeated motion. Fix and re-render until
clean.

## Hand over

Report in the user's plain language: what you made, how each reference was used, what you checked, and what you
could not check. You cannot hear the score or watch it at speed, so say so. Add:

- **One fact to know**, if you softened a claim.
- **Easy tweaks**: 3 or 4 specific changes they could ask for next.
- Whether a reference belongs to someone else and needs thought before commercial use.
Files in this package (30)
  • .gitignore 1 KB
  • LICENSE 1 KB
  • README.md 3 KB
  • SKILL.md 9 KB
  • requirements.txt 1 KB
  • assets/piece-template.html 2 KB
  • assets/fonts/IBMPlexMono-SemiBold.ttf 137 KB
  • assets/fonts/InstrumentSerif-Italic.ttf 70 KB
  • assets/fonts/OFL-IBMPlex.txt 4 KB
  • assets/fonts/OFL-InstrumentSerif.txt 4 KB
  • examples/bee-dance/beats.md 3 KB
  • examples/bee-dance/piece.html 55 KB
  • examples/bee-dance/score.json 7 KB
  • examples/bee-dance/style.md 3 KB
  • examples/moving-image/animate.py 11 KB
  • examples/moving-image/layers.py 7 KB
  • examples/moving-image/source.webp 356 KB
  • examples/seaside-scene/Seaside.tsx 10 KB
  • examples/seaside-scene/clouds.ts 9 KB
  • examples/seaside-scene/foliage.ts 2 KB
  • examples/seaside-scene/people.ts 10 KB
  • examples/seaside-scene/scene.ts 21 KB
  • references/move-an-image.md 3 KB
  • references/styles.md 4 KB
  • scripts/compare.py 1 KB
  • scripts/mix.py 1 KB
  • scripts/qc.py 4 KB
  • scripts/render.py 5 KB
  • scripts/study.py 5 KB
  • scripts/synth.py 7 KB

Versions

RepositoryScoreLicence
This page · JAYANTCH1797/animate-skill95MIT
hamedmp/matrix-os100AGPL-3.0
emilkowalski/skill100MIT
emilkowalski/skills100MIT
arcreel/arcreel100AGPL-3.0
growupanand/ConvoForm100Apache-2.0
mathews-tom/armory100MIT
owid/owid-grapher100MIT
d3uceY/SpriteWare100MIT

Database snapshot: 13.11.2026 · package version b410fa708be4 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100animation-studio
    This skill should be used when the user asks to "make an animated video about X with music", "make a cartoon / animated short", "animate this story", "make a video like the Opus animations", "make an explainer animation (with a voiceover)", "make a promo video for my app / brand…
  • 100video-by-reference
    Make a fully code-generated animated video at the highest achievable visual and design quality (with an original synthesized soundtrack) whose look, sound, editing and pacing are learned from a reference video — in whatever style that reference uses (flat 2D, 3D/CG, anime,…
  • 90animated-video
    Make animated videos in code with Remotion (React, SVG, three.js): explainers, character stories, motion graphics, kinetic typography, paper collage and animated infographics, in 2D or 3D, from a script or voiceover, in any aspect ratio. Use when asked to animate a script, make…
  • 100video-director
    Direct, build and verify short videos that are written as code and rendered frame by frame (HTML/Canvas/SVG/Three.js, GSAP or Remotion → MP4 or a live page). Covers motion graphics, product launch films, promos, explainers, kinetic typography, data stories, lyric and music…
  • 95motion
    Motion-graphics lane for Claude Code and Codex. Make launch videos, showreels, product reels, animated explainers, motion ads, kinetic type, UI-morph films, logo stings and social clips rendered from code (seek(t) HTML -> MP4) with synthesized music/SFX and a self-critique loop.…
  • 100story-animator
    Make a narrated 2D animated story video (kids' story, bedtime story, fable, festival story, short animated film) where every frame is drawn in code with Remotion, the narration is an ElevenLabs voice, and there is optional music and sound effects. No AI image or video…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.