manim_skill: AI Agent Skills That Actually Teach Your Copilot How to Write Manim Correctly

The Problem

Ask ChatGPT or Claude to generate a Manim animation today, and you get a mixed bag. Sometimes it imports from manim, sometimes from manimlib. Sometimes it uses Create(), sometimes ShowCreation(). Sometimes the scene extends Scene, sometimes InteractiveScene. The AI has read the docs—but it has read both versions’ docs at once, and it has no way to know which one you need.

The result: code that looks plausible but crashes on import, uses wrong API names, or mixes incompatible features from the two Manim versions. You spend more time debugging than you would writing the animation from scratch.

This is the problem manim_skill solves. It puts best-practice knowledge for each Manim version into your AI assistant’s context so the AI knows exactly which API to use, which patterns to follow, and which pitfalls to avoid.

How It Works

manim_skill provides two independent AI Agent Skills, one for each Manim version. When installed, your AI assistant loads the relevant skill automatically based on what you’re doing:

manimce-best-practices activates when you:

• Import from manim import *
• Use the manim CLI command
• Work with Scene classes, mathematical animations, or LaTeX rendering

manimgl-best-practices activates when you:

• Import from manimlib import *
• Use the manimgl CLI command
• Work with InteractiveScene, 3D rendering, or interactive mode

Each skill is a structured collection of best practices, code examples, patterns, and anti-patterns. Think of it as a condensed “Manim style guide” that your AI loads automatically when it detects you’re working with Manim.

The skill files organize knowledge by concept: scenes, animations, mobjects, colors, text, camera control, 3D rendering. Each file includes:

• Best practices for common tasks
• Working code examples that have been tested
• Common patterns with explanations
• Pitfalls to avoid — the things that waste hours

This structure is what makes it effective. Give an AI a “how to avoid version mismatch” rule vs. dumping the entire Manim docs, and the former produces dramatically better results.

Structured Knowledge, Not Raw Docs

## animations.md

- Use `Create()` for drawing objects (not `ShowCreation` which is ManimGL)
- Use `FadeIn()` / `FadeOut()` for visibility transitions
- Use `Transform()` for morphing between objects of similar type
- For text, use `Write()` which creates characters sequentially

Version Awareness Built In

The skill files include critical differences between versions:

Feature	ManimCE	ManimGL
Scene base	Scene	Scene / InteractiveScene
Creation animation	Create()	ShowCreation()
Text class	Text(), MathTex()	Text(), Tex()
3D	Limited	Full OpenGL
Interactive mode	No	Yes

When the AI has this table in context, it stops mixing up Create with ShowCreation.

When to Use It

manim_skill is most valuable in these scenarios:

• You frequently use AI assistants to generate Manim animations and want consistent, correct output
• You’re teaching Manim to beginners who get confused by the two-version situation
• You maintain projects that need to work with both ManimCE and ManimGL
• You’re using agent tools (Claude Code, Cursor, Copilot) that support the skills.sh format

Without it, every Manim question to your AI is a gamble. The AI has to guess which version you want—and the two versions have different enough APIs that guessing wrong means broken code.

Pitfalls to Watch For

manim_skill is not magic. A few things to keep in mind:

• Only works with skills.sh-compatible agents. If your AI tool doesn’t support the Agent Skills open standard, installing this does nothing. Check that your agent supports npx skills add before expecting results.
• Knowledge can lag behind API changes. Manim is actively developed. If the community edition renaming an API, the skill may take time to catch up. The testing suite is your best signal for currency.
• General best practices, not project-specific. The skills teach general Manim conventions, not your project’s internal coding style or conventions.
• Installing both skills simultaneously is useful only if you work with both versions. If you only use ManimCE, installing the ManimGL skill is unnecessary weight in your agent’s context.

Installation

Installation takes one command and auto-detects your local agents:

# Install both skills at once
npx skills add adithya-s-k/manim_skill

Or install only the version you need:

# Only Manim Community Edition
npx skills add adithya-s-k/manim_skill/skills/manimce-best-practices

# Only ManimGL
npx skills add adithya-s-k/manim_skill/skills/manimgl-best-practices

Quick Start

After installation, the skills are loaded automatically. No additional configuration needed.

Before manim_skill: You: “Create a circle animation with Manim” AI: from manim import * … ShowCreation(circle) — mixed version APIs, will crash

After manim_skill: You: “Create a circle animation with Manim Community Edition” AI: from manim import * … Create(circle) — correct community edition API, works on first run

The skill also comes with comprehensive tests to verify every code example:

# Test all ManimCE skill examples
uv run python tests/manimce/test_all_skills.py

# Test a specific skill file
uv run python tests/manimce/test_all_skills.py animations.md

# Test ManimGL skills with parallel workers
uv run python tests/manimgl/test_all_skills.py -j 4

This matters because untested code examples in AI skills become a liability. If a skill tells the AI to use a pattern that no longer works, it actively makes your AI worse. Manim skill’s test coverage ensures the knowledge stays accurate.

End-to-End Example

Here’s what changes when you have manim_skill installed. Same prompt, two different outcomes:

Without manim_skill:

You: Generate a Manim scene that shows a square transforming into a circle
AI: from manim import *
    class SquareToCircle(Scene):
        def construct(self):
            square = Square()
            circle = Circle()
            self.play(ShowCreation(square))   # <-- ShowCreation is ManimGL API!
            self.play(Transform(square, circle))

This code imports from ManimCE (from manim import *) but uses ShowCreation, which is a ManimGL function. It will fail with an AttributeError.

With manim_skill installed:

You: Generate a Manim scene that shows a square transforming into a circle
AI: from manim import *
    class SquareToCircle(Scene):
        def construct(self):
            square = Square()
            circle = Circle()
            self.play(Create(square))          # <-- correct ManimCE API
            self.play(Transform(square, circle))

The AI knows you’re using ManimCE because the skill’s activation rules tell it which version context applies. Create is the correct ManimCE API, and the code runs without errors.

The Bottom Line

manim_skill solves a specific but painful problem: your AI assistant can’t read your mind about which Manim version you’re using. By packaging version-specific best practices into AI Agent Skills, it eliminates the most common source of frustration in AI-assisted Manim development.

If you use AI tools to generate mathematical animations, this is one of the most useful skills you can install. One command, no configuration, and your AI stops mixing up Create and ShowCreation.

The question is: how many hours have you wasted debugging version-confused AI code?

GitHub: https://github.com/adithya-s-k/manim_skill Install: npx skills add adithya-s-k/manim_skill