PTENES
MODULE 4.2

🔁 Iteration That Builds Quality

The best Remotion outputs aren’t first-prompt masterpieces—they’re simple skeletons refined 3-4 times in the same conversation. Quality is cumulative.

6
Topics
30
Minutes
Advanced
Level
Process
Type
1

Turn 1: the basic skeleton

The first prompt should ask for just the structure. Elements in the right place, correct text, without worrying about timing, easing, or aesthetics. The goal of Turn 1 is to validate the composition — whether the elements are in place and the sequence makes sense.

sample prompt — Turn 1
Create a product intro animation in Remotion. Elements: logo in the center, then title, then subtitle. Don’t worry about easing or timing right now — I just want to see the elements in the right place.

💡 Why start simple?

If you ask for timing and aesthetics in Turn 1 and the composition is wrong, you waste time refining something that will be redone. Approve the skeleton first, then add layers.

Elements in place
Correct sequence
No easing yet
Validate the composition
2

Turn 2: add timing

With the composition approved, Turn 2 is about timing and sequence. How long each element stays on screen, when it enters, when it exits, and the delay between elements. Claude remembers the entire structure from Turn 1 and applies the timing to it—it doesn’t start from scratch.

sample prompt — Turn 2
Now add timing: logo appears at 0-1s, title enters at 1.5s, subtitle at 2.5s. Total of 5 seconds. Use easing ease-out for the inputs.

✓ What to specify in Turn 2

  • Total video duration
  • Entry/exit timestamps for each element
  • General easing (ease-in, ease-out, linear)
  • Delays between elements

✗ What to leave for later

  • Overshoot and spring (Turn 3)
  • Advanced stagger (Turn 3)
  • Colors and gradients (Turn 4)
  • Shadows and glow (Turn 4)
Exact timestamps
Base easing
Delays
Same session
3

Turn 3: refine the motion

With the timing approved, Turn 3 adds expressiveness in motion. This is where the animation gains personality—overshoot, spring, asymmetric stagger between elements. Subtleties that make the difference between "functional" and "fluid".

live demo 4 turns → animation evolution
static
+ timing
+ spring
polished
Turn 1
Turn 2
Turn 3
Turn 4

The same animation evolves in a loop—from the static structure to the final polish.

💡 Spring vs. ease-out

Spring adds natural overshoot — the element “passes” its destination and comes back. Ease-out simply slows down. For product animations, spring tends to feel more alive and less mechanical.

Overshoot
Spring physics
Asymmetric stagger
Expressiveness
4

Turn 4: final polish

Turn 4 is the finishing touch. Final colors, typography, gradients, shadows, glow. What turns "works" into "impressive." It only makes sense once the motion has been approved in the previous turns.

live demo cumulative quality per turn
Turn 1 — skeleton 25%
Turn 2 — timing 50%
Turn 3 — motion 75%
Turn 4 — polish 100%

Each turn builds on the previous one — quality isn’t replaced; it’s built.

Final colors
Typography
Gradients
Glow / shadow
5

The “no one-shot” rule

A single long, detailed prompt rarely beats 4 incremental prompts in the same session. Why? Because it's impossible to perfectly describe in words something you haven't seen yet. You need to see the skeleton to know what to change.

One-shot average result 1 attempt = fixed result vs Iteration (4 turns) T1: skeleton T2: timing T3: motion T4: polish ✓ optimal result

✗ One-shot

  • Long prompt full of requirements
  • Claude tries to do everything at once
  • Mediocre result that doesn’t impress
  • Difficult to fix without redoing everything

✓ 4 Turns

  • Each turn focuses on one dimension
  • Approves each layer before advancing
  • Great result that impresses
  • Easy to adjust: only the relevant turn changes
One-shot = medium
4 turns = great
Start with the minimum
Build on approved work
6

Context that shapes quality

Claude remembers all the code generated in the session. Each turn builds on the approved state—it doesn’t start from scratch. This means the quality is cumulative, not replaced. That’s why the same session produces a better result than separate sessions.

T1

Basic skeleton

Structure created. Claude keeps all the code in session memory. You approve the composition.

T2

+ Applied timing

Claude reads the T1 context and adds the timing about the structure. The skeleton stays intact; only the timing is new.

T3

+ Expressive motion

Spring, overshoot, and stagger added to the T1+T2 state. None of the previous layers are lost.

T4

= Polished result

Colors, typography, and glow applied to T1+T2+T3. The final result includes all the layers accumulated during the session.

💡 Separate sessions break the flow

If you start a new session in Turn 2, Claude has no context from T1. You lose the accumulated memory. Always keep all 4 turns in the same conversation to make use of the cumulative context.

Context persists
Cumulative quality
Same session
4 layers = great

Module summary

✓
4 turns, not 1 — skeleton → timing → movement → polish. Each turn focuses on one dimension.
✓
Approve before advancing — validate each layer before asking for the next. This avoids rework.
✓
Same session — the cumulative context is what makes the 4 turns effective. Don’t start new sessions midway.
✓
One-shot produces a medium result — incremental iteration produces an excellent result. Always start with the minimum.
✓
Cumulative quality — each turn builds on the previous one; nothing is lost, everything is built up.

Next module:

4.3 — Recap & final map: the complete library matrix, the 4 universal rules, and why this is production now.