Manim reels

Manim Reels — Production Short-Form Video Skill

When to Use

Use this skill when the user wants:

• Instagram Reels / TikTok / YouTube Shorts / LinkedIn carousels in video form
• Fast-paced, high-retention vertical videos (15–60 seconds)
• Professional voiceover + synchronized animation
• "Give me a reel about X" or "Create a viral reel from this context"
• Educational hooks, motivational content, tech explainers, product demos, storytelling reels
• Production quality with voice cloning consistency across multiple reels

This skill is NOT for long-form educational videos (use manim-video instead).

Core Philosophy

Hook in 1.5 seconds. Deliver value in 15–40 seconds. CTA in last 3 seconds.

Every reel follows the proven retention curve:

1. 0–1.5s: Pattern interrupt / bold visual + voice hook
2. 1.5–8s: Rapid value delivery with visual payoff every 2–3 seconds
3. 8–15s: Core insight or transformation
4. 15–40s: Supporting points / proof / story
5. Last 3s: Clear CTA + branding

Prerequisites

Required Tools

• Manim Community Edition (pip install manim)
• Qwen3-TTS voice clone repo at ~/clawd/Qwen-tts-voice-clone
• ffmpeg (for audio muxing and vertical formatting)
• Python 3.11+

Setup Check

# Verify Manim
manim --version

# Verify Qwen TTS
cd ~/clawd/Qwen-tts-voice-clone && python voice_design.py --help

Reel Specifications (Production Standard)

Parameter	Value	Notes
Resolution	1080 × 1920	9:16 vertical
FPS	30 or 60	60fps for smooth motion graphics
Duration	15–60 seconds	Target 30–45s for best retention
Audio	48kHz, 320kbps	Voice at -6dB, music at -18dB
Subtitles	Burned-in + SRT	High-contrast, 60–80 char/line max
Style	Dark mode default	High contrast for mobile viewing

Pipeline (Context → Final Reel)

CONTEXT → SCRIPT → VOICE DESIGN → SCENE PLAN → MANIM CODE → RENDER → SYNC → FINAL
   1         2          3             4            5         6      7      8

Step 1: Context Intake

User provides topic, goal, tone, target audience, or raw content.

Good context examples:

• "Explain how transformers work in 30 seconds for Gen-Z audience"
• "Motivational reel about shipping fast vs perfect for indie hackers"
• "Product demo of new feature X with voice of a confident founder"

Step 2: Script Generation

Break context into:

• Hook line (first 8–12 words)
• 3–5 value beats
• CTA
• Voice direction (persona)

Step 3: Voice Persona Selection

Choose or design a consistent voice persona using Qwen TTS:

• "Young male tech founder, energetic, slight Indian accent"
• "Female documentary narrator, calm, British RP"
• "Gen-Z female, casual, enthusiastic, West Coast"

Generate reference voice first, then clone for consistency.

Step 4: Scene Planning

Map script lines to visual scenes. Each scene = 2–5 seconds max.

Reel Scene Templates (use these as building blocks):

• HookScene — Bold text + geometric burst
• ValueScene — Icon + short text + animation
• TransformationScene — Before/after morph
• ListScene — Numbered points with staggered reveals
• QuoteScene — Large quote + subtle background motion
• ProofScene — Stats/numbers counting up
• CTAScene — Final frame with handle + logo

Step 5: Manim Code

Write one Python file with multiple Scene classes (one per beat).

Use vertical camera:

config.frame_width = 9
config.frame_height = 16

Step 6: Render (Proven Workflow)

Render each scene individually, then stitch:

# Render all scenes at production quality (1080x1920, 30fps)
manim -qh --format mp4 script.py Scene01_Hook Scene02_Value1 Scene03_Value2 ...

# Stitch with ffmpeg (run from the 1920p30 output directory)
cat > concat.txt << 'EOF'
file 'Scene01_Hook.mp4'
file 'Scene02_Value1.mp4'
file 'Scene03_Value2.mp4'
...
EOF

ffmpeg -y -f concat -safe 0 -i concat.txt -c copy final_reel.mp4

Note: Always render scenes separately first. Concatenation is more reliable than rendering multiple scenes in one pass for vertical content.

Step 7: Audio Sync + Subtitles

• Generate voice lines with Qwen TTS
• Use ffmpeg to mux audio
• Burn subtitles with drawtext or subtitles filter

Step 8: Final Polish

• Color grade
• Sound design (subtle whooshes, clicks)
• Export master + platform variants

Voice + Animation Sync Rules

1. Voice leads, animation follows — Start animation 0.1–0.3s after voice begins
2. Visual payoff on key words — Animate the exact word that carries meaning
3. Never animate during silence — Use self.wait() for breathing room
4. Subtitles appear with voice — Never more than 1 line ahead
5. End animation 0.2s before voice ends — Clean cutoff feels professional

Handling Slow Voice Generation (CPU Inference)

When qwen-tts-voice-clone runs on CPU, generation is slow (5–15 minutes per line). Use this workaround:

1. Check for existing audio first — Before generating new lines, list output/clone_*.wav and output/reel_line_*.wav
2. Use pre-generated lines — Map existing audio durations to script beats
3. Adjust script length — Create a shorter reel that fits available audio rather than waiting
4. Combine existing audio — Use ffmpeg concat on available .wav files, then sync Manim timing to the combined duration
5. Deliver partial but working — A 45-second reel with 5 voice lines is better than no reel while waiting for 10 lines

Example pattern (from session):

• 5 voice lines already existed (durations: 12.3s, 10.2s, 8.6s, 7.1s, 7.6s)
• Created cxas_scrapi_reel_v2.py with 5 scenes timed to match
• Combined audio with ffmpeg -f concat
• Final deliverable: 45.9s vertical video with cloned voice

Anti-pattern: Do not block on generating "perfect" voice lines when usable audio exists. The user wants the video, not the setup.

Color Palettes for Reels

Style	BG	Primary	Secondary	Accent	Use Case
Neon Tech	#0A0A0A	#00F5FF	#FF00FF	#39FF14	Tech, AI, startups
Warm Creator	#1A1423	#FF6B6B	#FFD93D	#6BCB77	Motivational, lifestyle
Corporate Pro	#0F172A	#3B82F6	#E2E8F0	#F59E0B	B2B, SaaS, thought leadership
Dark Educational	#111827	#60A5FA	#A5B4FC	#F472B6	Explainers, tutorials
High Contrast	#000000	#FFFFFF	#FF0050	#00FF85	Viral hooks, bold claims
NVIDIA Exam	#050805	#76B900	#F5F7F5	#101510	NVIDIA cert/practice MCQ reels
Databricks Exam	#0A1216	#FF3621	#F9F7F4	#1B3139	Databricks cert/practice MCQ reels

Example Workflow (User Provides Context)

User input:

"Create a 30-second reel about why most AI agents fail in production. Target audience: indie hackers. Tone: direct, slightly contrarian, helpful."

Skill output:

1. Script with 5 beats + hook + CTA
2. Voice persona: "30-year-old male founder, calm but direct, slight tech accent"
3. 7 Manim scenes
4. Qwen TTS calls for each line
5. Final final_reel.mp4 (1080x1920, 30s, voiced, subtitled)

Production Checklist

Before delivering any reel, verify:

• Hook lands in first 1.5 seconds (watch without sound)
• No text overflow or cut-off at edges
• Voice is consistent across all lines (same persona)
• Subtitles are readable on mobile (minimum 48px)
• Audio peaks at -6dB, no clipping
• Total duration under 60 seconds
• File size optimized (< 50MB for most platforms)
• Vertical framing correct (no letterboxing)
• For MCQ/exam reels: circular A/B/C/D badges are visually centered and option text blocks are vertically centered inside cards
• For bulk CSV jobs: final MP4 count, manifest rows, and expected CSV question count all match exactly; retry transient TTS failures until errors are zero

Bulk CSV / Exam Question Reels

When a user asks for one reel per CSV question, follow references/bulk_csv_exam_reels.md.

Key rules:

• Count CSV rows first; do not rely on estimated totals like “360*3” if the files contain a different number of questions.

• Generate and verify a small sample before full-batch rendering.

• Use a resumable generator with stable paths, manifest.csv, and SUMMARY.json.

• Arrange output by certification family and practice test.

• After completion, verify manifest rows, successful rows, actual MP4 count, and per-folder counts.

• If TTS has temporary network/DNS failures, rerun the resumable job rather than accepting missing videos.

• Multiple-choice option cards have vertically centered answer text and perfectly centered A/B/C/D badges; avoid cramped labels or large dead space inside cards

• For CSV/bulk reel jobs, count rows in every source CSV and make the expected video count match the data exactly; do not assume a requested shorthand like “360×3” is correct when files contain different row counts

• Bulk outputs are organized by source/category/test with a manifest CSV and summary JSON, and generation is resumable by skipping already-complete MP4s

• For CSV/question-bank batches, render exactly one sample first, verify it with ffprobe + extracted preview frames, and wait for user approval before bulk-generating hundreds of reels.

CSV / Practice-Question Reel Batches

When the input is a CSV of exam questions or practice-test items:

1. Inspect headers and a few rows; count rows exactly (expected video total = row count).
2. Build one reusable generator; render a single sample reel first (usually Q001).
3. Use the brand palette the user requested (NVIDIA green, Databricks lava/navy, etc.) — see references/brand_themes_csv_reels.md.
4. Prefer fast PIL two-frame + TTS + ffmpeg for bulk (50–1000+); use Manim only when motion graphics are required.
5. Prioritize legibility: auto-sized question card (height from wrapped text), centered option badges/text, concise answer reveal (Correct: B + short explanation).
6. After sample approval, smoke-test ~5 videos, then full resumable batch with manifest.csv + SUMMARY.json.
7. Check late answer-reveal frames for long-option collisions and bottom-panel overlap before reporting success.
8. Final verify: MP4 count by _Q(\d+)_ excluding only *_silent.mp4 suffix (never filter on the word "silent" in slugs).

See:

• references/csv_practice_question_reels.md — layout, multi-brand defaults, pitfalls
• references/bulk_csv_exam_reels.md — resumable bulk workflow
• references/brand_themes_csv_reels.md — NVIDIA + Databricks palettes, Windows path tip, count verification
• references/multi_platform_social_metadata.md — YT/IG/LI master-CSV append + required detailed YouTube description template (~3.5–4.5k chars)
• references/github_skill_package.md — package/push these skills to a public GitHub skill repo (Yash-Kavaiya pattern)

File Structure (Per Project)

reel-project-name/
  context.md              # Original user request
  script.md               # Full script + timing
  voice_persona.txt       # Qwen TTS persona description
  scenes/
    01_hook.py
    02_value_1.py
    ...
  audio/
    01_hook.wav
    02_value_1.wav
    ...
  renders/
    1080x1920/
      Scene1.mp4
      ...
  final_reel.mp4
  subtitles.srt
  changelog.md            # What changed between iterations

Bulk CSV/Q&A Reel Batches

When the user provides CSV practice-test questions and asks for hundreds of reels:

1. Count before rendering — inspect every CSV, count rows, and tell the user the exact expected video total. Do not assume a nominal count like 360*3; match the actual CSV row count.
2. Make one sample first — render Q001, extract preview frames, run ffprobe, and visually check: 1080x1920, audio present, readable text, no badge/text misalignment, no answer-panel overlap. Apply user feedback to the generator before batch mode.
3. Use a resumable generator — skip existing valid MP4s, write manifest.csv + SUMMARY.json, and keep per-question audio/frames so failed TTS calls can be retried without regenerating everything.
4. Organize output by source:

   ALL_CSV_REELS/
     <CERT>/
       Practice_Test_01/
         <CERT>_PT01_Q001_<question_slug>.mp4
         frames/
         audio/
     SOCIAL_METADATA/
       all_social_metadata.csv
       platform_upload_metadata_all.csv
       <CERT>/Practice_Test_01/platform_upload_metadata.csv
   

5. Filename rule — after batch render, rename from plain Q001.mp4 to descriptive names such as {CERT}_PT##_Q###_{question_slug}.mp4, then update the manifest and metadata paths. Verify mp4_count, zero missing manifest paths, and no old plain Q###.mp4 names remain.
6. Metadata deliverables — append platforms into one master CSV (YouTube → Instagram → LinkedIn). YouTube descriptions must be full detailed sections (~3.5–4.5k chars: options + per-option why + wrong-option analysis + study steps + SEO), not short stubs — see references/multi_platform_social_metadata.md. Also emit lean platform CSVs and per-video Q###_youtube.txt / _instagram.txt / _linkedin.txt packs.
7. Retry transient TTS errors — Edge/Qwen/network TTS may fail mid-batch. Treat connection/DNS/timeout failures as retryable; rerun the resumable generator after the main pass and verify final errors=0 and video count equals source row count.
8. Plan for disk pressure — large batches can fill a drive with Manim media, render logs, WAV lines, and voice_full.wav. After each verified final MP4, clean reproducible intermediates; force combined WAVs to 24 kHz/48 kHz instead of accidental 192 kHz PCM; add a disk-space preflight that stops cleanly before manifest writes fail.
9. Verify final count by group — report counts per certificate and per practice test, not just the grand total.

Brand / theme selection (MANDATORY)

Always ask the user which theme to follow before generating reels or bulk batches. Do not hardcode Databricks, NVIDIA, or any other brand unless the user chose it for this run.

Example:

Which brand theme?
1) NVIDIA green
2) Databricks lava/navy
3) Custom (paste hex colors)

For branded exam reels, match the user-selected theme:

• NVIDIA: dark #050805 + green #76B900
• Databricks: dark navy #0A1216 + Lava #FF3621 + Navy #1B3139 + Oat text #F9F7F4 Always use high-contrast text, centered option-letter badges, vertically centered option text, auto-sized question cards, and an answer reveal panel that never overlaps option cards. Full palettes: references/brand_themes_csv_reels.md.

Anti-Patterns (Never Do These)

• Long static text (more than 3 lines at once)
• Voice speaking while nothing is happening visually
• Using horizontal 16:9 scenes in vertical reel
• Inconsistent voice persona across lines
• Subtitles that require reading faster than voice speaks
• Bright white backgrounds (kills mobile viewing experience)
• More than 8 scenes in a 30-second reel

Integration with Existing Skills

• Use qwen-tts-voice-clone for all voice generation
• Reference manim-video for advanced Manim patterns (but adapt to vertical 9:16)
• Use humanizer skill on script before voice generation
• For bulk question-bank reels from CSV folders, follow references/csv_bulk_reels.md: count actual CSV rows first, generate resumably with a manifest, verify final MP4 counts, center option badges/text, rename files with Q number + question slug, and create platform metadata CSVs.
• When the user asks for an end-to-end AI agent around reel generation, combine this skill with dspy and use the package/CLI pattern in references/dspy_reelsgen_agent.md: DSPy plan signature, deterministic fallback, artifact directory, Manim render smoke test, ffprobe verification, and generated qwen_tts_commands.sh rather than automatically blocking on slow CPU voice cloning.
• When the user asks for an end-to-end AI agent around reel generation, combine this skill with dspy and use the package/CLI pattern in references/dspy_reelsgen_agent.md: DSPy plan signature, deterministic fallback, artifact directory, Manim render smoke test, ffprobe verification, and generated qwen_tts_commands.sh rather than automatically blocking on slow CPU voice cloning.

---

This skill is designed for rapid iteration. A skilled operator can go from context to final voiced reel in under 45 minutes for a 30-second video. The first 3 iterations should focus on hook strength and pacing. Polish comes last.