anything2explainer

What It Does

anything2explainer is a single-skill repository that turns a topic (or an article) into a finished, narrated motion-graphics explainer video: 1280x720 at 30fps H.264, black canvas with a star-field or dot-field backdrop, white line art with purple accents, TTS voiceover, word-aligned subtitles, chapter cards, a top HUD and a chapter progress bar. It targets Claude Code and Codex users, and any agent that reads a SKILL.md and can run shell commands can follow it; the official AutoClaw team has run it end to end on a real task (issue #8). The skill is not a CLI. It ships a method: a 9-stage workflow (scaffold, sourced research, narration and timeline, storyboard, overlays, pilot, parallel shot build, render, QC and delivery) distributed across build and QC subagents, plus a compilable Remotion 4 template (1,821 lines of TypeScript/TSX, remotion pinned to exactly 4.0.507), ten specification documents (796 lines), four Python QC tools, and one complete reference film ("RAG and Knowledge Bases", 44 shots) with its full paper trail. Language is Chinese or English; length is the user's call at the first of four mandatory checkpoints.

The Good

The deterministic toolchain works, and every claim GearScope could test held. With the README's pinned deps (edge-tts 7.2.8, numpy, pillow, scipy), a 3-sentence Chinese narration ran through tts_build.py against the real Microsoft edge-tts cloud endpoint with no API key: it produced a 40-char, 10.5s voiceover, a 520-frame timeline.json whose subtitle blocks carry per-block frame ranges (S01 f86-210, blocks f86-164 and f165-210), a matching timeline.ts whose TOTAL_FRAMES equals the JSON value, and a subtitle table export. The storyboard compiler substituted frame tokens (including an offset form {S02.from-8}) to the exact frame, and left a malformed {S9.from} token visibly unresolved in the output for a human to catch. Rendering the same Overlay still twice produced byte-identical PNGs (md5 3612ed49211a43ea7dd6b3d13552d4ea both runs), verifying the "re-rendering produces identical frames" claim at still level.

The static selfcheck catches real defects, both directions verified. With a fixture shot group matching the storyboard table, selfcheck.py reports 0 problems. Plant a mismatch (index.ts says frames 5-9 where the storyboard says 86-210) and it names the shot with evidence: ✗ SC01 (G1) 区间 5–9 ≠ 分镜表 86–210. The checker reconciles shot frame coverage against the storyboard, counts GlitchIn effects against a whitelist, and surfaces on-screen string literals that are absent from the fact list. Negative paths elsewhere are equally clean: an unknown TTS_ENGINE=bogus exits nonzero with the documented named error, and an English narration under TTS_ENGINE=auto routes to kokoro and refuses with install instructions plus a warning that config lang: 'zh' disagrees with the detected language.

Engineering discipline that most week-old viral repos do not have. new_project.sh validates the slug against a safe-character allowlist because the slug flows into filenames and sed expressions, and uses the portable sed -i.bak form after issue #4 found the BSD/GNU split breaking Linux. tts_build.py writes TypeScript string literals via json.dumps so quotes, backticks and ${} in narration cannot corrupt generated code, and keys its per-sentence audio cache on a model file fingerprint (realpath + size + mtime + first-megabyte hash) instead of a filename. All six Python scripts and six shell scripts pass py_compile and zsh -n from a bare clone. Issue history shows the same discipline upstream: the edge-tts 7.2.0 word-boundary regression was fixed with an explicit boundary request and empty-audio retry (issue #3), and Raspberry Pi 5 support landed with ARM TTS alternatives (issue #4).

The reference film's paper trail is evidence, not marketing. examples/rag/research.md carries 116 source URLs backing the on-screen facts (the skill's own rule: nothing unverified reaches the screen). The 44 shot components ship as source, the five QC reports quantify defects with measurements (a title exit flagged because brightness fell only 249 to 157, centroid moved 59px, bright-pixel count flat at 29.4k before a hard cut at f78), and reference/lessons.md records 202 lines of root-caused production traps from three films: the keyframe first-value trap, Chromium ignoring blur sigma below 0.8, CJK ascent offsets of 3 to 7px, exit fades that must reach zero opacity. The README is bilingual, documents the Raspberry Pi path with three concrete differences, and answers the commercial question plainly.

The Bad

The PolyForm Noncommercial 1.0.0 license decides who can use this, and it is not everyone. The license is present, readable and honest (GitHub reports NOASSERTION because it is custom), and it explicitly grants distribution and modification rights and says videos you produce are yours. But any commercial use of the toolkit requires prior authorization from the author, and two of the eight issues are people asking about commercial licensing (a course creator, an education channel). A company rolling this out internally is commercial use; companies additionally need a paid Remotion license, which the README flags. For a skill ecosystem built on clone-and-run, this is a real adoption ceiling, and it belongs in the decision, not the fine print.

The agent-facing surface is Chinese-primary. The SKILL.md frontmatter description is bilingual, but its 87-line body and all ten reference documents are Chinese. The English README is excellent, yet an English-only agent or user reading the actual execution contract gets a thinner experience, and the QC tooling prints Chinese verdicts. This limits reach outside the Chinese-speaking ecosystem without limiting craftsmanship (it is scored against Ecosystem fit, not Quality).

No test suite, no CI, no releases. The template's correctness rests on the deterministic scripts (which held up here) and the worked example, not on automated tests; motion_check.py and frame_metrics.py only run against a real render, so they were code-read but not executed in this review. There are zero git tags, no CHANGELOG, and the scripts are zsh-only (documented) with Windows untested.

The pipeline is heavy, and the README undersells the universal install. A fresh project pulls 248MB of node_modules plus a headless Chromium download on first render; a film needs roughly 2GB of disk and 1 to 3 hours of wall clock with multiple concurrent agents. The skill install itself is 23MB, of which 17.8MB is the four bundled OFL fonts (functional, used by renders) and 5.2MB is example frames. Meanwhile the README documents only clone-and-symlink for Claude Code and Codex; npx skills add works (verified byte-identical for hermes-agent) but appears nowhere, and Hermes and OpenClaw are never mentioned.

Smoke Test Results

Host-based hands-on testing on macOS 26.5.2 (aarch64), Node 24.13.1, ffmpeg 8.0.1, Python 3.11.14 venv, clone at 39MB. The sbx sandbox daemon was unavailable, so runs executed directly on host with full logs captured.

Run A: Fresh clone, no deps beyond stdlib

$ git clone --depth 1 https://github.com/Vincentwei1021/anything2explainer.git
✅ 39MB clone
$ grep "^name: anything2explainer" SKILL.md
✅ frontmatter name present, bilingual description
$ ls reference/*.md | wc -l
✅ 10 reference docs, 796 lines, all files named in SKILL.md exist
$ python3 -m py_compile template/scripts/*.py
✅ all 6 Python scripts compile
$ zsh -n template/scripts/*.sh (loop)
✅ all 6 shell scripts parse
$ ls template/src/config.ts template/src/ui.tsx template/src/fx.tsx
✅ template core files present, 1,821 lines TS/TSX, 4 fonts + OFL license
$ find examples/rag/shots_src -name "SC*.tsx" | wc -l
✅ 44 shot components; 5 QC reports; storyboard, timeline, delivery notes
$ ls examples/contrast/*.jpg | wc -l
✅ 13 contrast jpgs + README
$ grep -c http examples/rag/research.md
✅ 116 source URLs
$ grep "PolyForm Noncommercial" LICENSE
✅ license present and stated
PASS 14 of 14

Pass rate: 14 of 14. Structure, paper trail and licensing all check out from a bare clone with no dependencies.

Full log →

Run B: With deps preinstalled

$ python3.11 -m venv /tmp/a2e-venv && pip install edge-tts==7.2.8 numpy pillow scipy
✅ venv deps import cleanly
$ zsh template/scripts/new_project.sh /tmp/a2e-proj probevid
✅ scaffold + npm install + tsc --noEmit, "project ready" (node_modules 248MB)
$ npx tsc --noEmit (in project)
✅ typecheck clean
$ zsh scripts/still.sh Overlay 40 /tmp/a2e-stills ov
✅ renders 1280x720 PNG (first run downloads headless Chromium)
$ zsh scripts/still.sh Overlay 40 /tmp/a2e-stills2 ov (second run)
✅ byte-identical: md5 3612ed49211a43ea7dd6b3d13552d4ea == md5 3612ed49211a43ea7dd6b3d13552d4ea
PASS 7 of 7

Pass rate: 7 of 7. This is the canonical install verdict: the template installs, typechecks and renders deterministically on the first try.

Full log →

Run C: Functional verification

$ printf 3-line zh narration + chapter | scripts/tts_build.py (TTS_ENGINE=auto)
✅ edge cloud synth end to end: total_frames=520, 3 sentences S01-S03
$ assert timeline.json/subs.ts/timeline.ts/artifacts
✅ 10 of 10 assertions (frame math monotonic, TOTAL_FRAMES consistent, subs exported)
$ TTS_ENGINE=bogus python scripts/tts_build.py
✅ exits nonzero: 未知 TTS_ENGINE=bogus（可选 auto / edge / kokoro / piper / kokoro_onnx）
$ python scripts/render_storyboard.py (tokens {S01.from} {S02.from-8} {C1} {TOTAL})
✅ all tokens resolve to exact timeline.json values incl. offset; bad token left visible
$ python scripts/selfcheck.py (fixture matching storyboard)
✅ problems: 0
$ python scripts/selfcheck.py (planted range mismatch 5-9 vs 86-210)
✅ catches it: ✗ SC01 (G1) 区间 5–9 ≠ 分镜表 86–210
$ HOME=/tmp/a2e-installhome npx skills add ... --agent hermes-agent --copy --yes
✅ lands at .hermes/skills/anything2explainer, 23MB
$ cmp installed SKILL.md + reference/lessons.md vs raw.githubusercontent main
✅ byte-identical, both files
PASS 12 of 12

Functional pass rate: 12 of 12. Honesty note: the first functional pass logged 6 FAILs that were harness bugs in GearScope's own fixtures (an English narration under auto correctly routed to the uninstalled kokoro engine and stopped with install instructions; single-digit token ids that the documented two-digit format forbids). After fixing the fixtures to match the documented contract, everything passed. The initial "failures" were the skill's language detection and input validation working as documented.

Full functional log →

What the runs tell you

The parts of this skill that can be tested without a live agent session all work, first try, including a real cloud TTS call and a determinism check that passed byte-for-byte. What remains unverified is the orchestration layer (parallel build agents, QC agents, a full 8,000-frame render with motion metrics), which needs a coding agent, hours of wall clock and gigabytes of disk. The AutoClaw team's issue #8 report is currently the strongest public evidence for that layer.

Setup Walkthrough

1. Clone and link (or run npx skills add vincentwei1021/anything2explainer, which works even though the README does not mention it).
2. Install runtime deps: Node 18+, ffmpeg, and a Python venv with edge-tts==7.2.8 numpy pillow scipy (pinned because edge-tts tracks a Microsoft endpoint and breaks across upgrades). English voiceover additionally needs kokoro soundfile plus espeak-ng; on Linux/ARM the README documents two lighter engines (kokoro-onnx, piper).
3. Scaffold a project: template/scripts/new_project.sh copies the template, runs npm install (248MB) and typechecks. First render downloads a headless Chromium.
4. Write script/narration.txt, run scripts/tts_build.py, then scripts/render_storyboard.py, then build shots, scripts/preview.sh 30 for the checkpoint cut, and VER=v1 scripts/render.sh for the film.
5. Budget for real use: roughly 2GB disk and 1 to 3 hours per film, four mandatory user checkpoints, and multi-agent concurrency limited by your harness (dispatch in waves past 12).

Alternatives

1. heygen-com/hyperframes (reviewed 4.5/5) - an Apache-2.0 HTML-to-video framework for agents with 20 skills. Broader visual range and a permissive license, but no narration methodology, fact-sourcing rules or QC gates; prefer it for product and UI videos.
2. Manim (community) - the standard for programmatic math animation in Python. Maximum expressive freedom, minimum method: no TTS timeline, storyboard discipline or multi-agent QC.
3. Remotion direct - the canvas anything2explainer builds on. Choose it when the visual system should be yours and the pipeline is your problem to design.
4. calesthio/OpenMontage (reviewed 4.5/5) - agentic video production across 66 providers including generative models. Opposite philosophy: generated footage versus code-drawn, sourced frames.