# AgentCut prompts: Claude Code for editing

CLAUDE.md files, skills you call with a slash, and step by step starters for editing with Claude Code, Remotion and Claude Motion. Drop the files into your project folder.

Source: https://agentcut.dev/prompts/#claude-code
Written by AgentCut unless credited. Free to copy, edit and use. Run anything that edits a project on a copy first.

---

## 1. CLAUDE.md for a Remotion motion graphics project

When to use it: You make motion graphics or explainers in code with Claude Code and Remotion, and you want every session to follow the same rules for timing, fonts and renders.

Works with: Remotion Agent Skills (official) (https://agentcut.dev/tools/remotion-agent-skills-official/), Remotion MCP App (https://agentcut.dev/tools/remotion-mcp-app/), Motion Graphics Skill Pack (https://agentcut.dev/tools/motion-graphics-skills-charlie947/)

Save as: CLAUDE.md

Sources and credit: Remotion, Prompting videos with coding agents (https://www.remotion.dev/docs/ai/coding-agents): Project setup commands; Claude Code docs, How Claude remembers your project (https://code.claude.com/docs/en/memory): What belongs in CLAUDE.md

~~~~markdown
# Project: motion graphics in Remotion

This folder is a Remotion project. I am a video editor, not a developer. Explain changes in plain words.

## Setup facts
- Preview: `npm run dev` (Remotion Studio). I keep it open in another terminal.
- Render: `npx remotion render <CompositionId> out/<name>.mp4`
- Remotion Agent Skills are installed (`npx remotion skills add`). Use them for anything Remotion specific before guessing an API.
- Brand rules live in `brand/DESIGN.md`. Read it before you design anything.

## Video rules
- Default composition: 1920x1080, 30 fps. Vertical versions: 1080x1920, same fps.
- Never change fps or dimensions of an existing composition unless I ask.
- Express all timing in frames, and name it: `const IN = 12; const HOLD = 60;`
- Every animation needs an in, a hold and an out. Text holds at least 1.5 seconds per line so people can read it.
- Use `spring()` or `interpolate()` with easing. No linear moves on anything that enters or leaves the frame.
- Keep all text inside the safe area from `brand/DESIGN.md`.
- Fonts load through `@remotion/google-fonts` or local files in `public/fonts`. Never rely on system fonts.

## How to work with me
1. Before writing code, describe the animation in 3 to 6 short beats with frame numbers and wait for my OK.
2. Build one scene at a time as its own component in `src/scenes/`.
3. After each change, tell me which composition to look at in Studio and at which frame.
4. Make every word, number, color and duration a prop with a default value, so I can change it in Studio without code.
5. Do not install new packages without asking.

## Before you say it is done
- The composition renders without errors.
- No text is cut off at any frame (check the longest prop values).
- Audio, if any, starts and ends on the frames we agreed.
~~~~

---

## 2. CLAUDE.md for an FFmpeg editing folder

When to use it: You keep raw footage in a folder and let Claude Code trim, cut, caption and export it with FFmpeg, and you never want it to touch your originals.

Works with: ffmpeg-skill (https://agentcut.dev/tools/ffmpeg-skill/), Kinocut (formerly mcp-video) (https://agentcut.dev/tools/kinocut-formerly-mcp-video/), Video & Audio Editing MCP (https://agentcut.dev/tools/video-audio-editing-mcp/), Claude Video Vision (https://agentcut.dev/tools/claude-video-vision/)

Save as: CLAUDE.md

Sources and credit: n0an/ffmpeg-skill (MIT) (https://github.com/n0an/ffmpeg-skill): Idea of giving the agent vetted recipes instead of recalled commands; Claude Code docs, How Claude remembers your project (https://code.claude.com/docs/en/memory): What belongs in CLAUDE.md

~~~~markdown
# Project: FFmpeg editing folder

I edit videos here with FFmpeg through you. Treat my footage like a client's footage.

## Folders
- `raw/` original files. READ ONLY. Never write, move, rename or delete anything in here.
- `work/` temporary files. You can create and delete files here.
- `out/` finished exports only.
- `logs/` one text file per job with the exact commands you ran.

## Rules
- Run `ffprobe` on every input before you build a command. Report resolution, fps, codec, duration and audio channels.
- Keep the source fps and resolution unless I ask for something else.
- Prefer stream copy (`-c copy`) for simple trims on keyframes. Re-encode when cuts must be frame accurate and say so.
- Default delivery encode: H.264, `-crf 18`, `-preset slow`, `-pix_fmt yuv420p`, AAC 320k, `-movflags +faststart`.
- Never overwrite a file. If the output exists, add `_v2`, `_v3`.
- Show me the full command before any job that takes more than a minute, then run it after I say go.
- Write every command you ran into `logs/<job>.txt` so I can rerun it.

## Checks after every export
- `ffprobe` the output: duration, fps and resolution match what we planned.
- Audio is present and not silent (`volumedetect` mean volume above -50 dB).
- Tell me 3 timestamps worth checking by eye, for example the first cut, the busiest caption and the last second.
~~~~

---

## 3. CLAUDE.md for editing in Resolve, Premiere or After Effects through MCP

When to use it: You connected Claude Code to DaVinci Resolve, Premiere Pro or After Effects with an MCP server and want safe habits before it touches a real project.

Works with: DaVinci Resolve MCP Server (samuelgursky) (https://agentcut.dev/tools/davinci-resolve-mcp-server-samuelgursky/), Resolve MCP Server (guycochran) (https://agentcut.dev/tools/resolve-mcp-server-guycochran/), MCP Bridge for Adobe Premiere Pro (https://agentcut.dev/tools/mcp-bridge-for-adobe-premiere-pro/), Premiere Pro MCP (PPMCP) (https://agentcut.dev/tools/premiere-pro-mcp-ppmcp/), AE MCP Bridge (https://agentcut.dev/tools/ae-mcp-bridge/), mcp-aftereffects (Kumo Productions) (https://agentcut.dev/tools/mcp-aftereffects-kumo-productions/)

Save as: CLAUDE.md

Sources and credit: Claude Code docs, Connect Claude Code to tools via MCP (https://code.claude.com/docs/en/mcp): How MCP servers attach to Claude Code

~~~~markdown
# Project: editing through an MCP server

You control my editing app through an MCP server. The app is open on my screen and I can see every change.

## Safety first
- I always work on a duplicate project or a duplicated timeline. At the start of each session, ask me to confirm the name of the timeline or comp you may edit. Touch nothing else.
- Read before you write. Start with the read only tools (list projects, list timelines or comps, list clips, get markers) and summarize what you see.
- Never delete media, bins, timelines or comps. If something should go, move it to a bin or folder called `_to_delete` and tell me.
- If a tool can run raw scripts (ExtendScript, Python, JavaScript), show me the script and explain it in plain words before running it.
- Never start a render or export unless I ask for it in this session.

## How to work
1. Restate the task as a numbered plan with the exact tools you will call.
2. Do the first step only, then tell me what changed and where to look (timeline name, timecode, track).
3. Continue step by step. If a tool errors, stop and show me the error. Do not retry with a different, riskier tool.
4. Use markers to flag anything you are not sure about, named `AI CHECK: <reason>`.

## Project facts (fill these in)
- App and version:
- Edition (Resolve Free or Studio):
- Timeline fps and resolution:
- Naming style for clips and bins:
~~~~

---

## 4. Claude Code skill: /cut-silences

When to use it: You record talking head videos and want one command that finds the pauses, shows you the cut list, and exports a tighter version.

Works with: ffmpeg-skill (https://agentcut.dev/tools/ffmpeg-skill/), Kinocut (formerly mcp-video) (https://agentcut.dev/tools/kinocut-formerly-mcp-video/), Auto Cut for Premiere Pro (https://agentcut.dev/tools/auto-cut-premiere-rafcopy/), SmartCut MCP (CapCut talking-head) (https://agentcut.dev/tools/smartcut-mcp-capcut-talking-head/)

Save as: .claude/skills/cut-silences/SKILL.md

Sources and credit: r/ClaudeCode, Claude Code skill that edits raw video end to end (https://www.reddit.com/r/ClaudeCode/comments/1t6tdhk/i_built_a_claude_code_skill_that_takes_raw_video/): Pipeline idea: Whisper, silencedetect, Claude builds the cut list; Claude Code docs, Extend Claude with skills (https://code.claude.com/docs/en/skills): SKILL.md format and where skills live

~~~~markdown
---
name: cut-silences
description: Find pauses and dead air in a talking head video with ffmpeg silencedetect, propose a cut list, and export a tightened version. Use when the user asks to cut silences, tighten a take, or make a jump cut edit.
argument-hint: <video file> [min pause in seconds, default 0.6]
---

# Cut silences

Input: $ARGUMENTS

1. Run `ffprobe` on the file and report duration, fps and audio channels.
2. Detect silence on the first audio stream:
   `ffmpeg -hide_banner -i INPUT -map 0:a:0 -af silencedetect=noise=-35dB:d=MIN_PAUSE -f null - 2> work/silence.txt`
   If no audio stream exists, stop and tell the user.
3. Parse `silence_start` and `silence_end` pairs. Keep 0.12 s of padding on each side of every kept segment so words are not clipped.
4. Never cut a pause shorter than MIN_PAUSE. Never leave a kept segment shorter than 0.4 s, merge it with its neighbor instead.
5. Write the plan to `work/cutlist.csv` with columns: keep_start, keep_end, length. Show the user a summary: number of cuts, old duration, new duration, the 3 longest removed pauses with timestamps.
6. Wait for the user to say go.
7. Export with frame accurate cuts (re-encode) to `out/<name>_tight.mp4`, keeping source fps and resolution. Use the select and aselect filters or a concat list, whichever is simpler for the number of segments.
8. ffprobe the result, confirm the new duration matches the plan within 0.2 s, and list 3 cut points worth checking by eye.

Rules: never write into `raw/`. Never overwrite an existing output. If the user is in Premiere, Resolve or CapCut, offer to write the cut list as markers instead of exporting a file.
~~~~

---

## 5. Claude Code skill: /captions

When to use it: You want accurate SRT captions from local Whisper, split into readable lines, and optionally burned into a vertical export.

Works with: ffmpeg-skill (https://agentcut.dev/tools/ffmpeg-skill/), Video & Audio Editing MCP (https://agentcut.dev/tools/video-audio-editing-mcp/), Kinocut (formerly mcp-video) (https://agentcut.dev/tools/kinocut-formerly-mcp-video/)

Save as: .claude/skills/captions/SKILL.md

Sources and credit: ranahaani/i-hate-editing (MIT) (https://github.com/ranahaani/i-hate-editing): Rule that captions should land slightly after the word, never before; Netflix Timed Text Style Guide (English USA) (https://partnerhelp.netflixstudios.com/hc/en-us/articles/217350977-English-USA-Timed-Text-Style-Guide): Line length and reading speed limits

~~~~markdown
---
name: captions
description: Transcribe a video locally with Whisper, build clean SRT captions with readable line lengths, and optionally burn them in. Use when the user asks for captions, subtitles, an SRT or burned in text.
argument-hint: <video file> [burn] [language]
---

# Captions

Input: $ARGUMENTS

1. Extract audio: `ffmpeg -i INPUT -vn -ac 1 -ar 16000 work/audio.wav`
2. Transcribe with word timestamps (ask which Whisper the user has installed if unsure):
   `whisper work/audio.wav --model small --word_timestamps True --output_format json --output_dir work`
3. Build captions from the word timings:
   - Max 42 characters per line, max 2 lines per caption (vertical video: 1 line, max 28 characters).
   - Keep reading speed under 20 characters per second. Merge or extend if faster.
   - Minimum 0.8 s on screen, maximum 6 s.
   - Break lines after punctuation or before conjunctions, never between an adjective and its noun.
   - Start each caption about 0.05 s after the first word starts. Early captions look out of sync.
4. Fix obvious mistakes in names and product terms using the list in CLAUDE.md, if there is one. Do not rewrite what the speaker said.
5. Save `out/<name>.srt` and show the user the 5 captions you are least sure about with timestamps.
6. If the user asked to burn them in, use the caption style from `brand/DESIGN.md` if it exists, otherwise white text, black outline, bottom center, inside the safe area:
   `ffmpeg -i INPUT -vf "subtitles=out/<name>.srt:force_style='FontName=Inter,FontSize=18,Outline=2,MarginV=60'" -c:a copy out/<name>_captioned.mp4`
7. Never overwrite an existing file.
~~~~

---

## 6. Claude Code skill: /shorts from a long video

When to use it: You have a podcast, stream or long YouTube video and want Claude to find the best moments and export vertical clips you can review.

Works with: podcli (https://agentcut.dev/tools/podcli/), n8n: Viral clips from YouTube with Gemini + FFmpeg (https://agentcut.dev/tools/n8n-viral-clips-gemini-ffmpeg/), ffmpeg-skill (https://agentcut.dev/tools/ffmpeg-skill/), HyperFrames (HeyGen) (https://agentcut.dev/tools/hyperframes-heygen/)

Save as: .claude/skills/shorts/SKILL.md

Sources and credit: r/ClaudeAI, I open sourced the Claude Code skill I use to edit my own videos (https://www.reddit.com/r/ClaudeAI/comments/1w935ob/i_opensourced_the_claude_code_skill_i_use_to_edit/): The model reads the transcript and picks cuts, it never watches the video

~~~~markdown
---
name: shorts
description: Find the strongest self contained moments in a long video from its transcript and export vertical 9:16 clips for review. Use when the user asks for shorts, reels, TikToks or clips from a long video.
argument-hint: <video file> [number of clips, default 5] [max seconds, default 45]
---

# Shorts from a long video

Input: $ARGUMENTS

1. Transcribe with word timestamps (see the captions skill) into `work/transcript.json`. Read only the transcript, do not try to watch the video.
2. Find candidate moments that:
   - make sense with no context from earlier in the video
   - open with a strong first sentence (a claim, a question, a number or a surprise) inside the first 2 seconds
   - end on a complete thought, not mid sentence
   - run between 15 s and the max length
3. Show a table: rank, start, end, length, first line, last line, why it works. Propose more than requested so the user can choose.
4. Wait for the user to pick.
5. For each pick, cut with frame accuracy and reframe to 1080x1920. Default reframe: center crop. If the speaker is off center, ask for an x offset or use a face tracking tool if one is installed.
6. Add captions using the captions skill rules for vertical video, kept above the bottom 20% of the frame where app buttons sit.
7. Export `out/short_<rank>_<first-words>.mp4` and a `out/shorts.md` file with a suggested title and the start and end timecodes in the source.
8. Never claim a clip will go viral. Describe why it might hold attention and let the user decide.
~~~~

---

## 7. Claude Code skill: /qa-render before you deliver

When to use it: You want a repeatable final check on every export before it goes to a client or gets uploaded.

Works with: ffmpeg-skill (https://agentcut.dev/tools/ffmpeg-skill/), Claude Video Vision (https://agentcut.dev/tools/claude-video-vision/), Kinocut (formerly mcp-video) (https://agentcut.dev/tools/kinocut-formerly-mcp-video/)

Save as: .claude/skills/qa-render/SKILL.md

Sources and credit: ranahaani/i-hate-editing (MIT) (https://github.com/ranahaani/i-hate-editing): Idea of writing every failure down as a check that blocks delivery

~~~~markdown
---
name: qa-render
description: Run technical checks on a finished video file (specs, loudness, black frames, silence, duration) and report pass or fail. Use before delivering or uploading any export.
argument-hint: <video file> [target: youtube | broadcast | social]
disable-model-invocation: true
---

# QA a render

Input: $ARGUMENTS

Run each check, then print a table with check, result, pass or fail.

1. Specs with ffprobe: container, codec, resolution, fps, duration, audio codec, channels, sample rate. Compare with the delivery spec in CLAUDE.md if there is one.
2. Loudness with `ffmpeg -i FILE -af ebur128=peak=true -f null -`: report integrated LUFS and true peak.
   Targets: youtube and social around -14 LUFS, true peak at or below -1 dBTP. broadcast: ask the user for their spec (many use -23 or -24 LUFS).
3. Black frames: `ffmpeg -i FILE -vf blackdetect=d=0.2:pix_th=0.10 -an -f null -`. Flag any black section that is not at the very start or end.
4. Silence: `silencedetect=noise=-50dB:d=1.5` on the audio. Flag gaps longer than 1.5 s.
5. Frozen frames: `freezedetect=n=0.003:d=2`. Flag anything over 2 s that is not an intended still.
6. Save 6 evenly spaced frames to `work/qa/` so the user can glance at them.

End with: PASS or FAIL, the 3 most important problems, and the exact timecodes. Do not fix anything unless the user asks.
~~~~

---

## 8. Your first motion graphic with Claude Code and Remotion, step by step

When to use it: You have never used Remotion and want a 10 second animated title out of Claude Code today.

Works with: Remotion Agent Skills (official) (https://agentcut.dev/tools/remotion-agent-skills-official/), Motion Graphics Skill Pack (https://agentcut.dev/tools/motion-graphics-skills-charlie947/), claude-motion-design (https://agentcut.dev/tools/claude-motion-design-howseen/)

Save as: first-remotion-video.md

Sources and credit: Remotion, Prompting videos with coding agents (https://www.remotion.dev/docs/ai/coding-agents): Setup commands in step 1; Remotion, Claude Code plugin (https://www.remotion.dev/docs/ai/claude-code-plugin): Plugin install alternative

~~~~markdown
# First motion graphic with Claude Code + Remotion

## Step 1. Set up (once, in a terminal)
You need Node.js and Claude Code installed. Then:

    npx create-video --yes --blank my-video
    cd my-video
    npx remotion skills add
    npm run dev

Leave that terminal open. Remotion Studio opens in your browser.
Optional: Remotion also ships an official Claude Code plugin, see remotion.dev/docs/ai/claude-code-plugin

## Step 2. Start Claude Code in a second terminal

    cd my-video
    claude

## Step 3. Paste this first prompt

Make a 10 second, 1920x1080, 30 fps composition called TitleCard.
Beats:
1. Frames 0 to 20: a thin line draws from left to right in the center.
2. Frames 15 to 40: the title "YOUR TITLE HERE" rises 30 px into place and fades in, with a spring, no bounce.
3. Frames 40 to 70: a subtitle "Your subtitle" fades in under it.
4. Frames 70 to 270: hold, with a very slow 2% scale up on everything.
5. Frames 270 to 300: everything fades out together.
Use a warm off white background, near black text and one accent color.
Make the title, subtitle, colors and durations props with defaults so I can edit them in Studio.
Before writing code, list the beats back to me with frame numbers.

## Step 4. Iterate in small steps
Good follow ups, one at a time:
- "The title feels slow. Make the rise take 14 frames instead."
- "Add a 9:16 version called TitleCardVertical that reuses the same component."
- "Swap the font for a free Google font that feels editorial, and load it properly."

## Step 5. Render

    npx remotion render TitleCard out/title.mp4

Then drop the MP4 into Premiere, Resolve, Final Cut or CapCut like any other clip.
~~~~

---

## 9. Connect Claude Code to DaVinci Resolve, step by step

When to use it: You want Claude Code to read and edit your Resolve timeline and need a safe first session.

Works with: DaVinci Resolve MCP Server (samuelgursky) (https://agentcut.dev/tools/davinci-resolve-mcp-server-samuelgursky/), Resolve MCP Server (guycochran) (https://agentcut.dev/tools/resolve-mcp-server-guycochran/), DaVinci Resolve MCP — Works in Resolve Free (https://agentcut.dev/tools/davinci-resolve-mcp-works-in-resolve-free/), davinci-resolve-lite-mcp (https://agentcut.dev/tools/davinci-resolve-lite-mcp/)

Save as: resolve-mcp-first-session.md

Sources and credit: Claude Code docs, Connect Claude Code to tools via MCP (https://code.claude.com/docs/en/mcp): claude mcp add and .mcp.json; CineD on DaVinci Resolve 21.1 (https://www.cined.com/davinci-resolve-21-1-released-ai-assistant-integration-via-mcp-individual-hdr-trims-and-python-scripting-moves-to-studio/): Scripting and the built in MCP server moved to Studio in 21.1

~~~~markdown
# Claude Code + DaVinci Resolve: first session

## Step 1. Pick a server that fits your edition
- Resolve Studio: most MCP servers work, because external scripting is a Studio feature.
- Resolve Free: pick a server that says it works on Free. Since Resolve 21.1, Python scripting is Studio only, so many Free workarounds stopped working. Check each tool's notes on agentcut.dev/davinci-resolve-mcp/

## Step 2. Install the server
Follow that server's README exactly. It will give you a command to run the server.

## Step 3. Register it with Claude Code
Either run the command from the README, which usually looks like:

    claude mcp add resolve -- <the command from the README>

or add it to `.mcp.json` in your project folder:

    {
      "mcpServers": {
        "resolve": { "command": "<command from README>", "args": ["<args from README>"] }
      }
    }

Then start `claude` in that folder and type `/mcp` to confirm the server is connected.

## Step 4. First prompt (read only)

Resolve is open with a project I duplicated for testing.
Using only read tools, tell me:
1. the project name and the current timeline
2. the timeline fps, resolution and duration
3. how many video and audio tracks there are, and how many clips on each
4. any markers with their color, timecode and name
Do not change anything yet.

## Step 5. First small edit

On the current timeline only, add a blue marker named "AI CHECK" at the start of every clip on V1 that is shorter than 1 second. Tell me how many you added and list their timecodes. Do not move or delete any clip.

## Step 6. Save the rules
Copy the AgentCut "CLAUDE.md for editing through MCP" into this folder so every session starts with the same safety rules.
~~~~

---

## 10. Claude Code skill: /lower-third for Remotion

When to use it: You need name and title lower thirds for interviews, rendered with transparency so they drop straight onto any timeline.

Works with: Remotion Agent Skills (official) (https://agentcut.dev/tools/remotion-agent-skills-official/), Remotion MCP App (https://agentcut.dev/tools/remotion-mcp-app/), Motion Graphics Skill Pack (https://agentcut.dev/tools/motion-graphics-skills-charlie947/)

Save as: .claude/skills/lower-third/SKILL.md

Sources and credit: Remotion Agent Skills (remotion-dev/skills) (https://github.com/remotion-dev/skills): Use the official transparent video and timing guidance instead of guessing

~~~~markdown
---
name: lower-third
description: Build or update a reusable lower third component in this Remotion project and render it with transparency for use in an NLE. Use when the user asks for a lower third, name title, name strap or chyron.
argument-hint: "Name" "Title" [seconds on screen, default 5]
---

# Lower third

Input: $ARGUMENTS

1. Read `brand/DESIGN.md` for fonts, colors, easing and safe margins. If it does not exist, ask the user for a font and one accent color.
2. If `src/components/LowerThird.tsx` exists, reuse it. Otherwise create it with props: name, title, accentColor, align (left or right), durationInFrames.
3. Motion: accent bar wipes in over 10 frames, name slides 24 px and fades in over 12 frames starting at frame 4, title follows 4 frames later. Hold. Exit is the reverse, 2 frames faster than the entrance. Ease out on entrances, ease in on exits.
4. Position: inside the graphics safe area, bottom left by default, never closer than 5% to any edge.
5. Test with the longest likely name (at least 28 characters) and make sure nothing clips or wraps badly.
6. Register a composition per lower third named `LT-<name>` at the project fps and resolution.
7. Render with transparency using the guidance from the Remotion transparent videos rule (ProRes 4444 in a .mov, or WebM with alpha), to `out/LT-<name>.mov`.
8. Tell the user the file path and which NLEs read that format with alpha.
~~~~

---

## 11. Claude Motion prompt for a 30 second explainer

When to use it: You are on a Claude Team or Enterprise plan and want an animated explainer from your own script, numbers or slides, to finish in your editor.

Works with: Remotion Agent Skills (official) (https://agentcut.dev/tools/remotion-agent-skills-official/), HyperFrames (HeyGen) (https://agentcut.dev/tools/hyperframes-heygen/)

Save as: claude-motion-explainer.md

Sources and credit: Claude Help Center, Get started with Claude Motion (https://support.claude.com/en/articles/17454997-get-started-with-claude-motion): What Claude Motion is, plans, export to MP4, prompt tips (say who watches, where, how long); Anthropic, Build live dashboards and animate explainers with Claude (https://claude.com/resources/articles/dashboards-and-motion): Launch announcement, Oct 8 2026

~~~~markdown
# Claude Motion: 30 second explainer

Claude Motion (beta, Team and Enterprise plans) builds animations as code from text, charts, shapes and images and exports MP4. It does not generate footage or people. Start it from Output > Motion in the message box, or from a Motion template in the Artifacts tab.

## Prompt (attach your script, data or slides first)

Make a 30 second animated explainer from the attached file.
Audience: [who watches, for example new customers or my YouTube viewers].
Where it plays: [YouTube video intro / all hands screen / Instagram feed].
Format: [16:9 1920x1080 or 9:16 1080x1920], 30 fps.
Structure:
1. 0 to 4 s: one line hook with the main number or claim from the file.
2. 4 to 22 s: three beats, one idea each, max 8 words on screen per beat.
3. 22 to 30 s: one line takeaway and a still frame I can hold under a voiceover.
Style: off white background, near black type, one accent color [hex], one sans serif typeface, soft ease out on every entrance, nothing bounces.
Use only the facts and numbers in the attached file. If something is missing, leave a placeholder in brackets instead of inventing it.
Leave the last 2 seconds clean so I can add a logo in my editor.

## Good follow ups
- "Slow down the second beat by one second."
- "Change the number in beat 1 to [new value]."
- "Make a 9:16 version with the text larger and centered."

When it looks right, use Export > MP4 and drop it into your NLE.
~~~~