by zeative
Agent skill + film engine for teardown-style educational videos: 3D replicas of real things, product-film camera moves, pinned labels, one-take narration, music and SFX. Storyboard first, built in HTML, GSAP and three.js, rendered frame by frame.
# Add to your Claude Code skills
git clone https://github.com/zeative/motion-educatorGuides for using ai agents skills like motion-educator.
See how motion-educator compares with popular alternatives.
motion-educator is an open-source ai agents skill for AI coding assistants such as Claude Code, Codex CLI, and ChatGPT, built by zeative. Agent skill + film engine for teardown-style educational videos: 3D replicas of real things, product-film camera moves, pinned labels, one-take narration, music and SFX. Storyboard first, built in HTML, GSAP and three.js, rendered frame by frame. It has 50 GitHub stars.
motion-educator's catalog security scan is still queued. You can run an instant dependency and prompt-injection check now with the "Scan for vulnerabilities" button above.
Clone the repository with "git clone https://github.com/zeative/motion-educator" and add it to your Claude Code skills directory (see the Installation section above). motion-educator ships a SKILL.md manifest, so compatible agents can discover and load it automatically.
motion-educator is primarily written in JavaScript. It is open-source under zeative on GitHub, so you can review or fork the full source.
Yes. SkillsLLM lists many other AI Agents skills you can browse and compare side by side. Open the AI Agents category from the badge at the top of this page, or use the Related Skills and comparison links further down to weigh motion-educator against similar tools.
No comments yet. Be the first to share your thoughts!
Available after the catalog security scan passes.
⚠️ Third-Party Software Notice
This skill is third-party open-source software developed and hosted independently on GitHub. SkillsLLM lists this project for discovery and does not control or maintain the underlying repository.
Any security checks, ratings, or warnings displayed by SkillsLLM are automated and limited in scope. They do not constitute a security certification or guarantee that the software is safe, error-free, or free from malicious code, vulnerabilities, compromised dependencies, or prompt-injection risks.
Review the source code, permissions, dependencies, and configuration before installing or running any third-party skill. Use is at your own risk. To the maximum extent permitted by applicable law, SkillsLLM is not liable for losses arising from third-party software.
The deep catalog scan for this skill is still queued. Run an instant dependency check now instead.
You make short educational films (20 to 120 seconds, landscape explainers or portrait shorts) that look expensive
and teach one thing well. The film is a web page with one paused timeline: every frame is drawn by seeking it, so
nothing is ever dropped and any shot can be fixed and re-rendered on its own. The kit in this skill is that engine.
examples/ holds finished films made by following this skill, each with its storyboard, source, cue sheet and
narration: langit-biru (captions only, the most reviewed) and petir-guntur (a narrated short) are the ones to
read first.
Their prompt → your research (the topic, the blueprints, the narration) → the storyboard, sent to them → their yes → the finished film. The storyboard is the only stop. Everything they might want to weigh in on goes into it: the script, the voice, the length, the real version of each object and the drawings it is built from. After their yes you build, check, review and fix on your own and deliver the best film you can make, without asking again.
references/detail.md says how), write the
choice and its reason in the delivery note, and carry on. Ask only when the film cannot be made without them
(a missing drawing or photo that changes what the film shows), and ask it with the storyboard, not after.Read only the reference your current step needs.
| Step | Read |
|---|---|
| Deciding what to teach and in what order | references/pedagogy.md |
| Writing and drawing the storyboard (the gate) | references/storyboard.md |
| Choosing the look, the accent, the stage light, 3D | references/look.md |
| Building real things in detail; directing the camera | references/detail.md |
| Building the film with the kit | references/engine.md, then references/motion.md |
| Writing the narration: talk, not captions; Indonesian and English register | references/narration.md |
| The voice: choosing it, performing one take with ElevenLabs, cutting the film to it | references/voice.md |
| Music, sound effects, the mix | references/sound.md |
| Checking the render, independent review | references/review.md |
storyboard.json passes
kit/tools/storyboard.mjs with zero errors and the person has seen the board. Every shot has drawn frames (how
it starts, what happens, how it ends), sketched in the real frame's coordinates, so the build can be cut
straight from them. If the person asked for an unattended run, send the board and keep going; otherwise wait for
their yes. That yes is the last thing you wait for: from there to the finished film, you decide.requestAnimationFrame loops, no Date.now(), no unseeded randomness.storyboard.json; captions
and the chapter rail are generated from it. Change the plan there, never by hand in the film. In a film that
speaks, the recorded take writes those times (voice.mjs).references/review.md).kit/tools/anatomy.mjs, kit/engine/body3d.js) or a measured scan, and build tissue and cells from a dimension sheet taken from histology. Every 3D shot has a deliberate
camera move, and when the voice names a part the camera goes to it (references/detail.md).The kit is copied into the person's project, never used from the skill's own folder.
node <skill>/kit/tools/new.mjs <workspace> <film-name> # copies kit/ and package.json if missing, scaffolds films/<film-name>/
cd <workspace> && npm install # three.js, GSAP, the fonts
bash kit/audio/fetch.sh # the sound library (not committed: licence)
Needs Node 20+, Playwright with Chromium, FFmpeg, and Python 3 with numpy for the mix. node kit/tools/doctor.mjs
checks all of it and says what to install. Add --portrait to new.mjs for a 1080x1920 short.
Who is watching, what they already know, and the promise: the one sentence they can say after watching. One film, one promise. If the topic needs two promises, it is two films. Pick the language the audience reads, the format (landscape for a lesson, portrait for a short) and whether the film speaks or explains with captions alone.
List every claim the film will make, each with its source, as facts in storyboard.json. Prefer primary and
institutional sources. Do the arithmetic yourself and show it (a number like "5,9x" is written with what it is
computed from). Write down what you are simplifying, and decide how the film will be honest about it.
Research does not stop at the first closed door. When a page will not open, try the other routes before you call
it unavailable: the same document elsewhere (Google Patents for patents, with its drawings on
patentimages.storage.googleapis.com; Wikimedia Commons for photographs; the manufacturer's PDF catalogue; an archived
copy), a direct download with curl, a different search. Read images by downloading them and looking at them. Say
exactly which address failed and how, and only then ask the person for what is still missing. A mechanism or a
real object is never filled in from memory because a search was hard (references/detail.md).
Follow references/narration.md: one question, written as continuous talk in the audience's own register, said
aloud and timed, before there is a shot list. Then cut it into shots: each speaking shot's voice is its run of
the script.
Follow references/storyboard.md. In short: acts, then shots (a new picture about every three seconds), each shot
with what it teaches, its caption, what is on screen, the motion, what carries into the next shot, the transition,
the sound, what to check, the facts it cites, and two or three drawn frames. Cut on the music's beat.
node kit/tools/storyboard.mjs films/NAME --png # zero errors, then show films/NAME/storyboard/*.png
Send the pages to the person. The contact sheets (the whole film in frames) go first.
Follow references/voice.md: choose a voice native to the language (let the person hear two or three if you can),
perform the whole script as one take, and cut the film to it. The storyboard's times are the take's from here on.
node kit/audio/voice.mjs films/NAME --script # the take to perform
node kit/audio/voice.mjs films/NAME --generate # with an API key: the take and its word times
node kit/audio/voice.mjs films/NAME --take AUDIO --words WORDS # with a speech connector: hand both back
node kit/audio/voice.mjs films/NAME # every shot's time, and the words to listen to
Follow references/detail.md: for each real object the film explains, find its blueprints first (technical and
dimensional drawings, exploded views, parts lists, patent figures) and write the model sheet (the drawings, every
part they show, real sizes) into the storyboard's models before drawing the board, so the board shows the real
parts; build it with kit/engine/parts3d.js, render a turnaround (four angles and a
close-up) and fix it until it passes the crop test. Only then build shots around it.
Follow references/engine.md. Give each shot a <section class="scene"> and animate it between
s.sNN.start and s.sNN.end. Build in storyboard order and look at a still of each shot as you finish it:
node kit/tools/render.mjs films/NAME --stills 1.5,4.2,7.9 # finished frames, a few seconds of work
Compare each still with its drawn frame. What the frame placed at (x, y) is at (x, y).
node kit/tools/render.mjs films/NAME # out/picture.mp4, in four-second segments
node kit/tools/render.mjs films/NAME --only 12-16 # after a fix: only the segments that changed
A minute of film at 60 fps is about half an hour on four CPU cores. Run it in the background and write the cue sheet meanwhile.
Follow references/sound.md: one music bed whose beat the cuts already sit on, and small clean effects on real
events, written as films/NAME/cues.json. A bed composed for the film (kit/audio/music.mjs) fits better than a library track
when the film will be published.
python3 kit/audio/mix.py films/NAME # out/NAME.mp4, loudness measured on the finished file
python3 kit/audio/mix.py films/NAME --no-sfx --out films/NAME/out/NAME-music-only.mp4
node kit/tools/make.mjs films/NAME runs the commands of steps 4 to 9 in order (check, voice, render, mix, measure, a
share copy) and stops at the first that fails. It does not replace looking at stills while you build.
Follow references/review.md: node kit/tools/check.mjs films/NAME (contact sheets, frozen time, loudness), then a
fresh reviewer with the film, the storyboard and the person's own words. Fix the largest gaps, re-render only what
changed, and have a new reviewer verify the list. Stop at the quality bar or when the gains turn cosmetic. When a
fix changes what a shot shows, change the storyboard to say so and redraw the board: the plan and the film never
disagree.
The MP4 (H.264, 1080p60, about -14 LUFS, true peak under -1 dBFS), a lighter copy for sharing, the music-only version, the storyboard pages, and a short honest note: what was measured, what was only looked at, what nobody has listened to, and what you would do next.
films/NAME/
storyboard.json the plan: facts, acts, shots, drawn frames. The film reads its times from here
storyboard.html the board (generated), storyboard/*.png its pages
index.html one <section class="scene"> per shot or group of shots
film.css this film's pieces, on top of kit/css/film.css
film.js the timeline, built with kit/engine/motion.js
cues.json the music bed and every sound, on the film's clock
voice/ the narration: take.mp3, the time of every word, the cut (voice.json), subtitles.srt
out/ renders (never committed)
Educational films that look expensive, built in code, storyboard first.
An agent skill and the film engine behind it. You ask for an explainer; it draws the storyboard, waits for your yes, then renders a 1080p60 film frame by frame: detailed 3D replicas of real things shot by a directed camera, a lit stage, glass, metal type, diagrams, captions, narration, music and sound effects.
Quick start · How it works · Gallery · The kit · Docs
Moments from films made with the skill, each by an agent following it from the brief to the mix. Every frame is code: no stock footage, no video model.
Most explainer videos made by an agent are slides with a voice. This one is held to a different standard:
One paused timeline is the only clock, so any frame can be drawn by seeking to it. No dropped frames, no flicker, a fix re-renders four seconds, not the film, and the drawing runs on the GPU (or on every CPU core).
Pencil frames for every shot, drawn in the real frame's coordinates, with what each shot teaches, shows, moves, carries over and cites. A validator enforces the standard.
Narration through ElevenLabs, a music bed whose beat the cuts sit on, effects on real events, mastered to −14 LUFS and measured on the encoded file.
1920x1080 for lessons, 1080x1920 for shorts, from one field in the storyboard. A short gets safe areas for app
chrome, captions lit word by word, and an ending that loops back into its start.
3D replicas built from a model sheet (reference, parts, real sizes) with a parts kit and materials that have surface; a camera that orbits, pushes in and racks focus; exploded views, cutaways, pinned labels.
Stills while building, contact sheets and frozen-time checks after rendering, then independent critics with ready-made briefs. Their lessons are written back into the skill.
The storyboard is not a sketch of intentions. It is the source of time for the film: shot starts and ends, captions and the chapter rail are read from it, and the frames are drawn where the pixels will be.
Top: frames from the storyboard. Bottom: the same moments in the render.
The checker refuses a storyboard that has too few pictures (one about every 3.2 s), a shot drawn only once, a
caption nobody could finish reading, a number with no fact behind it, a spoken line that will not fit its shot,
three shots of the same kind in a row, a 3D object with no model sheet (which real version, from which reference,
with which parts), a 3D shot with no camera move, or a short whose ending does not loop. Full standard: references/storyboard.md.
git clone https://github.com/zeative/motion-educator ~/.claude/skills/motion-educator
It is a plain Agent Skills folder (SKILL.md, references/, a Node kit), so any agent
that reads skills can use it. Clone it into the folder yours looks in:
| Agent | For you (all projects) | For one project |
|---|---|---|
| Claude Code | ~/.claude/skills/motion-educator |
.claude/skills/motion-educator |
| OpenAI Codex | ~/.agents/skills/motion-educator |
.agents/skills/motion-educator |
| Gemini CLI | ~/.gemini/skills/motion-educator |
.gemini/skills/motion-educator |
| GitHub Copilot (CLI, cloud agent, VS Code agent mode) | ~/.copilot/skills/motion-educator |
.github/skills/motion-educator |
| Cursor | reads ~/.claude/skills and ~/.codex/skills |
.cursor/skills/motion-educator |
An agent without skill support can still follow it: clone it anywhere and tell it to read SKILL.md there first.
What the agent needs: a shell to run Node, FFmpeg and Python, and the ability to look at images, since it checks its
own stills and contact sheets. Every film in this repository was made with Claude Code; the others are untested here.
Then ask your agent for a film:
Make a 45-second explainer on why the Moon always shows us the same face. Portrait, English, with narration.
It scaffolds a workspace in your project, writes and draws the storyboard, and stops for your approval before it builds anything.
git clone https://github.com/zeative/motion-educator && cd motion-educator
npm install && bash kit/audio/fetch.sh
node kit/tools/doctor.mjs # is this machine ready?
node kit/tools/new.mjs ~/films moon-face --portrait # a workspace and films/moon-face
cd ~/films && npm install && bash kit/audio/fetch.sh
# 1. Write films/moon-face/storyboard.json, then check it and draw the board
node kit/tools/storyboard.mjs films/moon-face --png
# 2. Record the narration (optional) and let it set the shot lengths
node kit/audio/voice.mjs films/moon-face --generate # one take, and the film cut to it (ELEVENLABS_API_KEY)
# 3. Build index.html, film.css and film.js, looking at stills as you go
node kit/tools/render.mjs films/moon-face --stills 1.5,4.2 --safe
node kit/tools/render.mjs films/moon-face --serve # watch it live
# 4. Everything else, in order: render, mix, measure, a share copy
node kit/tools/make.mjs films/moon-face
Requirements: Node 20+, FFmpeg, Python 3 with numpy, and Playwright's Chromium
(npm i -D playwright && npx playwright install chromium). The renderer uses the GPU when there is one; on a Linux
machine without one it needs Mesa's software Vulkan (apt install mesa-vulkan-drivers). node kit/tools/doctor.mjs
checks all of it. See Rendering.
Every frame is drawn by seeking the timeline in headless Chromium, so nothing is ever dropped, and the picture is cut into four-second segments so a fix re-renders only the seconds it touches. There is one renderer and it takes the fastest drawing the machine has, with nothing to configure: the GPU when there is one (any Mac or Windows machine, Linux with a GPU), otherwise Mesa's lavapipe, software Vulkan that spreads each frame over every CPU core. It prints which one it got.
Measured on one heavy portrait frame (1080x1920, PBR materials, soft shadows, depth of field), on a CPU:
| Time per frame | Quality | |
|---|---|---|
Before: Chromium's own software renderer, page.screenshot |
7.1 s | the reference |
| Now: Mesa lavapipe, frames captured through the DevTools protocol | 1.1 s | PSNR 44.7 dB, SSIM 0.995 against the reference |
| Now: depth of field that skips in-focus pixels and sizes its blur | the pass 245 → 125 ms | PSNR 45.4 dB, SSIM 0.997 |
On a CPU about nine tenths of a frame is the 3D drawing itself, and it scales with cores. So the kit can also render on a bigger machine: a render worker runs in Docker anywhere you have room (a VPS, a home server, a Dokploy or Coolify host), capped in CPUs and memory and waiting before each job until the host has memory to spare, so the machine's other services keep theirs.
# on the bigger machine: run kit/farm/compose.yml (set FARM_TOKEN; FARM_CPUS caps the cores), expose port 8080
# then, from your workspace:
FARM_URL=https://your-host/farm FARM_TOKEN=... node kit/tools/farm.mjs films/moon-face --segment 1
It packs the kit and the film (with the segments already finished), sends them, follows the worker's log, and
brings out/picture.mp4 back; later fixes with --only render only what changed there too. Measured: a 4 s,
1080x1920, 60 fps 3D test took 91 s on a 10-core worker against 320 s on a busy 4-core machine. For a long
film at 60 fps, a GPU is still the way to minutes; a short at 30 fps renders in minutes on a worker.
flowchart LR
A([Brief]) --> B[Fact sheet]
B --> S[Script<br/>written as talk]
S --> C[Storyboard<br/>drawn frames]
C --> D{Check<br/>+ your yes}
D -- no --> C
D -- yes