Sep 27, 2026year 2026relevance 53524 min read

Claude Opus 5.5 Motion Design Studio · Full Course, Prompts and Repositories

Movez (@0xMovez) mapped the first wave of Opus 5.5 code-generated motion films into a studio pipeline. This guide turns that research into a practical build system: references, brand assets, a seek(t) renderer, springs, beat-aware audio, contact-sheet review, multi-format export and a reusable motion-reel skill.

Original article and video credit: Movez (@0xMovez).Original X source: How to build motion design studio with Opus 5.5 (Full-course).

Quick Summary

  • Movez's central argument is that the prompt is a small part of the result. The studio harness does the rest: deterministic rendering, reference analysis, brand assets, a beat grid, sound, critique and repeatable delivery.
  • Opus does not directly output an MP4 in this workflow. It writes a program that can draw an exact frame for any time value. A headless browser captures those frames and FFmpeg encodes the video.
  • The simplest route uses one HTML composition with window.seek(t), Playwright and FFmpeg. Remotion is better for React-based series and templates, while HyperFrames offers an agent-oriented HTML and GSAP path.
  • One-line showreel prompts are useful as an engine test, but they tend to produce similar results. Product work becomes more distinctive when the brief includes real UI, a reference, a state list, a visual system and explicit banned defaults.
  • Motion quality comes from time-addressable springs, deliberate continuity between scenes and a new visual payoff every two to four seconds, not from adding more particles or generic effects.
  • Sound is planned on the same timeline as the picture. A supplied track can be measured into beats, downbeats and transient hits, while clicks, pops, thumps and whooshes can be synthesized or sourced and aligned to visible events.
  • The strongest projects are iterative. Contact sheets, fast-action strips, phone-size tests, loop checks and repeated scoring make the model inspect and repair its own output before the full export.
  • The final step is operational: render 9:16, 1:1 and 16:9 from one timeline, then package the workflow as a skill so future projects begin with a short command instead of another enormous brief.

--what to try first

  • Treat the film as a program with an explicit time input, not a browser animation that depends on timers or previous frames.
  • Prove the renderer with a short showreel before committing a product, soundtrack or long-form story.
  • Use real product screenshots, logos, colors, fonts and verified metrics. Never invent UI to fill a shot.
  • Extract the grammar of a reference, including pacing, typography, transitions and camera behavior, without copying its brand, characters or content.
  • Write states and beats, not vague visual moods. Specify what changes, when it changes and which object carries continuity into the next scene.
  • Use closed-form springs and seeded noise so every frame can be rendered independently and reproduced exactly.
  • Build a beat grid before animation and align state changes, camera landings and sound effects to measured musical events.
  • Require contact sheets and at least three critique rounds before the final render.
  • Keep API keys in environment files and never place real credentials in prompts, screenshots, repositories or public examples.
  • Reframe each delivery format from the shared scene logic instead of cropping a widescreen export into vertical.

Credit, publication date and evidence level

The original full course was researched and written by Movez (@0xMovez) and published as an X article on September 27, 2026. Movez also published a readable Substack edition. The framework, source selection and twelve-part structure belong to the creator, and the original article remains the canonical source.

This post is an independent educational reorganization. The prompt pack is newly written from the public methods instead of copying the source article's long templates word for word. Every original X example and repository is linked below, with a smaller set embedded at the relevant step.

The performance figures, production times, model-call counts and client-price comparisons in the examples are creator reports. They demonstrate possibilities, not guaranteed speed, quality, cost or commercial value for another user.

Anthropic officially introduced Claude Opus 5.5 on September 22, 2026. Its release page describes higher effort settings for demanding work, but the motion-design results here come from independent creator experiments rather than an official Anthropic video workflow.

Step 1 · Understand what is actually producing the pixels

The model writes text, usually HTML, JavaScript, React or support scripts. The video is created when that code draws frames and a renderer encodes them. This distinction explains why the surrounding project matters as much as the creative prompt.

The core contract is window.seek(t) or an equivalent draw(t) function. Give it a time value and it must paint the same frame every time. A 15-second film at 60 frames per second needs 900 final frames, plus extra subframes if motion blur is calculated by temporal sampling.

A headless browser loads the composition, seeks to each sample time and captures the canvas or page. FFmpeg receives those frames, encodes H.264 and mixes the soundtrack. Because time is explicit, a revised color, spring or text cue can be rendered again without manually rebuilding a timeline.

Movez notes that Opus often chooses a dependency-light HTML route unless the brief explicitly asks for Remotion, HyperFrames or another framework. Pick the route based on reuse and team needs, not because one library is universally best.

Step 2 · Install a studio, not just a chat window

A useful local stack contains Node.js, FFmpeg, Python for audio analysis and a browser automation layer such as Playwright. The agent needs shell access so it can generate code, render frames, listen to the result, inspect images and repair the project.

Create one project folder per film. A practical structure includes assets, audio, references, documents, prompts, source code and output folders. Keep brand material and approved references separate from generated intermediates.

Put persistent production rules in CLAUDE.md or the equivalent project instruction file. Define deterministic rendering, banned visual defaults, typography limits, color rules, sound targets and the review loop once, then let every future task inherit them.

Use medium effort for narrow corrections and re-renders. Reserve xhigh or max for new visual systems, difficult storyboards and flagship openings. Higher effort can improve planning, but it also uses more time and allowance.

Step 3 · Use the one-line showreel as a renderer test

The viral test prompt asks for a dynamic 15-second motion-design showreel that demonstrates the model's ability and tells it to go all out. Its strength is genre compression: showreel implies fast cuts, varied techniques, a strong opening and best-work-first pacing.

It is a useful smoke test because there is no product fact to misrepresent. If the system can plan, animate, score and export the reel, the basic renderer works. It does not prove that the system can understand a brand, preserve a real interface or communicate a useful product story.

Repeated use creates visual convergence. Many reels default to centered type, gradient backgrounds, corner labels and broad fades. Keep the one-liner for technical validation, then move immediately to references, original assets and a structured brief.

Original article and video credit: Stephan Livera (@stephanlivera).Original X source: Opus 5.5 Max effort motion-design showreel.

Step 4 · Point the engine at a real brand

A product film needs more than a URL. The agent should collect the real logo, screenshots, fonts, colors, product copy and approved performance metric before animation. List every asset so the operator can catch a wrong or missing source early.

A compact story works well: open with the problem, assemble the product, demonstrate three actions, present one verified proof point and end on the logo plus call to action. Each beat should earn its place and use the real interface rather than a fictional reconstruction.

Keep one session and one source folder per brand. The renderer, sound vocabulary and export scripts can be reused, while the assets, claims and style guide remain isolated from other client work.

Tony Dinh reported creating a TypingMind reel in under thirty minutes after previously paying more than one thousand dollars for similar work. Treat that as his experience, not a universal production estimate or price benchmark.

Original article and video credit: Tony Dinh (@tdinh_me).Original X source: TypingMind product motion reel made with Opus 5.5.

Step 5 · Name a look and feed the model evidence

A reference can be one frame, a complete video or a folder of your own past work. A still is useful for palette, type, grain and composition. A video adds timing, transition and camera evidence. A personal image library can define a style that competitors cannot copy.

For video analysis, extract frames at a regular interval, then write a style guide and shot grammar before coding. Record exact colors, type roles, shot duration, transition families, camera paths, texture and how text enters or exits.

Tell the model to borrow grammar, not content. Do not reproduce another creator's brand, logo, proprietary footage, characters, music or exact sequence. References should help the system reason about design, not automate plagiarism.

Useful discovery sources include WhatShips for launch videos, Dribbble's motion graphics search and public films from adjacent products. Confirm asset rights separately before using any media in the final piece.

Step 6 · Write the state list, not the vibe

The strongest UI-morph prompts are specifications. They define required inputs, creative direction, an ordered state list, rendering rules, known failure modes and a planning gate before code.

A single container can become a call-to-action, field, loader, confirmation, card, chart, command palette and toast without cutting away. The container changes size, radius and fill while its contents enter and leave on their own timing. A cursor supplies visible cause and effect.

The loop is part of the design. The final container, cursor position and velocity must resolve to the opening state. A visual match without a matching motion state can still create a seam.

The embedded example by zero (@twoclipping) supplied the most widely shared XML-style prompt pattern in the source course. Movez adapts that structure into a reusable UI product-film specification.

Original article and video credit: zero (@twoclipping).Original X source: Open prompt template for a code-generated UI morph loop.

Step 7 · Build the deterministic seek(t) engine

Route A is a small browser renderer: one HTML composition, an explicit duration, a canvas or DOM scene graph and window.seek(t). Each scene calculates its state directly from local time. Seeded noise replaces Math.random so rerenders remain stable.

A Playwright render script opens the page at the delivery resolution, waits for fonts, calls seek for every sample and pipes screenshots into FFmpeg. Multiple subframes can be averaged for motion blur, although extra sampling increases render time and can expose ghosting in poor trajectories.

Route B uses a framework. Remotion is a strong fit for React components, data-driven templates and repeatable series. HyperFrames is designed around agent-authored HTML and GSAP compositions. The choice should be explicit in the brief so the model does not silently switch architectures.

Do not put will-change on text or UI that the camera scales if it produces blurry rasterization. Test typography, fonts and media seeking in the actual headless path, not only the live browser preview.

Step 8 · Replace generic easing with time-addressable springs

A fixed ease moves between two values but does not communicate mass. A damped spring accelerates, may overshoot slightly and settles. The closed-form version can be evaluated at any timestamp, which preserves deterministic seeking.

When one property receives several targets, represent every target change as its own timed spring contribution. Do not restart a hidden simulation. This lets the renderer jump directly to frame 812 without replaying the first 811 frames.

Different objects deserve different motion. Buttons and leading edges can be snappy. Cards and cameras can use a moderate response. Large type and logo lockups should feel heavier with little or no overshoot. Mascots can tolerate more playfulness when the brand supports it.

Text inside a morphing container should leave before the next shape transition and enter after the new state has begun. Independent content timing prevents labels from overlapping during fast changes.

Step 9 · Score the motion to a measured beat grid

If the production has a music track, analyze it before storyboarding. Store tempo, beats, downbeats and transient peaks in a JSON file. State changes can land on beats, major reveals on downbeats and interface sound effects on measured visual hits.

If no track is supplied, music and sound effects can be synthesized on the same timebase as the visuals. A small deterministic sound script can create clicks, pops, thumps and whooshes from oscillators and seeded noise, then export a WAV for mixing.

The final mix still needs listening, metering and rights review. A target such as minus 14 LUFS is a delivery starting point, not a substitute for checking dialogue, transient peaks, platform requirements and the exact license for every external track or effect.

Onur Ozcan's Steve Jobs film demonstrates the long-form version: Remotion, React and SVG scenes with a code-generated soundtrack and many transitions aligned to a shared tempo.

Original article and video credit: Onur Ozcan (@oozn).Original X source: Two-minute Steve Jobs animation made with Opus 5.5.

Step 10 · Write an overnight director's brief

A flagship brief hires an entire virtual crew. It defines the emotional result, references, tools, budgets, character rules, beat sheet, on-screen text, workflow gates, critique loop and deliverables. It does not ask for a final render before the plan exists.

The production sequence should move from style guide and shot list to stills, contact sheet, low-resolution animatic, full animation, sound and final output. Long projects benefit from one shared animation guide before subagents divide the chapters.

Donald Jewkes reported dictating for about five minutes and letting Claude work for twelve hours on the Claude Pop music video. His public prompt was much longer than the headline one-liner. The useful lesson is structured autonomy with checkpoints, not unattended execution as a universal recommendation.

For hybrid work, a video model can supply difficult character or physical motion, then the code layer can trace, restyle or composite the result. Keep generated assets, permissions, API budgets and provenance explicit in the brief.

Original article and video credit: Donald Jewkes (@donaldjewkes).Original X source: Claude Pop long-form Opus 5.5 production experiment.

Step 11 · Make Opus inspect its own frames

Render a contact sheet at regular intervals, a strip around the fastest action, a phone-width overview and a doubled loop. Each artifact reveals a different failure: weak composition, one-frame pops, unreadable type or a visible seam.

Score the opening hook, phone readability, motion, variety, composition, brand accuracy and sound synchronization. Record the three worst timestamped problems, fix only the affected sequences and generate new evidence. Repeat until the agreed threshold is met.

Mable Joseph's watercolor short is a useful counterweight to one-shot marketing. The creator reported 163 model calls and nearly seven hours of work. Iteration is not proof that the model failed; it is the production method that turns a first pass into a directed result.

Also run a determinism test. Render the same short interval or target frame twice and compare hashes. A mismatch means random state, timers, media seeking or another hidden dependency still affects the output.

Step 12 · Export every format and package the studio as a skill

Build scenes against a layout function instead of hard-coded widescreen coordinates. Render vertical, square and widescreen from the same story logic, but reflow typography and interface composition for each format. Do not treat a center crop as responsive direction.

Package the process as a motion-reel skill. It should collect inputs, gather approved assets, analyze the reference, measure or synthesize music, produce the shot list, build the deterministic renderer, run critique rounds and deliver video, poster and contact sheet.

A repeatable skill can support client work, but do not promise agency-level results, fixed turnaround or revenue based on social examples. Price creative direction, rights, review, revisions and delivery responsibility, not only rendering time.

Chain (@achxvi) publicly demonstrated a longer product film and offered related motion-design work as a service. The example supports the existence of a service opportunity, not a guaranteed customer acquisition model.

Original article and video credit: Chain (@achxvi).Original X source: Longer Opus 5.5 product film and service example.

Repository map · What to clone and why

PDoomVideo is a complete music-video source with ANIMATION_GUIDE.md, STORYBOARD.md, nine scene chapters, a browser studio and a resumable FFmpeg renderer. It is the best reference for multi-chapter delegation.

ClaudeAnimationBase is the smaller starting point. It packages p5.js, p5.brush, a reusable Clawd character, acted emotions, model sheets, contact-sheet review and a renderer under an MIT license.

buildwithhanif's claude-animation-skill is a hand-drawn Node Canvas route with a detail bible, rigs, brush and watercolor treatment, frame-matched recreation and synthesized sound.

HyperFrames provides the HTML and GSAP framework path. Remotion's official AI skills provide the React and composition path. Choose one when the project needs reusable components instead of a single custom HTML film.

Battle-of-Austerlitz-Film is a long-form example. awesome-ai-motion curates motion work, source code and prompts. athemeroy's collection tracks Claude 5.5 video demonstrations and links each result back to its evidence.

Inspect the current README, license, issues and recent commits before cloning. A public repository is not automatically suitable for every commercial project, dependency policy or security environment.

Verdict · The harness is the studio

The one-line prompt proves that the model can improvise. The twelve-step system proves whether a team can direct, reproduce, review and deliver the result.

The transferable advantage is not one visual style. It is the combination of an explicit render contract, real brand evidence, timed states, sound, frame-level critique and packaging. Once those pieces are stable, the next project can start from a short command without losing the discipline of the full course.

Complete motion studio prompt library

These are original, copyable templates written from the methods in Movez's course. They cover every prompt stage without reproducing the source article's long wording. Replace bracketed fields, keep credentials in .env and preserve human approval gates for brand claims, rights and final delivery.

Prompt pack credit: Framework credit · Movez (@0xMovez).

01 · Studio readiness audit

Run before asking for creative work. It checks the local toolchain without installing or changing anything automatically.

Audit this computer for a code-based motion-design workflow. Check, but do not install or modify, the following: Node.js 22 or newer, FFmpeg with H.264 support, Python, Chromium or Chrome, Playwright, and the Python packages required for beat analysis.

Return:
1. installed version and executable path for each dependency;
2. missing or incompatible items;
3. the exact commands I could run to install only the missing items on this operating system;
4. a two-second deterministic render test using a time-addressable seek function;
5. the expected output files and a verification checklist.

Do not execute installations, download software or expose environment variables until I approve the plan.
02 · CLAUDE.md motion studio rules

Use as the persistent project instruction file. Adapt formats and brand restrictions before saving it.

# Motion studio rules

## Render contract
- Every composition must be a pure function of time exposed as window.seek(t) or an equivalent frame function.
- Do not use CSS transitions, setTimeout, requestAnimationFrame history or state carried between rendered frames.
- Use deterministic seeded noise only. Never use Math.random in render mode.
- Render through the approved headless-browser script and encode H.264 yuv420p. Keep source and render settings documented.

## Visual system
- Avoid generic centered titles on gradients, corner labels, decorative frame borders, UI glow and unmotivated particles.
- Use one display typeface, one interface typeface and one accent color unless the approved style guide says otherwise.
- Introduce a meaningful visual change every two to four seconds.
- Use real product assets. Never invent interface screens or metrics.

## Motion and sound
- Use time-addressable springs with restrained overshoot. Large type should not bounce.
- Align important state changes and sound effects to the measured beat grid.
- Target the agreed loudness and preserve dialogue intelligibility.

## Review loop
1. Render a contact sheet, fast-action strip, phone-width test and loop check.
2. Score hook, readability, motion, variety, composition, brand accuracy and sound sync from 1 to 10.
3. Record the three largest timestamped problems and fix them.
4. Repeat for at least three rounds or until every agreed score is 8 or higher.
5. Ask for human approval before the final full-resolution export.
03 · Viral showreel smoke test

The short source prompt is retained because it is the widely repeated public test. Use it only to validate the pipeline.

Make a dynamic 15-second motion graphics video that shows what an incredible motion designer you are, like it is your showreel for a resume. Go all out.
04 · Distinctive showreel variants

Choose one direction instead of repeating the same generic showreel across projects.

Choose one variant and replace the bracketed fields.

A. Music-led: Create a [DURATION] [FORMAT] showreel scored to an original [INSTRUMENT] composition. Put every cut and camera landing on the measured beat grid. Avoid generic synth pads.

B. Anti-default: Create a ten-second introduction to [SUBJECT]. Ban corner labels, frame borders, centered type on gradients, broad fades and decorative particles. Use one accent color and a different technique in every shot.

C. Narrative: Use showreel energy to tell the history of [TOPIC] from [START] to [END]. Build a clear beginning, change and payoff instead of a technique montage.

D. Studio persona: Create a thirty-second reel as a specialist branding studio for [AUDIENCE]. Every graphic must be original and every shot must prove a different capability relevant to that buyer.
05 · Real product launch reel

Use after the site and product claims have been approved for access and public use.

Create a [DURATION]-second motion-design launch film for [PRODUCT] at [URL]. The target viewer is [AUDIENCE] and the desired action is [CTA].

Before animation:
- inspect the public site and collect the real logo, colors, fonts and approved interface screenshots into ./assets;
- list every asset and its source;
- identify any missing claim, metric or permission and ask me instead of inventing it;
- write docs/brand.md and docs/shotlist.md, then wait for approval.

Story beats:
1. Express the problem in no more than five words.
2. Assemble the product from real interface fragments.
3. Demonstrate three useful actions with a cursor that causes visible changes.
4. Present one verified metric: [METRIC AND SOURCE].
5. Finish with the real logo and [CTA].

Use original music at approximately [BPM] BPM, plus synchronized clicks, impacts and whooshes. Build one responsive timeline for 9:16, 1:1 and 16:9. Show a contact sheet before the full render.
06 · Reference deconstruction

This extracts design grammar while explicitly rejecting copied content or identity.

Reference inputs: [VIDEO, FRAMES OR IMAGE FOLDER]
Target subject: [PRODUCT OR STORY]
Target duration and formats: [DETAILS]

1. Extract or inspect reference frames at a regular interval.
2. Write docs/style_guide.md with palette, type roles, spacing, shot length, transition families, camera language, texture, grain and text entrance and exit behavior.
3. Write docs/shotlist.md for the target subject using that grammar.
4. Identify what must not be copied: brand identity, logos, characters, proprietary footage, exact copy, music and distinctive compositions.
5. Show both documents and wait for approval before writing animation code.

Take the reference's design logic, never its protected content or identity.
07 · UI morph specification

Use for a continuous product story in which one container transforms through several interface states.

<inputs>
Ask for the product URL, eight to twelve real UI states, the approved data for each state, brand colors, fonts, one accent, soundtrack rights, duration and delivery formats.
</inputs>

<direction>
Create a continuous UI product film. One primary container never cuts away. It changes size, radius and fill while its content swaps on independent timing. A cursor visibly causes every interaction. Use a neutral canvas, one accent and restrained springs. Ban UI glow, decorative particles, unexplained gradients, dead time and exaggerated bounce.
</direction>

<states>
Map the approved story to a beat grid, for example: logo, CTA, input, typed value, loader, result, dashboard card, chart, tooltip, command palette, toast, logo. Replace this example with real product states and real data.
</states>

<build>
Expose window.seek(t). Use no timers or carried state. Use closed-form springs and seeded noise. Delay content entry until a container morph begins and remove content before the next morph. Give leading and trailing indicator edges different spring responses. Measure the soundtrack and place interface sounds on visible actions. Render four subframes per output frame only when the motion test shows a real benefit.
</build>

<loop>
Make the final container, cursor position and cursor velocity resolve exactly to the first frame.
</loop>

<gate>
Ask for missing inputs, then show the ordered state list and beat map before writing code.
</gate>
08 · Deterministic renderer builder

Ask the agent to generate the local engine without copying a framework when a simple HTML route is enough.

Build a minimal deterministic motion renderer for [WIDTH] by [HEIGHT], [FPS] fps and [DURATION] seconds.

Composition requirements:
- index.html with a canvas or DOM scene and window.seek(t);
- every visual value computed from the supplied time;
- closed-form springs, seeded noise and explicit scene ranges;
- a live browser preview that is disabled during headless rendering;
- no timers, CSS transitions, frame history or Math.random in render mode.

Renderer requirements:
- Playwright opens the local composition, waits for fonts and seeks every sample;
- frames stream to FFmpeg instead of accumulating unbounded images in memory;
- H.264 yuv420p output with documented quality settings;
- optional subframe sampling controlled by a CLI flag;
- resumable output or a clear recovery plan for long renders;
- a two-second test, exact run commands and verification results before the real film.
09 · Spring-motion refactor

Use when the first pass relies on CSS easing, discontinuous keyframes or excessive bounce.

Audit the animation for generic easing and replace it with deterministic, closed-form spring motion.

Rules:
- buttons, toggles and leading edges may be snappy;
- cards, containers and camera motion use a moderate response;
- large type, 3D objects and logo lockups feel heavy with no visible bounce;
- mascots may overshoot only when the brand direction is playful;
- a property with multiple targets uses a sum of timed spring contributions, not a restarted simulation;
- content leaves before its container changes and enters only after the new state has begun;
- the loop's ending position and velocity equal the opening state.

Render a comparison strip around the three fastest transitions and explain which constants changed and why.
10 · Beat map and sound plan

Works with supplied music or a request for deterministic synthesized audio.

Create the audio plan for [PROJECT]. The source is [TRACK PATH / SYNTHESIZE].

If a track exists, analyze it into beats.json containing tempo, beats, downbeats and transient hits. Do not alter or redistribute the track unless its license allows it. If no track exists, propose a simple deterministic score and synthesized interface sounds on the same timebase as the animation.

Return a cue sheet with timestamp, visual event, sound type, source or synthesis method, peak alignment and mix priority. Put state changes on beats, major reveals on downbeats and clicks or impacts on the visible completion frame.

Create a low-resolution audiovisual animatic first. Report the final integrated loudness, true peak and any rights or attribution requirements. Do not perform the final mix until I approve the cue sheet.
11 · Flagship director's brief

Use for a longer multi-session production with explicit gates and controlled autonomy.

You are the director, motion designer, sound designer and render engineer for a [DURATION] code-generated film. Treat it as a staged production, not a one-pass generation.

FILM IN ONE LINE
[LOGLINE AND DESIRED FINAL FEELING]

REFERENCES AND INPUTS
- references: [PATHS OR URLS], use grammar only;
- approved audio: [PATH AND LICENSE];
- available framework or skills: [LIST];
- credentials live in .env under these variable names: [NAMES ONLY];
- maximum external generation budget: [AMOUNT], ask before exceeding it.

LOOK
[PALETTE, TYPE, TEXTURE, CAMERA AND BANNED DEFAULTS]

BEAT SHEET
[TIMECODED ACTS WITH A HOOK IN THE FIRST TWO SECONDS AND A PAYOFF EVERY THREE TO FIVE SECONDS]

WORKFLOW GATES
1. style guide and shot list for approval;
2. stills and contact sheet;
3. low-resolution animatic with placeholder or approved audio;
4. full animation;
5. polish and sound;
6. final render and delivery review.

If subagents are useful, write one shared ANIMATION_GUIDE.md first and divide work by chapter. Preserve a review log. Do not skip approval gates, publish externally or spend beyond the stated budget.

DELIVERABLES
Final MP4s in all approved formats, loop check, poster, contact sheet, clean source, asset and rights manifest, and README with exact render commands.
12 · Contact-sheet critique loop

Run after an animatic or partial render, then repeat with updated evidence.

Inspect the attached contact sheet, fast-action strip, phone-width test and loop-check video as a demanding motion director.

Score from 1 to 10:
- hook in the first two seconds;
- readability at 360 pixels wide;
- spring quality and absence of dead frames;
- visual variety every two to four seconds;
- composition and depth;
- brand and factual accuracy;
- synchronization between visual events and sound.

List the three largest problems with exact timestamps. Search specifically for overlapping labels, linear slides where a spring is needed, generic corner labels, centered-gradient defaults, blurry scaled text, stale layers, a beat with no event and a loop seam.

Propose the smallest code changes that fix those problems. Re-render only the affected intervals when possible, generate new evidence and rescore. Do not declare the film complete until the human reviewer approves it.
13 · Multi-format delivery

Use before final rendering so every aspect ratio receives a designed layout.

Adapt the approved film to 9:16, 1:1 and 16:9 from one shared timeline and scene data.

For each format, define its own safe areas, type scale, line breaks, UI layout, camera framing and crop behavior. Reflow the composition instead of center-cropping another format. Preserve beat timing and narrative order across all outputs.

Render representative stills from the hook, densest information scene and end card in all three formats. Present them as a comparison sheet and wait for approval before full exports. Deliver a manifest listing dimensions, frame rate, codec, audio settings, duration and file path.
14 · Motion-reel skill specification

Use this brief to create a reusable personal skill, not a one-off production prompt.

Create a reusable skill named motion-reel for launch videos, showreels, product films, animated explainers and motion ads.

The skill must:
1. collect product, URL, duration, formats, audience, brand assets, reference and music;
2. gather only authorized public or supplied assets and list their sources;
3. write a style guide from the reference without copying protected content;
4. measure or synthesize music and create a beat grid;
5. write a shot list and stop for approval;
6. build a deterministic seek(t) composition with the approved framework;
7. run at least three evidence-based critique rounds;
8. export all approved formats and deliver video, poster, contact sheet, source and README.

Hard rules: real product UI only, no invented metrics, no credentials in prompts, no Math.random or timers in render mode, no generic centered-gradient shots, and no external publishing or budget increase without confirmation.

Return the proposed folder tree and complete skill file for review before installing it.
15 · Asset, rights and claims manifest

Use for every commercial project before final approval.

Create an asset and claims manifest for this motion-design project.

For every logo, screenshot, font, photograph, video clip, music track, sound effect, generated asset, character likeness and product metric, record:
- filename and scene;
- original source URL or supplied-file reference;
- creator or rights holder when known;
- license and required attribution;
- modification performed;
- approval owner;
- unresolved restriction or factual risk.

Flag missing evidence, restricted commercial use, unverified metrics, implied endorsements, sensitive personal data and assets that cannot be redistributed in source files. Do not provide legal clearance or replace counsel. Finish with a human approval checklist and block final delivery until every high-risk item has an owner and decision.

FAQ

Does Claude Opus 5.5 generate the MP4 directly?

Not in this workflow. It writes the composition and support scripts. A browser renderer captures frames and FFmpeg encodes the video and mixes the audio.

What is the minimum useful local stack?

Node.js, FFmpeg, Python when beat analysis is needed, Chrome or Chromium and Playwright are enough for a basic deterministic HTML renderer. Remotion, HyperFrames and animation skills are optional routes for different production needs.

Why is seek(t) so important?

It makes every frame addressable and reproducible. The renderer can jump to any time, re-render a short interval and compare outputs without replaying a stateful browser animation from the beginning.

Should I use Remotion, HyperFrames or plain HTML?

Use plain HTML for a focused custom film with minimal dependencies, Remotion for reusable React compositions and data-driven series, and HyperFrames for an agent-oriented HTML and GSAP workflow. State the choice explicitly in the brief.

Can I copy the look of a viral reference video?

Study its pacing and design grammar, but create an original identity. Do not copy protected footage, music, logos, characters, product copy or a distinctive branded sequence.

Are the viral examples really one-shot?

Some short reels were reported as one-shot. Other strong examples used long briefs, existing skills, API keys, hours of work and many model calls. Treat iteration as part of the method, not an exception.

How do I prevent generic AI motion-design output?

Use a real reference, real brand assets, an ordered state list, explicit banned defaults, a restricted visual system and repeated contact-sheet critique. A longer adjective list is less useful than better evidence and structure.

Can this replace a professional motion designer?

It automates many production tasks, but professional work still requires concept judgment, typography, rights, accurate product representation, sound, revision strategy, client communication and final accountability. The better framing is a new production system for a skilled director.

--sources and credits