---
title: Motion that reads premium
description: "Eight rules for motion that reads as premium: nothing stops, the camera acts, action overlaps, and imperfection stays reproducible."
---

You can already specify a frame: exact copy, exact colors, exact layout, exact timing. This page makes it move.

But "make it move" is the wrong instruction. Here is why, and what to write instead.

## Every movement makes a claim

Movement says something about the thing that moves. A number that breathes says *this figure is live, it is still counting*. A card that flies in from the right says *it came from somewhere, there is more offscreen*. Overshoot says *this has mass and it arrived eagerly*. A slow, heavy entrance says *this matters*. A jitter says *this is unstable*.

You cannot opt out. Viewers read motion as meaning whether you intended meaning or not. The only question is whether what it says is true.

So the question is not *"does this feel too static?"* It is **"what is this movement saying, and do I mean it?"** A stat card that breathes because the number is live tells the truth. The same card breathing because the frame looked empty tells a live-data story about a static figure, and viewers feel the mismatch even when they cannot name it.

The strongest motion goes further and works as a metaphor for the content. A deployment pipeline should *flow*. A build should *assemble*. A countdown should *tick*, in discrete steps, the way time does. A route should *draw* in the direction of travel. When the movement and the meaning are the same gesture, the graphic stops needing an explanation.

### The mistake this prevents

When a piece feels dead, people add amplitude. More motion is not more meaning. Four decorative movements are worse than one motivated movement. They compete for the eye, none of them says anything, and the result reads busy rather than alive.

If a shot feels lifeless, find the one thing that genuinely *is* changing and let that carry the frame. Do not set everything else wobbling.

Here is the test. Name what each movement means, in a sentence that ends. *"The counter breathes because it's still receiving data."* If you cannot finish the sentence, cut the movement.

### What a movement can honestly be doing

Four jobs cover almost everything.

- **Direct attention.** Motion pulls the eye to the thing that matters this second — a count landing, a line igniting.
- **Carry continuity.** Motion ties one moment to the next, so the piece reads as one space instead of a stack of slides.
- **Show change.** Motion *is* the information — a value rising, a diff resolving, a route drawing.
- **Express character.** Motion carries the brand's temperament, snappy and confident or calm and editorial.

A movement doing none of those is decoration. Decoration is what makes a video read as cheap, no matter how smooth the easing is.

Product-UI motion frameworks name a fifth job, *feedback*, which confirms a user's action. Video has no user input, so it does not apply here.

## The eight rules

Once a movement has something to say, these rules make it read well. They govern *execution*. None of them is a reason to add a movement that has no job.

1. Nothing ever fully stops.
2. The camera is an actor.
3. Overlapping action.
4. Compound properties only when they tell one story.
5. Overshoot and follow-through.
6. Depth planes.
7. Match pacing to genre.
8. Handmade imperfection stays reproducible.

Each rule below comes with one A/B pair and the prompt that produces each half. Both halves come from the same base composition — same content, palette, layout and timing. The two prompts are the only difference, so you can see what the words buy.

Each subject makes its rule *unavoidable*. A live feed that freezes reads as a broken connection. A pipeline wider than the frame forces the camera to move. A split-flap board cannot stop dead, because it has mass.

The values are pushed far enough to read in a six-second loop. Even so, every movement in the applied half can finish the sentence "this moves because…". Copy a number here without finishing that sentence and you copied the exaggeration, not the rule.

### Rule 1 — Nothing ever fully stops

Every "hold" carries a little ambient idle motion — a 1-2% breathing scale, a slow drift, a shimmer. Never write "holds motionless." Write "settles into a gentle ambient idle." A frozen final second is the single biggest cheap-motion tell.

❌ **Without**

> 6-second 1920x1080 live telemetry panel: an `ARR · LIVE` eyebrow with a status dot, `PROD · US-EAST-1` opposite, `$4.200M` at display scale with a delta chip, a sparkline of the reading history beneath, and a footer row reading `LAST SYNC` and `READINGS`. The panel rises in and lands by 1.9s, then holds motionless to the end — the dot stops, the figure freezes, the sparkline stops extending, the footer stops updating.

✅ **With**

> 6-second 1920x1080 live telemetry panel: an `ARR · LIVE` eyebrow with a status dot, `PROD · US-EAST-1` opposite, `$4.200M` at display scale with a delta chip, a sparkline of the reading history beneath, and a footer row reading `LAST SYNC` and `READINGS`. The panel rises in and lands by 1.9s, then stays alive because the feed is — a new reading arrives every 300ms and each one moves exactly what it should: the last digits change, the sparkline extends one segment with its leading dot, `LAST SYNC` restamps, `READINGS` increments. The status dot keeps a 1s heartbeat because the connection is up. Nothing else moves. Fix the sparkline's y-scale up front so an arriving reading never rescales the axis.

<video controls muted loop playsinline preload="metadata" src="https://static.heygen.ai/hyperframes-oss/docs/images/prompting/motion-rule1-nothing-stops.mp4#t=0.1" style={{ borderRadius: "0.5rem", marginTop: "0.75rem" }}></video>
*Left `WITHOUT`, right `WITH`. From 2.0s the left half's remaining 120 frames all share a single hash. All 180 frames on the right are distinct. Every movement on the right answers "because": the dot beats because the connection is up, the digits change because a reading arrived, the sparkline extends because that reading is now history.*

*The footer is the clearest tell. The frozen half reads `LAST SYNC 09:41:21.75 · READINGS 22`. The live one reads `09:41:23.95 · 30`. A still frame of the left half looks like a perfectly good stat card. Sit it next to a running one and you can read exactly how long the feed has been dead. That is what a frozen hold tells a viewer, whether you meant it or not.*

### Rule 2 — The camera is an actor

Give each scene one continuous camera move. A 4-8% push-in, a slow orbit, or parallax — nearer layers travelling further than distant ones. Ease it gently, and never let it *decay* to a dead stop at the end of a scene. Compute the ease over a window slightly longer than the render.

The reason is not that stillness looks cheap. A move is what carries the **spatial relationship** between two shots. A cut or a cross-fade throws that away, so two views of one system read as two unrelated pictures. Move to get somewhere and the audience infers one continuous space for free.

Beware the corollary. Translating the scene and translating the camera are the *same transform*. "The content slid past a fixed frame" is not a static alternative. It is the same shot.

A deliberate mid-film rest is a different thing, and it is sanctioned. See [avoiding the slideshow](#avoiding-the-slideshow).

❌ **Without**

> …an isometric deploy pipeline of five stages, each with its own accent colour — `SOURCE` mint, `BUILD` cyan, `TEST` violet, `DEPLOY` amber, `EDGE` rose — bolted along a rail with support posts and numbered floor bays. The block at each stage and its card wear the same colour. **The camera never moves.** Stack all five stages on the same centred spot and cross-fade between them: the current card fades out as the next fades in already coloured, and the block beneath it changes to that colour. No wire and no work in transit. Nothing in the frame changes position at any point.

✅ **With**

> …an isometric deploy pipeline of five stages, each with its own accent colour — `SOURCE` mint, `BUILD` cyan, `TEST` violet, `DEPLOY` amber, `EDGE` rose — bolted along a rail with support posts and numbered floor bays. The block at each stage and its card wear the same colour. Lay the stages out where they really are, 640px apart across 2.5 frame widths, and **move the camera** across the whole run in one continuous linear pass, `ease: none`. The floor and rail travel with the camera 1:1 because they are the same space; distant structures track at a fifth. A packet of work runs the wire and ignites each stage in its colour as it reaches it, so a stage is revealed by arriving at it rather than by appearing.

<video controls muted loop playsinline preload="metadata" src="https://static.heygen.ai/hyperframes-oss/docs/images/prompting/motion-rule2-camera-actor-v2.mp4#t=0.1" style={{ borderRadius: "0.5rem", marginTop: "0.75rem" }}></video>
*Left `WITHOUT`, right `WITH` — same five stages, same colours, same six seconds. On the left the block never leaves the centre of frame: five stages, one place. On the right you travel to each one, and neighbours stay visible on the way, so the five read as five points along a single run. Watch the amber `DEPLOY` block still sitting behind frame-left as the camera settles on rose `EDGE`. That adjacency is information, and a dissolve does not carry it.*

*One trap is worth knowing. Earlier versions of this demo had the locked half slide the content past a fixed frame, then step it, then freeze the backdrop. Every one looked identical to the pan, because it was — measured, 3% of pixels differed. Only refusing to move at all produces the 30–47% you see here.*

### Rule 3 — Overlapping action

No two elements share a start time or an end time. Stagger entrances at irregular offsets. Begin the next element while the last is still settling.

The mechanism is a ratio. **Each offset should be clearly shorter than the animation it offsets.** A small offset-to-duration ratio reads fluid. A large one reads deliberate. An offset longer than the animation stops being a stagger and becomes a queue.

Delay the *supporting* elements, never the focal one. A focal element that waits reads as lag.

Stagger what is **happening**, not what is merely **present**. Things that arrive in sequence should animate in sequence. A set of things that already existed before the shot started should appear together. Staggering those just makes the scene take longer to assemble.

❌ **Without**

> …`Rolling out to every region` over a dotted world map with twelve edge regions marked and a live `n / 12` tally. A progressive rollout takes each region live: the region's core ignites, its dot field turns mint, and the tally counts. All twelve ignite at the same moment, 0.5s each.

✅ **With**

> …`Rolling out to every region` over a dotted world map with twelve edge regions marked and a live `n / 12` tally. A progressive rollout spreads outward from `us-east-1`, reaching each region in order of its distance from the origin, 0.09s apart: a link draws from the nearest already-live region and lands exactly as that region's core ignites, its dot field turns mint, a ping carries onward and an ACK dash returns up the link. Each region's 0.5s ignite is still running when the next three begin.

<video controls muted loop playsinline preload="metadata" src="https://static.heygen.ai/hyperframes-oss/docs/images/prompting/motion-rule3-overlapping-action.mp4#t=0.1" style={{ borderRadius: "0.5rem", marginTop: "0.75rem" }}></video>
*Left `WITHOUT`, right `WITH` — twelve distinct ignition frames on the right, 0.088s apart, against a single frame on the left. At peak, all twelve regions are animating at once.*

*Stagger here is not a styling preference. A rollout propagates, so twelve regions cannot go live on the same frame. The simultaneous version says something untrue about the system. Watch the tally: the left jumps `0 → 12` in one frame, and the map gives you no way to tell where the rollout started.*

*Note what is **not** staggered. The twelve region markers all appear on the same frame in both halves, because the regions already existed.*

### Rule 4 — Compound properties only when they tell one story

Every animation changes at least one property — position, scale, opacity, rotation. Combining them works when they say the same thing. A confirmation that slides up *and* fades in reads as one idea: this is arriving. A sheet that rises *and* rotates makes two unrelated claims about one object. Pick the properties that serve the movement's job and drop the rest.

Direction follows the same logic. Entrances ease **out** — fast in, gentle settle, because the object arrives. Exits ease **in** — gentle start, decisive departure. On-screen moves ease **in-out**. Impacts like a stamp or a slam ease **in**, because an impact is an acceleration.

❌ **Without**

> …an itemized coffee-shop receipt; a payment-confirmation sheet rises 470px over 1.2s to cover its lower half while simultaneously rotating in from 18°, scaling up from 0.8, and un-blurring from 14px. The receipt dims behind it. The sequence plays twice.

✅ **With**

> …an itemized coffee-shop receipt; a payment-confirmation sheet rises 470px over 1.2s to cover its lower half while fading up from 0. Rotation, scale and blur are never touched. The receipt dims behind it. The sequence plays twice.

<video controls muted loop playsinline preload="metadata" src="https://static.heygen.ai/hyperframes-oss/docs/images/prompting/motion-rule4-compound-properties.mp4#t=0.1" style={{ borderRadius: "0.5rem", marginTop: "0.75rem" }}></video>
*Left `WITHOUT`, right `WITH` — identical travel (470px), identical window (0.25s → 1.45s), identical ease. The only difference is how many properties ride along. Both halves are pixel-identical at rest, so everything you see mid-flight is the cost of the extra three. On the left, "Payment confirmed" is an unreadable tilted smear for most of its arrival. On the right it is legible the whole way up. Two properties agreeing on one claim beat four properties each making a different one.*

### Rule 5 — Overshoot and follow-through

Overshoot is a claim about mass. A thing with weight passes its target and settles back. The parts it drags — a shadow, a trailing panel, the housing it lands in — resolve a beat *after* it does, not with it. That one-frame lag is what sells the weight. Perfectly synchronized "follow-through" is just a bigger single object.

Apply it to **transforms only**. A number is not a physical object. A counter must never fly past its value and fall back. That renders a figure that was never true, and on a real metric it is a lie with a frame count.

❌ **Without**

> …a bolted airport departure board, `HF 402 · SAN FRANCISCO`, its split-flap gate cells riffling to **42**. The flap plates drop 34px and rotate from −16° straight to their final position and stop. Linear throughout, no overshoot, and the cast shadow moves locked to its plate. The sequence plays twice.

✅ **With**

> …a bolted airport departure board, `HF 402 · SAN FRANCISCO`, its split-flap gate cells riffling to **42**. The flap plates drop 34px and rotate from −16° on `back.out(5)`, swinging past their rest position and settling back; the housing recoils ~7px when they land, and each plate's cast shadow reaches its own peak one frame later than the plate that casts it. Transforms only — the gate number never overshoots **42**. The sequence plays twice.

<video controls muted loop playsinline preload="metadata" src="https://static.heygen.ai/hyperframes-oss/docs/images/prompting/motion-rule5-overshoot.mp4#t=0.1" style={{ borderRadius: "0.5rem", marginTop: "0.75rem" }}></video>
*Left `WITHOUT`, right `WITH` — the right's plates swing 1.51× past their travel before settling, while every transform on the left has peak == final. The shadow's lag is measured at 0.033s, exactly one frame at 30fps. Note the one thing that does **not** overshoot on either side: the number itself tops out at 42 and stays there. A counter that flies to 47 and falls back is reporting a number that was never true.*

### Rule 6 — Depth planes

Move each plane at a rate that matches its distance. Far background at a fraction of the camera's rate, content at full rate, foreground at several times.

The cue that does the most work is not blur. It is **occlusion** — one thing passing in front of another. A single large, heavily blurred foreground element that actually crosses in front of your content proves there is space between them. No amount of blur on an element that never overlaps can do that. Prefer one such element. A second stops reading as the room and starts reading as decoration.

❌ **Without**

> …a render-farm corridor: CSS-3D floor and ceiling converging on a single vanishing point, a bank of server racks with blinking status LEDs, a distant rack row near the horizon, and one rack column close to the lens. `CLUSTER 04 · WEST / Every frame, in parallel.` on a camera-locked HUD panel. The camera trucks forward for the full 6s. Every plane drifts at the same rate and nothing is blurred.

✅ **With**

> …a render-farm corridor: CSS-3D floor and ceiling converging on a single vanishing point, a bank of server racks with blinking status LEDs, a distant rack row near the horizon, and one rack column close to the lens. `CLUSTER 04 · WEST / Every frame, in parallel.` on a camera-locked HUD panel. The camera trucks forward for the full 6s and each plane drifts at its own distance: the horizon row at a fifth of the room's rate, the room and its racks at full rate, and the near column sweeping past at six times — `blur(22px)`, close enough to cross in front of the headline. Haze the far plane slightly.

<video controls muted loop playsinline preload="metadata" src="https://static.heygen.ai/hyperframes-oss/docs/images/prompting/motion-rule6-depth-planes.mp4#t=0.1" style={{ borderRadius: "0.5rem", marginTop: "0.75rem" }}></video>
*Left `WITHOUT`, right `WITH` — measured travel ratios on the right are exactly 0.20× / 1.00× / 6.00×, while on the left all five planes displace an identical 240px with `filter: none`. The strongest cue is not the blur, it is the occlusion: the near column crosses in front of the headline for about a third of the shot, which is only possible if it is in the room. One foreground element does this. A second would just be clutter with a blur on it.*

### Rule 7 — Match pacing to genre

Showreel-style cuts run 1.5-4 seconds per idea. A stretched 8-second version of a 2-second idea feels slow, no matter how it is animated.

❌ **Without**

> …a three-beat product showreel, each beat a titled panel with its own live evidence: `SEEK ANY FRAME` over a scrubbing timeline reading out frame 147, `RENDER ON LAMBDA` over six worker lanes filling their own frame ranges, `SHIP THE MP4` over a player with an encode bar. 2 seconds per beat, dissolving between them, filling the full 6s runtime. A rail under each half tracks time consumed and time spare.

✅ **With**

> …a three-beat product showreel, each beat a titled panel with its own live evidence: `SEEK ANY FRAME` over a scrubbing timeline reading out frame 147, `RENDER ON LAMBDA` over six worker lanes filling their own frame ranges, `SHIP THE MP4` over a player with an encode bar. Showreel pace — 1.1 seconds per beat, cutting hard rather than dissolving, all three delivered by 3.3s, then hold the last beat on a live idle. A rail under each half tracks time consumed and time spare.

<video controls muted loop playsinline preload="metadata" src="https://static.heygen.ai/hyperframes-oss/docs/images/prompting/motion-rule7-pacing.mp4#t=0.1" style={{ borderRadius: "0.5rem", marginTop: "0.75rem" }}></video>
*Left `WITHOUT`, right `WITH` — same three ideas, same evidence, same 6 seconds. At 3.6s the left is still working through beat 2 with `SPARE 0.00`. The right has already delivered all three and banked `+0.33s`. The left is not badly animated. It is correctly animated at the wrong tempo, which is why this failure survives review so often. Pace is a genre decision you make before you touch an ease.*

### Rule 8 — Handmade imperfection stays reproducible

A stop-motion or hand-animated feel wants irregular timing, not machine-smooth eases. But true unseeded randomness breaks the render. HyperFrames must produce the identical frame every time it seeks to the same point, and `Math.random()` cannot promise that.

Instead, seed a PRNG once at composition start. A PRNG is a pseudo-random number generator: a formula that returns the same "random" sequence every time from the same starting number. Then step discrete elements between held positions rather than tweening continuously between them. A "two-frame hold" means land, hold two frames, jump to the next offset. The irregularity is real. It just comes from a seed, not from chance.

❌ **Without**

> …a hanging paper mobile: five cut-paper shapes on fine visible wires from a wooden dowel, each with real paper grain, irregular hand-cut edges and its own layered drop shadow. They sway through a ±12° arc with smooth continuous tweens. A readout shows the current frame and how many distinct states the six seconds contain.

✅ **With**

> …a hanging paper mobile: five cut-paper shapes on fine visible wires from a wooden dowel, each with real paper grain, irregular hand-cut edges and its own layered drop shadow. They sway through the same ±12° arc, but driven by a mulberry32 PRNG seeded once at composition start and stepped on a two-frame hold quantized to the integer frame index — so the cadence is stop-motion, not a tween, and every render is byte-identical. A readout shows the current frame and how many distinct states the six seconds contain.

<video controls muted loop playsinline preload="metadata" src="https://static.heygen.ai/hyperframes-oss/docs/images/prompting/motion-rule8-seeded-handmade.mp4#t=0.1" style={{ borderRadius: "0.5rem", marginTop: "0.75rem" }}></video>
*Left `WITHOUT`, right `WITH` — the right holds each pose for exactly two frames: 90 states across 180 frames, no irregular holds, while the left has 180 distinct ones. Rendered twice, the whole thing came back byte-identical both times. This rule is easy to get wrong in the other direction. Reaching for `Math.random()` to buy the same irregularity produces a composition that renders differently every time and can never be re-rendered or resumed.*

[Handmade, still deterministic](#handmade-still-deterministic) below has a fuller prompt for this, plus the one trap that catches people.

## The grammar, measured

The same composition built twice. Identical content, identical layout, and the motion treatment as the only variable. The first build commits the anti-patterns above: simultaneous identical entrances, no camera, a frozen final 2.4 seconds. The second applies the eight rules.

<video controls muted loop playsinline preload="metadata" src="https://static.heygen.ai/hyperframes-oss/docs/images/prompting/motion-before.mp4#t=0.1" style={{ borderRadius: "0.5rem", marginTop: "0.75rem" }}></video>
*Every anti-pattern: tiles enter together, nothing overlaps, the last seconds are a freeze-frame.*

<video controls muted loop playsinline preload="metadata" src="https://static.heygen.ai/hyperframes-oss/docs/images/prompting/motion-after.mp4#t=0.1" style={{ borderRadius: "0.5rem", marginTop: "0.75rem" }}></video>
*The eight rules: staggered overshoot entrances, a continuous 5% push, ambient idle, a blurred foreground plane, sparkline draw-ins as secondary motion.*

The difference is measurable, not just visible. In the final second the frozen build has bit-identical consecutive frames, while the motion-grammar build changes every single frame. The encoder agrees: 211KB against 2.5MB for the same content. A frozen final second is the cheap-motion tell you can test for.

## Avoiding the slideshow

The eight rules govern motion *inside* a scene. Apply all eight, cut between scenes, and you can still end up with a slideshow — a run of well-animated cards that happen to play in order. It is the most common note on multi-scene work.

A slideshow is two failures at once. The scenes are *independent*, so nothing connects one to the next. And they are *uniform in energy*, so nothing tells you which moment matters. Any fix has to supply two properties:

1. **Something crosses the boundary.** Consecutive scenes need a shared element, space, or motion the eye can follow through the transition. Otherwise the viewer re-orients at every seam and reads slides.
2. **The energy varies.** The piece needs quiet against which a hero moment can register. Uniform motion is as flat as no motion. Emphasis is a *contrast* effect.

Ask for those two properties, not for a specific device. The rebuild passes on the [Level 7 film](/prompting/capstone), after its slideshow diagnosis, are what taught us this. Neither fix was more animation.

### One method: a continuous world-camera

The capstone treats the whole film as a single wide space the camera travels across. Three elements never leave frame, and the camera keeps a dwell-and-sweep rhythm.

For property 1, "no hard cuts" was not enough on its own. The first rebuild honored it and still played as slides, because each region faded up centered, sat, and faded out while the camera politely waited. What worked was naming the things that survive the boundary:

- **Persistent elements.** A wire that becomes the chart baseline, then the map arc, then the waveform, then the 3D coil. Plus a frame-ruler and a protagonist chip.
- **Arrivals instead of cuts.** The next region is already at the edge of frame before the camera reaches it, and the previous one exits by parallax.
- **A negative that names the tell.** Agents default to the slideshow because it is safe, so forbid it explicitly.

For property 2, the second rebuild fixed continuity and broke emphasis. The camera never stopped, so every hero moment landed mid-sweep and got thrown away. The fix was a **dwell**: a genuine full stop of 1.5–2.5 seconds while the point lands.

Two details keep a dwell consistent with the rules above. During a dwell the **camera** rests but the **film** does not — counters keep ticking, labels keep stamping. Say that, or you trade a slideshow for a freeze-frame. And a dwell is a rest the piece resumes from, not the decayed settle rule 2 guards against.

<Note>
**Capstone thread** — this is the method the [Level 7 film](/prompting/capstone) uses, and the reason it reads as a film instead of nine demos in a row.
</Note>

This is the clause in the [full capstone prompt](/prompting/capstone#the-prompt-word-for-word) that buys both properties — prompt language you can lift for your own video:

> ONE continuous camera journey with a dwell-and-sweep rhythm. The whole film is a single wide world (one large scene space) that the camera dollies across […] in one unbroken move with NO hard cuts anywhere except inside the two sanctioned seam moments named below. The rhythm: the camera SWEEPS between regions, then eases to a genuine REST at each region's hero moment — a full stop of roughly 1.5–2.5 seconds while the main point lands […] then accelerates away. The dwell is what gives the sweep meaning: without the rest, emphasis dies mid-motion. During a dwell the WORLD keeps resolving (counters tick, labels stamp, secondary motion continues) — the camera rests, the film never freezes.

<video controls muted loop playsinline preload="metadata" src="https://static.heygen.ai/hyperframes-oss/docs/images/prompting/capstone-region-camera.mp4#t=0.1" style={{ borderRadius: "0.5rem", marginTop: "0.75rem" }}></video>
*That clause, rendered: accelerating out of one region, arriving in the next, stopping to let the beat land — no cut anywhere in the span.*

This method is expensive. One continuous space is more work to author than a cut, and it only pays when the piece has a through-line worth following. For a 6-second stat card, cut.

### Other methods worth trying

Each of these supplies both properties by different means. They also compose — a beat grid pairs happily with a hero prop.

| Method | How it crosses the boundary | Where the emphasis comes from |
| --- | --- | --- |
| **Match cuts** ([Transitions](/prompting/transitions)) | Cut freely, but on a shared shape, color, or motion vector, so the eye carries a form through the seam | Break the rhyme deliberately at the moment that matters |
| **A hero prop** ([Storyboards](/prompting/storyboards)) | Cut the environment, keep one object continuously on screen — the product, a chart, a character | Push in on the prop and still everything else around it |
| **A persistent frame** | Scenes change *inside* a frame that never does — a HUD, a ruler, a browser shell, a border | Let the chrome fall away for one beat. Its absence is the accent |
| **Audio as the spine** ([Media and audio](/prompting/media-and-audio)) | One unbroken sentence or musical phrase crosses the cut, so the ear ties what the eye did not | A rest in the audio — a held note, or a beat of silence before the number lands |
| **Beat-locked cutting** | Cuts land on an analyzed grid, so the rhythm itself is the connective tissue ([Music](/prompting/music-and-slideshows)) | Hold through a downbeat, or drop a hit, so one card gets twice the space |
| **Accumulation** ([Storyboards](/prompting/storyboards)) | Nothing ever exits. Each scene adds to one canvas and the frame reflows to the new material | Everything but the newest element quiets to a low idle |

Whichever you choose, put the two properties in the prompt in your own words, and name the tell you are forbidding. The device is negotiable. The properties are not.

## Handmade, still deterministic

Rule 1's ambient idle is *continuous* — a slow, smooth breathing scale. Rule 8 is a different tool for a different job. When the brief wants something that reads as physically hand-animated (paper cutouts, stop-motion, a wobbly hand-drawn line), continuous easing is the wrong texture. It reads as digital no matter how organic the curve. What you want is irregular, but reproducible:

> A paper-cutout garden scene: flowers, leaves, and a bee drifting on visible wires, like stop-motion. Seed a random offset per element at the start (same seed every render) so each leaf sways to a slightly different rhythm, but hold each position for exactly two frames before stepping to the next — discrete jumps, not a smooth tween. It should read as intentionally handmade, not glitchy.

<video controls muted loop playsinline preload="metadata" src="https://static.heygen.ai/hyperframes-oss/docs/images/prompting/motion-handmade.mp4#t=0.1" style={{ borderRadius: "0.5rem", marginTop: "0.75rem" }}></video>
*Rendered from the prompt above, unedited — paper cutouts on visible wires, every position held for exactly two frames, and byte-identical across two separate renders.*

Name the seed and the hold length explicitly. "Seeded" and "two-frame hold" are the two phrases that keep an agent from reaching for `Math.random()` and quietly breaking every re-render.

<Warning>
  **Ask for the hold in frames, not seconds.** Validating this prompt surfaced a real trap. Quantizing the hold in the *time* domain (`Math.floor(t / 0.0667)`) produces irregular holds — a three-frame group here, a one-frame group there. That happens because the renderer's seek times do not land on exact 1/30-second doubles, so the arithmetic drifts across step boundaries. Quantize on the integer frame index instead (`Math.floor(Math.round(t * fps) / 2)`), which tolerates any seek error under half a frame. The visible symptom is a stop-motion cadence that stutters unevenly instead of ticking. It is worth naming in the prompt: "hold each position for exactly two frames, quantized on the frame index." Note also that a hold specified in frames is tied to the composition's fps, so re-rendering at a different frame rate changes the hold's duration.
</Warning>

Ask for it, and seeking to frame 214 twice gives you the identical frame twice, exactly like every other HyperFrames render. The imperfection is designed in, not left to chance.

Unseeded randomness is the obvious way to break a cold render. A handful of lint rules catch subtler seek-order mistakes in GSAP, the animation library HyperFrames drives:

- a relative tween colliding with another writer
- `repeatRefresh` combined with a relative value
- function-valued tween vars
- DOM measurement inside timeline callbacks

See the [seek-order safety rows](/prompting/rules-and-anti-patterns#seek-order-safety) in the appendix if the linter ever flags one.

*Next: [Transitions](/prompting/transitions) — the same grammar applied to the cut between scenes, not just the motion inside one.*

## Related topics

- [Transitions between scenes](/prompting/transitions)
- [The Level 7 capstone film](/prompting/capstone)
- [Rules and anti-patterns](/prompting/rules-and-anti-patterns)
- [Plan scenes with a storyboard](/prompting/storyboards)
