What it is: A step-by-step tutorial for building an automated YouTube Shorts production pipeline using Claude Code for scripting and Remotion for programmatic video rendering.
Who it’s for: Content creators, YouTubers, and marketers who want to produce short-form video at scale without manual video editing.
Best if: You want to generate 10-50 YouTube Shorts per week from text content, data, or templates using code instead of editing software.
Skip if: You prefer hands-on video editing in Premiere Pro or DaVinci Resolve and do not want an automated approach.
The YouTube Shorts Factory: Automate Short-Form Video Production
Bottom line up front: You can build a fully automated YouTube Shorts factory by combining Claude Code (for script generation, data processing, and orchestration) with Remotion (for rendering videos programmatically in React). This pipeline takes text input — blog posts, statistics, quotes, news headlines — and outputs finished vertical videos with animations, captions, and background music, ready to upload. This tutorial walks you through building the entire system from scratch, even if you have never written React code before.
Key Takeaways
- Remotion lets you create videos using React components — every frame is a function of data, making videos infinitely customizable through code
- Claude Code generates the video scripts, creates Remotion component code, and orchestrates the entire rendering pipeline from your terminal
- A single template can produce hundreds of unique Shorts by swapping data inputs (different facts, quotes, statistics, tips)
- The rendering process runs locally or in the cloud via Remotion Lambda, producing MP4 files ready for YouTube upload
- You can add animated captions, kinetic typography, progress bars, and transitions without learning After Effects or Motion
- The complete pipeline (script to render to export) takes under 2 minutes per video once the template is built
What Is Remotion and Why Pair It with Claude Code?
Remotion is an open-source framework that lets you create videos using React. Instead of dragging clips around a timeline, you write components that render frames. Each frame is a function of time and data, which means you can generate completely different videos just by changing the input data.
Claude Code is the orchestration layer. It writes the React components, generates script content, manages the data pipeline, and triggers rendering — all from your terminal. Together, they form a video factory where you feed in ideas and get back finished Shorts.
Prerequisites and Setup
Install the Required Tools
# Install Claude Code
npm install -g @anthropic-ai/claude-code
# Create a new Remotion project
npx create-video@latest youtube-shorts-factory
cd youtube-shorts-factory
# Install additional dependencies
npm install @remotion/player @remotion/lambdaProject Structure
Your Shorts factory will have this structure:
youtube-shorts-factory/
src/
compositions/
FactShort.tsx # Template: quick fact videos
QuoteShort.tsx # Template: animated quotes
ListShort.tsx # Template: top-5 lists
TutorialShort.tsx # Template: step-by-step tips
components/
AnimatedText.tsx # Reusable text animations
ProgressBar.tsx # Video progress indicator
Background.tsx # Gradient/image backgrounds
Caption.tsx # Auto-caption component
data/
scripts.json # Video scripts and content
public/
fonts/
audio/
CLAUDE.md # Instructions for Claude Code
render-batch.sh # Batch rendering scriptStep 1: Build Your First Shorts Template with Claude Code
Open Claude Code in your project directory and ask it to create a template:
claude "Create a Remotion composition for YouTube Shorts (1080x1920, 30fps,
30 seconds) called FactShort. It should:
1. Display a hook question for 3 seconds with a zoom-in animation
2. Show 3 facts one at a time, each for 7 seconds with slide-in transitions
3. End with a CTA 'Follow for more' with a subscribe animation
4. Use a dark gradient background
5. Accept props: { hook: string, facts: string[], cta: string }
Save to src/compositions/FactShort.tsx"Claude Code generates a complete React component. Here is what the core structure looks like:
import {
AbsoluteFill, useCurrentFrame, interpolate,
spring, useVideoConfig
} from "remotion";
interface FactShortProps {
hook: string;
facts: string[];
cta: string;
}
export const FactShort: React.FC<FactShortProps> = ({ hook, facts, cta }) => {
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
// Hook animation: frames 0-90 (3 seconds at 30fps)
const hookScale = spring({ frame, fps, config: { damping: 12 } });
const hookOpacity = interpolate(frame, [0, 15], [0, 1], {
extrapolateRight: "clamp",
});
// Each fact gets 210 frames (7 seconds)
const factStartFrames = [90, 300, 510];
return (
<AbsoluteFill style={{
background: "linear-gradient(135deg, #0f0f23, #1a1a3e)",
}}>
{frame < 90 && (
<div style={{
transform: `scale(${hookScale})`,
opacity: hookOpacity,
fontSize: 52, color: "#fff",
textAlign: "center", padding: 60,
}}>
{hook}
</div>
)}
{facts.map((fact, i) => {
const start = factStartFrames[i];
const slideIn = interpolate(
frame, [start, start + 20], [1920, 0],
{ extrapolateRight: "clamp" }
);
const visible = frame >= start && frame < start + 210;
return visible ? (
<div key={i} style={{
transform: `translateY(${slideIn}px)`,
fontSize: 42, color: "#e0e0ff",
padding: 60, lineHeight: 1.5,
}}>
<span style={{ color: "#7c7cff", fontSize: 72 }}>
{i + 1}.
</span>
<br />{fact}
</div>
) : null;
})}
</AbsoluteFill>
);
};Step 2: Generate Video Scripts with Claude Code
Now use Claude Code to create the content that feeds into your templates:
claude "Generate 10 YouTube Shorts scripts about 'AI facts that will blow
your mind'. Each script needs:
- hook: an attention-grabbing question (under 10 words)
- facts: array of 3 short facts (under 20 words each)
- cta: 'Follow @beginnersinai for more AI tips'
Save as JSON array to src/data/ai-facts-scripts.json"Claude generates a JSON file like this:
[
{
"hook": "Did you know AI can now write code?",
"facts": [
"Claude Code can build entire applications from a text description",
"GitHub Copilot writes 46% of code at companies that use it",
"AI-generated code passes 85% of standard coding interviews"
],
"cta": "Follow @beginnersinai for more AI tips"
},
{
"hook": "How fast is AI actually growing?",
"facts": [
"ChatGPT reached 100 million users in just 2 months",
"The AI market will exceed $1.8 trillion by 2030",
"AI patent filings increased 700% in the last decade"
],
"cta": "Follow @beginnersinai for more AI tips"
}
]Step 3: Register Compositions and Render
Tell Claude Code to wire everything together:
claude "Update src/Root.tsx to register the FactShort composition. Read
the scripts from src/data/ai-facts-scripts.json and create a composition
for each script entry. Use 1080x1920 resolution, 30fps, 900 frames.
Then create a render-batch.sh script that uses the Remotion CLI to render
all compositions to MP4 files in an output/ directory."The batch render script Claude generates:
#!/bin/bash
# render-batch.sh - Render all YouTube Shorts
mkdir -p output
for i in $(seq 0 9); do
echo "Rendering Short $i..."
npx remotion render src/index.ts "FactShort-${i}" \
--output "output/ai-fact-short-${i}.mp4" \
--codec h264 \
--width 1080 \
--height 1920
echo "Done: output/ai-fact-short-${i}.mp4"
done
echo "All shorts rendered successfully"Step 4: Add Animated Captions
YouTube Shorts perform better with captions. Ask Claude Code to build a caption component:
claude "Create a Caption component for Remotion that:
- Takes a text string and start/end frame numbers
- Displays words one at a time with a highlight animation (like karaoke)
- Uses white text with a semi-transparent black background pill
- Positions at the bottom third of the screen
- Includes a subtle scale bounce when each new word appears
Save to src/components/Caption.tsx"This component uses Remotion’s interpolate and spring functions to create professional-looking word-by-word caption reveals that keep viewers engaged throughout the Short.
Step 5: Scale with Remotion Lambda for Cloud Rendering
Local rendering works for small batches, but for true factory-scale production, use Remotion Lambda to render in the cloud:
claude "Set up Remotion Lambda for cloud rendering. Create a deploy script:
1. Deploys the Remotion bundle to AWS Lambda
2. Reads all scripts from src/data/
3. Triggers parallel renders for each script
4. Downloads the finished MP4s to output/
Include AWS credential setup instructions in comments."With Lambda, you can render 50 Shorts simultaneously instead of sequentially — the entire batch finishes in minutes instead of hours.
Step 6: Build Additional Templates
Expand your factory with more template types. Use Claude Code to generate each one:
# Quote template - animated inspirational quotes
claude "Create a QuoteShort Remotion composition: display a quote with
typewriter animation, author name fade-in, and particle background.
Props: { quote: string, author: string, topic: string }"
# List template - top 5 countdown
claude "Create a ListShort composition: countdown from 5 to 1 with flip
card transitions. Each item has a title and one-line description.
Props: { title: string, items: { name: string, desc: string }[] }"
# Tutorial template - step-by-step tips
claude "Create a TutorialShort composition: shows 3 steps with numbered
circles, progress bar at top, and code-style font.
Props: { title: string, steps: string[] }"Each template is a reusable React component. Feed it different data and you get a different video. For more on building different types of animated explainers with code, see our dedicated guide.
The Complete Factory Workflow
Here is the end-to-end process once your factory is built:
- Generate scripts:
claude "Create 20 scripts about [topic] in the FactShort format" - Preview:
npx remotion previewto check animations in the browser - Render:
bash render-batch.shto produce all MP4 files - Upload: Use the YouTube Data API or upload manually
Total time for 20 Shorts: approximately 30 minutes of active work plus rendering time. Compare that to 2-3 hours per Short in traditional video editing software. For a broader look at comparing video tools, see our Remotion vs Motion Canvas vs Manim comparison.
10 Shorts Factory Plays Most Creators Have Not Tried
You have the factory working. The 10 plays below push throughput and quality further in 2026.
1. Topic-cluster batching from search data
Instead of producing 1 short per topic, produce 5 from related search terms. Topic clustering improves YouTube algorithmic surfacing; production cost per short drops.
2. Hook optimization with multivariate testing
The first 3 seconds drive view-through. Generate 5 hook variations per short; ship 2 to 3 minor variants; keep what works. Iteration data compounds.
3. Caption-readability optimization for sound-off viewing
Most Shorts views are sound-off. Captions that read well matter more than voiceover that sounds good. Optimize visual flow first.
4. Cross-platform repurposing with platform-native edits
Same source content becomes Shorts, Reels, TikTok with platform-specific cuts (aspect ratio, length, caption style). One source produces 3 distribution channels.
5. Performance feedback loops into the script generator
Top-performing Shorts have patterns. Feed analytics back into your script generator; it learns what works for your channel. Output quality compounds.
6. Series-structure for binge consumption
Standalone Shorts get one view. Numbered series (Part 1 of 5) drives binge consumption. Your factory generates series, not random Shorts.
7. Niche-specific template library
Build 5 to 10 Shorts templates for your niche (tutorial, hot take, list, comparison, story). Generator pulls from the library based on content type. Production speeds up; quality stays high.
8. Disclosure-first AI-generation labeling
YouTube wants creators to disclose AI generation. Build disclosure into your workflow. Algorithm-favored creators build trust through transparency.
9. Long-form callback for retention
Each Short ends with a CTA to your long-form video on the topic. Shorts-to-long-form conversion is one of the highest-leverage moves for creator businesses.
10. Sustainable cadence over burnout sprints
Most factories produce 30 Shorts in a week then nothing for two months. Sustainable cadence (e.g., 3 Shorts per week for a year) compounds algorithmically. Tune your factory to sustainability, not bursts.
Adding Background Music and Sound Effects
Remotion supports audio through its Audio component. Ask Claude Code to integrate it:
claude "Add background music support to the FactShort template:
- Import a royalty-free audio file from public/audio/bgm.mp3
- Fade in over the first 1 second
- Reduce volume to 30% when text is displayed
- Fade out over the last 2 seconds
Use Remotion's Audio and Sequence components."Use royalty-free music sources like Uppbeat, Artlist, or Epidemic Sound to avoid copyright claims on your Shorts.
Get the Claude Essentials Toolkit
Want pre-built Remotion templates and Claude Code prompts for your YouTube Shorts factory? Our Claude Essentials toolkit includes starter templates, rendering scripts, and a complete CLAUDE.md configuration for video production workflows.
For weekly tutorials on AI-powered content creation, subscribe to the Beginners in AI newsletter.
Frequently Asked Questions
Do I need to know React to use Remotion with Claude Code?
No. Claude Code writes the React components for you. You describe what you want the video to look like in plain English, and Claude generates the component code. You might want to understand basic concepts like components and props to customize the output, but Claude handles the actual coding. Our Claude for coding guide covers how Claude assists with programming tasks.
How long does it take to render a single YouTube Short?
On a modern laptop, a 30-second Short at 1080×1920 resolution takes 1-3 minutes to render locally. With Remotion Lambda (cloud rendering), it takes 15-30 seconds. Complex animations with many layers or effects take longer.
Can I add background music to the Shorts?
Yes. Remotion supports audio through its Audio component. Place royalty-free music files in your public/audio directory, and Claude Code can add them to your compositions with volume control and fade in/out effects. Use royalty-free sources like Uppbeat or Artlist to avoid copyright strikes on YouTube.
Is this approach better than using CapCut or Canva for Shorts?
For individual videos, CapCut and Canva are faster because they have drag-and-drop interfaces. The Remotion plus Claude Code approach wins when you need scale — producing 10, 50, or 100 Shorts from a template. Manual tools do not support batch production. If you create Shorts occasionally, use CapCut. If you want a content factory, use this approach.
Can I customize the visual style of the templates?
Absolutely. Since everything is code, you have complete control over colors, fonts, animations, timing, and layout. Ask Claude Code to modify any visual aspect — change the background to a blue gradient, make the text animation faster, add a logo in the top right corner. Every visual element is a CSS or React property that Claude can adjust instantly.
Sources
- Remotion Documentation — remotion.dev
- Programmatic Video Generation — Wikipedia
Get Smarter About AI Every Morning
Free daily newsletter — one story, one tool, one tip. Plain English, no jargon.
Free forever. Unsubscribe anytime.