Opus 5.5 Makes Motion Graphics Now. Here's How to Get the Good Stuff

First, what's really going on

Here's the thing most people miss: Opus 5.5 can't hand you an MP4. It reads text and images and writes text. So every one of those videos is really a small program that Opus wrote, and something else turned that program into frames.

The trick is one function that answers a single question: what does the screen look like at time t? A headless browser asks that question for every frame (900 times for 15 seconds at 60 fps), takes a screenshot each time, and ffmpeg glues the screenshots into a video. Because the picture depends only on the time, you get the exact same video every run. Want to change one shot? Edit a line and render again.

Left alone, Opus tends to pick the simplest route: one HTML file, no framework, Playwright for the screenshots, ffmpeg for the video. If you'd rather work in Remotion (React) or HyperFrames (HTML and GSAP), just say so in your prompt.

The kit: about ten minutes of setup

The chat app can write an animation. But the magic happens when Opus can render it, look at the result and fix it, and for that it needs a terminal. That means Claude Code, or any agent that can run commands.

One more tip: drop a short house-rules file (CLAUDE.md) in your project folder. Claude Code reads it every time, so you only say things once. Good rules to start with: the picture depends only on time, with no timers and no unseeded random numbers; no centered title on a gradient, no fading everything in, no little labels in the corners; something new happens every couple of seconds; and before showing anything, render a sheet of stills, look at it, and fix the worst three problems.

And turn the effort up. The standout one-shots people shared ran on xhigh or max effort. Keep medium for small tweaks and re-renders.

Level 1: the one-line showreel

A lot of the viral clips started from the same tiny prompt: ask Opus for a punchy 15-second motion graphics video that shows off what it can do, "like it's your showreel for a résumé", and tell it to go all out. Stephan Livera's version on max effort is one of the posts that kicked it off.

Why does something so short work so well? "Showreel" is a genre Opus already knows: fast cuts, a new trick every shot, best stuff first. It makes Opus the subject, so there's no product to get wrong. Fifteen seconds is short enough to finish in one go and long enough for six to eight shots. And "go all out" works like an effort booster.

The catch: hundreds of people ran the same prompt, and the results started to look alike. Use the one-liner to test your setup, then move on. It tests the engine, not your idea, because it doesn't have one.

Level 2: point it at your product

This is where it gets useful if you sell something. Indie maker Tony Dinh posted that he paid about $1,000 for a launch video like this a year ago, and made a similar one with Opus 5.5 in under 30 minutes. In a reply he shared the prompt: the showreel idea plus his product link, an instruction to use the real screenshots, logo and assets, and a demand for music that the motion follows.

Two more habits help. Stay in the same chat for the same brand, because the second video comes out faster once the renderer and sound setup exist. And keep API keys in a .env file and tell Opus the variable name; never paste a real key into a prompt you might screenshot.

Here's a prompt in that spirit you can adapt. Brewline is a made-up café app, so swap in your own product.

Make a punchy 20-second vertical (1080 x 1920) launch video for Brewline, a café ordering app (brewline.example). Showreel energy.

1. Visit the site first. Grab the real screenshots, logo, colors and fonts, save them to ./assets and list what you found. Never invent a screen.
2. Story, one beat every 2 to 4 seconds: a hook in big type, the app appears, three features each shown with a cursor doing a real tap, one number that proves it works, then the logo and "Try it free".
3. Original music around 120 BPM, made in code, with small clicks and whooshes on the beat.
4. Before the full render, show me one still per beat so I can check the flow.

• The prompt he shared in the replies

Level 3: give it a look to copy

Without a reference, Opus falls back to its comfort zone. Yep: centered text, gradient, fade. The fix is to show it a style instead of describing one.

One frame works: screenshot a moment from a video you love, attach it, and say what to take (colors, type, texture) and what to leave (the subject). A whole video works too: ask Opus to pull frames with ffmpeg and describe the pacing shot by shot before it writes any code. Best of all is your own library, since nobody else can copy it. Ask Opus to write a short style_guide.md and shotlist.md first, and approve both before any animation code gets written. Borrow the grammar of a reference, never its logos or characters.

This is the easy place to use Ciyo. Generate a few key frames or a clean logo there, then hand them to Opus as the reference, so the look is yours before the motion starts.

• Animate your logo with Claude Opus 5.5
• Can Claude Opus 5.5 generate images?

Level 4: list the states, not the vibe

The most-saved motion prompts that week weren't one-liners. They were structured specs for slick UI animations where one shape never cuts. It just keeps morphing: a button becomes a loader, then a check mark, then a card, then a chart, and finally loops back to the start, with a cursor driving every change.

What made them work wasn't magic words. It was a clear list: what to ask you for (product, screens, colors, a music track), the direction (calm background, one accent color, no bouncy easing, no glows), the states laid out on a beat grid so something happens on every beat, the build rules (one file, time-based, the last frame matches the first) and the known gotchas. If you can list the states, Opus can animate them.

We tried the recipe: a six-second teaser

To check that all of this holds up, we built the core recipe on September 28, 2026 in Claude Code with Opus 5.5: one HTML file with a seek(t) function, a Playwright script that steps through time, and ffmpeg for the encode. The film is a six-second vertical teaser for our fictional Brewline app. One dark shape never cuts: it goes from a dot to a coffee cup with steam, to an order card with a check, and back to a small pill with the call to action.

It rendered 180 frames (six seconds at 30 fps, 1080 x 1920) in about nine seconds on a MacBook. We rendered it twice and the two MP4 files had the same hash, which is the whole point of drawing from time alone.

Then we made the contact sheet below, two stills per second, and looked at it the way a picky motion director would. It had three real problems: the steam ran into the "Order ahead" headline, the first second and a half was just a still dot, and the "Try it" button was too small to read on a phone.

The real secret: make Opus watch its own frames

Opus 5.5 can read images, which means it can look at what it just made. In our experience that one habit does more for quality than any clever wording in the prompt.

Our three fixes took one edit and one re-render: the headlines moved up and the steam got shorter, the dot now stretches into a pill during the first beat, and the final pill got wider with bigger type. The second contact sheet shows all three fixed. Same code, same nine-second render.

Iteration isn't cheating, it's the method. Watercolor animator Mable Joseph was refreshingly upfront that her hand-painted Opus 5.5 short wasn't a one-shot: in a follow-up she said it needed a well-planned character file, animation notes, a character design and a story prompt.

A contact sheet is one line of ffmpeg: ffmpeg -i out/final.mp4 -vf "fps=2,scale=270:-1,tile=6x5" -frames:v 1 out/contact.png (6 x 5 tiles covers 15 seconds at two stills per second). Then hand Opus the critique prompt below.

Open out/contact.png and look at it carefully. Be a harsh motion director, not a proud author.
Score 1 to 10: hook in the first 2 seconds, readable on a phone, motion quality, variety (something new every 2 to 4 seconds), on-brand, sound sync.
List the 3 worst problems with timestamps. Look especially for text that overlaps, shots where nothing moves, and text too small to read.
Fix them, re-render only those seconds, and show me the new contact sheet and scores. Repeat until every score is 8 or higher.

• Her follow-up on what it really took

Make motion feel expensive: springs and sound

Cheap motion slides from A to B on a fixed curve. Expensive motion feels like it has weight: it speeds up, overshoots a hair and settles. That's a spring, and you can write it as a plain formula of time, so the picture still depends on time alone and you can jump straight to frame 812 without playing frames 0 to 811.

When something moves to several spots in a row, like a cursor or our morphing shape, don't restart the spring each time. Add one spring per move, each starting at its own moment, and the motion stays smooth all the way through. You can ask for it in plain words: "Switch all the motion to time-based springs, with a little bounce on buttons and cards and none on headlines."

Then there's sound, which is where it starts to feel like a real film. You have two options. Bring a track and have Opus measure its beats with a short Python script, then line every cut and click up with a real beat. Or let Opus make the music and sound effects in code, on the same timeline as the picture. Our teaser is silent; a real launch clip shouldn't be.

// Where is the spring at time t? Starts at 0, settles at 1.
function spring(t, stiffness = 170, damping = 26) {
  if (t <= 0) return 0;
  const w = Math.sqrt(stiffness);
  const z = damping / (2 * w);
  if (z >= 1) return 1 - Math.exp(-w * t) * (1 + w * t);
  const wd = w * Math.sqrt(1 - z * z);
  return 1 - Math.exp(-z * w * t) * (Math.cos(wd * t) + ((z * w) / wd) * Math.sin(wd * t));
}

// A value that moves to several targets: one spring per move, added together.
function track(t, keys, stiffness, damping) {
  let v = keys[0][1];
  for (let i = 1; i < keys.length; i++)
    v += (keys[i][1] - keys[i - 1][1]) * spring(t - keys[i][0], stiffness, damping);
  return v;
}

Going big: the overnight film

The biggest hit of the week came from donald (@donaldjewkes), who said he talked to his computer for five minutes, Claude worked for 12 hours, and he woke up to a finished music video.

Long, hands-off runs like that work because the brief reads less like a description of a video and more like a job handed to a small studio. We'd group yours into four questions. What is it for: the story in a sentence and how people should feel at the end. What can it use: your references, the tools and keys it may call, and a budget. How should it work: stages with a stop to check stills and a rough cut before the full render, plus the critique loop at every stage. And what do you want back: the video, a poster frame, a contact sheet and tidy source code.

One twist worth stealing: some of these films used a video model for rough base shots with tricky motion, then had Opus redraw everything on top in code. The viewer only sees the clean code-drawn layer, so the whole film keeps one consistent look.

Last step: make the one prompt real

Once your setup works, package it as a Claude Code skill: a short instruction file that lists what to ask for (product, length, formats, colors, a reference, music), the pipeline step by step, and your hard rules, such as real product screens only and no timers or random numbers in render mode.

After that, your next video really is one line, something like "/motion-reel for brewline.example, 20 seconds, vertical, use ./refs/frame.png as the look". That's the one prompt everyone was talking about. It just took a little setup to earn it.