Animation Duration Rules in video-use: Guidelines for Timing Overlays

Video-use enforces soft duration guidelines—specifically 3–14 seconds for narration-synced animations, 0.5–2 seconds for beat-synced accents, and mandatory ≥1 second final frame holds—rather than hard-coded length limits.

These rules live in SKILL.md and propagate through the entire rendering pipeline, from LLM planning to final video assembly. Understanding how video-use handles animation timing helps you create overlays that feel natural and professional.

Core Duration Guidelines in video-use

The video-use repository, developed by browser-use, structures animation timing around communication purpose rather than arbitrary seconds. The guidelines in SKILL.md serve as a contract between the LLM planner and the rendering engine.

Sync-to-Narration: 3–14 Seconds

Animations that explain spoken content need time to be absorbed at normal reading speed. The typical range spans 3 seconds to 14 seconds, with simple information cards landing in the 5–7 second sweet spot.

This rule directly shapes the duration field in the EDL. In helpers/render.py (lines 498–503), each overlay entry carries this value, and the pipeline trims or pads clips to match.

Beat-Synced Accents: 0.5–2 Seconds

For fast-paced montages or music-driven sequences, animations function as visual punctuation rather than information delivery. These flash quickly—half a second to two seconds—creating rhythm without demanding attention.

Mandatory Hold Final Frame: ≥1 Second

Every animation must display its final frame for at least 1 second before the next cut begins. This prevents jarring transitions and gives viewers mental closure. The Manim example below demonstrates this with self.wait(1.0).

Over Voice-Over: Narration Length + 1 Second

When audio narration accompanies an animation, total duration must equal spoken length plus 1 second. This buffer guarantees the voice completes before visual transition, avoiding the common error of cutting mid-sentence.

One-Thing-At-A-Time Rule

Never reveal two independent visual elements simultaneously. The human eye tracks single new objects; overlapping introductions create confusion. The animation should focus, pause, transition—sequential revelation only.

Payoff Timing for Narrative Beats

When an animation illustrates a specific "payoff" word in narration, scheduling requires special handling. Start the reveal reveal_duration seconds earlier so the final frame aligns precisely with the spoken payoff word, creating synchronized impact.

How the Rendering Pipeline Enforces Durations

These guidelines are soft rules—recommendations for the LLM—not engine-enforced hard limits. The actual enforcement happens through data flow:

EDL Duration Field in helpers/render.py

The rendering engine reads planned durations from the Edit Decision List:

# Example EDL structure from helpers/render.py

edl = {
    "overlays": [
        {
            "file": "edit/animations/slot_3/render.mp4",
            "start_in_output": 12.5,
            "duration": 6.0      # Planned 6-second animation

        }
    ]
}

The duration value originates from the LLM's plan that followed the sync-to-narration guidelines. The pipeline uses this to trim source clips and assemble the final timeline.

Manim run_time Requirements

The Manim reference at skills/manim-video/references/animations.md requires explicit run_time on every animation object. Omitting it defaults to 1 second—often violating the 3–14 second narration rule and producing unreadable overlays.

from manim import *

class ExplainGraph(Scene):
    def construct(self):
        axes = Axes()
        self.play(Create(axes))
        graph = axes.plot(lambda x: x**2, color=BLUE)
        # Explicit 7-second duration follows sync-to-narration guideline

        self.play(Create(graph), run_time=7.0)
        self.wait(1.0)   # Hold final frame per ≥1s rule

HyperFrames and Remotion Duration Flags

For HTML/CSS-based animations, slot-generation scripts pass duration directly to render commands:

# HyperFrames slot generation with explicit duration

npx --yes hyperframes init . --example blank --non-interactive --skip-skills

# ... animation creation ...

npx --yes hyperframes render . -o render.mp4 --duration 6

The --duration 6 flag ensures the rendered output matches the LLM's planned timing.

Key Source Files for Duration Logic

File	Function
SKILL.md	Central repository of duration guidelines and production rules
helpers/render.py	Reads EDL duration fields and assembles final video with trimmed overlays
skills/manim-video/references/animations.md	Mandates explicit run_time for all Manim animations
helpers/pack_transcripts.py	Supplies transcript timestamps for calculating animation start times and payoff alignment

Common Duration Mistakes to Avoid

• Defaulting to Manim's 1-second run_time — Always set explicit run_time to match your narration timing
• Cutting before final frame hold — The ≥1 second rule exists because audiences need closure; violating it feels rushed
• Synchronizing payoff to animation start rather than end — Calculate reveal_duration backward from the spoken word
• Stacking simultaneous reveals — The one-thing-at-a-time rule prevents cognitive overload; sequence your elements

Summary

• Video-use duration rules are guidelines, not hard limits — The LLM plans timing; the rendering pipeline executes via EDL duration fields
• Narration-synced animations run 3–14 seconds (typically 5–7s); beat-synced accents run 0.5–2 seconds
• Every animation requires ≥1 second final frame hold and total duration exceeding voice-over length by 1 second
• Source files enforce timing through data: SKILL.md documents rules, helpers/render.py executes them, and skill-specific references like Manim's animations.md require explicit parameters

Frequently Asked Questions

Does video-use automatically calculate animation durations based on transcripts?

No. The helpers/pack_transcripts.py module provides transcript timestamps that the LLM uses for planning, but duration calculation remains a planning decision by the LLM following the guidelines in SKILL.md. The rendering pipeline executes what the EDL specifies without re-computing timing.

What happens if I omit run_time in a Manim animation for video-use?

Manim defaults to 1 second, which frequently violates the sync-to-narration guideline. The reference at skills/manim-video/references/animations.md explicitly requires setting run_time to ensure animations respect the planned duration strategy.

Are the duration rules enforced by code or just documented?

Both, but at different stages. The rules in SKILL.md are soft guidelines for LLM planning. Hard enforcement occurs when helpers/render.py reads the duration field from the EDL and trims clips accordingly—if the LLM followed guidelines, the output matches intent; if not, the engine still renders what was planned.

How does payoff timing work with non-Manim animation tools?

The same mathematical principle applies: begin the reveal early enough that the final frame aligns with the payoff word. In HyperFrames or Remotion, this means setting --start or equivalent offsets so the animation completes at the target timestamp, with the duration flag matching the calculated reveal_duration plus final hold time.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}