All thoughts

Motion Engineering: The Studio Matters More Than the Prompt

A model can make one good video. Getting the tenth one better than the first takes a system built around it.

How it works

One video run, and what it leaves behind for the next one1. Brief: goal, audience, length. 2. Storyboard: scenes as a spec. 3. Motion code: scenes in React. 4. Render: frames to MP4. 5. Check: style guide and rules (highlighted). 6. Human GO: I approve (highlighted). 7. Library: scenes and brand tokens. 01Briefgoal, audience,length02Storyboardscenes as a spec03Motion codescenes in React04Renderframes to MP405Checkstyle guide andrules06Human GOI approve07Libraryscenes and brandtokens
Select a step to see what it does.
The two gold steps are where quality is decided: an automatic check against the style guide, then my GO. Whatever passes goes into the library and starts the next video ahead.

Video as code

Tools like Remotion treat a video as a React component. Each frame is the component drawn at a given frame number, and timing, easing and layout are plain code. That matters for AI, because a model is much better at writing and fixing code than at pushing pixels in a timeline editor. HyperFrames takes a similar path with HTML, and ffmpeg handles the last mile: trimming, joining, encoding.

A spec before any frames

The brief becomes a storyboard written as data: each scene, how long it runs, what text it shows, which brand pieces it uses. The model writes the motion code from that spec, not from a loose paragraph. When something looks wrong, I fix the spec or the scene, and the next render follows.

The check

After a render, two kinds of checks run. Code checks are fast and exact: is the length right, are the colors from the brand set, is text inside the safe area, does every scene have a clean start and end. Then a model looks at sampled frames against a written style guide and lists what's off, like crowded text or motion that's too fast to read. Anything that fails goes back to the code step with that feedback.

The human GO

Nothing ships without me watching it. The check catches the rule-breaking stuff. I catch whether it actually says the right thing.

The library

This is the part people skip. Every approved scene becomes a reusable piece: a title card, a chart reveal, a lower third, all tied to brand tokens like colors, fonts and timing. The next brief starts by pulling from that shelf, so the model writes less from scratch and makes fewer of the old mistakes.

My take

I run my agent work the same way: a loop, a check, a person at the gate, and a memory that makes the next run cheaper. Motion is just a very visible version of that. You can see right away when the system is missing, because the second video looks nothing like the first.

The models are good now. Asking them for one clip and getting something nice is easy. What I care about is the fifth and fiftieth clip looking like they came from the same studio. That comes from the spec, the style guide, the check and the library, not from a cleverer prompt. It's the same split I wrote about in Generator vs Evaluator: one part makes, a separate part judges.

There's also a new wave of open-source, editor-style tools, like the FilmCraft and EffectCraft projects. They're early and changing fast, so I'd treat them as building blocks inside a sandbox, not as the studio itself. The studio is the loop around whatever tool you pick.

An idea I want to try next: score every approved video against the style guide and track it over time. If the library is working, that number should climb and the number of fix rounds should drop.

Try this

  1. Write a one-page style guide for your videos: colors, fonts, how long text stays on screen, how fast things move. Give it to the model with every request.
  2. Save the next scene you like as its own reusable component with your brand colors as variables. Start the next video from it.

A style guide to start from

Copy this, swap in your own values, and hand it to the model with every brief.

brand:
  colors:
    bg: "#0B0B0F"
    text: "#F5F3EE"
    accent: "#C9A227"
    muted: "#8A8A93"
  fonts:
    heading: "Inter, 700"
    body: "Inter, 400"
    mono: "JetBrains Mono, 400"
text:
  min_on_screen_seconds: 2.5
  max_words_per_card: 8
  max_lines_per_card: 2
motion:
  default_easing: "ease-in-out"
  enter_ms: 400
  exit_ms: 300
  max_moving_things_at_once: 2
layout:
  safe_area_percent: 90
  aspect_ratios: ["16:9", "9:16", "1:1"]
scenes:
  start: "fade or slide in from empty"
  end: "hold 0.5s, then fade out"
  no_hard_cuts_mid_text: true

Check checklist

Code checks, run on every render:

  • Length matches the brief, within a second.
  • Only brand colors from the token list appear.
  • All text sits inside the safe area.
  • Every text card stays up at least the minimum time.
  • Each scene starts and ends cleanly, no frozen or half-drawn frames.
  • Audio peaks stay under your set level, no clipping.

Model checks, on sampled frames:

  • Text is not crowded or hard to read.
  • Motion is not too fast to follow.
  • The look matches the style guide, nothing off-brand.
  • The video actually says what the brief asked for.

Sources