Claude Opus 5.5 Video Prompts That Look Actually Good

Before you paste a prompt

Use Claude Code with Opus 5.5 at high or xhigh effort. Prepare Node.js, a Chromium-based browser, and FFmpeg. Start in a new directory, and give Claude only assets you own or are licensed to use. Ask for a low-resolution preview before a full render; a 30-second 1080p render is much cheaper to debug than to redo.

The prompt templates assume that Claude can create files and run local commands. They do not hide API keys in .env, silently download stock footage, or call a video-generation API while claiming the result is pure code animation.

How I filtered for “actually looks good”

I did not keep prompts merely because they produce an MP4. A case had to pass four tests:

• A visible visual mechanism: morphing one object, moving through nested scales, a deliberate camera path, or a readable animation state machine;
• A concrete art direction: palette, lighting, materials, typography, composition, or motion language—not just “make it slick”;
• A timing and quality bar: beats, shot durations, loop closure, frame checks, or continuity constraints that explain why the result should feel finished;
• A disclosed dependency boundary: whether it needs owned footage, licensed music, Three.js, external generation tools, or only local code.

That is why the list below mixes one fast self-contained motion piece with heavier cases. The goal is not five prompts that all render something; it is five prompts where you can point to the mechanism that creates the visual appeal.

1. A beat-synced UI morph loop

Why this made the cut: this is real motion design, not a collection of cards. One object continuously transforms from a button into a loader, player, chart, command palette, and toast while the cursor drives the interaction. The beat grid, spring math, motion blur, and loop closure are what make it feel designed rather than randomly animated.

Copy this into an empty Claude Code project. It will ask you for the inputs before writing code:

Create a polished 14-second square UI motion-design loop for a fictional product called Northstar. This is a premium Dribbble-level motion piece, not a dashboard mockup or a slideshow.

Before coding, ask me for: 8–12 UI states, one accent color, a royalty-free song around 120 BPM, and the product promise in one sentence. Then show me the state list mapped to a beat grid before implementing anything.

The visual rule is strict: one continuous shape must morph through every state without a hard cut. It should become a button, loader, success check, music player, progress scrubber, volume slider, toggle, liquid tab indicator, self-drawing chart with tooltip, command palette, filter result, toast, and finally the original button. Use a warm light-gray canvas, black-and-white UI, one accent color, one clean sans-serif font, tight spacing, precise cursor clicks and drags, spring-based motion, restrained overshoot, and camera zooms that make each state fill the frame.

Build one standalone local HTML file at 1440x1440. Every visual value must be a pure function of seek(t): no CSS transitions, timers, wall-clock state, or hidden mutation. Use closed-form springs, direct-manipulation cursor paths, deterministic text swaps, and a fixed 120 BPM beat grid with one meaningful event on every beat. The final frame must match the first frame exactly, including cursor position and velocity, so the loop is seamless.

Render with Playwright at 60 fps using 4 temporal subframes per frame, then use FFmpeg to assemble the final MP4 with controlled motion blur. Render one frame per beat before the full export. Check that morphing content never overlaps, icon strokes stay consistent, drags feel physical, labels remain readable, and no beat is empty. Do not use particle bursts, neon glows, gradients on UI chrome, bouncy easing, generic template cards, or dead time.

Deliver the source HTML, the beat/timing table, the exact preview and final render commands, and out/northstar-ui-loop.mp4.

Expected result: a seamless loop where viewers can follow one shape changing identity on every beat. If it looks like separate screens, the prompt has failed: remove the cuts and make the geometry, cursor, and content all inherit from the same morphing object.

2. A premium SaaS product film with real footage

Why this made the cut: the premium look comes from edit decisions and real material, not from adding random effects. The structure gives the video a hook, a beat-synced product reveal, a drop, a hero moment, and a clean finish.

Prepare a folder of 10–20 vertical clips you own before pasting this:

Create a premium 20-second launch film for [PRODUCT], using the real video clips in ./assets/clips and no placeholder footage. The product promise is [PROMISE]. The visual identity uses one accent color: [ACCENT COLOR]. The final film must feel like a high-end Apple-style product spot: controlled, sparse, tactile, and confident, not like a template or a slideshow.

First inspect the assets and ask me to confirm the product name, promise, 3–5 UI moments, the song, and the license for every clip. Then produce a 10-bar storyboard at 120 BPM. Every bar needs one editorial decision and every major cut must land on a measured downbeat.

Use this arc:
1. bars 1–2: the promise appears word by word with masked typography;
2. bars 3–4: one word transforms into the product UI while a cursor types and clicks;
3. bar 5: the music drops as a circle opens from the button into a dark scene;
4. bars 6–8: a moving wall of real clips is scanned down to three winners, then one hero clip is selected with a motion-blurred whip;
5. bar 9: the hero clip appears inside a phone beside a result panel that flips into place;
6. bar 10: three verified stats, a three-word ticker, the logo, and a fade to black.

Implement the composition in one local HTML/Remotion project at 1920x1080. Extract owned clips to deterministic 30 fps image sequences with FFmpeg, decode frames before capture, and compute all layout from seek(t). Use empty space, masked reveals, match cuts, reflections, restrained blur, and one camera language. Never use shockwave rings, particle bursts, RGB split, lens flares, neon glows, flashing backgrounds, bouncy easing, or fake UI cards. On-screen claims must come only from [FACTS FILE].

Analyze the song for tempo, beat grid, energy per bar, and drop location. Place sound effects by their measured peak, keep them below the music, and normalize the mix to -14 LUFS. Render 20 representative frames before the full export and fix clutter, overlap, unreadable type, bad crop choices, and off-beat cuts.

Deliver the storyboard, asset/license manifest, source project, preview command, final render command, and out/product-launch.mp4.

Expected result: a short film that feels edited by a motion designer: real clips, decisive cuts, one controlled accent color, and a memorable drop. Without real clips and a licensed song, use another case instead of pretending a placeholder montage is premium.

3. An infinite zoom from a room to a quark

Why this made the cut: the visual hook is immediately understandable and naturally cinematic: every camera move reveals a smaller world inside the previous one. The prompt forces scale continuity, so it does not become a sequence of unrelated illustrations.

Create an 18-second cinematic infinite-zoom animation that begins in a quiet bedroom and travels continuously into a laptop, an Apple M4 chip, a transistor gate, an atom, and finally a glowing quark field. The viewer should feel that the camera is physically passing through nested worlds, not cutting between six slides.

Before coding, make a timing board with six scale transitions:
1. 0–3s: a moonlit bedroom with a laptop on the desk;
2. 3–6s: push through the laptop screen into a luminous circuit board;
3. 6–9s: descend into the chip package and reveal transistor gates;
4. 9–12s: follow an electron-like pulse into an atom;
5. 12–15s: pass through the nucleus into a stylized particle field;
6. 15–18s: resolve into one bright quark, then pull back just enough to echo the opening composition.

Build the piece locally with Canvas, SVG, or Three.js. Use a fixed 1920x1080 canvas at 30 fps, a deep blue-black palette with controlled cyan and amber light, volumetric-looking dust, layered parallax, depth-of-field simulation, scale-linked motion blur, and match cuts based on circles, rings, and glowing points. Every transition must share a shape, color, or motion vector with the next scale. Use procedural geometry and generated textures; do not download stock footage or invent scientific labels beyond the supplied facts.

The camera path must be deterministic and driven by normalized time. Keep the subject centered only when the story needs it: use lateral drift, rack-focus-style blur, and foreground occlusion to create depth. Avoid six static tableaux, generic starfields, random camera shake, unreadable labels, and sudden teleportation. Use a sparse sound design plan with low rumbles and one rising tonal layer; if no licensed audio is supplied, leave the track silent and print exact sync markers.

Render a 4-second preview covering the laptop-to-chip transition, inspect the opening, one nested transition, and the quark reveal, then render the final MP4 with Chromium and FFmpeg. Verify that scale changes are smooth, nested geometry does not pop, the focal subject remains legible, and the final frame has a deliberate visual relationship to the first.

Deliver the storyboard, scale/timing table, source files, exact render commands, and out/room-to-quark.mp4.

Expected result: a single visual journey with a clear “how did it get inside there?” moment. The key test is the transition frame: if the laptop, chip, atom, and quark look like unrelated scenes, rebuild the shared ring/point/scale motif before adding detail.

4. A polished 16-bit wizard spell

Why this made the cut: a strict low-resolution palette can look more intentional than a weak attempt at realism. The spell has a readable silhouette, anticipation, impact, particles, and a seamless loop—four things that make a tiny animation feel finished.

Create a polished 12-second 16-bit pixel-art spell animation in one self-contained HTML file using vanilla JavaScript and Canvas 2D. No external assets, libraries, network requests, gradients, anti-aliasing, or vector shapes scaled down after rendering.

Render to an offscreen logical canvas at 128x96, then scale it by the largest integer factor that fits the window. Center it, disable image smoothing, snap every draw to integer coordinates, and use a fixed palette of about 24 hand-picked colors: deep blue and purple night tones, warm robe colors, and three bright magic colors. The result must look like a deliberate 16-bit sprite animation, not blurry pixelated vector art.

Build a consistent wizard from pixel runs: bent pointed hat, long beard, two-tone robe with a dark outline, staff, and gem. Parameterize staff angle, arm raise, head tilt, robe sway, and eye position. Use a fixed 60 Hz timestep but quantize the final pose to the pixel grid so the animation reads like 8–12 fps pixel animation.

Use this looping state machine:
1. IDLE: two-frame bob, beard sway, stars twinkle;
2. CHARGE: staff rises, gem flickers, sparks spiral inward, rim light grows;
3. CAST: a one-frame white-hot burst, projectile crosses the scene, and the screen shifts by 1–2 pixels;
4. RECOVER: the robe settles and the pose returns exactly to the opening state.

Preallocate a particle pool. During CHARGE, sparks orbit the gem; during CAST, they explode outward and step from white to magic color to dark before despawning. Keep the silhouette readable during the brightest frame. Add only a dark sky, a few one-pixel stars, a moon, a stone floor line, and a subtle gem rim light.

Capture a contact sheet with the opening, charge, impact, and recovered frames. Test a seamless loop, stable 60 fps preview, crisp scaling at multiple window sizes, and identical first/last frames before exporting out/pixel-wizard.mp4 with Chromium and FFmpeg.

Deliver the HTML source, palette, state/timing table, preview command, and final render command.

Expected result: a tiny character animation with a strong silhouette and a satisfying spell impact. If it looks like rectangles with a glow, reduce detail, redesign the silhouette, and enforce the palette before adding more particles.

5. A cinematic 3D prehistoric island fly-through

Why this made the cut: this is the ambitious option for users who want a real “wow” scene: a miniature world, an underwater cross-section, creatures with distinct motion, and a camera path designed for a trailer. It is intentionally marked as a heavier Three.js project rather than pretending it is a beginner one-liner.

Create a 20-second cinematic fly-through of a stylized 3D prehistoric island using Three.js and WebGL. Deliver a local project that opens in Chrome and can be captured to out/prehistoric-island.mp4. The result should feel like a premium miniature world, not a collection of primitive shapes.

Plan six camera beats before coding:
1. 0–3s: sunrise over the rounded island and ocean;
2. 3–6s: a low camera pass over beaches, cliffs, giant ferns, and a waterfall;
3. 6–10s: reveal a sauropod herd crossing the valley while a pterosaur circles above;
4. 10–13s: dive below the transparent water cross-section to show the seabed, fish, bubbles, and a marine reptile;
5. 13–17s: rise past the research station and volcano as ash and warm lights activate;
6. 17–20s: pull back to the opening island silhouette with one final atmospheric beat.

Use a cohesive stylized art direction: lush but controlled colors, warm sunrise light, cool underwater caustics, fog layers, animated waves, shoreline foam, moving foliage, drifting clouds, and restrained bloom. Include a sauropod, Triceratops, Stegosaurus, theropod, pterosaurs, and one marine reptile with recognizable silhouettes. Use hierarchical joints, terrain sampling, and simple inverse-kinematics corrections so feet stay on the ground; creatures must not float, slide, intersect props, or walk through each other.

Make the camera path and creature behavior deterministic. Use instancing for repeated vegetation, efficient geometry, baked or procedural materials, and a fixed cinematic path rather than a heavy interactive simulation. The underwater volume must have a readable rounded cross-section with no gaps or transparency sorting artifacts. Keep the scene dominant; use only a small cinematic title card at the beginning or end.

Render low-poly preview passes for the sunrise, dinosaur valley, underwater dive, and final pullback. Inspect screenshots and the browser console, then capture the final camera path with Playwright or Chromium and assemble the MP4 with FFmpeg. Fix floating feet, broken shadows, texture seams, camera clipping, loading errors, and dead shots before delivery.

Deliver the source project, camera/timing table, asset manifest, preview commands, capture command, and out/prehistoric-island.mp4. Do not claim photorealism; prioritize a coherent art direction and readable motion.

Expected result: a short trailer with a clear reveal sequence and a memorable underwater dive. If the scene becomes an unfinished game demo, remove interaction panels and spend the budget on camera composition, lighting, creature silhouettes, and the six planned beats.

Prompts I did not include

Some public examples are valuable as inspiration but poor beginner instructions. I left out one-line requests such as “make a modern slick video,” long historical films that need research and reference art, prompts whose source text is truncated, and entries that rely on private skills, paid image services, or another video model. A prompt can produce a spectacular post and still be a bad copy-and-paste recommendation.

From prompt to API key

Claude Code is the tool that writes and renders the project; APIMaster is the API route you can use when your workflow calls Claude programmatically or when you want a single key for multiple models. Create an APIMaster account, add a small pay-as-you-go balance starting from $1, create a key in the console, and use claude-opus-5-5 at https://apimaster.ai/v1. Check the live card and route status before a long render.

FAQ

Does Claude Opus 5.5 output an MP4 by itself?

No. Claude writes the animation code and local render commands. Chromium, a browser recorder, or another renderer produces frames, and FFmpeg commonly assembles them into an MP4.

Can I paste these prompts into the Claude web app?

You can use the planning portions there, but the complete workflow assumes a local project where Claude Code can create files, run a browser, inspect output, and call FFmpeg.

Which prompt should I try first?

Start with the UI morph loop if you want a short, self-contained motion-design test. Use the product film when you have real footage, the infinite zoom or pixel wizard for a distinctive visual style, and the prehistoric island only when you are ready for a heavier Three.js build.

Are these prompts guaranteed to produce the same videos as the public examples?

No. Results depend on the model version, effort setting, local tools, assets, follow-up edits, and rendering pipeline. The templates make the work reproducible; they do not remove iteration.

Sources and selection method

This article was checked on September 29, 2026. The selection was based on whether a prompt had a clear output, feasible local dependencies, a bounded duration, and a way to inspect or repair the result.

• joeseesun/opus-video-prompts for the public prompt files behind the UI morph loop, high-end product video, pixel wizard, infinite zoom, and Three.js island examples.
• UI morph loop, high-end product video, pixel wizard, and prehistoric island were selected because their prompts specify a visual system, timing, implementation constraints, and a quality bar rather than only asking for a “slick” result.
• yihui-dev/awesome-opus5-5-videos for the larger public prompt archive and its warning that entries vary in completeness.
• athemeroy/awesome-opus-5-5-videos for the prompt playbook and disclosure guidance around code, assets, and external video models.
• ClaudeAnimationBase for the reproducible local rendering pattern and the importance of timing checks.
• APIMaster live route data and model card for current pricing and availability.

Start with a small render

Open APIMaster, create a key in the console, and test claude-opus-5-5 through https://apimaster.ai/v1 before sending a long coding or rendering job.