anything2explainer: a Claude Code skill that renders explainer videos frame by frame in Remotion

The gap anything2explainer fills: video as generated source code

Most text-to-video tooling asks a model to synthesise pixels. anything2explainer takes the opposite route. The README states plainly that there is no stock footage, no generative video model, and no frames lifted from anyone else's work. Instead every frame is drawn in code with Remotion, which is React plus TypeScript, and the repository ships the whole method an AI coding agent needs to finish the film rather than a runtime you invoke. That is the specific problem: an agent can write prose about a topic in seconds, but producing a timed, voiced, subtitled motion-graphics film normally requires a human to hold the storyboard, the audio timeline and the render pipeline in their head at once. This project externalises that state into files (research doc, narration, storyboard, per-shot source) so the agent can work through it stage by stage.

The audience is narrow and worth naming. You need a Claude Code or Codex installation, a macOS or Linux shell with zsh and Python 3, and a willingness to inspect generated React components. If you want to type a topic and receive an MP4 with no intermediate artefacts to review, this is the wrong shape of tool. The README describes the deliverable as the MP4 plus the full paper trail, and the reference film in examples/rag/ includes research, narration, storyboard, shot source, QC reports and delivery notes. The paper trail is part of the product, not exhaust.

How the nine stages actually move data from topic to MP4

The pipeline in SKILL.md has nine named stages and the data flows linearly through files on disk. Stage 1 scaffolds a Remotion project from the template. Stage 2 dispatches one research agent that produces a sourced document with a list of numbers and analogies, each item carrying a URL. Stage 3 is where the timing is fixed: the narration script is written, TTS is run, and per-word boundaries are converted into a frame-accurate timeline plus a subtitle table. That timeline is the spine. Every later artefact references frame ranges rather than seconds.

Stage 4 turns the narration into a storyboard, one line per shot with frame range, beat, visuals, motion, hero element and lighting. Stage 5 builds overlays and primitives: title, chapter cards, HUD, pipeline rail, plus two to five topic-specific icons. Stage 6 is a pilot, a single agent building the first shot group and then a 30-second cut for you to judge. Stage 7 is the parallel build, where the remaining groups are distributed five to seven shots per agent, each agent writing pure-function Remotion components. Stage 8 renders the full film and runs quantitative frame metrics. Stage 9 assigns one QC agent per chapter, fix agents per group, re-verification, then delivery notes.

The architectural bet is that pure-function components are independently writable. Because each shot is a function of frame number and config, agents do not need to coordinate on shared mutable state, which is what makes the parallel build stage plausible. The cost is that visual continuity across shots has to be enforced by the written motion and lighting specs rather than by a shared scene graph. The README lists those specs as part of what ships, and the QC stage exists precisely because that enforcement is not automatic.

Install: a symlink into the skills directory, then three dependency groups

Installation is a clone and two symlinks, one per agent host:

git clone https://github.com/Vincentwei1021/anything2explainer.git ln -s "$PWD/anything2explainer" ~/.claude/skills/anything2explainer ln -s "$PWD/anything2explainer" ~/.codex/skills/anything2explainer

Dependencies come in three groups. Node 18 or newer is required, and the template's npm install pulls Remotion 4.0.507 and React 19. ffmpeg is installed via brew and the README marks it required for frame extraction and transcoding. Python dependencies go into a virtualenv: edge-tts pinned at 7.2.8, numpy, pillow and scipy. The README explains the pin directly, noting that edge-tts tracks a Microsoft endpoint and breaks across upgrades. scipy is used only by the QC script frame_metrics.py. English narration needs a separate install of kokoro and soundfile plus espeak-ng, because kokoro-82m runs locally.

Two config keys do most of the customisation. src/config.ts holds lang, which switches typography, subtitle budgets and TTS between Chinese and English, and bg, which selects between the star field with fog gradient and the dot-field wave. The README attributes the dot-field wave to video-talkcraft. Manual driving follows a numbered sequence: template/scripts/new_project.sh ~/work/my-video myslug, then research, then python3 scripts/tts_build.py, then python3 scripts/render_storyboard.py, then editing src/config.ts, then authoring src/shots/G1 through Gn, then scripts/preview.sh 30 for the first 30 seconds, then VER=v1 scripts/render.sh alongside python3 scripts/frame_metrics.py, then QC and a v2 or v3 pass.

Voiceover is the part most likely to break, and the README says so

The default Chinese voice is edge-tts zh-CN-YunxiNeural, a male voice. The default English voice is kokoro-82m am_liam, also male, running locally. The asymmetry matters. The Chinese path depends on a remote Microsoft endpoint, which is why the README pins edge-tts to 7.2.8 and warns that the library breaks across upgrades. Upgrading that single package can take the whole narration stage offline, and because the frame-accurate timeline is derived from TTS word boundaries, a failure here does not degrade gracefully. It stops stage 3.

The English path trades that network dependency for local compute and a system package, espeak-ng, installed through brew. The README also documents a bring-your-own-TTS path, and the Chinese reference cut uses it: Volcengine TTS 2.0 with forced alignment. That is the escape hatch if the default voices do not fit. Note that the two reference cuts share one storyboard and 44 shots, and the English cut re-times every shot to the English voiceover. Re-timing is therefore a real operation, not a relabelling, and swapping TTS after the storyboard exists means the frame ranges move.

What the output spec commits you to

The output is fixed at 1280x720, 30fps, H.264. Length is your call, and the README states that 2 to 8 minutes all work. Persistent layers are a 44px subtitle line with a white-on-black stroke, a bottom chapter progress bar, a top capsule HUD, and an optional pipeline rail. The look is a black canvas, white line art with purple accents, and ultra-bold headline type.

The length table is the most concrete planning artefact in the repository. A 2 to 3 minute film maps to 700 to 950 Chinese characters or 280 to 420 English words, 24 to 32 lines and shots, 4 to 6 build agents, roughly one hour of wall clock and about 2 GB of disk. The 3 to 5 minute reference tier maps to 1200 to 1500 characters or 420 to 700 words, 40 to 50 lines and shots, 8 agents, about two hours and about 2 GB. The 5 to 8 minute tier maps to 1800 to 2400 characters or 700 to 1150 words, 60 to 80 lines and shots, 10 to 14 agents, two to three hours and about 3 GB.

Two constraints deserve attention. Chapter count is explicitly not tied to length, and the progress bar splits evenly across however many chapters the narration declares, so a single long chapter produces one very slow-moving bar. And the wall-clock figures are agent time, not your time. The README says you are consulted at exactly four checkpoints, which means the pipeline runs unattended between them and a wrong decision at the pilot stage is not caught until much later.

Where the skill model is the wrong tool

The README is unusually direct about platform limits, and they should be taken at face value. The shell scripts are zsh and Python 3, developed and verified on macOS. Linux should work. Windows is untested. If your team is on Windows, the automated path is not something you can assume.

The deeper limitation is that this is not a CLI. The repository ships a compilable Remotion template, a primitives and lighting library, tooling for voiceover, storyboard, rendering and quantitative QC, written style and motion specs, a multi-agent division-of-labour protocol, and one complete reference film. There is no single entry point that takes a topic and returns a file. The trigger is a natural-language request inside Claude Code or Codex, which means reproducibility depends on the agent following SKILL.md rather than on a deterministic program. Two runs of the same topic can diverge in storyboard and shot count. The quantitative QC script frame_metrics.py gives you numbers on rendered frames, but it measures frames, not whether the explanation is correct. The research stage produces a sourced document with URLs, and nothing in the described pipeline verifies those sources beyond the QC agents reviewing frames against written criteria.

Cost is also real but bounded. The README's own figures put a reference-tier film at about 2 GB of disk and roughly two hours of agent wall clock, with the 5 to 8 minute tier reaching 3 GB. That is not a per-render cost you can ignore if you iterate on several topics.

Remotion versus generative video models, and where each wins

The obvious alternative is a generative video model, the kind that takes a prompt and returns footage. The difference in approach is not quality, it is determinism and editability. A generative model gives you pixels you cannot diff. anything2explainer gives you TypeScript files, one component per shot, that you can read, edit and re-render. If a chart label is wrong at frame 412, you open the shot component and change a string. With generated footage you regenerate and hope.

That editability is paid for in coverage. A generative model can depict a person, a landscape, a physical process, anything photographic. anything2explainer draws line art on a black canvas with two backdrop options and a fixed accent palette, and the README describes the icon set as two to five topic-specific icons per film. For a topic that needs texture, faces or real footage, the visual vocabulary here is too thin. For a topic that is fundamentally diagrammatic, such as the vector databases example in the README, the constraint is an advantage because the visuals are the explanation rather than decoration around it.

The second alternative is the standard editing stack, an NLE plus a stock library plus a voice actor. That gives you full control and no agent time, at the cost of a person doing the work. anything2explainer's claim is that the agent does the assembly and you review at four checkpoints. Whether that trade is worth it depends on how much you value the paper trail, since the research doc, narration, storyboard and per-shot source are all inspectable artefacts that a rendered MP4 from an NLE would not give you.

Licence, maintenance and what to check before you build on it

The repository carries a PolyForm Noncommercial licence badge, and the README links to a LICENSE file. The GitHub metadata shown here reports NOASSERTION, which means the licence could not be automatically classified. Those two signals should be reconciled before you use this for anything revenue-generating. PolyForm Noncommercial, by its name, restricts commercial use, so a client deliverable or a monetised channel is likely outside the grant. That is a reading of the badge, not legal advice, and the actual terms are in the LICENSE file. Note also that the template pulls Remotion 4.0.507, and Remotion has its own licensing terms that apply independently of this repository's licence.

Maintenance signals are thin. There are no releases retrieved, so there is no versioned artefact to pin against. The last push is 2026-09-09. The dependency surface is small but sharp-edged: edge-tts is pinned to 7.2.8 precisely because it breaks across upgrades, Remotion and React versions are fixed by the template's package.json, and ffmpeg and espeak-ng come from brew. Upgrading any of those is your problem, not the repository's, and the README's own warning about edge-tts suggests the author has already hit that wall.

The practical verification order is short. Confirm the LICENSE file's actual terms against your intended use. Run scripts/preview.sh 30 and watch the 30-second cut before letting the parallel build stage run, because that is the cheapest point to reject the look. Then check that your edge-tts install still reaches the endpoint, or switch to the bring-your-own-TTS path the Chinese reference cut uses. If all three hold, the pipeline is worth the two hours.

Editorial conclusion

Adopt anything2explainer if you already run Claude Code or Codex, you are comfortable editing src/config.ts and Remotion components, and the output is noncommercial, since the licence badge points to PolyForm Noncommercial. Do not adopt it if you need a Windows pipeline, a commercial deliverable, or a one-command CLI, because the repository ships a skill and a template rather than a packaged binary, and the README states Windows is untested. Before committing, verify which licence file the NOASSERTION metadata corresponds to, confirm edge-tts 7.2.8 still reaches its Microsoft endpoint from your network, and render the 30-second preview with scripts/preview.sh to judge whether the star-field or dot-field look is acceptable for your topic.

Official sources

1. Issues
2. README
3. Vincentwei1021/anything2explainer on GitHub