Math-To-Manim — Claude Code skill: what it does, how to install
Math-To-Manim turns a maths or science topic into a prerequisite map, animation plan, and Manim Python code for educational videos.
MIT 1 installs ★ 2,889 updated 2026-10-27
npx skills add HarleyCoops/Math-To-Manim --skill math-to-manim -a claude-codeWhat Math-To-Manim does
Math-To-Manim takes a concept through a six-agent pipeline. It first extracts the topic, domain, level, and learning goal, then recursively finds prerequisites and orders them from foundations to the target. Each node receives LaTeX equations, variable explanations, worked examples, visual elements, colours, camera moves, and transitions.
The skill produces {concept}_prompt.txt, {concept}_tree.json, {concept}_animation.py, and {concept}_result.json. Its code target is Manim Community Edition, with raw Python strings used for LaTeX such as r"E = mc^2". The prerequisite search runs to a depth of 3–4 levels; the narrative uses 200–300 words per concept and assembles a 2000+ token prompt.
Generated code is tied to Manim Community Edition, so that implementation is the one to use when running the Python scene.
What it helps with
- map prerequisites for a maths or science concept
- turn foundations into a coherent teaching sequence
- add LaTeX formulas and variable definitions
- design animated scenes with graphs and diagrams
- generate a runnable Manim Python file
Example prompts for the agent
- Create an educational animation that explains the Pythagorean theorem from its prerequisites.
- Visualize quantum tunnelling and build the prerequisite tree before writing the scene.
- Generate Manim Python code for this formula with LaTeX, consistent colours, and smooth transitions.
How to install Math-To-Manim
1Skills CLI (Vercel)
npx skills add HarleyCoops/Math-To-Manim --skill math-to-manim -a claude-code2Manually: put the files in place
~/.claude/skills/math-to-manim/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/math-to-manim/
1Skills CLI (Vercel)
npx skills add HarleyCoops/Math-To-Manim --skill math-to-manim -a codex2Manually: put the files in place
.agents/skills/math-to-manim/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add HarleyCoops/Math-To-Manim --skill math-to-manim -a cursor2Manually: put the files in place
.cursor/skills/math-to-manim/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install HarleyCoops/Math-To-Manim legacy/Math-To-Manim/.claude/plugins/math-to-manim/skills/math-to-manim2Manually: put the files in place
.github/skills/math-to-manim/SKILL.md1Skills CLI (Vercel)
npx skills add HarleyCoops/Math-To-Manim --skill math-to-manim -a gemini-cli2Platform CLI
gemini skills install https://github.com/HarleyCoops/Math-To-Manim --path legacy/Math-To-Manim/.claude/plugins/math-to-manim/skills/math-to-manimManually: put the files in place
.devin/skills/math-to-manim/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add HarleyCoops/Math-To-Manim --skill math-to-manim -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about Math-To-Manim
How do I install Math-To-Manim in Claude Code?
Run npx skills add HarleyCoops/Math-To-Manim --skill math-to-manim -a claude-code, then check ~/.claude/skills/math-to-manim/SKILL.md.
What does Math-To-Manim do?
It turns a concept into a prerequisite tree, a detailed visual plan, and Python code for Manim. The pipeline also specifies equations, scene elements, colours, animations, and transitions.
What files does Math-To-Manim generate?
It generates {concept}_prompt.txt, {concept}_tree.json, {concept}_animation.py, and {concept}_result.json. The repository also includes reference files and a Pythagorean theorem workflow example.
Source text
SKILL.md · MIT
---
name: Math-To-Manim
description: This skill should be used when the user asks to "create a math animation", "animate a mathematical concept", "generate Manim code", "visualize [topic] with animation", "explain [concept] visually", "create an educational video", "build a Manim scene", or mentions "reverse knowledge tree", "prerequisite discovery", or "verbose prompt generation". Provides a complete six-agent workflow for transforming any concept into professional Manim animations through recursive prerequisite discovery.
version: 1.0.0
---
# Math-To-Manim: Reverse Knowledge Tree Animation Pipeline
Transform any concept into professional mathematical animations using a six-agent workflow that requires NO training data - only pure LLM reasoning.
## Core Innovation: Reverse Knowledge Tree
Instead of training on example animations, this system recursively asks: **"What must I understand BEFORE this concept?"** This builds pedagogically sound animations that flow naturally from foundation concepts to advanced topics.
## When to Use This Skill
Invoke this workflow when:
- Creating mathematical or scientific animations
- Building educational visualizations with Manim
- Generating code from conceptual explanations
- Needing pedagogically structured content progression
## The Six-Agent Pipeline
### Agent 1: ConceptAnalyzer
Parse user intent to extract:
- **Core concept** (specific topic name)
- **Domain** (physics, math, CS, etc.)
- **Level** (beginner/intermediate/advanced)
- **Goal** (learning objective)
### Agent 2: PrerequisiteExplorer (Key Innovation)
Recursively build knowledge tree:
1. Ask: "What are the prerequisites for [concept]?"
2. For each prerequisite, recursively ask the same question
3. Stop when hitting foundation concepts (high school level)
4. Build DAG structure with depth tracking
**Foundation detection criteria**: Would a high school graduate understand this without further explanation?
### Agent 3: MathematicalEnricher
For each node in the tree, add:
- LaTeX equations (2-5 key formulas)
- Variable definitions and interpretations
- Worked examples with typical values
- Complexity-appropriate rigor
### Agent 4: VisualDesigner
For each node, design:
- Visual elements (graphs, 3D objects, diagrams)
- Color scheme (maintain consistency)
- Animation sequences (FadeIn, Transform, etc.)
- Camera movements and transitions
- Duration and pacing
### Agent 5: NarrativeComposer
Walk tree from foundation to target:
1. Topologically sort nodes
2. Generate 200-300 word segment per concept
3. Include exact LaTeX, colors, animations
4. Stitch into 2000+ token verbose prompt
### Agent 6: CodeGenerator
Generate working Manim code:
- Use Manim Community Edition
- Handle LaTeX with raw strings: `r"$\frac{a}{b}$"`
- Implement all visual specifications
- Produce runnable Python file
## Workflow Execution
To execute this workflow for a user request:
### Step 1: Analyze the Concept
```python
# Extract intent
analysis = {
"core_concept": "quantum tunneling",
"domain": "physics/quantum mechanics",
"level": "intermediate",
"goal": "Understand barrier penetration"
}
```
### Step 2: Build Knowledge Tree
Recursively discover prerequisites with max depth of 3-4 levels:
```
Target: quantum tunneling
├─ wave-particle duality
│ ├─ de Broglie wavelength [FOUNDATION]
│ └─ Heisenberg uncertainty
├─ Schrödinger equation
│ ├─ wave function
│ └─ probability density
└─ potential barriers [FOUNDATION]
```
### Step 3: Enrich with Mathematics
Add to each node:
- Primary equations in LaTeX
- Variable definitions
- Physical interpretations
### Step 4: Design Visuals
Specify for each concept:
- Elements: `['wave_function', 'potential_barrier']`
- Colors: `{'wave': 'BLUE', 'barrier': 'RED'}`
- Animations: `['FadeIn', 'Create', 'Transform']`
- Duration: 15-30 seconds per concept
### Step 5: Compose Narrative
Generate verbose prompt with:
- Scene-by-scene instructions
- Exact LaTeX formulas
- Specific animation timings
- Color and position details
### Step 6: Generate Code
Produce complete Python file:
```python
from manim import *
class ConceptAnimation(ThreeDScene):
def construct(self):
# Implementation following verbose prompt
...
```
## Critical Implementation Details
### LaTeX Handling
Always use raw strings for LaTeX:
```python
equation = MathTex(r"E = mc^2")
```
### Color Consistency
Define color palette at scene start and reuse throughout.
### Transition Pattern
Connect concepts with smooth animations:
- Previous concept fades
- New concept builds from prior elements
- Use `Transform` or `ReplacementTransform`
### Verbose Prompt Format
Structure prompts with:
1. Overview section with concept count and duration
2. Scene-by-scene instructions
3. Exact specifications (no ambiguity)
See `references/verbose-prompt-format.md` for complete template.
## Output Files
The pipeline generates:
- `{concept}_prompt.txt` - Verbose prompt
- `{concept}_tree.json` - Knowledge tree structure
- `{concept}_animation.py` - Manim Python code
- `{concept}_result.json` - Complete metadata
## Additional Resources
### Reference Files
- **`references/reverse-knowledge-tree.md`** - Detailed algorithm explanation
- **`references/agent-system-prompts.md`** - All six agent prompts
- **`references/verbose-prompt-format.md`** - Complete prompt template
- **`references/manim-code-patterns.md`** - Code generation patterns
### Example Files
- **`examples/pythagorean-theorem/`** - Complete workflow example
## Quick Start
For immediate use, follow this simplified pattern:
1. **Parse**: Extract the core concept from user input
2. **Discover**: Build prerequisite tree (depth 3-4)
3. **Enrich**: Add math and visual specs to each node
4. **Compose**: Generate verbose prompt (2000+ tokens)
5. **Generate**: Produce working Manim code
The key insight: verbose, specific prompts with exact LaTeX and visual specifications produce dramatically better code than vague descriptions.
© HarleyCoops · MIT · HarleyCoops/Math-To-Manim