How to Make Videos with Claude Code

Claude Code is a terminal-based coding agent that can read project files, write code, run commands, and revise its work. It does not generate complete videos by itself. It helps you build and run a video pipeline with code-based tools such as Remotion, MoviePy, or Manim.

Remotion is the most direct approach. You describe the video, Claude Code writes a React-based composition, and Remotion renders it as a video file. This workflow supports animated graphics, captions, data-driven scenes, reusable templates, and batch rendering.

You can also use Claude Code to plan shots for external AI video generators, edit clips with Python, or create mathematical and technical animations. The right choice depends on the type of video you need:

• Choose Remotion for polished motion graphics, explainers, templates, and programmatic scenes.
• Use MoviePy for Python-based editing, compositing, titles, and clip processing.
• Use Manim for mathematical and technical animations.
• Use a storyboard skill when you need shot planning and prompts for a separate AI video generator.

Start with a Remotion project

Remotion turns video scenes into code. A composition defines the visual elements, their timing, and their animation. Claude Code can create and modify that code through the terminal.

Create a blank Remotion project with the command documented in Remotion’s coding-agent workflow:

npx create-video --yes --blank --no-tailwind my-video
cd my-video

The command creates a project named my-video. The --blank option gives Claude Code a minimal starting point, while --no-tailwind avoids adding Tailwind CSS to the project.

Install Remotion’s Agent Skills:

npx remotion skills add

A skill is a set of instructions and supporting files that extends what Claude Code knows how to do in a project. Claude Code reads skills from SKILL.md files and can use them automatically or when you invoke them with a command such as /skill-name. Anthropic documents this mechanism in its guide to Claude Code skills.

Start Claude Code from the project directory:

claude

Then give it a concrete production brief. For example:

Create a 30-second product explainer in Remotion.

Use a 16:9 composition with three scenes:
1. A title scene that introduces the product.
2. A problem scene with animated text and simple geometric graphics.
3. A solution scene with a call to action.

Use a consistent color palette, readable typography, and smooth transitions.
Keep the composition easy to edit by storing the main text and colors in a configuration object.
Render a preview after implementing the composition.

A detailed request gives Claude Code useful constraints. Specify the duration and aspect ratio. Describe the scene sequence, text, visual style, and assets, then state the output requirements. Ask for configuration values when you expect to produce multiple versions.

Ask Claude Code to build reusable scenes

Claude Code works best when the video has a clear structure. Instead of asking for “a cool video,” describe the production as a sequence of scenes with visible outcomes.

For example:

Build a three-scene animated data report.

Scene 1: show the report title and reporting period.
Scene 2: animate three metrics one at a time with labels and supporting icons.
Scene 3: show a horizontal bar chart and highlight the largest value.

Keep all text in a single data object so I can replace the values later.
Use one composition for the full video and separate components for each scene.

This prompt encourages Claude Code to separate the video into components. A component is a reusable piece of the interface, such as a title card, chart, caption block, or transition. Separating scenes makes revisions easier because you can change one part without rewriting the entire composition.

Parameterization means exposing values such as text, colors, images, or durations as inputs. It also supports batch production. Remotion promotes parameterized videos and batch rendering, so one codebase can produce multiple versions from different data.

A useful follow-up request is:

Add a configuration object for the title, subtitle, colors, logo path, and metric values.
Make the composition read from that object instead of hard-coding the values inside the scene components.

This approach works well for social clips, localized versions, customer-specific reports, and recurring announcements.

Review the render instead of trusting the code

Video code can compile even when the rendered video has visual problems. Text can overflow, elements can appear too late, and animations can move too quickly for viewers to read.

Ask Claude Code to render a preview after each meaningful change. Then inspect the output yourself. Look for:

• Text extending beyond the frame
• Captions that disappear before the narration finishes
• Poor contrast between text and background
• Scene transitions that cut off important content
• Images with incorrect cropping or aspect ratios
• Audio that starts at the wrong time
• Animations that look correct in code but feel too fast in playback

You can then give Claude Code targeted feedback:

The title is readable, but the second line overlaps the chart in Scene 2.
Move the chart down, keep the title in the upper third, and render another preview.
Do not change the colors or scene duration.

Specific visual feedback produces more reliable revisions than a general request to “make it better.” When a problem involves timing, identify the scene and the desired relationship between events, such as “show the label before the bar begins growing.”

Add a storyboard before generating shots

Remotion is suited to videos assembled from code-driven scenes. A different problem arises when you want cinematic shots, generated footage, or a production plan for an external video model.

The open-source AI video storyboard skill turns a vague idea into a storyboard with multiple shots. It produces a shared visual theme, a shot list, prompts ready to copy, audio direction, and a post-production checklist.

Install that skill by placing its SKILL.md file and supporting files in:

~/.claude/skills/ai-video-storyboard/

After installation, ask Claude Code to create a storyboard:

Create a six-shot storyboard for a short educational video about coastal erosion.

Define one consistent visual style across all shots.
For every shot, include the subject, camera movement, composition, lighting, duration,
audio direction, and a prompt ready to copy into an external AI video generator.
End with a post-production checklist.

The skill creates the production plan and prompts. It does not generate the final footage. You still need an external AI video service or another production tool to create the clips, then an editor to assemble, caption, and export them.

This workflow separates two tasks that are easy to confuse:

1. Claude Code plans the shots and keeps the visual language consistent.
2. A separate video generator produces the footage.

That separation is useful when a video depends on generated characters, locations, camera moves, or live-action-style scenes that would be difficult to reproduce with ordinary motion-graphics code.

Use MoviePy for Python-based editing

MoviePy is a Python library for editing video. It supports cuts, concatenation, title insertion, compositing, and custom effects, and it runs on Windows, macOS, and Linux with Python.

MoviePy fits when you already have video clips, audio files, images, or generated assets and need to assemble them with code. Ask Claude Code to create a Python script that:

• Loads source clips
• Trims each clip
• Places the clips in sequence
• Adds titles or captions
• Mixes audio
• Exports the final file

For example:

Write a Python video-editing script with MoviePy.

Use the clips in the input directory in filename order.
Trim each clip according to a configuration section at the top of the file.
Add a title card at the beginning and a closing card at the end.
Keep the edit settings separate from the processing code.
Explain how to run the script and where the exported video will be written.

Claude Code can then revise the script when you identify a concrete problem, such as incorrect clip order or an audio track that continues after the final scene.

MoviePy and Remotion serve different purposes. Remotion describes the video as a front-end-style composition and works well for animated graphics. MoviePy focuses on media-file operations and is a natural choice when editing existing footage with Python.

Use Manim for technical and mathematical animation

Manim is a code-driven animation engine designed for mathematical and technical explanations. You describe objects and transformations in Python, then render the animation.

A suitable Claude Code request might look like this:

Create a Manim scene that explains gradient descent.

Show a function curve, a point on the curve, and the point moving toward a local minimum.
Label the axes and the point.
Reveal each explanation step in order.
Keep the animation readable at normal playback speed.

Manim works well for geometry, equations, graphs, algorithms, and other subjects where the visual explanation depends on precise transformations.

A research system called Manimator shows a multi-stage approach. It generates a scene description, writes Manim code, and renders the result from a research paper or natural-language prompt. The work describes a research pipeline. Manimator is not a production-ready Claude Code tool, so use it as a workflow example and not as an installation recommendation.

Claude Code skills for Manim and MoviePy also appear in third-party marketplaces. Those listings indicate interest in reusable video skills, but some published excerpts contain content unrelated to the advertised tools. Verify the skill’s files, instructions, dependencies, and output before using one in a production workflow.

Choose the right workflow

The video format should determine the tool. The following comparison summarizes the practical decision:

You can combine these tools. For example, an external generator can produce background footage, MoviePy can assemble the clips, and Remotion can add a branded title or data overlay. Keep the boundaries clear so you know which tool owns each part of the production.

Treat video production as a code project

Set up a consistent project structure before asking Claude Code to add features. Organize the project so source media has its own directory, configuration stays separate from rendering logic, and generated files go outside the source directories.

A practical structure might look like this:

video-project/
├── public/
│   ├── audio/
│   ├── images/
│   └── video/
├── src/
│   ├── components/
│   ├── scenes/
│   └── config/
├── renders/
└── README.md

The exact structure depends on the tool, but the principle remains useful: source assets, editable code, and generated output should have distinct locations.

Ask Claude Code to document the project:

Add a README that explains:
- how to install dependencies
- how to preview the video
- how to render the final output
- where to place images, audio, and video assets
- which configuration values control the content

Version control also helps. Commit a working render before asking for a major change. If a new animation breaks the timing or introduces a dependency problem, you can compare the code with the last known-good version.

Check licensing and external services

Remotion’s coding-agent workflow requires a paid subscription for coding agents, and commercial use can require a license. Review Remotion’s current licensing information before using Remotion for client work or commercial distribution.

The storyboard workflow has a separate dependency: it produces prompts for external AI video generators. Each service sets its own access rules and pricing. It also defines usage rights and content policies. Claude Code does not remove those requirements.

MoviePy and Manim also depend on local Python environments and their respective packages. Ask Claude Code to record the required versions and setup commands in the project README, then test the project on the machine that will perform the final render.

A practical production sequence

Use this sequence to move from planning to implementation and then to visual review:

1. Define the audience, runtime, aspect ratio, message, and scene sequence.
2. Choose Remotion, MoviePy, Manim, or a storyboard workflow based on the output.
3. Create the project and install the relevant skill or library.
4. Ask Claude Code to implement a small working version.
5. Render a preview and inspect the actual video.
6. Give feedback tied to specific scenes, elements, and timing.
7. Move recurring values into configuration.
8. Render the final output only after the preview meets the visual and audio requirements.

Start with one short scene when the tool or codebase is unfamiliar. A small render reveals dependency, asset, timing, and typography problems before they affect a longer production.