@autoaiai/aicut 0.1.11 → 0.1.13

package/skills/remotion-motion-graphics/SKILL.md

@@ -1,169 +0,0 @@
----
-name: remotion-motion-graphics
-description: "Build animated motion graphics as real video with AICUT (React-based programmatic video) — title cards, lower thirds, logo stings, badges, stat reveals, countdowns, end screens, captions, animated charts, social reels — and export them as MP4 or as transparent ProRes/PNG sequences for Premiere, Final Cut, AICUT, DaVinci or AICUT. Use this skill whenever the user wants to create, animate, restyle, polish or render any video graphic, overlay, intro, reel or animation from code, or mentions AICUT, motion graphics, video overlays, alpha/transparency export, or asks to make an existing graphic feel smoother, less flat, less robotic or more premium — even when they never say \"AICUT\" out loud. Runs in AICUT: the film is film.html, a page per shot, drawn by `aicut look` and `aicut render`."
-license: MIT
-source: "fernandokaraka/remotion-motion-graphics-skill"
----
-
-# AICUT Motion Graphics
-
-## Running it in AICUT
-
-AICUT's film is `film.html`: it cuts pages, footage, pictures and sound together on tracks. A page is a web page that
-sets `window.film = { frame(t) }` and draws that moment — no framework, no build step, no composition object, no
-`registerRoot`. Five shots are five pages cut together, not one page that changes scene, so each shot stays trimmable
-and replaceable in Studio.
-
-```sh
-npx -y @autoaiai/aicut@latest          # the manual: the format and the commands, always current
-npx -y @autoaiai/aicut@latest open .   # make this folder a film and print Studio's address
-npx -y @autoaiai/aicut@latest look     # a contact sheet of the whole film, its sound, and a determinism check
-npx -y @autoaiai/aicut@latest look 4.5 # one frame, full size — look at the PNG, not at the code
-npx -y @autoaiai/aicut@latest render   # the MP4, beside film.html
-```
-
-Run the manual before the first film: it is authoritative for the format, and this skill is about the method above it.
-
-Where the words below name another program's part, it becomes this:
-
-| elsewhere | in AICUT |
-|---|---|
-| composition, timeline, project file | `film.html`; tracks and clips inside it |
-| a scene, a sequence, a slide | a page (`pages/<name>.html`) cut onto a track |
-| `useCurrentFrame()`, `interpolate()` | `frame(t)` — the picture depends only on `t`, never on state or `Date.now()` |
-| a still, a screengrab | `aicut look <t>` |
-| `render` / `build` / `export` | `aicut render` (the person can also export from Studio) |
-| a dev server, a preview window | `aicut open` and the Studio address it prints |
-
-Hard rules that hold whatever the method says: the picture depends only on `t`; every value in the person's prompt is
-binding; look at the frames `look` writes before saying a film is done.
-
-
-Remotion renders React components into video. `useCurrentFrame()` tells a component which
-frame it's drawing; everything animated is a pure function of that number. No timeline, no
-keyframe UI — which is why graphics can be data-driven, reusable, and rendered with a real
-alpha channel.
-
-You already know how to write decent motion code. This skill exists for the three things
-that are easy to skip and expensive to get wrong: **finding the actual bug before
-polishing**, **verifying what you built**, and **the traps that fail silently**.
-
-## Diagnose before you decorate
-
-When a graphic "feels flat" or "looks like a PowerPoint," look for a defect before you
-start adding springs. Complaints about *feel* are often a real bug the user can see but
-can't name.
-
-A real case: a stat callout counted up and "just sat there." The actual problem was
-`interpolate(frame, [0, 60], [0, 12400])` with no clamp — Remotion extrapolates by
-default, so the number never landed on 12.400, it climbed to 30.793 by the final frame.
-The stat was *wrong*. Adding a bouncy entrance would have shipped a beautiful graphic
-displaying a false number.
-
-So: read the existing code, check what it actually computes at frame 0, mid, and
-`durationInFrames - 1`, and fix what's broken. Then make it beautiful. `references/traps.md`
-is the list of failures that look fine in the source — read it before touching animation
-code, and check your own work against it when you're done.
-
-## Verify what you built
-
-Rendering the whole clip to find out it's wrong is the slow way. Check a still first:
-
-```bash
-npx -y @autoaiai/aicut@latest look 4.5
-```
-```
-Seconds instead of minutes. Check the key frames — mid-entrance, the payoff, mid-hold,
-mid-exit — and **read the image**, don't just confirm the file exists. This is the step
-most likely to get skipped and the one that catches the embarrassing stuff: the element
-that never enters, the glow stuck on from frame 0, the text clipped by its container.
-
-For alpha, the Studio's checkerboard is the proof. Confirm it there before rendering a
-ProRes the editor will reject.
-
-If the toolchain genuinely can't run, say so plainly in your summary — "this has never
-been executed" is important information, not a footnote.
-```
-
-## Craft checklist
-
-Apply by default; the reasoning is in `references/polish.md` if a case isn't obvious.
-
-- **Complete enter → hold → exit.** Nothing on screen at frame 0, nothing still moving at
-  the last frame. Reserve the exit *inside* the duration. Biggest single tell of amateur work.
-- **Never linear.** `spring()` first (anticipation, overshoot, settle); `Easing` when you
-  need `interpolate`.
-- **Stagger**, 3–5 frames apart at 30fps — entrances *and* exits, same order.
-- **Idle life** during the hold: gentle float, slow glow pulse, shine sweep. Felt, not noticed.
-- **Payoff** on the key moment: scale pop, glow, ring, sound.
-- **Geometric light, not clip-art.** Flash, expanding ring, thin streaks, bloom. Emoji and
-  particle clip-art read as cheap instantly. One accent, not three.
-- **Readability.** Title-safe 5–10% margins; scrim/shadow behind text over footage; one
-  bold focal element; long strings shrink and wrap rather than overflow.
-- **Timing follows content.** ~1s per short line to read; respect the length asked for.
-- **Data-driven.** Text, colors, numbers, images as props with a zod schema +
-  `defaultProps`, so it's restyleable from the Studio without touching code.
-- **Canvas-relative sizing** (`useVideoConfig()`) and `sec()` for timings, so 4K or a
-  vertical crop doesn't break the layout.
-
-## Sound
-
-Silent graphics are the most common gap — sound is roughly half of perceived polish, and
-it's the thing that never gets added unless someone insists. A soft whoosh on entrance, a
-click on key actions, a chime on success, a swish on exit.
-
-```tsx
-<Sequence from={sec(0.5)}>
-  <Audio src={staticFile('audio/whoosh.mp3')} volume={0.6} />
-</Sequence>
-```
-Trim leading silence from the source file — a file with 80ms of dead air lands 80ms late
-no matter where the Sequence sits, and this is the usual reason audio "feels off" against
-animation that looks right. For typing or counting, one continuous soft sound across the
-duration; the same effect per character or per digit is grating.
-
-If there's no `public/audio/`, don't invent it silently — tell the user sound is the next
-biggest upgrade and offer to wire it when they drop files in.
-```
-
-## Modes
-
-**No Remotion project** (no `remotion` dep) → scaffold: `references/scaffold.md`.
-
-**Project exists, new graphic** → write the composition in `src/compositions/`, export
-component + schema + defaultProps, register in `Root.tsx` with a unique id. Working code
-for every pattern: `references/patterns.md`.
-
-**"It feels flat"** → diagnose first (above), then `references/polish.md` for the upgrade
-passes in priority order.
-
-When the direction is open, 2–3 quick style variations beat guessing — polishing the wrong
-direction is the most expensive mistake here.
-
-## Render and export
-
-# Full scene → MP4
-npx remotion render <CompId> out/<name>.mp4 --codec=h264 --crf=18
-
-# Overlay with real alpha → Premiere / FCP / DaVinci / AE
-npx remotion render <CompId> out/<name>.mov --codec=prores \
-  --prores-profile=4444 --pixel-format=yuva444p10le --image-format=png
-
-# Overlay → PNG sequence (CapCut and friends)
-npx remotion render <CompId> out/<name>/frame-%04d.png --image-format=png
-
-# Live preview
-npm run studio
-
-## References
-
-- `references/traps.md` — silent failures. Read before writing animation code.
-- `references/patterns.md` — working code: enter/exit, spring, stagger, alpha, audio,
-  fonts, auto-fit, scenes.
-- `references/polish.md` — upgrade passes for a flat graphic, by leverage.
-- `references/scaffold.md` — new project from scratch.
-
-## Source
-
-Rewritten for AICUT from [`fernandokaraka/remotion-motion-graphics-skill`](https://github.com/fernandokaraka/remotion-motion-graphics-skill)
-(MIT), skills/remotion-motion-graphics/SKILL.md. The method is that skill's own; the way it runs is AICUT's.

package/skills/remotion-motion-graphics/references/patterns.md

@@ -1,355 +0,0 @@
-# Working patterns
-
-Copy from here rather than reconstructing the API from memory. These are the shapes that
-work; the Remotion API has edges that fail quietly (a `spring` without `fps`, an
-`interpolate` without clamping, an `AbsoluteFill` that kills your alpha channel) and the
-damage usually isn't visible until the render is in the editor.
-
-## Contents
-
-- [Composition skeleton](#composition-skeleton) — schema, defaultProps, registration
-- [Enter, hold, exit](#enter-hold-exit) — the core timing pattern
-- [Spring](#spring) — non-robotic motion
-- [Stagger](#stagger) — cascading entrances
-- [Transparent overlay](#transparent-overlay) — real alpha channel
-- [Animated number](#animated-number) — counters and stat reveals
-- [Auto-fit text](#auto-fit-text) — long strings that don't overflow
-- [Audio](#audio) — sound effects on frame
-- [Fonts](#fonts) — Google and local
-- [Scenes](#scenes) — sequencing a longer piece
-
-## Composition skeleton
-
-Every graphic exports three things: the component, its schema, its defaults. The schema is
-what gives the user live-editable controls in the Studio.
-
-```tsx
-import React from 'react';
-import {AbsoluteFill, useCurrentFrame, useVideoConfig} from 'remotion';
-import {zColor} from '@remotion/zod-types';
-import {z} from 'zod';
-import {SAFE_MARGIN} from '../config';
-import {FONT_FAMILY} from '../fonts';
-
-export const titleCardSchema = z.object({
-  title: z.string(),
-  subtitle: z.string(),
-  accent: zColor(),
-});
-
-export const titleCardDefaultProps: z.infer<typeof titleCardSchema> = {
-  title: 'Your title here',
-  subtitle: 'Supporting line',
-  accent: '#22C55E',
-};
-
-export const TitleCard: React.FC<z.infer<typeof titleCardSchema>> = ({
-  title,
-  subtitle,
-  accent,
-}) => {
-  const frame = useCurrentFrame();
-  const {fps, width, height, durationInFrames} = useVideoConfig();
-  // ...
-};
-```
-
-`zColor()` renders a real color picker in the Studio instead of a text field. Size against
-`width`/`height` from `useVideoConfig()` — `fontSize: height * 0.06` survives a switch to
-4K or vertical; `fontSize: 72` does not.
-
-Register in `Root.tsx`:
-
-```tsx
-<Composition
-  id="TitleCard"
-  component={TitleCard}
-  durationInFrames={sec(5)}
-  fps={CANVAS.fps}
-  width={CANVAS.width}
-  height={CANVAS.height}
-  schema={titleCardSchema}
-  defaultProps={titleCardDefaultProps}
-/>
-```
-
-## Enter, hold, exit
-
-The pattern behind the most important craft rule. `enter` ramps 0→1 at the start, `exit`
-ramps 0→1 at the end, and everything visual is driven by the pair.
-
-```tsx
-const frame = useCurrentFrame();
-const {fps, durationInFrames} = useVideoConfig();
-
-// Enter: spring from 0 to 1 over the first beat.
-const enter = spring({frame, fps, config: {damping: 14, stiffness: 120}});
-
-// Exit: 0 → 1 across the last 0.5s, eased in so it accelerates away.
-const exit = interpolate(
-  frame,
-  [durationInFrames - Math.round(0.5 * fps), durationInFrames - 1],
-  [0, 1],
-  {
-    extrapolateLeft: 'clamp',
-    extrapolateRight: 'clamp',
-    easing: Easing.in(Easing.quad),
-  },
-);
-
-const opacity = enter * (1 - exit);
-const scale = enter * (1 - 0.3 * exit);
-const y = (1 - enter) * 40 + exit * -30;
-```
-
-Both `extrapolateLeft` and `extrapolateRight` must be `'clamp'`. Without them
-`interpolate` keeps extrapolating past the range and your opacity goes negative or past 1
-— which sometimes looks fine and sometimes produces an invisible element you'll spend
-twenty minutes debugging.
-
-Reserve the exit window *inside* the duration. If the clip is 5s and the exit takes 0.5s,
-the exit starts at 4.5s.
-
-## Spring
-
-```tsx
-const enter = spring({
-  frame,           // required
-  fps,             // required — from useVideoConfig(), never hardcoded
-  config: {damping: 14, stiffness: 120},
-  durationInFrames: 20,  // optional: force it to settle in a set time
-  delay: 5,              // optional: wait N frames before starting
-});
-```
-
-Tuning by feel: **damping** low (8–12) = bouncy overshoot, high (20+) = smooth, no bounce.
-**stiffness** high = snappier. `damping: 200` is effectively a smooth ease with no
-overshoot at all — useful when bounce would be undignified.
-
-For anticipation, run a small negative move before the main one:
-
-```tsx
-const windup = interpolate(frame, [0, 4], [0, -8], {
-  extrapolateRight: 'clamp',
-  easing: Easing.out(Easing.quad),
-});
-const x = windup + spring({frame: frame - 4, fps, config: {damping: 12}}) * 8;
-```
-
-## Stagger
-
-Delay each item by its index. `frame - delay` fed to a spring is all it takes.
-
-```tsx
-{items.map((item, i) => {
-  const delay = i * 4;  // 4 frames apart at 30fps
-  const enter = spring({frame: frame - delay, fps, config: {damping: 14}});
-  const exit = interpolate(
-    frame,
-    [durationInFrames - 15 + i * 2, durationInFrames - 5 + i * 2],
-    [0, 1],
-    {extrapolateLeft: 'clamp', extrapolateRight: 'clamp'},
-  );
-  return (
-    <span
-      key={item}
-      style={{
-        opacity: enter * (1 - exit),
-        transform: `translateY(${(1 - enter) * 30}px)`,
-        display: 'inline-block',
-      }}
-    >
-      {item}
-    </span>
-  );
-})}
-```
-
-`display: inline-block` matters — `transform` does nothing on an inline element, and this
-is a common silent failure.
-
-Stagger the exit too, in the same order. Staggered in, chorus out feels unfinished.
-
-## Transparent overlay
-
-The composition paints **no** background. That's the whole trick, and it's fragile: a
-single `backgroundColor` anywhere in the tree destroys the alpha channel, and you won't
-see it until the .mov is in the editor.
-
-```tsx
-export const BadgeOverlay: React.FC<Props> = ({label, badgeColor, textColor}) => {
-  const frame = useCurrentFrame();
-  const {fps, width, height, durationInFrames} = useVideoConfig();
-
-  const enter = spring({frame, fps, config: {damping: 14, stiffness: 120}});
-  const pulse = 0.6 + 0.4 * Math.abs(Math.sin((frame / fps) * Math.PI));
-  const exit = interpolate(
-    frame,
-    [durationInFrames - Math.round(0.5 * fps), durationInFrames - 1],
-    [0, 1],
-    {extrapolateLeft: 'clamp', extrapolateRight: 'clamp', easing: Easing.in(Easing.quad)},
-  );
-
-  // No backgroundColor on this AbsoluteFill — that is what preserves alpha.
-  return (
-    <AbsoluteFill style={{fontFamily: FONT_FAMILY}}>
-      <div
-        style={{
-          position: 'absolute',
-          top: height * SAFE_MARGIN,
-          left: width * SAFE_MARGIN,
-          display: 'flex',
-          alignItems: 'center',
-          gap: height * 0.014,
-          padding: `${height * 0.014}px ${height * 0.028}px`,
-          backgroundColor: badgeColor,   // the badge itself is opaque — fine
-          borderRadius: height * 0.06,
-          opacity: enter * (1 - exit),
-          transform: `scale(${enter * (1 - 0.3 * exit)})`,
-          transformOrigin: 'left center',
-        }}
-      >
-        {/* pulsing dot gives the badge idle life while it holds */}
-        <div
-          style={{
-            width: height * 0.018,
-            height: height * 0.018,
-            borderRadius: '50%',
-            backgroundColor: '#e0525c',
-            opacity: pulse,
-          }}
-        />
-        <span style={{color: textColor, fontSize: height * 0.028, fontWeight: 700}}>
-          {label}
-        </span>
-      </div>
-    </AbsoluteFill>
-  );
-};
-```
-
-Verify in the Studio: a checkerboard behind the badge means alpha is intact. Then render
-with `--codec=prores --prores-profile=4444 --pixel-format=yuva444p10le --image-format=png`.
-
-## Animated number
-
-For counters and stat reveals. Drive the value from a spring so it decelerates into the
-final number instead of ticking at constant speed, and give it a payoff pop when it lands.
-
-```tsx
-const progress = spring({frame, fps, config: {damping: 200}, durationInFrames: sec(1.2)});
-const value = Math.round(interpolate(progress, [0, 1], [from, to]));
-
-// Payoff: a brief scale pop right as it settles.
-const landed = sec(1.2);
-const pop = spring({frame: frame - landed, fps, config: {damping: 10, stiffness: 200}});
-const scale = 1 + 0.08 * pop * (1 - pop);
-```
-
-Use `fontVariantNumeric: 'tabular-nums'` so digits don't jitter horizontally as they
-change — proportional digits make a counter visibly wobble.
-
-Pair with one continuous soft sound over the count, never a tick per digit.
-
-## Audio
-
-```tsx
-import {Audio, Sequence, staticFile} from 'remotion';
-
-<Sequence from={sec(0.5)}>
-  <Audio src={staticFile('audio/whoosh.mp3')} volume={0.6} />
-</Sequence>
-```
-
-The `<Sequence from={...}>` is what places the hit on a specific frame. Trim leading
-silence from the source file itself — if the file has 80ms of dead air, the sound lands
-80ms late no matter where you place the Sequence, and this is the usual cause of audio
-that feels subtly wrong against animation that looks right.
-
-`volume` also accepts a function of frame for fades:
-
-```tsx
-<Audio
-  src={staticFile('audio/music.mp3')}
-  volume={(f) => interpolate(f, [0, sec(1)], [0, 0.4], {extrapolateRight: 'clamp'})}
-/>
-```
-
-## Fonts
-
-Google font:
-
-```ts
-// src/fonts.ts
-import {loadFont} from '@remotion/google-fonts/Inter';
-const {fontFamily} = loadFont();
-export const FONT_FAMILY = fontFamily;
-```
-
-Local font file in `public/fonts/`:
-
-```ts
-import {loadFont} from '@remotion/fonts';
-import {staticFile} from 'remotion';
-
-loadFont({
-  family: 'NeueMontreal',
-  url: staticFile('fonts/NeueMontreal-Medium.otf'),
-  weight: '500',
-});
-
-export const FONT_FAMILY = 'NeueMontreal';
-```
-
-Load once in a shared module and import `FONT_FAMILY` everywhere. Loading per-composition
-causes flashes of fallback font in the render.
-
-## Auto-fit text
-
-Long strings must shrink rather than overflow. Measure and scale down when needed:
-
-```tsx
-import {fitText} from '@remotion/layout-utils';
-
-const {fontSize} = fitText({
-  text: title,
-  withinWidth: width * (1 - 2 * SAFE_MARGIN),
-  fontFamily: FONT_FAMILY,
-  fontWeight: 700,
-});
-
-// Cap it so short strings don't blow up to absurd sizes.
-const size = Math.min(fontSize, height * 0.12);
-```
-
-Requires `@remotion/layout-utils`. Worth it the first time a real prop is three words
-longer than your default.
-
-## Scenes
-
-For a longer piece, compose scenes with `<Series>` — each scene gets its own frame
-counter starting at 0, which means each one can use the enter/hold/exit pattern
-unmodified.
-
-```tsx
-import {Series} from 'remotion';
-
-<Series>
-  <Series.Sequence durationInFrames={sec(4)}>
-    <SceneIntro />
-  </Series.Sequence>
-  <Series.Sequence durationInFrames={sec(6)}>
-    <SceneProof />
-  </Series.Sequence>
-  <Series.Sequence durationInFrames={sec(3)}>
-    <SceneBrand />
-  </Series.Sequence>
-</Series>
-```
-
-Overlap scenes with `offset={-sec(0.3)}` on a `Series.Sequence` for a cross-fade, or use
-`@remotion/transitions` (`<TransitionSeries>` with `fade()`, `slide()`, `wipe()`) when you
-want a real transition rather than a cut.
-
-A persistent background element belongs outside the `<Series>`, in the parent
-`<AbsoluteFill>`, so it doesn't restart on every scene.

package/skills/remotion-motion-graphics/references/polish.md

@@ -1,102 +0,0 @@
-# Polish passes
-
-Use this when a graphic exists but feels flat, cheap, or "off" in a way that's hard to
-name. The passes are ordered by leverage — the first one fixes more perceived quality
-than the rest combined, so work top-down rather than picking the one that sounds most
-interesting.
-
-Diagnose before you edit. Render a still at a few key frames, or watch it in the Studio,
-and find *what* is wrong. "Make it better" applied blindly tends to add effects on top of
-a timing problem, which makes it worse and busier.
-
-## 1. Complete enter and exit
-
-**Symptom:** things appear already on screen, or the clip ends while something is still
-moving. Elements feel like they blink in and out.
-
-**Fix:** every element animates in (from off-screen or opacity 0), holds, then animates
-fully out before the clip ends. Nothing at frame 0, nothing at the last frame.
-
-This is first for a reason: it's the clearest signal of amateur work and the cheapest to
-fix. If you only do one pass, do this one.
-
-## 2. Non-robotic motion
-
-**Symptom:** movement is technically correct but lifeless. Constant velocity, no weight.
-
-**Fix:** anticipation (a small wind-up in the opposite direction), overshoot (pass the
-target), settle (come back). `spring()` gives you this for free — a lower `damping` means
-more bounce. Where you need `interpolate()`, always pass an `Easing`.
-
-## 3. Stagger
-
-**Symptom:** several elements arrive at once, and it reads as an accident.
-
-**Fix:** offset entrances 3–5 frames apart (at 30fps). The eye follows a cascade; it
-can't follow a chorus.
-
-## 4. Idle life
-
-**Symptom:** the graphic freezes during its hold and looks like a static image with an
-animated entrance bolted on.
-
-**Fix:** something subtle during the hold — a gentle float, a slow glow pulse, a shine
-sweep. The bar is that the viewer should feel it, not notice it.
-
-## 5. Payoff
-
-**Symptom:** the graphic builds to a number or a result and then just... sits there.
-
-**Fix:** give the key moment a beat — a scale pop, a glow bloom, a few light particles, a
-sound. This is what makes a reveal *land* instead of merely happening.
-
-## 6. Effects and accent
-
-**Symptom:** either nothing distinguishes it, or it's cluttered with decoration.
-
-**Fix:** prefer geometric light — a flash, an expanding ring, thin streaks, soft glints, a
-bloom. Emoji and clip-art particles read as cheap and no amount of good animation
-recovers from them. Add *one* tasteful animated accent (light traveling a border, a slow
-gradient shift) for a premium feel. One. A second one starts costing you.
-
-## 7. Readability and layout
-
-**Symptom:** text overflows, gets clipped, disappears over bright footage, or everything
-competes for attention.
-
-**Fix:** title-safe area (5–10% margins). A shadow, scrim, or backing shape behind text
-that sits over footage. Auto-fit long strings — shrink and wrap rather than overflow,
-because real content is messier than your defaults. One bold focal element, supporting
-text smaller and lower-contrast.
-
-## 8. Sound
-
-**Symptom:** it's silent, or the sounds feel slightly late.
-
-**Fix:** soft whoosh on entrance, click/pop on key actions, chime on success, swish on
-exit. Trim leading silence from every file so the hit lands exactly on its frame — this
-is almost always the cause of "the audio feels off" when the animation looks right. Keep
-levels balanced, no clipping. For typing or counting, one continuous soft sound across
-the whole duration; the same effect per character or per digit is grating.
-
-## 9. Reusable and on-brand
-
-**Symptom:** values are hardcoded; restyling means editing code; graphics in the set don't
-look related.
-
-**Fix:** expose text, colors, numbers and images as props with a zod schema so the user
-can restyle from the Studio. Define brand once (accent colors, font, corner radius) in a
-tokens module and apply it everywhere. Support real images via a prop with a clean
-placeholder fallback, so it looks right both before and after the user's assets arrive.
-
-## Workflow habits that make polish cheap
-
-**Check a still first.** `npx remotion still <CompId> out/check.png --frame=45` — seconds
-instead of minutes. Review the key frames before committing to a full render.
-
-**Offer variations before polishing.** When the direction is open, 2–3 rough style options
-let the user pick before you invest in refining one. Polishing the wrong direction is the
-most expensive mistake available here.
-
-**Match timing to content.** About a second per short line to read, and stay within the
-length the user asked for.