This is the prompt behind our motion graphics reels, written generally so it works for any idea. You paste it into Claude Code in an empty folder, and it takes the video through every step: script, voice, plan, animation, sound, review and the final render. It stops three times to ask you before it moves on, so you stay the one making the decisions.
The builder below fills in the prompt for you. The rest of the article explains what is inside it and why, so you can change it with confidence.
What you need
- Claude Code, opened in an empty folder.
- Node.js (LTS) and ffmpeg. The prompt checks for both and tells you how to install whatever is missing. It is told not to install anything without asking you.
- An ElevenLabs account and API key for the voice and the sound effects. No account? Record the voice yourself and give Claude the file. The prompt covers that case.
The video itself is built with Remotion, which turns React code into video. You don't need to know it; Claude sets it up.
Build your prompt
Write your idea. Everything else is optional: the format, length, language, audience, voice, visual identity, character and the call to action at the end. Any field you leave empty gets a sensible value. If you leave the script empty, the prompt tells Claude there is none, and Claude writes it.
Prompt builder
Only the idea is required. Empty fields get a sensible default, shown in the prompt below.
══════════ INPUTS ══════════ Video idea: [write your video idea here] Format: Reel 9:16 Length: 30–40 seconds Language and dialect: the same language as the video idea Audience: decide it yourself from the idea Voice (ElevenLabs): pick a suitable voice yourself Visual identity: suggest one yourself Character: no character End CTA: suggest one that fits the idea Script (if it says "none", write it yourself): none ════════════════════════════ You'll make this video from start to finish in this folder, with Remotion (React + TypeScript). Work as creative director, motion designer, sound designer and developer at the same time. Everything in the video is made with AI and code: the script, the voice, the motion and the sound effects. The goal isn't "a video that moves". The goal is that the viewer understands the idea from the picture even with the sound off, and that any frame you pause on looks deliberately designed. Talk to me in the language of the inputs. Work in stages. At every line marked "STOP", stop and wait, and don't continue until I say "continue". ━━ STAGE 0: SETUP ━━ - Check that Node.js (LTS) and ffmpeg are installed. If anything is missing, tell me how to install it. Don't install anything on my machine without my approval. - If the folder is empty, create a Remotion project with `npx create-video@latest` (blank TypeScript template). Install `@remotion/three`, `three`, `@react-three/fiber` and `@react-three/drei`, and keep every `@remotion/*` package on exactly the same version as `remotion`. - API keys live only in `.env` (for example `ELEVENLABS_API_KEY=`), and `.env` goes in `.gitignore`. Never print a key, write it in the chat or put it in code. If the key is missing, tell me where to put it. - Run `git init` and commit after every stage that works. - Create `CLAUDE.md` with the identity and the rules in this prompt, plus a section called "Lessons learned": every mistake I correct gets added there with its date, so it never happens again in any future video. ━━ STAGE 1: SCRIPT ━━ If the script is "none", write it yourself, to a professional standard: - The hook lands in the first two seconds: a question, a pain the viewer knows, a surprising number, or a shot that shows how big the subject is. Open a question that gets answered at the end, and the answer has to add something new. - One clear idea, split into 3 to 5 beats. Each beat carries one piece of information with a picture that can actually be built. - Written for the ear, not the eye: short sentences, in the audience's natural dialect, with technical terms said the way people actually say them. - Length: about 2.5 words per second (30 seconds ≈ 75 words). - The CTA at the end is shown in the picture, not just said. - Not allowed: wrong information, a number without a source, an exaggerated promise. If a script was given: don't change its meaning or its facts. Put any suggestions separately. Deliver: the script line by line, plus a performance version (where the stress falls, where the pauses are, the tone). STOP: wait for my approval of the script. ━━ STAGE 2: VOICE ━━ - Generate the voice with the ElevenLabs API (a small script that reads the key from `.env`) using the requested voice, and make two takes. - In the text you send for the voice: spell foreign terms the way they are pronounced (in the script's own alphabet if that keeps the accent steadier), and use commas and full stops for pauses. The words that appear on screen come only from the original script. - Save the raw files in `inbox/voice/`. Working copy: 48 kHz WAV, about 0.4 seconds of silence before the first word, loudness around −14 LUFS. Don't change the speed or the pitch. - Timings come from the audio itself, not from guesses: use the text-to-speech endpoint that returns timestamps, or transcribe the audio with a speech-to-text tool that gives the time of every word. Then check the start of each sentence with `ffmpeg silencedetect` and fix any drift by hand. - Confirm every word of the script was spoken (transcribe the audio and compare). - Make a cues file with the start of every line and every word. Scenes take their timing only from this file. Never hard-code a second inside a scene, so if the voice changes, everything re-times itself. - If there is no ElevenLabs account, tell me, and I'll record the voice and send it to you. STOP: tell me to listen to both takes and pick one (you can't hear). ━━ STAGE 3: CREATIVE PLAN ━━ Before any code, write `plan.md`: 1. The message in one sentence, the ideas and how they relate, and the order in which they need to be understood. 2. For each beat: the kind of information (a process? a comparison? a number? a misconception? a set?), how the viewer will see it, and how it turns into the next beat. The form comes from the kind of information, not from a ready-made template. 3. Think of 2 or 3 visual concepts for the whole video, compare them, pick one and tell me why. 4. One world: every place where something gets explained exists in the same world from the first frame, and the camera travels from one place to the next. A transition is the camera moving through the world, not letters and pieces flying across the frame. Exactly one element is the focus of attention in each beat. 5. The hook is in frame 0: words and something moving from the very first frame, no empty second. 6. Use real things when they are clearer than a drawing: real data (like the waveform of the voice itself), real logos, screenshots, free CC0 3D models. Recolour them all with the identity so the video keeps one style. 7. The caption plan and the sound plan (rules below). Send me a summary of the plan and 3 or 4 stills of the key moments. STOP: wait for my approval of the plan. ━━ STAGE 4: BUILD ━━ - The whole video is a function of time: `t = frame / fps`. Camera, motion and captions are all computed from `t`. No `Math.random()` without a seed, and no state that changes from one frame to the next. - 3D with `@remotion/three`: soft light from one direction, shadows, and only colours from the identity. No depth of field or blur on anything that has to be read. The camera has poses tied to the cues and moves between them with deliberate easing; fast moves are rare. - Captions: every spoken word is written inside the world, next to the thing it is about, and the same camera computes its position on screen (projecting a 3D point) so it moves with the world. A word appears exactly when it is said. Regular words are 64px or larger, important words are larger and in the identity colour, and the key word is around 150px. A line leaves before the next one takes its place. - Arabic and other connected scripts: never animate letter by letter (the letters break apart); animate word by word. Any Latin word inside right-to-left text is isolated with `dir="ltr"` and `unicode-bidi: isolate`, and consecutive Latin words stay in one run, or their order flips. A question mark after a Latin word goes inside the same run. Every font you use must be loaded before rendering, or it will silently be swapped for another one. - Motion: objects have weight (a spring with a slight overshoot), text never bounces, and elements don't all enter with the same animation. - Safe zone for a reel: important content between y = 220 and y = 1560, and x between 60 and 1020 (the app's interface covers the rest). Every element is either fully in frame or fully out of it; nothing is cut off by the edge. Nothing passes in front of the camera and covers the focus. - If it's a reel, make it loop: the last frame continues into the first without a cut. - Anything that repeats becomes a component, or a script in `scripts/`, instead of being written again each time. ━━ SOUND AND EFFECTS ━━ - No music unless I ask for it: the voice, a few effects and intentional silence. - Effects only on moments that mean something (a press, an arrival, a reveal), synced to the motion (±2 frames). An effect never lands on top of an important word: put it 0.2 to 0.4 seconds after the word, or before it. Any effect whose picture isn't in frame gets removed. - Sources: generate them with ElevenLabs Sound Effects, make them with ffmpeg, or take them from a free library whose licence allows commercial use. Record the source of every file. - Set every effect's level by measurement (LUFS), not by feel: hits about 5 LU below the voice, movement about 7, small clicks about 11. The final video is −14 LUFS with peaks below −1.5 dBTP. ━━ STAGE 5: REVIEW (the most important stage) ━━ - Export stills at every cue and every 3 or 4 frames inside each transition, put them on one contact sheet, and look at it yourself. - Look for: text on top of text, text or elements cut off by the edge, something passing in front of the camera and covering the frame, an empty frame, two elements colliding as they move, something appearing before it is said or after its explanation is over. - Silence test: with the sound off, is the idea still clear? - Fix and repeat until the sheet is clean. Then render a short clip, with sound, of the key transitions and review it. - `npx tsc --noEmit` has to pass with no errors. ━━ STAGE 6: RENDER AND DELIVERY ━━ - Render at 1080×1920 (or 1920×1080 for YouTube), 30 fps, H.264, with audio at −14 LUFS. - Confirm that the video is exactly as long as the voice and that the dimensions are right. - Make an `.srt` file from the script with the real timings, for YouTube. - Deliver the video and the srt, and tell me honestly what wasn't done or wasn't checked (for example: the audio still needs your ears). ━━ NOT ALLOWED (things that make a video look "made by AI" in the bad sense) ━━ Neon or glow, grid backgrounds, gradients with no purpose, cards with an icon in a square plus a title and a grey line, a pill background behind every word, emoji, everything centred and symmetrical, every element entering with the same fade, a shaking camera, effects with no reason.
Copy it, paste it into Claude Code, and answer it each time it stops.
The stages
The prompt runs the work in seven stages, in this order:
- Setup. Checks Node.js and ffmpeg, creates a Remotion project with 3D support, keeps API keys in
.env, starts git, and writes aCLAUDE.mdwith the rules. - Script. Writes the script if you didn't give one. If you did, it keeps your meaning and facts exactly and puts any suggestions to one side.
- Voice. Generates two takes on ElevenLabs and gets the timing of every word from the audio.
- Plan. Writes
plan.mdbefore any code: the message, the beats, two or three visual concepts and the one it chose. - Build. Builds the video as a function of time, inside one 3D world.
- Review. Exports stills, looks at them, fixes what is wrong and repeats.
- Delivery. Renders the video and an
.srtsubtitle file, and tells you what it could not check.
Three places where Claude stops and waits
Claude doesn't run straight to the end. It stops at three points and waits until you say "continue":
- After the script. Everything after it is built on the script's words and their timing, so a weak line costs the most if it is caught late.
- After the voice. Claude can't hear. It makes two takes, and you listen and pick one.
- After the plan. You see the concept and a few stills of the key moments before the building starts, while changing direction is still cheap.
When you don't have a script
Leave the script empty and Claude writes it under these rules:
- A hook in the first two seconds: a question, a pain the viewer knows, a surprising number, or a shot that shows how big the subject is. It also opens a question that gets answered at the end, and the answer has to add something new.
- One idea, in 3 to 5 beats. Each beat carries one piece of information, and each one needs a picture that can actually be built.
- About 2.5 words per second. A 30-second video is around 75 words.
- Written for the ear: short sentences, in the audience's own dialect, with technical terms said the way people say them.
- No wrong facts, no numbers without a source, and no exaggerated promises.
The rules that make it look designed
Generating a video is the easy part. These rules are what make it look like someone designed it.
Timing comes from the voice itself
Nothing is timed by guessing. The word timings come from the audio (ElevenLabs can return them with the speech, or a speech-to-text tool can), and the start of each sentence is checked with ffmpeg. They go into one cues file, and every scene reads its timing from there. No scene contains a hand-typed second, so if you change the voice, the whole video re-times itself.
One 3D world, and the camera travels through it
Every part of the explanation exists in the same 3D world from the first frame. Moving to the next idea means the camera moving to another place in that world, not text and shapes flying across the screen. Each beat has exactly one thing for the eye to follow.
Every word is written inside the world
The captions aren't a layer pasted on top. Each spoken word sits in the world next to the thing it describes, and the same camera that films the scene works out where it lands on screen, so the words move with the world. A word appears exactly when it is said. Regular words are 64px or more, and the key word is around 150px.
Arabic and English in the same line
This matters if you make videos in Arabic, as we do. Arabic letters connect, so animating text letter by letter breaks the words apart; the prompt animates word by word instead. English words inside an Arabic line are isolated with dir="ltr" and unicode-bidi: isolate, and English words that follow each other stay together in one run, or the browser flips their order. A question mark after an English word stays inside that run too. Fonts are loaded before the render, or another font quietly takes their place.
Sound effects never sit on an important word
Effects only go on moments that mean something, like a press, an arrival or a reveal, and they are synced to the motion. An effect never lands on top of a key word: it comes 0.2 to 0.4 seconds after it, or before it. Levels are measured, not judged by ear: hits sit about 5 LU under the voice, movement about 7 and small clicks about 11.
The final mix is −14 LUFS
The whole video is mixed to −14 LUFS with peaks below −1.5 dBTP. That is a common loudness target for online video, so the voice comes through at a steady, comfortable level and doesn't clip.
Stills are reviewed before the render
Before anything is rendered, Claude exports stills at every cue and every few frames inside each transition, puts them on one sheet, and looks for text on text, anything cut off by the edge, empty frames, collisions, and things that appear before they are said. Then the silence test: with the sound off, is the idea still clear? It fixes and repeats until the sheet is clean. Finding a problem in a still takes seconds; finding it in a render takes minutes each time.
The "made by AI" list
The prompt also bans the things that make a video look generated: neon and glow, grid backgrounds, gradients with no purpose, icon-in-a-square cards, a pill behind every word, emoji, everything centred, the same fade on every element, and a shaking camera.
Working with Claude Code: the two habits that matter most
Make it plan before it writes code
Stage 3 exists for this. A plan is a page you can read and correct in a minute; the same mistake found in code costs a rebuild. Ask for the plan, read it, push back, and only then let it build. For your own tasks outside this prompt, Claude Code has a plan mode (press Shift+Tab) that does the same thing.
Every corrected mistake goes into CLAUDE.md
Claude Code reads CLAUDE.md at the start of every session. The prompt creates one with a "Lessons learned" section, and every time you correct something, Claude adds it there with the date. An entry looks like this:
## Lessons learned
- 2026-11-09: Arabic captions were animated letter by letter and the letters broke apart. Always animate Arabic word by word.
A correction you make once becomes a rule for every video after it. This is what makes each video better than the one before.
A few smaller ones
- Commit after every stage that works, so you can always go back. The prompt already asks for this.
- Be specific when you correct it. "At 0:12 the word 'data' covers the chart" gets fixed in one go. "It looks off" does not.
- Give it real material when you have it: your logo, real screenshots, real numbers with their source.
Questions
Do I need to know how to code?
You won't write code, but you will run Claude Code in a terminal, read what it tells you, and answer its questions. If you can do that, you can use this prompt.
Can I make the video in Arabic or another language?
Yes. Set the language and dialect field. The prompt already includes the rules for Arabic captions with English words in them.
Can I use my own voice instead of ElevenLabs?
Yes. Tell Claude you don't have an ElevenLabs account and send it your recording. Everything is timed from the audio, so it works the same way.