manim-video
affaan-m/everything-claude-code
Build animated technical explainers with Manim for graphs, diagrams, and system walkthroughs.
What is manim-video?
Manim Video creates clean, motion-driven animations for technical concepts, system architectures, and product explainers. Use it when you need precise, structured visuals that explain through progressive reveal and state change rather than generic cinematic motion.
- Render technical concept animations with Manim CLI
- Create network graph and system diagram explainers
- Build progressive-reveal scenes that prove one concept each
- Generate 16:9 MP4 videos with thumbnail frames and storyboards
- Plan and structure multi-scene explainers before coding
- Hand off to video-editing or remotion-video-creation for final polish
How to install manim-video
npx skills add https://github.com/affaan-m/everything-claude-code --skill manim-video- manim CLI installed
- ffmpeg for post-processing (optional)
- video-editing skill for final assembly (optional)
- remotion-video-creation skill for composited UI or captions (optional)
How to use manim-video
- 1.Define the core visual thesis in one sentence
- 2.Break the concept into 3–6 distinct scenes
- 3.Decide what each scene proves or demonstrates
- 4.Write the scene outline and storyboard before coding
- 5.Render a low-quality smoke test to validate composition and timing
- 6.Refine typography, spacing, color, and pacing after the render works
- 7.Export a clean thumbnail frame at social size
- 8.Hand off to video-editing or remotion-video-creation only if additional polish adds value
Use cases
- Animate a graph algorithm or data structure transformation
- Create a system architecture or workflow diagram explainer
- Build a product feature walkthrough or launch video
- Visualize metric progression or performance optimization
- Explain network topology or social graph optimization
- Technical content creators
- Product and engineering teams building explainers
- Documentation authors needing animated diagrams
- Launch and marketing teams creating technical demos
- Educators explaining algorithms or system design
manim-video FAQ
Use Manim when the concept is visual (graphs, workflows, diagrams, state changes) and precision matters more than photorealism. It's ideal for technical explainers where motion clarifies the idea.
A short 16:9 MP4 video, one thumbnail or poster frame, and a storyboard plus scene plan documenting the structure.
Yes. The skill includes a reusable starter template (assets/network_graph_scene.py) that shows current vs. optimized graphs, highlights signal paths, and distinguishes clutter from bridges.
Not always. Hand off to video-editing for final polish or remotion-video-creation only if you need composited UI, captions, or additional motion layers that add real value.
Plan first (thesis, scenes, storyboard), render a low-quality smoke test to validate timing and composition, then tighten visuals. Only push to higher quality after the structure is stable.
Full instructions (SKILL.md)
Source of truth, from affaan-m/everything-claude-code.
name: manim-video description: Build reusable Manim explainers for technical concepts, graphs, system diagrams, and product walkthroughs, then hand off to the wider ECC video stack if needed. Use when the user wants a clean animated explainer rather than a generic talking-head script. metadata: origin: ECC
Manim Video
Use Manim for technical explainers where motion, structure, and clarity matter more than photorealism.
When to Activate
- the user wants a technical explainer animation
- the concept is a graph, workflow, architecture, metric progression, or system diagram
- the user wants a short product or launch explainer for X or a landing page
- the visual should feel precise instead of generically cinematic
Tool Requirements
manimCLI for scene renderingffmpegfor post-processing if neededvideo-editingfor final assembly or polishremotion-video-creationwhen the final package needs composited UI, captions, or additional motion layers
Default Output
- short 16:9 MP4
- one thumbnail or poster frame
- storyboard plus scene plan
Workflow
- Define the core visual thesis in one sentence.
- Break the concept into 3 to 6 scenes.
- Decide what each scene proves.
- Write the scene outline before writing Manim code.
- Render the smallest working version first.
- Tighten typography, spacing, color, and pacing after the render works.
- Hand off to the wider video stack only if it adds value.
Scene Planning Rules
- each scene should prove one thing
- avoid overstuffed diagrams
- prefer progressive reveal over full-screen clutter
- use motion to explain state change, not just to keep the screen busy
- title cards should be short and loaded with meaning
Network Graph Default
For social-graph and network-optimization explainers:
- show the current graph before showing the optimized graph
- distinguish low-signal follow clutter from high-signal bridges
- highlight warm-path nodes and target clusters
- if useful, add a final scene showing the self-improvement lineage that informed the skill
Render Conventions
- default to 16:9 landscape unless the user asks for vertical
- start with a low-quality smoke test render
- only push to higher quality after composition and timing are stable
- export one clean thumbnail frame that reads at social size
Reusable Starter
Use assets/network_graph_scene.py as a starting point for network-graph explainers.
Example smoke test:
manim -ql assets/network_graph_scene.py NetworkGraphExplainer
Output Format
Return:
- core visual thesis
- storyboard
- scene outline
- render plan
- any follow-on polish recommendations
Related Skills
video-editingfor final polishremotion-video-creationfor motion-heavy post-processing or compositingcontent-enginewhen the animation is part of a broader launch
Related skills
More from affaan-m/everything-claude-code and the wider catalog.

security-review
Security checklist and patterns for authentication, input validation, secrets, and sensitive features.

golang-patterns
Idiomatic Go patterns, best practices, and conventions for building robust, efficient, and maintainable applications.

coding-standards
Baseline coding conventions for naming, readability, immutability, and quality across projects.

frontend-patterns
React and Next.js patterns for components, state management, performance, and modern frontend practices.

backend-patterns
REST/GraphQL API design, database optimization, and server-side patterns for Node.js, Express, and Next.js.

golang-testing
Go testing patterns: table-driven tests, subtests, benchmarks, fuzzing, and TDD methodology.