APIMODELSAPIMODELS

Claude Opus 5.5 Video Motion Design & UI Animation Prompts

Sixty real videos made with Claude Opus 5.5, each credited to its creator and linked to the original post, with the toolchain they used and, where they published it, the prompt word for word. Opus 5.5 does not draw pixels: every clip here was rendered from code it wrote, or cut together from video models it directed.

← All 60 Claude Opus 5.5 Video prompts

Last updated: · Claude Opus 5.5 API — pricing & playground · API docs

TL;DR

Claude Opus 5.5 (model id claude-opus-5-5, released by Anthropic on 22 September 2026) is a language model. Anthropic's documentation lists text and image input and text output only, states that Claude cannot generate or edit images, and offers no video input: an animated GIF is read as its first frame. The videos credited to it are made in one of three ways. It writes animation code (a self-contained HTML page driven by a seek(t) function, Remotion or HyperFrames compositions, Manim scenes, Three.js and WebGL shaders, Blender Python) that a headless browser or renderer turns into frames and FFmpeg encodes into an MP4. It directs video, image and music models through APIs, writing the shot list and every prompt, then edits the results. Or it edits existing footage through FFmpeg, After Effects or DaVinci Resolve. A video billed as "one prompt" is often a brief of several thousand characters, run inside an agent with skills, API keys and hours of autonomous work, so each case below records what the creator actually supplied and what they reported spending. The 60 cases were posted between 22 September and 3 October 2026 and each was checked against the original post. On apimodels.app, Opus 5.5 is $2.40 per 1M input tokens and $12 per 1M output tokens, against Anthropic's $4 / $20 list.

Source: Anthropic · Claude Opus 5.5 (the model vendor’s official site)

Hover to preview · click for sound

The 15-second motion-designer showreel

make a dynamic 15-second motion graphics video that shows what an incredible motion designer you are, like it's your showreel for a résumé. go all out.

Model:
Post: "Opus 5.5 on Max effort".
Toolchain:
One sentence at max effort. Indexers describe the result as Canvas drawing cut to a 128 BPM grid; the usual route is one HTML file rendered frame by frame by a headless browser, then FFmpeg.
Clip:
15 s, 1920x1080, about 2.25M views (6 Oct 2026).
Same prompt, other runs:
@ajith_io (x.com/ajith_io/status/2103449416325890146), @kenn at xhigh (x.com/kenn/status/2103337314021937232), @himanshutwtxs with sound (x.com/himanshutwtxs/status/2103495232637882858), @thismacapital as a French product ad, "15 minutes, 2-3 revisions, all HTML/JS/CSS" (x.com/thismacapital/status/2103773635714375808).
Pitfalls:
Thousands of people ran this exact sentence, so the results rhyme with each other. A one-liner tests the setup, not an idea; use it to check your environment works.
by @stephanliveraSource
Hover to preview · click for sound

Showreel brief that lists the techniques

Create a bold, dynamic 15-second motion graphics showreel that feels like the ultimate portfolio piece of an exceptionally talented motion designer. Showcase a wide range of advanced techniques: kinetic typography, smooth transitions, 2D and 3D animation, abstract geometry, fluid simulations, particles, distortion, creative masking, compositing, lighting, depth, and seamless camera movement. Keep the pacing fast, confident, and visually surprising, with every shot transitioning naturally into the next. Make it feel meticulously art-directed rather than like a random collection of effects. Push the creativity, polish, timing, and visual impact as far as possible. This should feel like the opening reel that gets a motion designer hired.

Model:
Post (Czech): all of it is code made in Opus 5.5 at max effort.
Toolchain:
Three.js, WebGL shaders and Canvas; the creator says no image, video or music generator was used.
Clip:
Two 15 s clips, 1920x1080.
by @lukasersilSource
Hover to preview · click for sound

One shape morphs through a dozen UI states on the beat

<inputs> Ask me for: 8 to 12 UI states I want the shape to become (e.g. button, loader, player, slider, toggle, tabs, chart, command palette, toast), pure black and white or one accent color, and a royalty-free song around 120 BPM (e.g. Mixkit, free for commercial use). </inputs> <direction> Dribbble-level UI motion. One shape, never cut: every state is the same element morphing its size, radius and color while its content swaps with a short blur. A cursor drives every change with real clicks and drags. Light warm-gray canvas, black and white components, one clean UI font (Geist). Springs everywhere, a tiny overshoot at most. The camera zooms so each state fills the frame. The last frame is the first frame, so it loops. Banned: bouncy easing, particle bursts, glows, gradients on UI chrome, mismatched icon strokes, dead time, anything that looks like a template. </direction> <structure> 120 BPM, 7 bars, something happens on every beat. Button → loader → check → dynamic island → music player with a play/pause morph → scrub the progress bar → it becomes a volume slider that stretches when dragged past max → a toggle flips on the beat → the knob becomes a liquid tab indicator → the tabs open into a chart that draws itself, with a tooltip on hover → it collapses into ⌘K → type to filter → enter → toast → back to the button. </structure> <build> 1. One HTML file, square 1440x1440. Every style is computed from time inside seek(t): no CSS transitions, no timers, no state carried between frames. 2. Springs are closed-form step responses. A value that changes target many times is the sum of one spring per change, so it stays a pure function of time. 3. The tab indicator's two edges ride different springs, so the leading edge stretches ahead of the trailing one. Same trick for the toggle knob. 4. Drags are direct manipulation: while the cursor is held, the value is computed from its position. On release it springs back from wherever it was. 5. Analyze the song with numpy for the beat grid and start on a downbeat. Place every UI sound by its measured peak. 6. Render with Playwright: 4 subframes per frame, blended with ffmpeg tmix for motion blur at 60fps. 7. Render one frame per beat before the full render. Fix anything off the grid, cramped or hard to read. </build> <gotchas> Never put will-change on anything the camera scales or the text renders blurry. Text that swaps inside a morphing container needs its own enter and exit timing or it overlaps. Make the last frame identical to the first, cursor position and speed included, or the loop stutters. </gotchas> <start> Ask me for the inputs, then show me the state list on the beat grid before you write any code. </start>

Model:
Post: "opus 5.5 is f*cking cracked at motion design this entire video is code, 0 after effects". The author open-sourced the prompt and wrote "steal it".
Toolchain:
Single 1440x1440 HTML; every style computed inside seek(t); closed-form springs; numpy beat analysis of the song; Playwright renders 4 subframes per frame blended with FFmpeg tmix for 60fps motion blur; one frame per beat is checked before the full render.
Clip:
14 s, 1440x1440, about 1.04M views and 12K likes.
Pitfalls:
Needs Node, Playwright, FFmpeg and Python with numpy (a Claude Code-style environment). The gotchas block is the author's own scar tissue: will-change blurs scaled text; a last frame that differs from the first makes the loop stutter. Use music licensed for commercial use.
by @twoclippingSource
Hover to preview · click for sound

One-take keynote-style launch film with liquid glass and an iris transition

<inputs> Ask me for: a one-word brand name for the wordmark (a verb works best), 9 to 12 high-res photos, a royalty-free song around 120 BPM with a drop and a quiet breakdown (Mixkit, free for commercial use), and a free stock clip of a plain wall with moving plant shadows (Pexels). </inputs> <direction> An Apple-keynote launch film, 2D only, one continuous take. Every scene is made out of the previous one: nothing fades, blurs or cuts. Objects change shape instead: text rises out of a mask line, icons pop from zero on a spring, bars draw across, pages push, and a black shape floods the whole frame and contracts into the next scene. Warm off-white canvas, black UI, iOS 26 liquid glass over the photos. Archivo (wdth 125, weight 800) for the wordmark, Geist for UI. A cursor drives every change with real clicks, drags and long-presses. The camera zooms screen-studio style so each moment fills the square, and the cursor scales with it. Banned: crossfades, blur-ins, brightness "developing", 3D flips, particles, glows, holds longer than 1s, anything that looks like a template. </direction> <structure> 120 BPM, 54 beats, something happens on every beat. Open: the wordmark squeezes into its own period like an accordion, the dot grows into a black pill, a label rises inside it. Click: six iris blades close over the label and snap open onto a photo. The circle becomes a square, shrinks, the grid unfolds from behind it like a paper map (center, plus, corners), reflows into a bento, and a click zooms into one tile, landing exactly on the drop. Glass: a glass word pops in letter by letter, melts into a droplet that stretches into a glass toolbar. The adjust icon turns it into a slider. Dragging relights the photo from day to golden hour (two aligned shots), and the knob turns into a glass lens while held. It lifts into a glass orb, the next photo opens inside it as a circle, and the orb expands into a lock screen: glass clock digits, date, and a home bar that stretches into a glass music player. Stage: the lock screen pulls back into a phone (the bezel grows out of the screen edge). The Dynamic Island stretches like liquid, pinches off, flies over and grows into a Mac window that rolls up like a blind. Long-press the wallpaper, drag it onto a Safari tab, the page pushes in, drop it and it becomes the hero of a landing page. Scroll: the hero morphs into a framed print on a product card, with the mat and molding growing out of the photo's edge. Pick a frame color (it paints across) and a size, then the nav button flies down into "Order print". Order: one black shape keeps morphing: Ordered ✓ → Printing % → On its way (a van on a route) → Delivered ✓. Wall: the delivered circle floods the frame edge to edge, holds black for a beat, and contracts into the framed print hanging on the real wall footage. The same iris opens onto the print, closes again, the frame floods the screen and contracts into the pill → the dot → the letters spring back out, landing on the beat return. Last frame = first frame. </structure> <build> 1. One HTML file, square 1440x1440. Every style is computed from time inside an async seek(t): no CSS transitions, no timers, no state between frames. 2. Springs are closed-form step responses. A value with many targets is the sum of one spring per change, so it stays a pure function of time. 3. Liquid glass: each glass element holds its own clone of the scene behind it, filtered with an SVG feImage displacement map (a rounded-rect distance field) through three feDisplacementMaps at slightly different scales for chromatic edges, plus a rim light. Glass letters: a canvas distance field per glyph gives the map, mask and highlights. 4. Goo: blur + alpha threshold, then composite the source atop it so the glass stays sharp inside. 5. Iris: 6 blades around a hexagonal aperture. Each blade is its two vertices, both edge extensions and the SHORT arc between them. 6. Wordmark squeeze: every letter moves toward the dot by the same factor and its drawn width follows (narrow the wdth axis, scale the rest), so the letters stay touching. 7. Footage: re-encode all-intra (ffmpeg -g 1), load it as a blob URL, await 'seeked' before drawing each frame. 8. Sound: a downloaded SFX for every event (Mixkit), never synthesized, each placed by its measured peak. The song starts on a downbeat: the zoom lands on the drop, the wall sits in the breakdown, the wordmark returns with the beat. Loudnorm to -14 LUFS. 9. Render with Playwright: 4 subframes per frame blended with ffmpeg tmix, 60fps. Check one frame per beat, then scan for single-frame pops (frame-difference spikes 3x their neighbours). </build> <gotchas> backdrop-filter: url() misreads displacement maps in Chromium, so clone the scene instead. A flood must overscale past the corners and take about 0.3s, or half the screen changes in one frame. A child with visibility: visible shows through a hidden parent, so use inherit. Text that swaps inside a morphing shape needs its own mask. python http.server can't range-seek video, so use the blob URL. </gotchas> <start> Ask me for the inputs, then show me the beat map and 4 stills (open, glass, stage, wall) before you write the full film. </start>

Model:
Post: "OPUS 5.5 IS THE ONLY MOTION DESIGNER YOU NEED… pure code". Full prompt (5,200+ characters) published in the post.
Toolchain:
Single 1440x1440 HTML with async seek(t); closed-form springs; SVG feDisplacementMap liquid glass; real footage re-encoded all-intra and seeked per frame; licensed SFX placed by measured peak; loudness normalised to -14 LUFS; Playwright 4 subframes + tmix at 60fps; frame-difference scan for single-frame pops.
Clip:
About 29 s, 1440x1440, about 130K views.
Pitfalls:
You supply the photos, the track and a stock clip. Chromium's backdrop-filter: url() misreads displacement maps, and python http.server cannot range-seek video; both are in the gotchas.
by @twoclippingSource
Hover to preview · click for sound

Minimal product launch: scanning wall of vertical clips, cut on the beat

<inputs> Ask me for: the product name and a one-line promise, 3 to 5 UI moments to show, one accent color, 10 to 20 real vertical clips I own, and a royalty-free song with a clear drop (e.g. Mixkit, free for commercial use). </inputs> <direction> High-end minimal. One idea per shot, lots of empty space, one accent color, one clean sans (Geist or Inter) with tight tracking. Masked type reveals, match cuts, one smooth camera language. Real footage only, never placeholder cards. No full stops in on-screen text. Banned: shockwave rings, particle bursts, RGB split, camera shake, lens flares, neon glows, grid floors, flashing backgrounds, bouncy easing. </direction> <structure> 10 bars at 120 BPM, 2 seconds each. Bar 1: the hook lands word by word on the beats. Bar 2: one hook word morphs into the product UI. A cursor types and clicks. The drop: a circle opens out of the button into a dark scene. Then one move per bar: a wall of real clips with a scan line and 3 winners, the key output as big type, a 3D carousel of real videos with floor reflections and a motion-blurred whip onto one hero clip, the hero in a phone next to a panel that flips into results, big stats on push cuts, a 3-word ticker, a logo reveal, a fade to black. </structure> <build> 1. One HTML file at 1920x1080. Every style is computed from time inside window.seek(t): no CSS animations, no timers, no state between frames. 2. Real video: extract clips to 30fps JPEG sequences with ffmpeg and swap img sources per frame. seek awaits the image decodes. 3. Analyze the song with numpy: tempo, beat grid, energy per bar, the drop. Calibrate the grid to the real kick hits. Every cut sits on a downbeat, every UI hit on a beat. 4. Render with Playwright: 3 subframes per frame at t minus, at, and plus 1/240s, then blend with ffmpeg tmix for real motion blur at 60fps. 5. Place each sound effect so its measured peak, not its file start, lands on the event. Keep the effects quiet under the music. Loudnorm to -14 LUFS. 6. Probe 20 or more frames before the full render. Fix anything cluttered, overlapping or hard to read. </build> <gotchas> Never set opacity or filter on a preserve-3d element, because it flattens and both faces show. Fade its wrapper instead. Measure element positions at runtime for match cuts. Only use music and sound effects whose license allows commercial use. </gotchas> <start> Ask me for the inputs, then show me a storyboard with every timing on the beat grid before you write any code. </start>

Model:
Post: "this entire video is code opus picked the music, downloaded the sfx, built every frame and synced it all to the beat by itself".
Toolchain:
Single 1920x1080 HTML with window.seek(t); real clips extracted to 30fps JPEG sequences and swapped per frame; numpy tempo, beat grid, energy and drop analysis; 3 subframes of motion blur; 20+ frames probed before the full render.
Clip:
20 s, 1920x1080.
About the prompt:
X auto-inserted a stray "http://" into build step 1 of the posted text; it is removed here and nothing else is changed.
Pitfalls:
Opacity or filter on a preserve-3d element flattens it and shows both faces; fade the wrapper instead.
by @twoclippingSource
Hover to preview · click for sound

Mobile-game reward and gacha reveal (Three.js toon shading + GSAP)

帮我做一个原创的手游「高光时刻」动效:[主体,例如:开宝箱 / 段位晋升 / 成就解锁 / Boss 掉落 / 角色升级]。 做成一个可以直接打开的单文件网页(HTML + CSS + JS),点一下就能完整播放,效果对标商业手游的结算 / 奖励演出。 【世界观与风格】 - 原创美术,不要模仿任何现有游戏的 IP、角色或 Logo。 - 卡通手游风:高饱和配色,统一的深色描边(例如 #1A1033),圆润厚重的造型。 - 配色随等级升级:[等级阶梯,例如:普通绿 → 稀有蓝 → 史诗紫 → 传说金]。每升一级都要切换主色、光效颜色和背景色调。 - 标题用圆胖的游戏字体(如 Titan One / Lilita One),描黑边,加投影;文字逐字「砸」进画面,带回弹。 【主体物:做成真 3D】 - 用 Three.js 建模,不要用平面 SVG 贴图。要有厚度、倒角,以及符合主体的结构细节(木板缝、铆钉、包边、宝石切面、锁扣等);木板缝这类细节用真实几何体拼出来,不要贴黑线条。 - 着色用卡通分阶(MeshToonMaterial 加 3~4 阶的渐变贴图),配三种灯光:主光、天光、等级色的轮廓光。 - 描边用后期边缘检测:渲染法线图 + 深度图,再用着色器画线。外轮廓粗、零件交界细,粗细全程一致;另外做 1.5 倍超采样和多重采样抗锯齿。 不要用「放大一圈的黑色背面」那种描边,那样粗细不均、转角会断。 深度判断的阈值要放宽,接缝主要靠法线判断,否则斜着看的表面会冒出细碎斜纹。 - 活动部件要真实运动,比如箱盖绕铰链翻开、奖章绕竖轴旋转。 - 待机时主体缓慢左右转动,让人看到侧面和厚度,同时轻微上下浮动;脚下要有随高度变化的柔和投影。 【如果画面里有 2D 插画(卡面、奖励图标、角色)】 - 三层卡通着色:底色、成块的阴影色、高光色,不要只用一层渐变。 - 线条分粗细:外轮廓粗,内部结构线细。 - 每个角色或物件要有自己的表情和姿态,不要所有东西共用同一张脸。 - 脚下画投影,让主体「站」在画面里;背景按属性区分图案,不要全用同一套放射线。 【演出节奏:五个阶段,缺一不可】 1. 预备:主体待机浮动,每隔几秒抖一下提示可以点击,底部显示「点击」提示。 2. 升级:每点一次,主体跳起、在空中转一圈、落地时压扁再回弹;同时切换到下一等级的颜色,闪一下光,冒一圈粒子,标题更新。 3. 蓄力(约 1 秒):主体越抖越剧烈,缝隙透出光,四周粒子往中心吸,音效音调持续上升;最后一刻猛地压扁。 4. 爆发:从爆点向外扩散的泛光闪白、屏幕震动、镜头往前一推、多层冲击波、细长流光迸射、闪光星点、金币和宝石(带旋转)。高等级的爆发要明显更强。彩带只在最高潮用一次,不要满屏彩带。 5. 揭晓与结算: - 奖励卡片从主体里沿弧线飞出,落位时带超调和晃动收尾,数字滚动计数。 - 稀有物品带彩虹流光边框和「NEW!」角标。 - 点击领取后,金币和宝石沿贝塞尔曲线飞进右上角的余额,每到一个余额就跳一下。 【揭晓舞台:让主角独占画面】 - 最高稀有度揭晓时,其他元素收起或淡出,背后换成一层干净的渐变幕布加缓慢旋转的柔光,不要让主角压在杂乱的背景上。 - 幕布出现时,把场景里的其他 3D 物件隐藏掉,否则后期描边会把它们的轮廓线画在幕布上。 - 主角的外发光要放在主体背后,只从边缘溢出,不能盖在主体前面把它糊成一片白。 - 可以加一圈围绕主角盘旋的星尘拖尾,但轨道必须完整在主角轮廓外侧,不能从主体正面扫过。 【光效:必须柔和,不能有硬边】 - 背景光芒:用带渐变过渡的 conic-gradient,不要一刀切的色块边缘;叠 2~3 层不同密度、不同转速的光。 - 光柱:由 5~7 道带模糊的光束呈扇形散开,亮度各自轻微闪动;根部加一团柔光核心,光里有光尘缓慢上飘。 - 闪白:从爆点向外的径向泛光(mix-blend-mode: screen),强度不超过 0.8,不要整屏纯白过曝。 - 粒子:每个火花都带一圈低透明度的外晕;冲击波用三层描边(宽而淡、中等、细而亮)。 【材质与界面】 - 边框、名牌、按钮要有材质感:金属拉丝渐变、左上亮右下暗的倒角光、内阴影;按稀有度换镶嵌件(钢铆钉 → 银框宝石 → 金框钻石加小王冠)。 - 小卡片上不要塞小字数值;详细数值放到揭晓时的信息面板里,面板里的数字滚动上涨,并弹出「▲+数值」。 - 画在 Canvas 上的贴图,分辨率至少是屏幕上最大显示尺寸的 1.5 倍,否则放大时会发虚。 【动画原则】 - 用 GSAP 时间线编排。所有动作都要有挤压拉伸、超调和弹性回弹,不要匀速。 - 粒子系统用 Canvas 2D 自己写:重力、阻力、生命周期、叠加混合,以及「吸入」「曲线飞行」「环绕」三种运动。 - 不要用 CSS 3D 透视去翻转大尺寸元素,放大加侧翻时会被投影成铺满屏幕的平面,3D 翻转一律放在 WebGL 里做。 - 所有「抖动」「呼吸」类的循环补间,在状态切换时要先取消再归零,避免它比停止指令晚一帧结束,又把值设回去。 【音效】 - 全部用 Web Audio 实时合成,不用音频文件:跳起、落地、升级和弦、蓄力上升音、爆炸低频加噪声、弹出音、计数滴答、金币叮当、胜利号角。 - 第一次点击时才初始化音频;右上角放静音开关。 【界面与工程】 - 顶部 HUD:模式切换、金币和宝石余额、静音按钮。 - 手机宽度也要能用;遵守「减少动态效果」设置(关闭震屏,减少粒子)。 - 动画状态机要严谨:动画播放中忽略点击,不能出现点击被吞或状态错乱。 - 目标 60fps。第一次打开时就是完整的待机画面,不能是空白。 【交付前自检】 在蓄力、爆发、揭晓、结算这几个时刻各截一张图,逐张检查: - 主角有没有被光晕、粒子或文字挡住? - 有没有过曝成一片白? - 背景是否杂乱,有没有穿帮的描边线? - 小字是否能看清? - 结算后是否还有东西在不该动的时候继续抖动? 最后告诉我:每个阶段的时长,以及哪些参数可以调整演出强度。

Model:
Posts: "using Opus 5.5 to make game result animations" and "the Opus 5.5 game motion prompt is here" (Chinese).
Toolchain:
A 2D SVG version first, then rebuilt in Three.js as real 3D (MeshToonMaterial bands, normal + depth post-process outlines), a GSAP timeline, Canvas 2D particles and Web Audio synthesised effects, in one HTML page that plays on click and is screen-recorded.
Clip:
Gacha version with the prompt: about 17.6 s, 1920x1080, about 130K views. Treasure-chest version: x.com/op7418/status/2103724883301814408 (about 14.7 s, about 140K views).
Pitfalls:
The long "do not" lists are the lessons: inverted-hull outlines vary in width, CSS 3D flips of large elements project across the whole screen, and looping tweens that are not reset keep shaking after the reveal.
by @op7418Source
Hover to preview · click for sound

Pixel-art wizard casting a spell, pure Canvas code

Create a single self-contained HTML file that renders an animated pixel art wizard casting a spell, using vanilla JavaScript and Canvas 2D. No external assets, libraries, or network requests. RENDERING - Draw everything to an offscreen canvas at a fixed logical resolution of 128x96, then blit to a fullscreen display canvas scaled by the largest integer factor that fits the window, centered, with imageSmoothingEnabled = false and CSS image-rendering: pixelated. - All drawing snaps to integer coordinates on the logical canvas. No sub-pixel positions, anti-aliasing, gradients, or shadowBlur. - Fixed palette of ~24 hex colors: deep blues/purples for night sky, warm robe tones, 3-4 bright magic colors. Every pixel comes from this palette. CHARACTER - Build the wizard procedurally from filled rects and pixel runs, ~24x32 logical pixels: pointed hat with a bend, long beard, two-shade robe with darker outline, staff with a gem at the tip. - Parameterize the pose (staff angle, arm raise, head tilt, robe sway). Animate parameters smoothly, then quantize to the pixel grid each frame so motion reads at an 8-12 fps pixel animation feel even though the loop runs at 60fps. ANIMATION - Looping state machine: IDLE (2-frame bob, beard sway) -> CHARGE (staff raises, gem flickers, sparks spiral inward) -> CAST (bright burst, projectile fires across the scene, 1-2 pixel screen shake) -> RECOVER (settle back). Ease pose parameters between keyframes. - Pooled allocation-free particle system: preallocate and reuse. Sparks orbit the gem during CHARGE, explode outward on CAST, each particle stepping its palette index from white to magic color to dark before despawn. Snap particle positions to the grid when drawing. - Fixed 60hz timestep update with rAF rendering. Zero object allocation inside the loop. SCENE - Minimal background: dark sky, a few twinkling 1px stars, moon, stone floor line. Character silhouette must read clearly. - Subtle 1px rim light on the wizard from the gem, brightening during CHARGE and CAST. QUALITY BAR - Crisp pixels at any window size, seamless loop, stable 60fps, readable silhouette. Should look like a polished 16-bit sprite animation, not vector shapes scaled down.

Model:
Post: "opus 5.5, animated pixel art wizard, pure code prompt shared below" (launch day). Prompt shared in the reply.
Toolchain:
Single HTML, vanilla JS and Canvas 2D at a 128x96 logical resolution scaled by an integer factor, a fixed palette of about 24 colours, a state-machine animation and an allocation-free particle pool; the clip is a screen recording.
Clip:
About 11 s, 1080x890, about 450K views.
Pitfalls:
This one runs a live requestAnimationFrame loop rather than deterministic seek(t), so a screen recording depends on machine speed. For a stable MP4, rewrite it in the seek(t) style of the UI-morph template.
Hover to preview · click for sound

Colourful remix of the UI-morph template that exposed the default render pipeline

Summary

Ran @twoclipping's "one shape, a dozen UI states" template unchanged, with one extra instruction: make the video more colorful.

Model:
Post: "opus 5.5 is really amazing one shot".
Toolchain:
Per the author: Opus put all the code in one index.html, rendered it frame by frame in a headless Playwright window via a seek function plus eval, then assembled the MP4 with FFmpeg. It prefers zero dependencies and writes everything from scratch, and did not reach for Remotion or HyperFrames even though they were available.
Clip:
About 15.4 s, 1440x1440.
Pitfalls:
This post is the clearest evidence that the single-HTML route is the default. If you want a framework, name it in the prompt.
video by @__morseSource

How to write great Claude Opus 5.5 Video prompts

  1. 1Ask for the plan before the code. The strongest briefs in this library end the same way: show me the shot list, the beat grid or the list of states, then wait. Fixing a storyboard costs one message; fixing a rendered film costs a re-render and often a rewrite.
  2. 2Make every frame a function of time. Have it expose window.seek(t) and compute every style from t: no timers, no requestAnimationFrame loop, no CSS transitions, no unseeded randomness. Then a headless browser can render any frame on demand and FFmpeg can encode a steady 60fps. A live animation captured by screen recording drops frames whenever the machine is busy.
  3. 3Name the framework, or it will not use one. Left alone, Opus 5.5 writes one dependency-free HTML file from scratch even when Remotion or HyperFrames is installed. If you want a React timeline, Manim's equation animation or Blender's renderer, say so in the first line and install the matching skill.
  4. 4Ban the defaults by name. Anthropic's own prompting guide for Opus 5.5 notes that asking it to avoid a generic look only swaps one default style for another. The briefs that stand out list exactly what is banned (centered text on a gradient, everything fading in, particle bursts, neon glows, bouncy easing, lens flares) and pair that with one accent colour and one typeface.
  5. 5Render stills and make it critique them. It can read images but not video, so the review loop runs on frames: one still per beat, or twenty sampled frames, inspected before the full render. Several creators here ran that loop dozens of times or split it into reviewer and fixer agents, and credit it for the difference between a good clip and a forgettable one.
  6. 6Hand it the soundtrack, then let it do the maths. Give it a track whose licence covers your use and ask it to measure tempo and beats (numpy is enough), cut on downbeats, place each sound effect by its measured peak rather than where the file starts, and normalise loudness to -14 LUFS. With no track, it can synthesise music and effects in Web Audio or Python on the same timeline.
  7. 7Put a cost gate in front of every paid call. When it directs video or image models, make it list every generation with its estimated cost and wait for your OK, and show you stills before each expensive step. Without that line, an agent running for hours will happily spend whatever the keys allow.
  8. 8Match effort and time to the job. Creators report xhigh or max effort on the pieces that travelled and medium for small fixes; Anthropic suggests raising effort only where you measure a quality gain. Budget wall-clock time too: a five-minute history film here took 90 minutes to build and four hours to render, and one music video ran overnight.

Prompt formula

Director brief = the inputs it must ask you for + direction (one style, one accent colour, one typeface, an explicit banned list) + structure (every shot timed on a beat grid) + build contract (resolution, fps, seek(t), renderer, how to check frames) + known gotchas + a start line that asks for the plan before any code

Example: <inputs> Ask me for the app name, three screenshots and a 100 BPM track I hold a licence for. </inputs> <direction> 20 seconds, 1080x1920, one continuous take. Off-white background, one green accent, Inter. Banned: gradients, particle bursts, glows, bouncy easing. </direction> <structure> Eight bars: the name types on; a screenshot rises into a phone; a cursor taps through three screens on the beat; a delivery route draws itself; logo and the line "Fresh beans every Friday". </structure> <build> One HTML file, every style computed inside window.seek(t). Render with Playwright at 60fps, encode with FFmpeg, check one frame per bar first. </build> <start> Ask for the inputs, then show me the bar-by-bar plan before writing any code. </start>

Frequently asked questions

Can Claude Opus 5.5 generate a video by itself?

Not as pixels. Anthropic's documentation lists text and image input and text output for its current models and states that Claude cannot generate, produce or edit images. Every video on this page was either rendered from code Opus 5.5 wrote (HTML and Canvas, Remotion, HyperFrames, Manim, Three.js, Blender Python and so on) by a headless browser or renderer plus FFmpeg, or made by video models it directed through an API and then cut together. In a chat window with no shell you get the animation as an HTML page you can open and screen-record; producing an MP4 directly needs an agent environment that can run commands.

Can Opus 5.5 watch a video I give it?

No. It has no video input, and an animated GIF is read as its first frame only. The workaround every editing case here uses is to have it extract frames (and transcribe the audio) with FFmpeg and look at those stills. It reviews its own renders the same way.

Do the "one prompt" videos really come from one sentence?

Some do: the 15-second showreel prompt is a single sentence. Many of the widely shared cases ran on briefs of thousands of characters, with skills installed in advance, API keys for voice, music or video models, and runs of one to twelve hours, sometimes with dozens of review rounds. Costs on these cards are what each creator reported, from about $2 for a 26-second launch clip to around $400 of credits across 33 versions of a product trailer. Every card is marked as an original prompt, our summary of a method the creator described, or a case whose prompt was never published.

What do I need installed to reproduce these?

For an MP4: an agent that can run commands (Claude Code or a similar tool), Node.js, Playwright or another headless Chromium, and FFmpeg. The UI-motion templates also use Python with numpy to analyse the soundtrack; Manim cases need Manim and LaTeX; Blender cases need Blender; music-video and director cases usually need API keys for voice, music or video models.

Which approach should I start with?

For a product clip or a UI animation, start with the single-HTML route or a framework such as Remotion; both are on this page with full prompts. For a lesson, use Manim. For anything with real people, natural motion or physics, let Opus direct a video model and keep a cost gate in the brief. For footage you already shot, use the editing route and expect to make the pacing calls yourself.

How much does Opus 5.5 cost for this on apimodels.app?

$2.40 per 1M input tokens and $12 per 1M output tokens (Anthropic lists $4 / $20), billed per token with failed calls free, through /v1/messages or the OpenAI-compatible /v1/chat/completions, so Claude Code and other Anthropic-compatible agents connect with a base URL and a key. Video work is output-heavy: one creator's Blender test wrote about 200K output tokens, roughly $2.40 of output at our rate. Our own single-HTML test through apimodels.app was one call of 31,786 output tokens, billed $0.368, for a 12-second 1280x720 promo. If Opus directs video models, those calls are billed separately per model; Seedance 2.5, MiniMax H3, Kling V3 and Wan 3.0 run under the same key.

Can I reuse these prompts and videos?

The videos belong to their creators. Clips from X play straight from X's own servers, every card links to the original post, and we do not host or re-upload any of them. Prompts are quoted with credit and a link: several authors explicitly invited reuse, others simply published theirs, so check the post before using one commercially. Some cases use third-party music, pay homage to an existing film or show real people, and each of those cards names the source material. If you made one of these and want the card removed or the credit corrected, email us.

Run these prompts on apimodels.app

Claude Opus 5.5 is live here alongside 180+ other image, video, audio and language models — one API, one key, pay as you go, with $0.10 of trial credit on sign-up.

This library is open source on GitHub

The whole collection is on GitHub as Markdown and JSON: all 60 cases with credits and links to the original posts, the six workflows with templates, and the prompt and render scripts from our own run. The videos stay with their creators and are linked, not re-hosted. Prompts are quoted in full when the author invited reuse or the prompt is short; long ones are excerpted and unpublished ones are left out. Our own notes, templates and code are licensed CC BY 4.0. Open an issue to add a case or correct a credit.

View on GitHub

Other prompt libraries