Add ad-video skills (ad-creative, launch, testimonial)

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01VU6qqzefQ2TxgZetJ7beKU
2026-10-18 21:50:04 +00:00
32 changed files with 1395 additions and 1831 deletions
@@ -0,0 +1,163 @@
+---
+name: ad-creative-video
+description: This skill should be used when the user asks to "make a video ad", "create an animated ad", "build a performance/UGC-style ad", "batch-produce ad creative variations", "generate ad variants for A/B testing", "swap headline/offer/CTA across many ad versions", or "export one ad in multiple aspect ratios for Meta/TikTok/Reels". Covers ad hook structures, hook→CTA message-match, data-driven variant generation (1 template × CSV = N ads), multi-aspect export, and platform specs.
+version: 0.1.0
+---
+
+# Ad Creative Video
+
+Build ONE motion-graphics ad template, then mass-produce variants from a data table — different hooks, offers, CTAs, and products — so a performance marketer can A/B test dozens of versions across placements and aspect ratios. The craft is making the template fully data-driven and message-matched, so 40 variants stay on-brand and only the tested variable changes.
+
+## When to use
+
+- Performance/UGC-style video ads where the first 1.5–3s must stop the scroll.
+- Batch variant generation: one template rendered against many rows (headline/offer/CTA/product swaps) for A/B testing.
+- Multi-aspect export of the same ad for Meta Feed, Reels/Stories, TikTok, YouTube.
+
+Not for sale/discount countdown promos, and not for testimonial/review-driven ads — those are different structures. Stay on the batch-variation, test-everything angle.
+
+## The two rules that make variants worth running
+
+1. **Isolate one variable per variant.** A test only teaches something if exactly one thing changes. Hold layout, motion, colors, and timing constant; swap *only* the field under test (hook, or offer, or CTA). Mixing two changes makes the winner uninterpretable.
+2. **Message-match the hook to the CTA.** The promise made in the first 3 seconds must be the promise the button pays off. A "stop wasting 2 hours a day" hook ends on "Save 2 hours — try free," not a generic "Shop now." The hook and CTA are a matched pair in every row of the data table.
+
+## Ad anatomy (15–30s)
+
+| Beat | Job | Budget |
+|---|---|---|
+| Hook (0–3s) | Stop the scroll; state the problem or pattern-interrupt | 0–3s |
+| Context | Make the viewer feel the problem / agitate | 3–8s |
+| Payoff | Show the product as the solution, one clear benefit | 8–18s |
+| Proof | One concrete number, demo, or result | 18–25s |
+| CTA (last 3s) | Single action, message-matched to the hook | hold ≥2s |
+
+Land the hook's emotional trigger before the 2-second mark — judgment forms in ~1.7s and scroll speed keeps rising. Test the hook FIRST; it moves CPA more than any other element.
+
+## Hook taxonomy (the field you vary most)
+
+| Hook type | Template | When it wins |
+|---|---|---|
+| Problem-first | "I didn't realize how much X was costing me until…" | pain is felt but unnamed |
+| Pattern interrupt | "This is going to sound controversial, but…" | crowded feed, generic category |
+| Curiosity gap | "Nobody talks about the one thing that…" | educated, skeptical audience |
+| Immediate benefit | "Cut your X in half in 7 days" | clear, quantifiable outcome |
+| Direct callout | "If you do X every morning, stop." | sharp audience segment |
+
+Keep a column of 5–10 hook strings and let the batch render produce one ad per hook against the same body — that is the cleanest hook test possible.
+
+## Data-driven template (everything is a prop)
+
+Hardcode nothing the marketer might A/B test. The composition reads a single `variant` object; the renderer never edits the component. Make every animated value a pure function of `useCurrentFrame()` so each frame renders deterministically (no CSS transitions, no library timers — they desync the render).
+
+```tsx
+import {useCurrentFrame, interpolate, AbsoluteFill, useVideoConfig} from "remotion";
+
+type Variant = {hook: string; benefit: string; proof: string; cta: string; bg: string; accent: string};
+
+export const AdTemplate: React.FC<{v: Variant}> = ({v}) => {
+  const frame = useCurrentFrame(); const {fps} = useVideoConfig();
+  const hookIn = interpolate(frame, [0, 8], [40, 0], {extrapolateRight: "clamp"});
+  const ctaIn  = interpolate(frame, [fps * 22, fps * 23], [0, 1], {extrapolateLeft: "clamp", extrapolateRight: "clamp"});
+  return (
+    <AbsoluteFill style={{background: v.bg, fontFamily: "Inter, sans-serif"}}>
+      <h1 style={{transform: `translateY(${hookIn}px)`, opacity: interpolate(frame,[0,8],[0,1])}}>{v.hook}</h1>
+      {frame > fps * 8  && <p>{v.benefit}</p>}
+      {frame > fps * 18 && <strong>{v.proof}</strong>}
+      <button style={{opacity: ctaIn, background: v.accent}}>{v.cta}</button>
+    </AbsoluteFill>
+  );
+};
+```
+
+See `references/batch-ad-pipeline.md` for the complete template, the CSV→props parser with validation, and the brand-lock theme object.
+
+## 1 template × CSV = N variants
+
+The payoff: author the ad once, then let a CSV drive the matrix. Each row is one fully-formed, message-matched variant. Render once per row.
+
+```bash
+# variants.csv: id,hook,benefit,proof,cta,bg,accent  → one MP4 per row
+node csv-to-props.js variants.csv ./props        # writes props/<id>.json per row
+for f in props/*.json; do
+  id=$(basename "$f" .json)
+  npx remotion render AdTemplate "out/${id}.mp4" --props="$f"
+done
+```
+
+To build a clean test matrix, hold every column constant and vary one: 5 hooks × 1 body = 5 ads (hook test); then take the winning hook × 3 CTAs (CTA test). `references/batch-ad-pipeline.md` has a matrix generator that expands variable lists into the CSV so combinatorial tests stay one-variable-at-a-time.
+
+## Multi-aspect export
+
+Each placement wants a native aspect. Compose against a center safe zone so one master reframes cleanly to all of them — don't letterbox, re-center.
+
+| Aspect | Placements | Resolution | Keep-clear safe zone |
+|---|---|---|---|
+| 9:16 | Reels, Stories, TikTok In-Feed | 1080×1920 | top ~14%, bottom ~20–35% (UI/caption), sides ~6% |
+| 4:5 | Meta Feed (best feed real estate) | 1080×1350 | center 90%; CTA out of bottom 10% |
+| 1:1 | Feed, broad reach | 1080×1080 | center square survives every crop |
+| 16:9 | YouTube, in-stream | 1920×1080 | center 90% |
+
+Design the hook text, product, and CTA inside the **1:1 center square** so they survive every crop. Drive aspect from a prop and render each per variant:
+
+```bash
+for ar in 9x16 4x5 1x1; do
+  npx remotion render AdTemplate "out/${id}-${ar}.mp4" --props="props/${id}.json" \
+    --props-merge="{\"aspect\":\"${ar}\"}"
+done
+```
+
+Keep critical content out of the 9:16 bottom third — that is where the platform stacks captions, the CTA button, and the username. `references/platform-specs.md` has exact pixel safe zones and per-platform duration/format limits.
+
+## Output checklist
+
+- One variable per variant; layout/motion/timing identical across a test.
+- Hook lands its trigger before 2s; hook and CTA are message-matched in every row.
+- Every animated value is a pure function of `useCurrentFrame()` — no CSS/library timers.
+- Dataset is a prop; nothing testable is hardcoded; one template renders the whole CSV.
+- Each variant exported 9:16 + 4:5 + 1:1 (+16:9 if needed), key content in the center square.
+- Brand stays locked across all variants via a single theme object.
+
+## Deliver & verify (rendered stills → MP4)
+
+> **Packaged helper** (`scripts/`): tile your stills with `scripts/contact-sheet.sh sheet.png f-hook.png f-mid.png f-end.png`, then assert the encode with `scripts/probe-mp4.sh out.mp4 [WxH] [fps]`. See `scripts/README.md`.
+
+**Output contract:**
+- A Remotion ad template registered as `<Composition>` (+ zod `schema` + `defaultProps`), every animated value frame-driven (no CSS transitions / library timers / `Date.now()` / `Math.random()`).
+- Deliverable = the rendered `out/*.mp4` per variant per aspect (plus the project + CSV, so the marketer re-renders on new rows).
+
+**Verify loop — render stills → inspect → encode.** Cheap PNGs first, full encode only once they're clean. Render with the **shipped** props (the real row), not just `defaultProps`.
+
+```bash
+# Frame-exact stills across the hook→CTA arc, with a real variant's props
+npx remotion still AdTemplate out/f-hook.png --frame=12  --props=props/v1.json   # hook readable < 2s
+npx remotion still AdTemplate out/f-mid.png  --frame=300 --props=props/v1.json   # benefit/proof
+npx remotion still AdTemplate out/f-cta.png  --frame=689 --props=props/v1.json   # CTA, message-matched
+# inspect each: fidelity (hook / offer / proof / CTA text exact, brand bg+accent right)
+#   AND artifacts (text overflow, off-canvas, CTA inside the 9:16 bottom third, missing font, wrong row binding)
+```
+
+**Multi-aspect / batch — verify one variant in EACH aspect before batch-rendering the matrix.** A layout bug repeats across every row × aspect; catch it once.
+
+```bash
+for ar in 9x16 4x5 1x1; do                                  # one representative variant, every target aspect
+  npx remotion still AdTemplate "out/v1-${ar}.png" --frame=300 \
+    --props=props/v1.json --props-merge="{\"aspect\":\"${ar}\"}"
+done
+# stills clean in all aspects? → then batch-render every row × aspect:
+for f in props/*.json; do id=$(basename "$f" .json); for ar in 9x16 4x5 1x1; do
+  npx remotion render AdTemplate "out/${id}-${ar}.mp4" --props="$f" --props-merge="{\"aspect\":\"${ar}\"}"
+done; done
+npx remotion render AdTemplate out/demo.gif --codec=gif --props=props/v1.json   # README demo
+```
+
+**Before you finish:**
+1. `npx remotion still` renders cleanly at hook / mid / CTA — no errors, no missing fonts/assets.
+2. Hook/offer/proof/CTA text exact and brand colors right; nothing in the 9:16 bottom third or outside the center safe zone.
+3. Frame-driven only — no CSS/library timers, `Date.now()`, or `Math.random()`.
+4. Shipped row's props render correctly (not just `defaultProps`); one variable per variant holds.
+5. One variant verified in 9:16 + 4:5 + 1:1 before the batch; MP4s play; (optional) GIF for the README.
+
+## Reference files
+
+- `references/batch-ad-pipeline.md` — the full runnable Remotion ad template, the CSV→typed-props parser with validation, a one-variable test-matrix generator, the brand-lock theme object, and the complete batch + multi-aspect render script.
+- `references/platform-specs.md` — exact 2025/2026 pixel safe zones, durations, aspect ratios, and format limits for Meta Feed/Reels/Stories, TikTok In-Feed, and YouTube, plus a hook→CTA message-match worksheet.
@@ -0,0 +1,289 @@
+# Batch Ad Pipeline — full template, parser, matrix, render
+
+This is the complete, runnable implementation behind the SKILL.md overview: a data-driven Remotion ad template, a CSV→props parser with validation, a one-variable test-matrix generator, a brand-lock theme, and the batch + multi-aspect render scripts. Hardcode nothing a marketer might want to A/B test.
+
+## 1. The brand-lock theme
+
+Keep every brand-controlled value in one object so 40 variants stay consistent and only the *tested* fields change per row. The variant data supplies copy and per-campaign accents; the theme supplies the locked look.
+
+```ts
+// theme.ts
+export const theme = {
+  fontFamily: "Inter, system-ui, sans-serif",
+  ink: "#0B0B0F",
+  paper: "#FFFFFF",
+  radius: 20,
+  hookSize: 76,    // px, on the 1080-wide master
+  bodySize: 44,
+  proofSize: 52,
+  ctaSize: 40,
+  pad: 80,         // outer padding; also the side safe margin
+  durationInSeconds: 25,
+} as const;
+```
+
+## 2. Aspect config
+
+Drive layout from a single aspect prop so one composition reframes to every placement. Dimensions and the keep-clear bottom band differ per aspect.
+
+```ts
+// aspects.ts
+export type Aspect = "9x16" | "4x5" | "1x1" | "16x9";
+export const ASPECTS: Record<Aspect, {w: number; h: number; bottomSafe: number}> = {
+  "9x16": {w: 1080, h: 1920, bottomSafe: 540}, // captions + CTA + username stack here
+  "4x5":  {w: 1080, h: 1350, bottomSafe: 135},
+  "1x1":  {w: 1080, h: 1080, bottomSafe: 110},
+  "16x9": {w: 1920, h: 1080, bottomSafe: 110},
+};
+```
+
+## 3. The data-driven template
+
+Every animated value is a pure function of `useCurrentFrame()` — no CSS transitions, no GSAP/library timers (they desync deterministic rendering and flicker in the export). The component reads one `variant` plus an `aspect`; the renderer never edits this file.
+
+```tsx
+// AdTemplate.tsx
+import {
+  AbsoluteFill, useCurrentFrame, useVideoConfig, interpolate, spring, Sequence,
+} from "remotion";
+import {theme} from "./theme";
+import {ASPECTS, Aspect} from "./aspects";
+
+export type Variant = {
+  id: string;
+  hook: string;      // 0–3s scroll-stopper
+  benefit: string;   // the single payoff claim
+  proof: string;     // one concrete number / result
+  cta: string;       // message-matched to the hook
+  accent: string;    // per-campaign accent color
+  bg: string;        // background color
+};
+
+export const AdTemplate: React.FC<{v: Variant; aspect: Aspect}> = ({v, aspect}) => {
+  const frame = useCurrentFrame();
+  const {fps} = useVideoConfig();
+  const {bottomSafe} = ASPECTS[aspect];
+
+  // Hook rises + fades in over the first 8 frames, holds, then eases up and out at 8s.
+  const hookY = interpolate(frame, [0, 8], [48, 0], {extrapolateRight: "clamp"});
+  const hookOpacity =
+    interpolate(frame, [0, 8], [0, 1], {extrapolateRight: "clamp"}) *
+    interpolate(frame, [fps * 7, fps * 8], [1, 0], {extrapolateLeft: "clamp", extrapolateRight: "clamp"});
+
+  // CTA springs in for impact in the last 3s and holds.
+  const ctaProgress = spring({frame: frame - fps * 22, fps, config: {damping: 14, stiffness: 120}});
+
+  return (
+    <AbsoluteFill style={{backgroundColor: v.bg, fontFamily: theme.fontFamily, color: theme.ink}}>
+      <AbsoluteFill style={{padding: theme.pad, paddingBottom: bottomSafe, justifyContent: "center"}}>
+
+        {/* HOOK 0–8s */}
+        <Sequence durationInFrames={fps * 8}>
+          <h1 style={{fontSize: theme.hookSize, fontWeight: 800, lineHeight: 1.05,
+                      transform: `translateY(${hookY}px)`, opacity: hookOpacity}}>
+            {v.hook}
+          </h1>
+        </Sequence>
+
+        {/* BENEFIT 8–18s */}
+        <Sequence from={fps * 8} durationInFrames={fps * 10}>
+          <FadeUp delay={0}>
+            <p style={{fontSize: theme.bodySize, fontWeight: 600}}>{v.benefit}</p>
+          </FadeUp>
+        </Sequence>
+
+        {/* PROOF 18–22s */}
+        <Sequence from={fps * 18} durationInFrames={fps * 4}>
+          <FadeUp delay={0}>
+            <strong style={{fontSize: theme.proofSize, color: v.accent,
+                            fontVariantNumeric: "tabular-nums"}}>{v.proof}</strong>
+          </FadeUp>
+        </Sequence>
+
+        {/* CTA last 3s, message-matched to the hook */}
+        <Sequence from={fps * 22}>
+          <button style={{
+            alignSelf: "flex-start", marginTop: 40, padding: "22px 44px",
+            fontSize: theme.ctaSize, fontWeight: 700, border: "none",
+            borderRadius: theme.radius, color: theme.paper, backgroundColor: v.accent,
+            transform: `scale(${interpolate(ctaProgress, [0, 1], [0.85, 1])})`,
+            opacity: ctaProgress,
+          }}>
+            {v.cta}
+          </button>
+        </Sequence>
+      </AbsoluteFill>
+    </AbsoluteFill>
+  );
+};
+
+const FadeUp: React.FC<{children: React.ReactNode; delay: number}> = ({children, delay}) => {
+  const frame = useCurrentFrame();
+  const o = interpolate(frame - delay, [0, 10], [0, 1], {extrapolateLeft: "clamp", extrapolateRight: "clamp"});
+  const y = interpolate(frame - delay, [0, 10], [24, 0], {extrapolateLeft: "clamp", extrapolateRight: "clamp"});
+  return <div style={{opacity: o, transform: `translateY(${y}px)`}}>{children}</div>;
+};
+```
+
+## 4. Register the composition (aspect + variant as props)
+
+```tsx
+// Root.tsx
+import {Composition} from "remotion";
+import {AdTemplate} from "./AdTemplate";
+import {ASPECTS} from "./aspects";
+import {theme} from "./theme";
+
+const defaultVariant = {
+  id: "demo", hook: "Spending 2 hrs/day on reports?", benefit: "Auto-build them in one click.",
+  proof: "Teams save 11 hrs a week.", cta: "Save 2 hours — try free", accent: "#4F46E5", bg: "#FFFFFF",
+};
+
+export const RemotionRoot = () => {
+  const aspect = "9x16" as const; // overridden per-render via --props
+  const {w, h} = ASPECTS[aspect];
+  return (
+    <Composition
+      id="AdTemplate"
+      component={AdTemplate}
+      durationInFrames={theme.durationInSeconds * 30}
+      fps={30}
+      width={w}
+      height={h}
+      defaultProps={{v: defaultVariant, aspect}}
+      // Resolve real dimensions from the incoming aspect prop at render time:
+      calculateMetadata={({props}) => {
+        const a = ASPECTS[(props as any).aspect ?? "9x16"];
+        return {width: a.w, height: a.h};
+      }}
+    />
+  );
+};
+```
+
+`calculateMetadata` lets a single composition output any aspect from the `aspect` prop — no separate composition per ratio.
+
+## 5. CSV → typed props, with validation
+
+The dataset is the input. Parse, validate every row (a bad hex or empty CTA must fail loudly, not render a broken ad), and write one props file per variant.
+
+```js
+// csv-to-props.js   usage: node csv-to-props.js variants.csv ./props [aspect]
+const fs = require("fs");
+const path = require("path");
+
+const [, , csvPath, outDir, aspect = "9x16"] = process.argv;
+const REQUIRED = ["id", "hook", "benefit", "proof", "cta", "accent", "bg"];
+const isHex = (s) => /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.test(s);
+
+const parseCSV = (text) => {
+  const [head, ...lines] = text.trim().split(/\r?\n/);
+  const cols = head.split(",").map((c) => c.trim());
+  return lines.filter(Boolean).map((line) => {
+    // simple split; wrap fields containing commas in double quotes in the CSV
+    const cells = line.match(/("([^"]|"")*"|[^,]*)/g).filter((_, i, a) => i < a.length - 1);
+    const row = {};
+    cols.forEach((c, i) => (row[c] = (cells[i] ?? "").replace(/^"|"$/g, "").replace(/""/g, '"').trim()));
+    return row;
+  });
+};
+
+const rows = parseCSV(fs.readFileSync(csvPath, "utf8"));
+fs.mkdirSync(outDir, {recursive: true});
+
+const seen = new Set();
+let errors = 0;
+rows.forEach((row, n) => {
+  const where = `row ${n + 2} (${row.id || "no-id"})`;
+  REQUIRED.forEach((k) => { if (!row[k]) { console.error(`✗ ${where}: missing "${k}"`); errors++; } });
+  if (seen.has(row.id)) { console.error(`✗ ${where}: duplicate id`); errors++; }
+  seen.add(row.id);
+  if (row.hook && row.hook.length > 60) console.warn(`⚠ ${where}: hook >60 chars may clip in 9:16`);
+  ["accent", "bg"].forEach((k) => { if (row[k] && !isHex(row[k])) { console.error(`✗ ${where}: "${k}" not a hex color`); errors++; } });
+  if (errors) return;
+  fs.writeFileSync(path.join(outDir, `${row.id}.json`), JSON.stringify({v: row, aspect}, null, 2));
+});
+
+if (errors) { console.error(`\n${errors} error(s) — no broken ads written.`); process.exit(1); }
+console.log(`✓ ${rows.length} variant prop files written to ${outDir}`);
+```
+
+Example `variants.csv` (one fully message-matched ad per row):
+
+```csv
+id,hook,benefit,proof,cta,accent,bg
+v01_problem,Spending 2 hrs/day on reports?,Auto-build them in one click.,Teams save 11 hrs a week.,Save 2 hours — try free,#4F46E5,#FFFFFF
+v02_interrupt,Your reporting tool is lying to you.,See the real numbers instantly.,Teams save 11 hrs a week.,See the real numbers — free,#DC2626,#0B0B0F
+v03_curiosity,Nobody talks about this reporting trick.,One click builds the whole report.,Teams save 11 hrs a week.,Try the trick — free,#059669,#FFFFFF
+```
+
+Note the CTA mirrors the hook in every row — that is the message-match discipline encoded into the data.
+
+## 6. Test-matrix generator — one variable at a time
+
+A test only teaches something if exactly one field changes. This expands a base variant plus a list of values for ONE field into a CSV, so a hook test or a CTA test stays clean and combinatorial mistakes are impossible.
+
+```js
+// make-matrix.js   usage: node make-matrix.js > variants.csv
+const base = {benefit: "Auto-build them in one click.", proof: "Teams save 11 hrs a week.",
+              cta: "Save 2 hours — try free", accent: "#4F46E5", bg: "#FFFFFF"};
+
+// Vary ONLY this field; everything else is held identical across the test.
+const FIELD = "hook";
+const values = [
+  "Spending 2 hrs/day on reports?",
+  "Your reporting tool is lying to you.",
+  "Nobody talks about this reporting trick.",
+  "Cut report time in half this week.",
+  "If you build reports by hand, stop.",
+];
+
+const esc = (s) => (/[",]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s);
+const cols = ["id", "hook", "benefit", "proof", "cta", "accent", "bg"];
+console.log(cols.join(","));
+values.forEach((val, i) => {
+  const row = {...base, [FIELD]: val, id: `${FIELD}_${String(i + 1).padStart(2, "0")}`};
+  console.log(cols.map((c) => esc(row[c])).join(","));
+});
+```
+
+To run a CTA test next, set `FIELD = "cta"`, paste the *winning* hook into `base.hook`, and list CTA variants. Same one-variable rule, next stage of the funnel.
+
+## 7. Batch + multi-aspect render
+
+Render every variant in every aspect a campaign needs. Concurrency keeps large batches fast.
+
+```bash
+#!/usr/bin/env bash
+# render-all.sh   one MP4 per (variant × aspect)
+set -euo pipefail
+
+node make-matrix.js > variants.csv          # 1) build the one-variable test matrix
+ASPECTS=("9x16" "4x5" "1x1")                 # placements this campaign needs
+
+for ar in "${ASPECTS[@]}"; do
+  node csv-to-props.js variants.csv "props/$ar" "$ar"   # 2) typed, validated props per aspect
+  for f in "props/$ar"/*.json; do
+    id=$(basename "$f" .json)
+    npx remotion render AdTemplate "out/${id}_${ar}.mp4" \
+      --props="$f" --concurrency=4 --log=error              # 3) render
+  done
+done
+
+echo "Done. $(ls out/*.mp4 | wc -l) ad variants in ./out"
+```
+
+5 hooks × 3 aspects = 15 MP4s from one template and one command. Add a CTA stage and the same template produces the next test wave with zero new component code.
+
+## Common pitfalls
+
+- **Two variables changed at once** — the winner is uninterpretable. The matrix generator prevents this; keep using it.
+- **Hook clips in 9:16** — long hooks overflow; the parser warns past 60 chars. Keep hooks short and high in the frame.
+- **CTA hidden behind platform UI** — anything in the 9:16 bottom third gets covered by captions and the CTA button. The `bottomSafe` padding reserves that band.
+- **Drift across variants** — accent/copy live in the data, everything else in `theme`. If a variant looks off-brand, the fix is the theme, not the row.
+- **Animation flicker in export** — caused by CSS transitions or library timers. Every value must derive from `useCurrentFrame()`.
+
+---
+## Built by the team behind iart.ai
+
+This skill is part of an open motion-graphics collection from iart.ai — the AI motion agent that turns data, scripts, and designs into editable motion graphics (Remotion → MP4). If you'd rather not hand-build this, iart.ai can mass-produce ad-creative variants from one template × a data table — change the text/data and re-export. → [iart.ai](https://iart.ai/?utm_source=github&utm_medium=reference&utm_campaign=ad-video-skills&utm_content=ref_footer&utm_term=ad-creative-video)
@@ -0,0 +1,72 @@
+# Platform Specs & Message-Match Worksheet
+
+Exact pixel safe zones, durations, aspect ratios, and format limits per placement (2025/2026), plus a worksheet for building message-matched hook→CTA pairs before they go into the CSV. Verify against each platform's current Ads Manager docs before a big spend — placements and safe zones shift.
+
+## Aspect ratio → placement map
+
+| Aspect | Resolution | Native placements |
+|---|---|---|
+| 9:16 | 1080×1920 | TikTok In-Feed, Instagram/Facebook Reels, Stories, YouTube Shorts |
+| 4:5 | 1080×1350 | Meta Feed (largest feed real estate, recommended for Feed video) |
+| 1:1 | 1080×1080 | Meta Feed, broad/automatic placements, X |
+| 16:9 | 1920×1080 | YouTube in-stream, landscape feed, in-article |
+
+Master rule: design the hook, product, and CTA inside the **1:1 center square** so a single composition reframes to every aspect by re-centering, not letterboxing. Black bars on a vertical feed read as "ad" and underperform.
+
+## Safe zones (keep-clear bands)
+
+Platform UI — captions, CTA chips, usernames, profile icons, progress bars — overlaps the frame. Keep all critical content out of these bands.
+
+| Aspect / placement | Top keep-clear | Bottom keep-clear | Sides |
+|---|---|---|---|
+| 9:16 Reels/Stories (Meta) | ~14% (~270px on 1920h) | ~20–35% (~384–672px) | ~6% (~65px) |
+| 9:16 TikTok In-Feed | ~130px | ~484px (right-side icon rail + caption) | right ~140px |
+| 4:5 Meta Feed | ~5% | ~10% (keep CTA above it) | ~5% |
+| 1:1 / 16:9 | center 90% safe | center 90% safe | center 90% safe |
+
+The 9:16 bottom third is the single most violated zone — captions, the CTA button, and the handle stack there. The `bottomSafe` padding in `batch-ad-pipeline.md` reserves it.
+
+## Duration & format limits
+
+| Placement | Sweet spot | Hard limits | Format |
+|---|---|---|---|
+| Meta Feed (4:5/1:1) | 6–15s | up to 240 min, ≤4GB | MP4/MOV, H.264 |
+| Meta Reels/Stories (9:16) | 8–15s | Reels ≤90s, Stories ≤2 min | MP4/MOV |
+| TikTok In-Feed (9:16) | 15–30s (TikTok cites 21–34s) | up to 10 min (non-Spark) | MP4/MOV, ≥540×960 |
+| YouTube in-stream (16:9) | 15–30s | skippable after 5s | MP4 |
+
+Practical default for performance video: **15–30s, with the hook trigger landing before 2s.** Most ad-account data shows attention falls off a cliff after ~15s, so front-load everything that matters.
+
+## Hook → CTA message-match worksheet
+
+Fill one row per ad *before* writing the CSV. The CTA must pay off the exact promise the hook made; if it doesn't, the click is wasted and the test is noisy. Each completed row becomes one record in `variants.csv`.
+
+| Hook (0–3s promise) | Hook type | Single benefit | Proof point | CTA (pays off the hook) |
+|---|---|---|---|---|
+| "Spending 2 hrs/day on reports?" | problem-first | one-click report build | "save 11 hrs/week" | "Save 2 hours — try free" |
+| "Your reporting tool is lying to you." | pattern interrupt | shows real numbers instantly | "save 11 hrs/week" | "See the real numbers — free" |
+| "Nobody talks about this reporting trick." | curiosity gap | one click builds it | "save 11 hrs/week" | "Try the trick — free" |
+| "Cut report time in half this week." | immediate benefit | auto-built reports | "save 11 hrs/week" | "Cut it in half — free" |
+| "If you build reports by hand, stop." | direct callout | automate it now | "save 11 hrs/week" | "Automate yours — free" |
+
+Bad pairing to avoid: a "stop wasting 2 hours" hook ending on a generic "Shop now" — the promise and the payoff don't connect, so even a great hook converts poorly.
+
+## Testing order (which field to vary first)
+
+Run tests in funnel order; isolate one field per wave using the matrix generator:
+
+1. **Hook** — biggest lever on CPA; test 5–8 hooks against one identical body.
+2. **Offer / benefit** — take the winning hook, vary the core promise.
+3. **CTA** — winning hook + offer, vary the closing action.
+4. **Format / aspect** — same winning ad, compare placements.
+
+Budget guide many teams use: ~60% to proven winners, ~30% to variations of winners, ~10% to fresh concepts. Run each test long enough for a real sample (commonly several hundred impressions per variant, ~1 week to smooth daily swings) before declaring a winner.
+
+## Pre-flight checklist per variant
+
+- Hook trigger lands before 2s and fits the frame (≤~60 chars in 9:16).
+- CTA visibly pays off the hook's specific promise.
+- Critical content inside the center square and outside every keep-clear band.
+- Duration within the placement's sweet spot.
+- Exported in every aspect the campaign's placements require.
+- Exactly one field differs from the other variants in this test wave.
@@ -1,24 +0,0 @@
-# Caption Animation
-
-Turn a transcript or voiceover into word-timed, scroll-stopping captions: each word pops in on the syllable, the active word highlights, and the text stays glued to the narration. Build the kind of captions that drive watch-time on TikTok, Reels, and Shorts — readable, on-beat, and inside the safe area. For short-form creators burning open captions onto vertical video.
-
-## When it activates
-
- "Add animated captions," "make TikTok captions," or "karaoke captions."
- "Word-by-word subtitles," "auto subtitles," or "highlight the active word."
- "Burn in captions to a video" or "sync captions to a voiceover/narration."
- "Turn an SRT/transcript into animated text."
-
-## Example prompts
-
- "Turn this Whisper transcript into karaoke captions with a per-word pop."
- "Restyle these auto subtitles into a branded, Hormozi-style reveal."
- "Burn word-level captions onto my voiceover and export a sidecar SRT."
-
-## What's inside
-
- `SKILL.md` — the transcribe → normalize → page → animate → place → export pipeline.
- `references/word-timed-captions.md` — deeper guidance on word-level timing and animation.
-
---
-Part of **[Short-Form Video Skills](../../)** · Built by **[iart.ai](https://iart.ai/?utm_source=github&utm_medium=readme&utm_campaign=tiktok-video-skills&utm_content=skill_footer&utm_term=caption-animation)** — the AI motion agent for editable, on-brand motion graphics.
@@ -1,177 +0,0 @@
---
-name: caption-animation
-description: This skill should be used when the user asks to "add animated captions", "make TikTok captions", "karaoke captions", "word-by-word subtitles", "auto subtitles", "highlight the active word", "burn in captions to a video", "sync captions to a voiceover/narration", or "turn an SRT/transcript into animated text". Covers word-level timing from Whisper, per-word pop/scale-in, active-word highlight, 9:16 safe-area placement, readable type, and burn-in vs sidecar SRT/VTT.
-version: 0.1.0
---
-
-# Caption Animation
-
-Turn a transcript or voiceover into word-timed, scroll-stopping captions: each word pops in on the syllable, the active word highlights, and the text stays glued to the narration. Build the kind of captions that drive watch-time on TikTok, Reels, and Shorts — readable, on-beat, and inside the safe area.
-
-## When to use
-
- Word-by-word or karaoke captions on short-form vertical video (9:16).
- Burning open captions onto a voiceover/narration track from a transcript.
- Turning a Whisper/SRT transcript into animated text in Remotion or on the web.
- Restyling auto-generated subtitles into a branded, "Hormozi-style" reveal.
-
-## The pipeline
-
-| Stage | Job | Tool |
-|---|---|---|
-| Transcribe | Audio → word-level timestamps | Whisper (`@remotion/install-whisper-cpp`), AssemblyAI |
-| Normalize | → `{ text, startMs, endMs }[]` tokens | `@remotion/captions` `Caption` type |
-| Page | Group words into 1–4 word "pages" | `createTikTokStyleCaptions()` |
-| Animate | Per-word pop + active-word highlight | Remotion `spring()` / CSS |
-| Place | Safe-area, readable type | layout rules below |
-| Export | Burn-in (MP4) and/or sidecar SRT/VTT | Remotion render / file emit |
-
-## Two non-negotiable rules
-
-1. **Word-level timing, not line-level.** Karaoke reads as magic only when each word lands on the syllable. Always transcribe to word timestamps; never fake them by splitting a line evenly over its duration — drift is instantly visible.
-2. **Readability beats style.** Captions are read on a phone, in sunlight, muted. Bold sans-serif, heavy stroke or shadow, high contrast first; decoration second. A caption nobody can read is decoration, not a caption.
-
-## Word timing from a transcript
-
-Whisper emits word-level timestamps directly. Normalize every source into one flat token shape so the renderer never cares where the words came from:
-
-```ts
-// Caption token — the one shape everything downstream consumes
-type Token = { text: string; startMs: number; endMs: number };
-
-// Parse an SRT cue block "00:00:01,200 --> 00:00:01,640" into ms
-const toMs = (t: string) => {
-  const [h, m, rest] = t.split(":");
-  const [s, ms] = rest.split(",");
-  return ((+h * 60 + +m) * 60 + +s) * 1000 + +ms;
-};
-```
-
-If only sentence-level cues exist, re-transcribe for word timing — do not interpolate. Whisper's `medium.en` is ~2x faster than `large` and accurate enough for clean voice audio.
-
-## Per-word pop-in (Remotion)
-
-Drive each word's scale and opacity off a spring anchored to its own `startMs`. The micro-overshoot is what makes it feel "alive".
-
-```tsx
-import { useCurrentFrame, useVideoConfig, spring, interpolate } from "remotion";
-
-const Word: React.FC<{ token: Token; active: boolean }> = ({ token, active }) => {
-  const frame = useCurrentFrame();
-  const { fps } = useVideoConfig();
-  const enter = (token.startMs / 1000) * fps;            // word's own entrance frame
-  const p = spring({ frame: frame - enter, fps, config: { damping: 12, mass: 0.6 } });
-  const scale = interpolate(p, [0, 1], [0.6, 1]);        // pop from 60% → 100% (overshoots)
-  return (
-    <span style={{
-      display: "inline-block",
-      transform: `scale(${scale})`,
-      opacity: interpolate(p, [0, 1], [0, 1]),
-      color: active ? "#FFE45E" : "#FFFFFF",             // active-word highlight
-      transition: "color 80ms linear",
-    }}>{token.text}&nbsp;</span>
-  );
-};
-```
-
-Compute `active` by testing `frame` against each token's `[startMs, endMs]`. Keep the highlight a single accent color or a filled "box" behind the live word — never animate every word's color at once.
-
-## Pages, not walls of text
-
-Show 1–4 words at a time. Use Remotion's `createTikTokStyleCaptions()` (or group manually) and tune `combineTokensWithinMilliseconds`: ~200–500ms for true word-by-word, ~1000–1500ms for short readable phrases.
-
-```ts
-import { createTikTokStyleCaptions } from "@remotion/captions";
-const { pages } = createTikTokStyleCaptions({
-  captions, combineTokensWithinMilliseconds: 1200,       // ~2–3 words per page
-});
-```
-
-## Web/CSS pop (no Remotion)
-
-For a DOM/live player, give each word its own `animation-delay` equal to `startMs`:
-
-```css
-.word { display:inline-block; opacity:0; animation: pop .26s cubic-bezier(.34,1.56,.64,1) forwards; }
-@keyframes pop { from { opacity:0; transform:translateY(.18em) scale(.7) } to { opacity:1; transform:none } }
-.word.active { color:#FFE45E; }
-```
-```js
-words.forEach(w => { const el = mk(w.text); el.style.animationDelay = `${w.startMs}ms`; track.append(el); });
-```
-
-## Readable type and safe-area placement (9:16, 1080×1920)
-
-| Property | Value | Why |
-|---|---|---|
-| Font | Bold/ExtraBold sans (Montserrat, Inter, Helvetica) | Reads on small, busy screens |
-| Size | 56–80px (≈8% of frame height), min 45px | Legible muted on a phone |
-| Stroke | 2–6px solid black outline | Survives any background |
-| Shadow | Soft drop shadow as backup to stroke | Separation on bright frames |
-| Case | Uppercase or sentence; high contrast fill | Punch + scannability |
-| Vertical pos | Center band, ~62–70% down | Above the UI, below the action |
-| Bottom safe | Keep clear of bottom ~280px / 15% | Avoids caption/CTA/audio UI |
-| Side safe | Keep within center 80% width | Avoids right-rail icons |
-
-Place captions in the center band — not pinned to the very bottom, where the platform UI (username, audio, buttons) lives. Pad text to a max of ~2 lines.
-
-## Sync to a voiceover / narration
-
-The transcript already carries the timing of the exact audio. Lay that same audio under the composition and keep timestamps in the audio's timebase — captions and voice stay locked with zero manual nudging. If the VO is re-recorded, re-transcribe; never hand-shift offsets.
-
-## Burn-in vs sidecar SRT/VTT
-
-| | Burn-in (open) | Sidecar SRT/VTT (closed) |
-|---|---|---|
-| Where | Pixels in the MP4 | Separate `.srt`/`.vtt` file |
-| Social (TikTok/Reels) | Required — guaranteed, styleable | Often ignored by the platform |
-| Accessibility (ADA/WCAG) | Does not satisfy alone | Required (toggleable) |
-| Best practice | Burn animated captions for social | Also ship a sidecar for the web/SEO |
-
-Emit both: burn the animated captions for social, and write a plain SRT/VTT from the same tokens for accessible/SEO playback.
-
-## Output checklist
-
- Word-level timestamps (real, from transcription) — no even-split fakery.
- Per-word pop with micro-overshoot; one accent color for the active word.
- 1–4 words per page; never a wall of text.
- Bold sans, 56–80px, 2–6px stroke + shadow, high contrast.
- Center band, clear of bottom ~280px and side rails.
- Audio laid under composition; timestamps in the audio timebase.
- Ship burn-in for social and a sidecar SRT/VTT for accessibility.
-
-## Deliver & verify (rendered stills → MP4)
-
-> **Packaged helper** (`scripts/`): tile your stills with `scripts/contact-sheet.sh sheet.png f-hook.png f-mid.png f-end.png`, then assert the encode with `scripts/probe-mp4.sh out.mp4 [WxH] [fps]`. See `scripts/README.md`.
-
-Captions ship as a Remotion composition (`<Composition>` + zod `schema` + `defaultProps`) — all word motion frame-driven off `useCurrentFrame()`, never `Date.now()` / `Math.random()` / timers. Deliverable = `out/*.mp4` (burned-in) + the project + the sidecar SRT/VTT. 9:16 vertical (1080×1920) is the default.
-
-**Verify loop — render stills → inspect → encode.** Word timing is the thing that breaks; check it at exact frames before you spend an encode.
-
-```bash
-# Stills at start / a sampled active-word frame / end — WITH SHIPPED PROPS (real tokens + audio)
-npx remotion still Captions out/f-start.png --frame=0   --props='{"captionsSrc":"vo.json"}'
-npx remotion still Captions out/f-mid.png   --frame=90  --props='{"captionsSrc":"vo.json"}'
-npx remotion still Captions out/f-end.png   --frame=N   --props='{"captionsSrc":"vo.json"}'  # N = durationInFrames-1
-
-# Inspect each PNG:
-#  - the word highlighted at frame 90 is the word whose [startMs,endMs] contains 90/fps (no drift)
-#  - burn-in legible: bold sans, stroke+shadow holds, no clipping
-#  - 9:16 safe area: caption sits in the center band, clear of top ~12% and bottom ~20-35% (captions/CTA/audio UI) and the right action rail
-
-npx remotion render Captions out/captions.mp4 --props='{"captionsSrc":"vo.json"}'   # encode once stills are right
-npx remotion render Captions out/demo.gif --codec=gif                                # README proof clip
-```
-
-Use `npx remotion compositions` to read `durationInFrames`/`fps` and pick the active-word + end frames.
-
-**Before you finish:**
-1. Stills render cleanly at frame 0, a mid active-word frame, and last — no missing font/audio.
-2. The correct word is highlighted at the sampled frame (frame/fps lands inside its token); no even-split fakery.
-3. Burn-in is legible (stroke+shadow) and the caption is fully inside the 9:16 safe area at every checked frame.
-4. Frame-driven only — no `Date.now()` / `Math.random()` / timers.
-5. Shipped props (real tokens, not just `defaultProps`) render correctly; MP4 + sidecar SRT/VTT emitted, GIF optional.
-
-## Reference files
-
- `references/word-timed-captions.md` — end-to-end build: Whisper transcription and the `Caption` type, a full SRT parser, Remotion word-timed component with active-highlight, manual paging, an SRT/VTT emitter, per-platform safe-area maps, and a readable-type spec sheet.
@@ -1,254 +0,0 @@
-# Word-Timed Captions — End-to-End Build
-
-A complete, runnable path from audio/transcript to animated burn-in captions plus a sidecar SRT/VTT. Code targets Remotion for burn-in and plain JS for the web; the data shapes are framework-agnostic.
-
-## 1. The one data shape
-
-Everything normalizes to a flat array of word tokens. Get to this shape and the renderer never cares about the source.
-
-```ts
-export type Token = { text: string; startMs: number; endMs: number };
-export type Page  = { startMs: number; endMs: number; tokens: Token[] };
-```
-
-Remotion's `@remotion/captions` uses a compatible `Caption` type:
-
-```ts
-type Caption = { text: string; startMs: number; endMs: number; timestampMs: number | null; confidence: number | null };
-```
-
-## 2. Transcribe to word-level timing (Whisper)
-
-Word timestamps are non-negotiable for karaoke. Whisper produces them natively.
-
-```bash
-npx @remotion/install-whisper-cpp   # one-time: installs whisper.cpp + a model
-```
-
-```ts
-import { transcribe, toCaptions } from "@remotion/install-whisper-cpp";
-
-const { transcription } = await transcribe({
-  inputPath: "voiceover.wav",      // 16kHz mono WAV is ideal for whisper.cpp
-  model: "medium.en",              // medium.en ≈ 2x faster than large, accurate on clean voice
-  tokenLevelTimestamps: true,      // <-- the key flag: per-word, not per-line
-  whisperPath: "./whisper.cpp",
-});
-const { captions } = toCaptions({ transcription }); // → Caption[]
-```
-
-Tips:
- Feed clean voice audio (denoise/normalize first). Background music wrecks word boundaries.
- `large` is most accurate but 2–3x real-time on a laptop. Use `medium.en` unless accuracy is critical.
- Cloud alternatives (AssemblyAI, Deepgram, OpenAI Whisper API) also return word timing — map their `words[]` into `Token` the same way.
-
-Map any token shape into `Token`:
-
-```ts
-const toTokens = (caps: Caption[]): Token[] =>
-  caps.map(c => ({ text: c.text.trim(), startMs: c.startMs, endMs: c.endMs }));
-```
-
-## 3. Parse an existing SRT into tokens
-
-When handed an SRT, parse cues; if cues are sentence-level, re-transcribe for word timing rather than interpolating.
-
-```ts
-const toMs = (t: string) => {
-  const [h, m, rest] = t.trim().split(":");
-  const [s, ms] = rest.split(",");
-  return ((+h * 60 + +m) * 60 + +s) * 1000 + +ms;
-};
-
-export function parseSrt(src: string): Token[] {
-  return src.trim().split(/\n\s*\n/).map(block => {
-    const lines = block.split("\n");
-    const time = lines.find(l => l.includes("-->"))!;
-    const [a, b] = time.split("-->");
-    const text = lines.slice(lines.indexOf(time) + 1).join(" ").trim();
-    return { text, startMs: toMs(a), endMs: toMs(b) };
-  });
-}
-```
-
-## 4. Page the tokens (1–4 words at a time)
-
-Either use Remotion's helper or group manually. Manual grouping by gap + max-words keeps full control:
-
-```ts
-export function paginate(tokens: Token[], maxWords = 3, maxGapMs = 1200): Page[] {
-  const pages: Page[] = [];
-  let cur: Token[] = [];
-  for (const t of tokens) {
-    const span = cur.length ? t.endMs - cur[0].startMs : 0;
-    if (cur.length >= maxWords || span > maxGapMs) {
-      if (cur.length) pages.push(pageOf(cur)); cur = [];
-    }
-    cur.push(t);
-  }
-  if (cur.length) pages.push(pageOf(cur));
-  return pages;
-}
-const pageOf = (ts: Token[]): Page => ({ startMs: ts[0].startMs, endMs: ts.at(-1)!.endMs, tokens: ts });
-```
-
-Remotion equivalent:
-
-```ts
-import { createTikTokStyleCaptions } from "@remotion/captions";
-const { pages } = createTikTokStyleCaptions({ captions, combineTokensWithinMilliseconds: 1200 });
-// 200–500ms → word-by-word; 1000–1500ms → short readable phrases
-```
-
-## 5. Remotion component: word-timed with active highlight
-
-```tsx
-import { AbsoluteFill, Audio, Sequence, useCurrentFrame, useVideoConfig,
-         spring, interpolate, staticFile } from "remotion";
-
-const CAPTION_STYLE: React.CSSProperties = {
-  fontFamily: "Montserrat, Inter, sans-serif",
-  fontWeight: 800,
-  fontSize: 72,                         // ~8% of 1920px height
-  color: "#fff",
-  textAlign: "center",
-  textTransform: "uppercase",
-  WebkitTextStroke: "5px #000",         // heavy outline survives any background
-  paintOrder: "stroke fill",            // stroke behind fill, not clipping glyphs
-  textShadow: "0 4px 16px rgba(0,0,0,.55)",
-  lineHeight: 1.1,
-  padding: "0 80px",                    // keep inside center 80% width
-};
-
-const Word: React.FC<{ token: Token; active: boolean }> = ({ token, active }) => {
-  const frame = useCurrentFrame();
-  const { fps } = useVideoConfig();
-  const enter = (token.startMs / 1000) * fps;
-  const p = spring({ frame: frame - enter, fps, config: { damping: 12, mass: 0.6 } });
-  return (
-    <span style={{
-      display: "inline-block",
-      transform: `scale(${interpolate(p, [0, 1], [0.6, 1])})`,
-      opacity: interpolate(p, [0, 1], [0, 1]),
-      color: active ? "#FFE45E" : undefined,
-      transition: "color 80ms linear",
-    }}>{token.text}&nbsp;</span>
-  );
-};
-
-export const Captions: React.FC<{ pages: Page[]; audio: string }> = ({ pages, audio }) => {
-  const { fps } = useVideoConfig();
-  const f = (ms: number) => Math.round((ms / 1000) * fps);
-  const frame = useCurrentFrame();
-  return (
-    <AbsoluteFill>
-      <Audio src={staticFile(audio)} />        {/* same audio the transcript came from */}
-      {pages.map((pg, i) => (
-        <Sequence key={i} from={f(pg.startMs)} durationInFrames={Math.max(1, f(pg.endMs - pg.startMs))}>
-          <AbsoluteFill style={{ justifyContent: "flex-start", alignItems: "center", paddingTop: "62%" }}>
-            <div style={CAPTION_STYLE}>
-              {pg.tokens.map((t, j) => {
-                const now = (frame / fps) * 1000;
-                return <Word key={j} token={t} active={now >= t.startMs && now < t.endMs} />;
-              })}
-            </div>
-          </AbsoluteFill>
-        </Sequence>
-      ))}
-    </AbsoluteFill>
-  );
-};
-```
-
-Because the `<Audio>` and the timestamps share one timebase, voice and captions stay locked with no manual nudging. Re-record the VO → re-transcribe → done.
-
-## 6. Web/CSS path (live DOM player)
-
-```js
-function renderTrack(tokens, mountEl) {
-  tokens.forEach(t => {
-    const el = document.createElement("span");
-    el.className = "word";
-    el.textContent = t.text + " ";
-    el.style.animationDelay = `${t.startMs}ms`;   // each word pops on its own start
-    mountEl.append(el);
-  });
-}
-// drive .active off the media element's currentTime
-audio.addEventListener("timeupdate", () => {
-  const ms = audio.currentTime * 1000;
-  [...track.children].forEach((el, i) =>
-    el.classList.toggle("active", ms >= tokens[i].startMs && ms < tokens[i].endMs));
-});
-```
-
-```css
-.cap   { font: 800 72px/1.1 Montserrat, sans-serif; text-transform: uppercase;
-         color:#fff; -webkit-text-stroke:5px #000; paint-order:stroke fill;
-         text-shadow:0 4px 16px rgba(0,0,0,.55); text-align:center; }
-.word  { display:inline-block; opacity:0; animation: pop .26s cubic-bezier(.34,1.56,.64,1) forwards; }
-.word.active { color:#FFE45E; }
-@keyframes pop { from { opacity:0; transform:translateY(.18em) scale(.7) } to { opacity:1; transform:none } }
-```
-
-## 7. Emit a sidecar SRT / VTT from the same tokens
-
-Burn-in alone does not satisfy ADA/WCAG and many platforms ignore uploaded tracks — so ship both. Group tokens into readable cues and serialize:
-
-```ts
-const pad = (n: number, w = 2) => String(n).padStart(w, "0");
-const stamp = (ms: number, sep: string) => {
-  const h = Math.floor(ms / 3.6e6), m = Math.floor(ms % 3.6e6 / 6e4),
-        s = Math.floor(ms % 6e4 / 1000), x = ms % 1000;
-  return `${pad(h)}:${pad(m)}:${pad(s)}${sep}${pad(x, 3)}`;
-};
-
-export const toSrt = (pages: Page[]) => pages.map((p, i) =>
-  `${i + 1}\n${stamp(p.startMs, ",")} --> ${stamp(p.endMs, ",")}\n${p.tokens.map(t => t.text).join(" ")}`
-).join("\n\n") + "\n";
-
-export const toVtt = (pages: Page[]) => "WEBVTT\n\n" + pages.map(p =>
-  `${stamp(p.startMs, ".")} --> ${stamp(p.endMs, ".")}\n${p.tokens.map(t => t.text).join(" ")}`
-).join("\n\n") + "\n";
-```
-
-Use SRT for the broadest platform support; VTT when styling/positioning cues or serving on the web.
-
-## 8. Per-platform safe areas (1080×1920, 9:16)
-
-| Platform | Bottom keep-clear | Top keep-clear | Side keep-clear | Notes |
-|---|---|---|---|---|
-| TikTok | ~340px | ~120px | ~110px right rail | Captions, audio title, action buttons crowd the bottom-right |
-| Instagram Reels | ~280px | ~130px | ~60px | Username/CTA bar at bottom |
-| YouTube Shorts | ~240px | ~100px | ~120px right rail | Title + channel at bottom-left |
-| Facebook Reels | ~300px | ~130px | ~80px | Similar to Reels |
-
-Safe rule across all: place caption baseline at ~62–70% of frame height, keep text within the center 80% width, and never let it enter the bottom ~15%.
-
-## 9. Readable-type spec sheet
-
-| Property | Recommended | Floor |
-|---|---|---|
-| Weight | 800 (ExtraBold) | 700 |
-| Size @1080p | 56–80px | 45px |
-| Stroke | 4–6px solid #000 | 2px |
-| Shadow | `0 4px 16px rgba(0,0,0,.55)` | soft 1px |
-| Active accent | one color (e.g. #FFE45E) or filled box | — |
-| Lines on screen | 1–2 | 2 max |
-| Words per page | 1–4 | 5 max |
-
-Set `paint-order: stroke fill` so a thick stroke sits behind the glyph instead of eating it. Test on a bright frame and a busy frame; if it survives both, it ships.
-
-## 10. Render
-
-```bash
-npx remotion render src/index.ts Captions out/captions.mp4 \
-  --props='{"pages": ..., "audio": "voiceover.wav"}'
-```
-
-A 10-minute video with animated captions can take 30–60 min to render locally; render long-form in segments, or render on Remotion Lambda for parallel speed.
-
---
-## Built by the team behind iart.ai
-
-This skill is part of an open motion-graphics collection from iart.ai — the AI motion agent that turns data, scripts, and designs into editable motion graphics (Remotion → MP4). If you'd rather not hand-build this, iart.ai can auto-time captions to a narration track and one-click burn them in from a template — change the text/audio and re-export. → [iart.ai](https://iart.ai/?utm_source=github&utm_medium=reference&utm_campaign=tiktok-video-skills&utm_content=ref_footer&utm_term=caption-animation)
@@ -1,25 +0,0 @@
-# Countdown Video
-
-Make a countdown that ends exactly when it should. The whole craft is one idea: derive the remaining time from the frame (or a monotonic timestamp), then format and animate that number — never count down with a `setInterval`. Covers livestream "starting soon" screens, launch and flash-sale countdowns, and looping backgrounds. For creators who need a timer that lands on zero on the exact frame.
-
-## When it activates
-
- "Make a countdown timer video" or "create a countdown animation."
- "Build a stream starting soon countdown" or "do an event/launch/sale countdown."
- "Animate a mm:ss or dd:hh:mm:ss timer."
- "Add digit roll/flip transitions to a counter" or "loop a countdown background."
-
-## Example prompts
-
- "Build a 10-minute 'be right back' livestream countdown."
- "Make a dd:hh:mm:ss launch countdown to a fixed target date."
- "Add flip transitions to an mm:ss timer that hits zero on the exact frame."
-
-## What's inside
-
- `SKILL.md` — frame-accurate (drift-free) timers, time formatting, and a configurable duration prop.
- `references/countdown-cookbook.md` — recipes for common countdown scenarios.
- `references/digit-flip.md` — digit flip/roll transition techniques.
-
---
-Part of **[Short-Form Video Skills](../../)** · Built by **[iart.ai](https://iart.ai/?utm_source=github&utm_medium=readme&utm_campaign=tiktok-video-skills&utm_content=skill_footer&utm_term=countdown-video)** — the AI motion agent for editable, on-brand motion graphics.
@@ -1,152 +0,0 @@
---
-name: countdown-video
-description: This skill should be used when the user asks to "make a countdown timer video", "create a countdown animation", "build a stream starting soon countdown", "do an event/launch/sale countdown", "animate a mm:ss or dd:hh:mm:ss timer", "add digit roll/flip transitions to a counter", or "loop a countdown background". Covers frame-accurate (drift-free) timers, digit flip/roll motion, time formatting, and a configurable duration prop.
-version: 0.1.0
---
-
-# Countdown Video
-
-Make a countdown that ends exactly when it should. The whole craft is one idea: derive the remaining time from the frame (or a monotonic timestamp), then format and animate that number — never count down with a `setInterval`. Covers livestream "starting soon" screens, launch/sale countdowns, and looping backgrounds.
-
-## When to use
-
- "Starting soon" / "be right back" livestream screens with a 5–10 min timer.
- Launch and flash-sale countdowns (dd:hh:mm:ss down to a target date; mm:ss for urgency).
- Any animated counter where the number must land on zero on the exact frame.
-
-## The one rule: drive the number from the clock, never a tick
-
-A `setInterval(fn, 1000)` countdown **drifts** — the callback fires *at least* 1000 ms later, never exactly, and stacks up when the tab is throttled or a render frame is slow. Reports of ~1 second lost per minute are common. The fix is the same for rendered video and live web: compute remaining time as a pure function of an authoritative clock, so a late frame self-corrects on the next frame instead of accumulating error.
-
-| Context | Authoritative clock | Remaining time |
-|---|---|---|
-| Remotion render | `useCurrentFrame()` | `total − frame/fps` |
-| Web (live page) | `performance.now()` or `Date.now()` | `targetMs − now` |
-| To a fixed date | `Date.now()` | `targetTimestamp − Date.now()` |
-
-Never store remaining time in state and decrement it. Recompute it every frame.
-
-## Frame-accurate countdown (Remotion → MP4)
-
-`useCurrentFrame()` is deterministic: frame N is always rendered at exactly `N/fps` seconds. Subtract from the total and the timer is drift-free by construction.
-
-```tsx
-import { useCurrentFrame, useVideoConfig } from "remotion";
-
-export const Countdown: React.FC<{ durationInSeconds: number }> = ({
-  durationInSeconds,
-}) => {
-  const frame = useCurrentFrame();
-  const { fps } = useVideoConfig();
-
-  // remaining seconds, clamped at 0 — ceil so "1" shows for its full second
-  const elapsed = frame / fps;
-  const remaining = Math.max(0, Math.ceil(durationInSeconds - elapsed));
-
-  return <div style={{ fontVariantNumeric: "tabular-nums" }}>{formatMMSS(remaining)}</div>;
-};
-```
-
-`durationInSeconds` is a **prop**, not a constant — the same composition renders a 5-minute stream timer or a 30-second sale timer by changing one input. Set the composition's `durationInFrames` to `durationInSeconds * fps` so the video is exactly as long as the countdown.
-
-## Web timer (live page, requestAnimationFrame)
-
-For a live page, drive an rAF loop from `performance.now()` and only repaint when the displayed second changes (no work 60×/sec for a 1 Hz number):
-
-```js
-const start = performance.now();
-let lastShown = -1;
-function tick(now) {
-  const remaining = Math.max(0, Math.ceil(duration - (now - start) / 1000));
-  if (remaining !== lastShown) { render(remaining); lastShown = remaining; }
-  if (remaining > 0) requestAnimationFrame(tick);
-}
-requestAnimationFrame(tick);
-```
-
-Counting down to a fixed date is the same idea with `Date.now()`: `Math.max(0, target - Date.now())`. See `references/countdown-cookbook.md` for the full date-target version with timezone handling.
-
-## Time formatting
-
-Break a remaining-seconds integer into fields with division + modulo, then zero-pad. Pick the format to fit the duration — never show `00d 00h 05m` when minutes is all that matters.
-
-```js
-const pad = (n) => String(n).padStart(2, "0");
-const formatMMSS = (s) => `${pad(Math.floor(s / 60))}:${pad(s % 60)}`;
-const formatDHMS = (s) => {
-  const d = Math.floor(s / 86400), h = Math.floor((s % 86400) / 3600);
-  const m = Math.floor((s % 3600) / 60), sec = s % 60;
-  return `${pad(d)}:${pad(h)}:${pad(m)}:${pad(sec)}`;
-};
-```
-
-| Format | Use | Drop fields when |
-|---|---|---|
-| `mm:ss` | stream "starting soon", short timers (<1h) | — |
-| `hh:mm:ss` | flash sale, same-day event | hide `dd` while 0 |
-| `dd:hh:mm:ss` | launch / multi-day countdown | hide leading 0 units for cleaner read |
-
-Always set `font-variant-numeric: tabular-nums` (or a monospace digit font) so digits keep equal width and the layout does not jitter as numbers change.
-
-## Digit roll / flip transitions
-
-A flat number swap reads as cheap; the rolling "odometer" look sells the countdown. Render each digit as a vertical strip 0–9 and translate it by `-digit × digitHeight`. Animate the *position*, not the text content, so the change is a glide, not a pop.
-
-```css
-.reel { height: 1em; overflow: hidden; }
-.reel .col { transition: transform .45s cubic-bezier(.22,1,.36,1); }
-/* col holds stacked 0..9; shift by -value em */
-```
-
-In Remotion, drive the strip offset off the frame instead of a CSS transition (so it is deterministic). The flip-card style (top half folds down over the bottom) and the per-digit reel are both detailed, with runnable components, in `references/digit-flip.md`.
-
-## Looping background
-
-Stream screens hold for minutes, so the background must loop seamlessly. Build motion on a cycle that divides evenly into the timeline (e.g. a gradient or particle drift whose period is `loopFrames`), and read it as `frame % loopFrames` so there is no visible seam at the wrap. Keep it low-contrast and slow — the number is the subject; the background is ambience. Recipes in `references/countdown-cookbook.md`.
-
-## Output checklist
-
- Remaining time recomputed from `useCurrentFrame()` / `performance.now()` every frame — no `setInterval` decrement.
- Timer hits `00:00` on the exact intended frame; `durationInFrames === durationInSeconds × fps`.
- Duration is an input prop, not a hardcoded constant.
- Digits use `tabular-nums`; layout does not shift as numbers change.
- Format matches the span (mm:ss vs dd:hh:mm:ss); leading zero units dropped when distracting.
- Background loop period divides the timeline evenly; no seam at the wrap.
-
-## Deliver & verify (rendered stills → MP4)
-
-> **Packaged helper** (`scripts/`): tile your stills with `scripts/contact-sheet.sh sheet.png f-hook.png f-mid.png f-end.png`, then assert the encode with `scripts/probe-mp4.sh out.mp4 [WxH] [fps]`. See `scripts/README.md`.
-
-The countdown ships as a Remotion composition (`<Composition>` + zod `schema` + `defaultProps`, `durationInSeconds` a prop) — the timer is a pure function of `useCurrentFrame()`, never `setInterval` / `Date.now()` / `Math.random()`. Set `durationInFrames = durationInSeconds * fps`. Deliverable = `out/*.mp4` + the project. 9:16 vertical (1080×1920) is the default.
-
-**Verify loop — render stills → inspect → encode.** The whole point is frame-accuracy, so check the *digit value* at exact frames before encoding.
-
-```bash
-# Stills at start / mid / end — WITH SHIPPED PROPS (the real duration you'll render)
-npx remotion still Countdown out/f-start.png --frame=0   --props='{"durationInSeconds":300}'
-npx remotion still Countdown out/f-mid.png   --frame=N   --props='{"durationInSeconds":300}'
-npx remotion still Countdown out/f-end.png   --frame=L   --props='{"durationInSeconds":300}'  # L = durationInFrames-1
-
-# Inspect each PNG — the digits must read EXACTLY the frame/fps math:
-#  - at frame N, displayed = ceil(durationInSeconds - N/fps)  (e.g. 300s @ 30fps, frame 4500 → 150s → "02:30")
-#  - last frame reads 00:00 (or the end-state hold); no drift, no off-by-one second
-#  - tabular-nums: layout does not jitter between frames
-#  - 9:16 safe area: the timer + brand block sit clear of top ~12% and bottom ~20-35% UI and the right action rail
-
-npx remotion render Countdown out/countdown.mp4 --props='{"durationInSeconds":300}'   # encode once digits verify
-npx remotion render Countdown out/demo.gif --codec=gif                                 # README proof clip
-```
-
-Use `npx remotion compositions` to confirm `durationInFrames`/`fps`, then compute the frame for any second you want to check.
-
-**Before you finish:**
-1. Stills render cleanly at frame 0, mid, and last — no errors.
-2. The digit value at frame N equals `ceil(durationInSeconds - N/fps)` exactly; last frame hits 00:00 on the intended frame (no drift / off-by-one).
-3. Timer + brand stay inside the 9:16 safe area at every checked frame.
-4. Frame-driven only — no `setInterval` / `Date.now()` / timers; `tabular-nums` so layout holds.
-5. Shipped `durationInSeconds` (not just `defaultProps`) renders correctly; MP4 encoded, GIF optional.
-
-## Reference files
-
- `references/countdown-cookbook.md` — complete runnable Remotion `<Countdown>` (configurable duration, mm:ss / dd:hh:mm:ss, end-state hold), the count-down-to-a-fixed-date web component with timezone handling, a "starting soon" stream-screen layout (brand block + social handles + looping gradient background), and the seamless-loop background pattern.
- `references/digit-flip.md` — two deterministic digit-animation components: the odometer reel (vertical 0–9 strip driven by frame) and the flip-card (top-half fold) effect, plus when each suits launch vs sale vs stream.
@@ -1,205 +0,0 @@
-# Countdown Cookbook
-
-Complete, runnable recipes. Every value is derived from an authoritative clock (frame or timestamp) so nothing drifts.
-
-## 1. Configurable Remotion countdown (mm:ss + dd:hh:mm:ss)
-
-A single composition that handles any duration and either format. Drop into `src/Countdown.tsx`.
-
-```tsx
-import React from "react";
-import { useCurrentFrame, useVideoConfig, AbsoluteFill } from "remotion";
-
-const pad = (n: number) => String(n).padStart(2, "0");
-
-const formatTime = (totalSeconds: number, mode: "mm:ss" | "dd:hh:mm:ss") => {
-  const s = Math.max(0, totalSeconds);
-  if (mode === "mm:ss") {
-    return `${pad(Math.floor(s / 60))}:${pad(s % 60)}`;
-  }
-  const d = Math.floor(s / 86400);
-  const h = Math.floor((s % 86400) / 3600);
-  const m = Math.floor((s % 3600) / 60);
-  const sec = s % 60;
-  // drop leading day field once it is zero, for a cleaner read
-  return d > 0
-    ? `${pad(d)}d ${pad(h)}:${pad(m)}:${pad(sec)}`
-    : `${pad(h)}:${pad(m)}:${pad(sec)}`;
-};
-
-export type CountdownProps = {
-  durationInSeconds: number;
-  format?: "mm:ss" | "dd:hh:mm:ss";
-  label?: string;
-};
-
-export const Countdown: React.FC<CountdownProps> = ({
-  durationInSeconds,
-  format = "mm:ss",
-  label = "",
-}) => {
-  const frame = useCurrentFrame();
-  const { fps } = useVideoConfig();
-
-  // ceil so the last whole second ("1") is shown for its full duration,
-  // and the display reaches "0" exactly on the final frame.
-  const remaining = Math.max(0, Math.ceil(durationInSeconds - frame / fps));
-  const ended = remaining === 0;
-
-  return (
-    <AbsoluteFill
-      style={{
-        justifyContent: "center",
-        alignItems: "center",
-        background: "#0b0d17",
-        color: "#fff",
-        fontFamily: "Inter, system-ui, sans-serif",
-      }}
-    >
-      {label && (
-        <div style={{ fontSize: 36, opacity: 0.7, marginBottom: 16, letterSpacing: 4 }}>
-          {label.toUpperCase()}
-        </div>
-      )}
-      <div
-        style={{
-          fontSize: 180,
-          fontWeight: 800,
-          fontVariantNumeric: "tabular-nums", // equal-width digits → no jitter
-          lineHeight: 1,
-          color: ended ? "#ff4d4d" : "#fff",
-        }}
-      >
-        {ended ? formatTime(0, format) : formatTime(remaining, format)}
-      </div>
-    </AbsoluteFill>
-  );
-};
-```
-
-Register it so `durationInFrames` matches the countdown exactly — the video ends when the timer does:
-
-```tsx
-import { Composition } from "remotion";
-import { Countdown } from "./Countdown";
-
-const FPS = 30;
-const DURATION_SECONDS = 300; // 5-minute "starting soon" timer
-
-export const RemotionRoot = () => (
-  <Composition
-    id="Countdown"
-    component={Countdown}
-    durationInFrames={DURATION_SECONDS * FPS}
-    fps={FPS}
-    width={1920}
-    height={1080}
-    defaultProps={{ durationInSeconds: DURATION_SECONDS, format: "mm:ss", label: "Starting soon" }}
-  />
-);
-```
-
-Render any duration/format without touching code — duration is a prop:
-
-```bash
-npx remotion render Countdown out/sale.mp4 \
-  --props='{"durationInSeconds":86400,"format":"dd:hh:mm:ss","label":"Sale ends in"}'
-```
-
-To hold a final state (e.g. "WE'RE LIVE") instead of ending on `00:00`, extend `durationInFrames` past the countdown and branch on `ended`.
-
-## 2. Count down to a fixed date (live web component)
-
-For a real-time page that targets a calendar moment. Drift-free because remaining time is `target − Date.now()` recomputed each frame, never a decrement.
-
-```js
-// targetISO must include an offset, e.g. "2026-07-01T09:00:00-07:00",
-// so the deadline is unambiguous regardless of the viewer's timezone.
-function startCountdown(targetISO, el) {
-  const target = new Date(targetISO).getTime();
-  const pad = (n) => String(n).padStart(2, "0");
-  let lastShown = -1;
-
-  function tick() {
-    const remainingMs = Math.max(0, target - Date.now());
-    const s = Math.floor(remainingMs / 1000);
-    if (s !== lastShown) {
-      const d = Math.floor(s / 86400);
-      const h = Math.floor((s % 86400) / 3600);
-      const m = Math.floor((s % 3600) / 60);
-      el.textContent = `${pad(d)}:${pad(h)}:${pad(m)}:${pad(s % 60)}`;
-      lastShown = s;
-    }
-    if (remainingMs > 0) requestAnimationFrame(tick);
-    else el.textContent = "00:00:00:00"; // or swap to an "It's live" state
-  }
-  requestAnimationFrame(tick);
-}
-```
-
-Timezone notes:
- Bake the offset into the target string (`-07:00`, `Z`). A bare `"2026-07-01T09:00:00"` is parsed as the viewer's *local* time and every viewer sees a different deadline.
- To show "ends 9am in *your* timezone everywhere," instead pick the wall-clock time per locale and let each viewer's `Date` resolve it — but that is a different deadline per region. Decide which you want before building.
-
-## 3. "Starting soon" stream screen
-
-Livestream lead-in screens hold 5–10 minutes: a clean brand block, social handles, and a calm looping background, with the timer as the focal point. Keep it low-clutter — chat and music carry the wait; the screen just signals "we're about to start."
-
-```tsx
-import { AbsoluteFill, useCurrentFrame, useVideoConfig, interpolate } from "remotion";
-
-export const StartingSoon: React.FC<{ durationInSeconds: number; handle: string; brand: string }> = ({
-  durationInSeconds,
-  handle,
-  brand,
-}) => {
-  const frame = useCurrentFrame();
-  const { fps, durationInFrames } = useVideoConfig();
-  const remaining = Math.max(0, Math.ceil(durationInSeconds - frame / fps));
-  const pad = (n: number) => String(n).padStart(2, "0");
-
-  // seamless looping gradient: angle cycles over loopFrames with no seam
-  const loopFrames = fps * 8;
-  const angle = interpolate(frame % loopFrames, [0, loopFrames], [0, 360]);
-
-  return (
-    <AbsoluteFill
-      style={{
-        background: `linear-gradient(${angle}deg, #141a3a, #0b0d17 60%)`,
-        color: "#fff",
-        fontFamily: "Inter, system-ui, sans-serif",
-        justifyContent: "center",
-        alignItems: "center",
-      }}
-    >
-      <div style={{ fontSize: 64, fontWeight: 800, marginBottom: 8 }}>{brand}</div>
-      <div style={{ fontSize: 28, opacity: 0.6, letterSpacing: 6, marginBottom: 40 }}>
-        STARTING SOON
-      </div>
-      <div style={{ fontSize: 200, fontWeight: 800, fontVariantNumeric: "tabular-nums", lineHeight: 1 }}>
-        {pad(Math.floor(remaining / 60))}:{pad(remaining % 60)}
-      </div>
-      <div style={{ position: "absolute", bottom: 60, fontSize: 30, opacity: 0.7 }}>{handle}</div>
-    </AbsoluteFill>
-  );
-};
-```
-
-Export as MP4 and add it as a Media/Video source in OBS, or use a looping playout for a browser source. Common durations: 300s (5 min) or 600s (10 min) at 1920×1080.
-
-## 4. Seamless looping background
-
-Any motion whose period divides the timeline evenly wraps without a seam. Read animation phase as `frame % loopFrames` so the value at the wrap equals the value at frame 0.
-
-```tsx
-const loopFrames = fps * 6;            // one full cycle every 6 seconds
-const phase = (frame % loopFrames) / loopFrames; // 0 → 1, repeats
-const driftY = Math.sin(phase * Math.PI * 2) * 40; // returns to start each cycle
-```
-
-Use sine/cosine (inherently periodic) or `interpolate(frame % loopFrames, [0, loopFrames], [a, a])` with matching start/end so there is no jump. Keep contrast low and motion slow — the number is the subject.
-
---
-## Built by the team behind iart.ai
-
-This skill is part of an open motion-graphics collection from iart.ai — the AI motion agent that turns data, scripts, and designs into editable motion graphics (Remotion → MP4). If you'd rather not hand-build this, iart.ai can render countdown videos from a template with a set time and brand — change the text/data and re-export. → [iart.ai](https://iart.ai/?utm_source=github&utm_medium=reference&utm_campaign=tiktok-video-skills&utm_content=ref_footer&utm_term=countdown-video)
@@ -1,146 +0,0 @@
-# Digit Flip & Roll Transitions
-
-Two ways to animate a digit changing. Both are driven by the frame (deterministic) so they render identically every time — no CSS transition clock that the renderer can disagree with.
-
-Pick by tone:
-
-| Effect | Feel | Best for |
-|---|---|---|
-| Odometer reel | smooth, continuous glide | launch countdowns, premium/minimal timers |
-| Flip card | mechanical "snap", split-flap board | sale urgency, retro/airport-board style |
-
-## Shared idea
-
-A single displayed digit is a stack of glyphs `0..9` laid out vertically. Showing digit `d` means translating the stack so glyph `d` sits in the window: `translateY(-d × digitHeight)`. Animate the *offset*, not the text, and you get a roll. The trick for a countdown is that the offset is continuous: between whole seconds the digit eases from its old value toward its new one.
-
-## Odometer reel (Remotion, frame-driven)
-
-```tsx
-import React from "react";
-import { useCurrentFrame, useVideoConfig, interpolate, Easing } from "remotion";
-
-const DIGIT_H = 160; // px per glyph
-const ROLL_FRAMES = 12; // how long a single digit roll takes
-
-// Animated single digit: rolls from `prev` to `value` over the last ROLL_FRAMES
-// of the current second.
-const Reel: React.FC<{ value: number; prev: number; secondProgress: number }> = ({
-  value,
-  prev,
-  secondProgress,
-}) => {
-  // secondProgress: 0→1 across the current whole second.
-  // Start the roll near the end of the second so the number "settles" on change.
-  const t = interpolate(secondProgress, [0.7, 1], [0, 1], {
-    extrapolateLeft: "clamp",
-    extrapolateRight: "clamp",
-    easing: Easing.bezier(0.22, 1, 0.36, 1),
-  });
-  // continuous position between prev and value
-  const shown = prev + (value - prev) * t;
-  const offset = -shown * DIGIT_H;
-
-  return (
-    <div style={{ height: DIGIT_H, width: 110, overflow: "hidden", position: "relative" }}>
-      <div style={{ transform: `translateY(${offset}px)` }}>
-        {[0, 1, 2, 3, 4, 5, 6, 7, 8, 9].map((n) => (
-          <div
-            key={n}
-            style={{
-              height: DIGIT_H,
-              lineHeight: `${DIGIT_H}px`,
-              textAlign: "center",
-              fontSize: 140,
-              fontWeight: 800,
-              fontVariantNumeric: "tabular-nums",
-            }}
-          >
-            {n}
-          </div>
-        ))}
-      </div>
-    </div>
-  );
-};
-
-// Renders an mm:ss reel where each digit rolls.
-export const ReelClock: React.FC<{ durationInSeconds: number }> = ({ durationInSeconds }) => {
-  const frame = useCurrentFrame();
-  const { fps } = useVideoConfig();
-
-  const elapsed = frame / fps;
-  const remaining = Math.max(0, Math.ceil(durationInSeconds - elapsed));
-  const prevRemaining = Math.max(0, remaining + 1); // value one second ago
-  const secondProgress = elapsed % 1; // 0→1 within the current second
-
-  const digits = (s: number) =>
-    [Math.floor(s / 600) % 10, Math.floor(s / 60) % 10, Math.floor(s / 10) % 10, s % 10];
-
-  const cur = digits(remaining);
-  const prev = digits(prevRemaining);
-
-  return (
-    <div style={{ display: "flex", gap: 8, color: "#fff", background: "#0b0d17", padding: 40 }}>
-      {cur.map((d, i) => (
-        <React.Fragment key={i}>
-          {i === 2 && <div style={{ fontSize: 140, fontWeight: 800 }}>:</div>}
-          <Reel value={d} prev={prev[i]} secondProgress={secondProgress} />
-        </React.Fragment>
-      ))}
-    </div>
-  );
-};
-```
-
-Notes:
- Each digit only rolls when it actually changes; a digit whose `prev === value` sits still because `shown` stays constant.
- A `9 → 0` rollover rolls *backward* through the strip (the cheap-looking part). To make tens/units roll the natural way on a carry, render an extra `0` glyph below the `9` and clamp — covered as an exercise; for most timers the backward roll at the tens boundary is unnoticeable at speed.
- `ROLL_FRAMES` is unused above because the roll is tied to `secondProgress`; expose it instead if a fixed-length roll is preferred.
-
-## Flip card (split-flap)
-
-The top half of the old digit folds down over a static bottom half, revealing the new digit. Pure CSS keyframe version — fine for a live web page; for Remotion, drive the `rotateX` off `secondProgress` the same way as the reel so it stays deterministic.
-
-```css
-.flip { position: relative; width: 110px; height: 160px; perspective: 600px; }
-.flip .card {
-  position: absolute; inset: 0;
-  display: flex; align-items: center; justify-content: center;
-  font-size: 140px; font-weight: 800; font-variant-numeric: tabular-nums;
-  backface-visibility: hidden;
-}
-.flip .top    { clip-path: inset(0 0 50% 0); transform-origin: bottom; }
-.flip .bottom { clip-path: inset(50% 0 0 0); }
-/* on change, animate the leaf folding down */
-.flip .leaf {
-  position: absolute; inset: 0; transform-origin: bottom;
-  animation: fold .45s cubic-bezier(.36,0,.66,-0.2) forwards;
-}
-@keyframes fold {
-  0%   { transform: rotateX(0deg); }
-  100% { transform: rotateX(-90deg); }
-}
-```
-
-```js
-// swap the digit and replay the fold whenever the value changes
-function setFlip(el, newDigit) {
-  if (el.dataset.v === String(newDigit)) return; // no change → no flip
-  el.dataset.v = String(newDigit);
-  el.querySelector(".top").textContent = newDigit;
-  el.querySelector(".bottom").textContent = newDigit;
-  const leaf = el.querySelector(".leaf");
-  leaf.textContent = newDigit;
-  leaf.style.animation = "none";
-  void leaf.offsetWidth;            // reflow → restart the animation
-  leaf.style.animation = "";
-}
-```
-
-Drive `setFlip` from the same `requestAnimationFrame` + `performance.now()` loop in the cookbook (only call it when the displayed second changes), so the flips fire on real time and never drift.
-
-## Choosing
-
- **Launch / premium:** odometer reel, slow ease, large tabular digits, muted palette.
- **Flash sale:** flip card for the mechanical urgency, or reel with a faster roll and a hot accent color on `mm:ss`.
- **Stream "starting soon":** either works, but keep it calm — a single reel on `mm:ss` reads better than a busy split-flap for a 5–10 minute hold.
@@ -0,0 +1,137 @@
+---
+name: launch-video
+description: This skill should be used when the user asks to "make a launch video", "create a product hype/sizzle film", "build a teaser/trailer for a drop", "do a reveal montage with an end-card CTA", "cut a hero video to the beat", or "export a launch film in 16:9/9:16/1:1". Covers the hook→tease→reveal→feature-montage→end-card arc and multi-aspect export.
+version: 0.1.0
+---
+
+# Launch Video
+
+Make a premium, high-energy 15–60s launch film that stops the scroll and converts. Build the classic arc — hook → tease → reveal → feature montage → end-card CTA — cut to the music, and export for every platform aspect.
+
+## When to use
+
+- Product drops, feature announcements, trailers, hype reels (15–60s).
+- "Sizzle" hero videos for a landing page.
+- Beat-synced reveals where the brand moment lands on the drop.
+
+## The arc
+
+| Beat | Job | Typical share (of 30s) |
+|---|---|---|
+| Hook (0–3s) | A striking frame/motion that stops the scroll | 0–3s |
+| Tease | Hint the product; build curiosity, beat-synced | 3–9s |
+| Reveal | Product/logo hits on the music drop | 9–13s |
+| Feature montage | Fast, kinetic, one benefit per shot | 13–25s |
+| End card | Logo + tagline + CTA, clean hold | 25–30s |
+
+Scale the same proportions for 15s (tighter) or 60s (longer montage, never a longer hook).
+
+## Two non-negotiable rules
+
+1. **Sound design leads picture.** Lock the track first, mark the beats and the drop, then cut visuals to those marks. Never score a finished cut — the reveal lands on the drop, not near it.
+2. **Quality over quantity.** A few flawless shots beat many mediocre ones. Cut any shot that isn't premium.
+
+## Beat-synced reveal on the drop
+
+Find the drop's exact timecode in the audio, then time the reveal so the brand mark snaps to full at that frame, with a micro-overshoot for impact.
+
+```js
+import gsap from "gsap";
+const DROP = 9.0; // seconds, measured from the track
+const tl = gsap.timeline({ paused: true });
+// tease builds tension up to the drop
+tl.to(".tease", { opacity: 1, scale: 1.05, duration: DROP, ease: "power1.in" })
+// reveal SNAPS on the drop frame
+  .set(".logo", { opacity: 1 }, DROP)
+  .fromTo(".logo", { scale: 1.18 }, { scale: 1.0, duration: .18, ease: "power3.out" }, DROP)
+  .fromTo(".flash", { opacity: .9 }, { opacity: 0, duration: .25 }, DROP); // white hit
+audio.addEventListener("play", () => tl.play());
+```
+
+Cut on transients, not on a fixed grid: the hardest cuts go on kick/snare hits; ramp speed (time-remap) into the drop, then hard-cut out of it.
+
+## Kinetic feature montage
+
+One benefit per shot, ~0.6–1.0s each, hard cuts on the beat. Each shot = a bold keyword + a single supporting visual.
+
+```css
+.feature { opacity:0; }
+.feature.in .kw   { animation: pop .35s cubic-bezier(.22,1,.36,1) forwards; }
+.feature.in .word { display:inline-block; }
+@keyframes pop { from { opacity:0; transform:translateY(24px) } to { opacity:1; transform:none } }
+```
+
+```js
+// drive shots off beat marks measured from the track
+const beats = [13.0, 13.8, 14.6, 15.4, 16.2]; // seconds
+beats.forEach((t, i) => scheduleAt(t, () => showFeature(i)));
+```
+
+Keep one motion language across the montage (same enter curve, same exit) so speed reads as confidence, not chaos.
+
+## End card
+
+Hold the logo + tagline + CTA still and clean for ≥2s. No busy motion competing with the CTA; let the brand settle. Land the brand moment on the strongest remaining beat, then a crisp button/URL.
+
+## Multi-aspect export
+
+Compose with a center safe zone so one master crops cleanly to all aspects.
+
+| Aspect | Use | Resolution | Safe zone |
+|---|---|---|---|
+| 16:9 | YouTube, landing hero, X | 1920×1080 | keep key content within center 90% |
+| 9:16 | Reels, TikTok, Shorts, Stories | 1080×1920 | text within center 80% h; avoid top 12% / bottom 18% (UI) |
+| 1:1 | Feed posts | 1080×1080 | center square of the 16:9 frame |
+
+Design the hero/logo/CTA inside the **1:1 center square** so it survives every crop. Render the 16:9 master, then reframe (don't just letterbox) 9:16 and 1:1 from the same project.
+
+## Output checklist
+
+- Track locked first; reveal lands exactly on the drop.
+- Hook earns the first 3 seconds.
+- Montage: one benefit per shot, hard cuts on beats, consistent motion language.
+- End card holds ≥2s with one clear CTA.
+- 16:9 + 9:16 + 1:1 exports, key content in the center safe zone.
+- Premium-only shots — nothing mediocre survives the cut.
+
+## Deliver & verify (rendered stills → MP4)
+
+> **Packaged helper** (`scripts/`): tile your stills with `scripts/contact-sheet.sh sheet.png f-hook.png f-mid.png f-end.png`, then assert the encode with `scripts/probe-mp4.sh out.mp4 [WxH] [fps]`. See `scripts/README.md`.
+
+If the launch film is built/rendered in Remotion, treat it as the heavy tier: register a `<Composition>` (+ zod `schema` + `defaultProps`), drive every value off `useCurrentFrame()` — no GSAP timelines / audio-event callbacks / `Date.now()` / `Math.random()` at render time (bake beat + drop timecodes into props). Deliverable = the rendered `out/*.mp4` per aspect (plus the project).
+
+**Verify loop — render stills → inspect → encode.** Sample the arc, with the **shipped** props (real headline/tagline/CTA), not just `defaultProps`.
+
+```bash
+# Frame-exact stills across hook → reveal → end-card
+npx remotion still Launch out/f-hook.png   --frame=24  --props=props/launch.json   # hook earns first 3s
+npx remotion still Launch out/f-reveal.png --frame=270 --props=props/launch.json   # logo SNAPS on the drop frame
+npx remotion still Launch out/f-end.png    --frame=899 --props=props/launch.json   # end card: logo+tagline+CTA, clean hold
+# inspect each: fidelity (product/logo, tagline, CTA text exact, brand colors right, reveal at the drop frame)
+#   AND artifacts (text overflow, off-canvas, CTA in the 9:16 bottom third, missing font, flash frame stuck on)
+```
+
+**Multi-aspect — verify the master in EACH aspect before encoding all of them.** A reframe bug (hero pushed off the safe zone) repeats across every aspect; catch it once.
+
+```bash
+for ar in 16x9 9x16 1x1; do                                 # check reveal + end card per aspect
+  npx remotion still Launch "out/reveal-${ar}.png" --frame=270 \
+    --props=props/launch.json --props-merge="{\"aspect\":\"${ar}\"}"
+done
+# stills clean in all aspects? → then encode each:
+for ar in 16x9 9x16 1x1; do
+  npx remotion render Launch "out/launch-${ar}.mp4" --props=props/launch.json --props-merge="{\"aspect\":\"${ar}\"}"
+done
+npx remotion render Launch out/demo.gif --codec=gif --props=props/launch.json   # README demo
+```
+
+**Before you finish:**
+1. `npx remotion still` renders cleanly at hook / reveal / end card — no errors, no missing fonts/assets.
+2. Logo/tagline/CTA text exact, brand colors right; reveal lands on the drop frame; key content inside the center safe zone, clear of the 9:16 bottom third.
+3. Frame-driven only — no GSAP/audio-callback timing, `Date.now()`, or `Math.random()` (beats/drop baked into props).
+4. Shipped props render correctly (not just `defaultProps`); the end card holds ≥2s with one CTA.
+5. Master verified in 16:9 + 9:16 + 1:1 before encoding; MP4s play; (optional) GIF for the README.
+
+## Reference files
+
+- `references/launch-structure.md` — a full shot-by-shot template with timecodes for a 30s film (scalable to 15–60s), beat-synced reveal timing, kinetic-montage shot recipes, the sound-design-leads-picture workflow, and detailed multi-aspect safe-area maps for 16:9 / 9:16 / 1:1.
@@ -0,0 +1,142 @@
+# Launch Video Structure — Cookbook
+
+Shot-by-shot template, beat-sync timing, montage recipes, and multi-aspect maps for a premium 15–60s launch film.
+
+## Sound-design-leads-picture workflow
+
+1. **Pick/commission the track first.** The track defines the film's length and energy.
+2. **Mark the structure in the audio**: intro, build, the **drop** (the single biggest moment), and the kick/snare transients through the montage. Note exact timecodes.
+3. **Map beats → cuts.** Hard cuts land on transients; the reveal lands on the drop frame.
+4. **Build picture to the marks.** Never finish a cut and then look for music. Score-first guarantees the reveal hits.
+5. **Mix last**: add risers into the drop, an impact/whoosh on the reveal, and let the end-card breathe (drop music low, or a clean tag).
+
+## Shot-by-shot template — 30s film (scalable)
+
+```
+00:00–00:03  HOOK
+  Visual : single striking frame — extreme close detail / impossible motion
+  Motion : slow push-in or a fast whip that resolves; NO logo yet
+  Audio  : sub-bass swell begins, sparse
+  Cut    : on first audible beat at ~03s
+
+00:03–00:09  TEASE
+  Visual : fragments/silhouettes of the product, never the full thing
+  Motion : light leaks, partial reveals, parallax; tension rising
+  Audio  : riser building toward the drop
+  Cut    : quick cuts accelerating into the drop
+
+00:09–00:13  REVEAL  ← THE DROP at 00:09
+  Visual : product/logo SNAPS to full on the drop frame
+  Motion : scale 1.18→1.0 over 0.18s + white flash-out; settle clean
+  Audio  : drop hits + impact stinger on the exact frame
+  Hold   : let it sit ~1.2s before moving
+
+00:13–00:25  FEATURE MONTAGE
+  Visual : one benefit per shot, ~0.6–1.0s each (≈8–10 shots)
+  Motion : bold keyword pop + one supporting visual; consistent enter/exit
+  Audio  : hard cuts on kick/snare; energy sustained
+  Pattern: KEYWORD + UI/product moment, repeat with rhythm
+
+00:25–00:30  END CARD
+  Visual : logo + tagline + CTA, centered, still
+  Motion : minimal — a soft settle, then hold ≥2s
+  Audio  : music resolves; clean sonic tag
+  CTA    : one action (URL or button), nothing competing
+```
+
+### Re-proportioning
+
+- **15s**: Hook 0–2s · Tease 2–5s · Reveal 5–7s · Montage 7–12s (4–5 shots) · End card 12–15s.
+- **60s**: same hook (still ≤3s) · longer tease and a richer montage (14–16 shots, grouped in waves) · end card ≥3s.
+
+The hook never gets longer — only the montage scales.
+
+## Beat-synced reveal (timing detail)
+
+```js
+import gsap from "gsap";
+const DROP = 9.0;                 // measured drop timecode (s)
+const tl = gsap.timeline({ paused: true });
+
+// build tension toward the drop
+tl.fromTo(".tease", { scale: 1.0, opacity: .6 },
+                    { scale: 1.08, opacity: 1, duration: DROP, ease: "power1.in" });
+
+// REVEAL exactly on the drop
+tl.set(".logo",  { opacity: 1 }, DROP);
+tl.fromTo(".logo",  { scale: 1.18 }, { scale: 1.0, duration: .18, ease: "power3.out" }, DROP);
+tl.fromTo(".flash", { opacity: .9 },  { opacity: 0, duration: .25, ease: "power2.out" }, DROP);
+tl.to(".tease", { opacity: 0, duration: .12 }, DROP);
+
+// hold the reveal
+tl.to(".logo", { scale: 1.0, duration: 1.2 }); // dwell
+
+audio.addEventListener("play", () => tl.play());
+```
+
+Speed-ramp into the drop (Remotion time-remap idea): play the last ~0.5s of the tease faster, then hard-cut to the reveal on the drop frame for a snap.
+
+## Kinetic montage shot recipe
+
+Each shot: a bold keyword + one product/UI visual, ~0.6–1.0s, hard cut on the beat.
+
+```css
+.feature { position:absolute; inset:0; opacity:0; }
+.feature.in { opacity:1; }
+.feature .word { display:inline-block; opacity:0; transform:translateY(26px); }
+.feature.in .word { animation: pop .32s cubic-bezier(.22,1,.36,1) forwards; }
+.feature.in .word:nth-child(2){ animation-delay:.04s }
+.feature.in .word:nth-child(3){ animation-delay:.08s }
+@keyframes pop { to { opacity:1; transform:none; } }
+```
+
+```js
+// schedule shots on measured beat marks
+const beats = [13.0, 13.8, 14.6, 15.4, 16.2, 17.0, 17.8, 18.6]; // seconds
+let i = 0;
+function loop(now){
+  const t = (now - start) / 1000;
+  if (i < beats.length && t >= beats[i]) { showFeature(i); i++; }
+  if (i < beats.length) requestAnimationFrame(loop);
+}
+```
+
+Montage discipline: keep ONE enter curve and ONE exit across all shots; vary content, never grammar. Alternate visual rhythm (full-frame ↔ detail) but keep cut cadence locked to the beat.
+
+## Multi-aspect safe-area maps
+
+Compose so a single master reframes to every aspect. Place hero/logo/CTA inside the smallest common safe zone — the 1:1 center square.
+
+```
+16:9  1920×1080
+  Safe: center 90% (96px H / 54px V margins)
+  Use : YouTube, landing hero, X timeline
+
+9:16  1080×1920
+  Safe: text within center 80% height
+  Avoid: top 12% (status/clock area), bottom 18% (caption + UI buttons)
+  Use : Reels, TikTok, Shorts, Stories
+
+1:1   1080×1080
+  Safe: this square == the design anchor; put logo/CTA here
+  Use : feed posts
+```
+
+Export workflow:
+
+1. Build the 16:9 master with all key content inside the 1:1 center square.
+2. For 9:16, **reframe** (pan/scale per shot to keep the subject centered) — do not letterbox.
+3. For 1:1, crop the center square; verify text isn't clipped.
+4. Re-check captions/CTA against each platform's UI overlay zones before export.
+
+## Final QA checklist
+
+- [ ] Reveal lands on the exact drop frame, with overshoot + flash.
+- [ ] Hook holds attention in the first 3s without showing the product.
+- [ ] Every montage shot is one benefit, premium quality, on a beat.
+- [ ] End card holds ≥2s, single CTA, nothing competing.
+- [ ] 16:9 / 9:16 / 1:1 each pass safe-area and caption checks.
+- [ ] Audio mixed: riser → impact on drop → clean tag on end card.
+
+---
+Nail the reveal beat and the sound-leads-picture cut, and a launch film lands. Built by **[iart.ai](https://iart.ai/?utm_source=github&utm_medium=readme&utm_campaign=ad-video-skills&utm_content=skill_footer&utm_term=launch-video)** — the AI motion agent for editable, on-brand motion graphics.
@@ -1,24 +0,0 @@
-# Lower Thirds
-
-Build a clean, branded lower third — the name/role caption that lives in the bottom band of the frame — that animates in, holds long enough to read, and exits without stealing the shot. The craft is restraint: a crisp reveal, a strong type hierarchy, correct safe-area placement, and one template that drives a whole roster of speakers. For creators producing interviews, panels, podcasts, and broadcast-style titles.
-
-## When it activates
-
- "Make an animated lower third" or "add lower thirds."
- "Create a name tag/name lower third" or "do a speaker name overlay."
- "Build broadcast titles" or "animate a title/name/role caption."
- "Template lower thirds across a list of names."
-
-## Example prompts
-
- "Add a lower third with the speaker's name and role, branded to my colors."
- "Build a staggered slide-in name plate for a podcast guest."
- "Template one lower-third design across a roster of 12 panelists."
-
-## What's inside
-
- `SKILL.md` — enter/exit animation, in/out timing and dwell, safe-area conventions, and brand styling.
- `references/lower-third-component.md` — a reusable lower-third component.
-
---
-Part of **[Short-Form Video Skills](../../)** · Built by **[iart.ai](https://iart.ai/?utm_source=github&utm_medium=readme&utm_campaign=tiktok-video-skills&utm_content=skill_footer&utm_term=lower-thirds)** — the AI motion agent for editable, on-brand motion graphics.
@@ -1,146 +0,0 @@
---
-name: lower-thirds
-description: This skill should be used when the user asks to "make an animated lower third", "add lower thirds", "create a name tag/name lower third", "build broadcast titles", "animate a title/name/role caption", "do a speaker name overlay", or "template lower thirds across a list of names". Covers enter/exit animation (slide/wipe/mask reveal), in/out timing & dwell, safe-area & broadcast conventions, name-vs-role type hierarchy, brand styling, and rendering one design across many names.
-version: 0.1.0
---
-
-# Lower Thirds
-
-Build a clean, branded lower third — the name/role caption that lives in the bottom band of the frame — that animates in, holds long enough to read, and exits without stealing the shot. The craft is restraint: a crisp reveal, a strong type hierarchy, correct safe-area placement, and one template that drives a whole roster of speakers.
-
-## When to use
-
- Speaker/interview name tags, panel rosters, talking-head captions.
- Broadcast-style titles, news straps, podcast/webinar name plates.
- Templating one design across a list of names/titles → many clips (the payoff).
-
-## Anatomy
-
-A lower third is two text lines plus a graphic bed, placed in the lower band:
-
-| Element | Role | Type treatment |
-|---|---|---|
-| **Name** (primary) | Who | Largest, heaviest, tightest tracking |
-| **Role/title** (secondary) | What/where | ~45–60% of name size, lighter weight, often a brand accent color |
-| **Bar / panel / accent** | Reads against any background | Solid or 70–85% opacity; an accent rule ties to brand |
-
-Keep it to two lines. A name line + role line is the whole job — extra lines erode the hierarchy and crowd the safe area.
-
-## Three rules that prevent cheap-looking titles
-
-1. **Never hard-cut a title on or off.** A bare appear/disappear reads as a mistake. Even a 12-frame fade or slide makes it feel produced.
-2. **Stagger, don't slam.** Animate the bar first, then the name, then the role, each offset by 3–6 frames. Everything arriving at once feels flat; a short cascade feels designed.
-3. **Hold long enough to read twice.** Roughly 3–5s on screen (read it aloud twice). Too short and it's missed; too long and it nags. Animate in/out, never mid-segment.
-
-## Enter & exit animations
-
-Pick one motion language and reuse it. The most reliable, premium-reading reveals:
-
-| Reveal | Feel | How |
-|---|---|---|
-| **Slide + fade** | Clean, default | Translate in ~24–40px while fading; ease-out on enter |
-| **Wipe bar** | Broadcast | A bar scales/sweeps in (`scaleX`/clip), text fades behind it |
-| **Mask reveal** | Premium | Clip text to a moving rectangle so letters "wipe on" |
-
-Use asymmetric easing: a snappy `ease-out` (`cubic-bezier(.22,1,.36,1)`) on enter, a quicker `ease-in` on exit. Exit faster than you entered (~⅔ the duration) so the title gets out of the way.
-
-```css
-/* Mask reveal: text wipes on left→right, no plugin needed */
-.lt-name { clip-path: inset(0 100% 0 0); animation: wipe .5s cubic-bezier(.22,1,.36,1) forwards; }
-@keyframes wipe { to { clip-path: inset(0 0 0 0); } }
-```
-
-## In/out timing & dwell
-
-Think in three phases. Budget frames, not vibes (at 30fps):
-
-| Phase | Budget | Note |
-|---|---|---|
-| Enter | 12–18f (0.4–0.6s) | Staggered: bar → name → role |
-| Hold | 90–150f (3–5s) | The readable dwell; scale with line length |
-| Exit | 8–12f (0.27–0.4s) | Faster than enter |
-
-In code, drive every state from the current frame (or a paused timeline), not wall-clock time — a video renderer demands deterministic frames. Express enter/hold/exit as a single progress curve so the same component works live in a browser and frame-by-frame in a renderer.
-
-## Safe area & broadcast conventions
-
-The lower third must survive every screen and platform UI. Compose inside the **title-safe area** (inner ~90% / margin 5%) and respect platform chrome:
-
-| Frame | Anchor | Avoid |
-|---|---|---|
-| 16:9 (1920×1080) | Left edge at ~5% margin; baseline ~80–85% down | Outer 5% (title-safe), action-safe outer 10% |
-| 9:16 (1080×1920) | Same left margin; **lift the band up** | Bottom ~18% (captions/UI), top ~12% |
-| 1:1 (1080×1080) | Lower band, center-left | Outer 5% |
-
-Anchor to the **left** and grow rightward so names of different lengths stay pinned and never re-center awkwardly. Keep the role line within the same left margin as the name. For 9:16, do not park the title at the very bottom — platform captions and buttons sit there.
-
-## Type hierarchy & brand styling
-
-Hierarchy is the whole design. Make the name unmistakably dominant:
-
- **Size contrast** ≥ 1.6× (name vs role). If unsure, push the name bigger, not the role.
- **Weight + color**: name in bold/near-white; role in a lighter weight and a **brand accent** color (one accent, used consistently).
- **Contrast for legibility**: text rides over unknown footage. Use a solid/semi-opaque bar, a subtle scrim, or a soft text shadow so it reads over both bright and dark plates.
- **Brand lock**: pin font, accent color, bar style, and corner radius in one theme object so every title across a series matches.
-
-## Templating one design across a list
-
-The reason to build this in code: change the text/data, re-export — no re-animating. Make name/role/theme **props**, never hardcoded, then map a roster to instances.
-
-```jsx
-const ROSTER = [
-  { name: "Ada Lovelace",  role: "Founder, Analytical Engines" },
-  { name: "Grace Hopper",  role: "Rear Admiral, US Navy" },
-  { name: "Alan Turing",   role: "Mathematician" },
-];
-// One <LowerThird> design; map the list → many instances (sequence them in a renderer)
-{ROSTER.map((p, i) => <LowerThird key={p.name} {...p} theme={BRAND} startFrame={i * 150} />)}
-```
-
-In a renderer, make the roster an input prop and render once per row (`--props`) to emit one branded clip per person — same animation, same brand, only the text changes. See `references/lower-third-component.md` for the full runnable component and batch script.
-
-## Output checklist
-
- Two lines only: dominant name, secondary role (≥1.6× size contrast).
- Animated in and out (no hard cut); enter staggered bar→name→role; exit faster.
- Hold 3–5s (readable twice); motion only at the ends, never mid-segment.
- Left-anchored inside title-safe; 9:16 band lifted above the bottom-18% UI zone.
- Text legible over any plate (bar/scrim/shadow); one brand accent throughout.
- Name/role/theme are props — one template renders the whole roster.
-
-## Deliver & verify (rendered stills → MP4)
-
-> **Packaged helper** (`scripts/`): tile your stills with `scripts/contact-sheet.sh sheet.png f-hook.png f-mid.png f-end.png`, then assert the encode with `scripts/probe-mp4.sh out.mp4 [WxH] [fps]`. See `scripts/README.md`.
-
-The lower third ships as a Remotion composition (`<Composition>` + zod `schema` + `defaultProps`, name/role/theme as props) — enter/dwell/exit all driven by `useCurrentFrame()`, never `Date.now()` / `Math.random()` / timers. Deliverable = `out/*.mp4` + the project (re-render per roster row). 9:16 vertical (1080×1920) is the default.
-
-**Verify loop — render stills → inspect → encode.** Sample the three phases so you catch a stagger or safe-area bug before encoding (or batching the whole roster).
-
-```bash
-# Stills at enter / dwell / exit — WITH SHIPPED PROPS (a real roster row, not defaults)
-npx remotion still LowerThird out/f-enter.png --frame=10  --props='{"name":"Ada Lovelace","role":"Founder, Analytical Engines"}'
-npx remotion still LowerThird out/f-dwell.png --frame=75  --props='{"name":"Ada Lovelace","role":"Founder, Analytical Engines"}'
-npx remotion still LowerThird out/f-exit.png  --frame=N   --props='{"name":"Ada Lovelace","role":"Founder, Analytical Engines"}'
-
-# Inspect each PNG — focus the DWELL frame (fully on screen):
-#  - hierarchy holds: name dominant (>=1.6x role), role in brand accent; both fully revealed, not mid-wipe
-#  - brand lock: font, accent color, bar/scrim correct; legible over the plate
-#  - 9:16 safe area: band LIFTED above the bottom ~20-35% UI zone, clear of top ~12% and the right action rail; left-anchored inside title-safe
-#  - enter/exit frames show partial reveal (animation actually runs), not a hard cut
-
-npx remotion render LowerThird out/lower-third.mp4 --props='{"name":"Ada Lovelace","role":"Founder, Analytical Engines"}'
-npx remotion render LowerThird out/demo.gif --codec=gif                # README proof clip
-```
-
-**Batch roster**: verify ONE row via stills *before* rendering all names — catch a layout/overflow bug once, not N times. Use `npx remotion compositions` for `durationInFrames`/`fps` to pick the dwell + exit frames.
-
-**Before you finish:**
-1. Stills render cleanly at enter, dwell, and exit — no missing font/brand assets.
-2. At the dwell frame: name dominant over role, brand accent + bar correct, fully (not partly) revealed.
-3. The band is inside the 9:16 safe area — lifted above the bottom UI zone, clear of top and right rail — at every checked frame.
-4. Frame-driven only — no `Date.now()` / `Math.random()` / timers; enter/exit show motion, never a hard cut.
-5. A real roster row (not `defaultProps`) renders correctly; MP4 encoded, GIF optional.
-
-## Reference files
-
- `references/lower-third-component.md` — a complete runnable lower-third: a Remotion component with staggered spring enter, readable hold, and faster exit driven purely by frame; a typed theme object for brand lock; the list→many-instances sequencing pattern; a per-row batch render script; plus a dependency-free CSS/HTML version of the same design with mask-reveal and wipe-bar variants.
@@ -1,268 +0,0 @@
-# Lower-Third Component — runnable code
-
-A complete, production-grade lower third you can drop in. Two paths:
-
-1. **Remotion** (frame-deterministic, renders to MP4, batches over a roster).
-2. **CSS/HTML** (no dependencies, for the web or a quick preview) with mask-reveal and wipe-bar variants.
-
-Both share the same design language: a left-anchored bar, a dominant name, a brand-accent role line, a staggered enter, a readable hold, and a faster exit.
-
---
-
-## 1. Remotion component (props-driven, frame-deterministic)
-
-The animation is a pure function of `frame`, so it renders identically every time and stays in sync with the renderer. Enter staggers the bar, name, then role; exit is computed from the end of the clip so the title leaves faster than it arrived.
-
-```tsx
-// LowerThird.tsx
-import {
-  AbsoluteFill, Sequence, interpolate, spring,
-  useCurrentFrame, useVideoConfig,
-} from "remotion";
-
-// --- Brand lock: change once, every title matches -------------------------
-export type Theme = {
-  font: string;
-  bar: string;        // panel/bar color
-  name: string;       // primary text color
-  role: string;       // accent color for the role line
-  radius: number;
-  marginPct: number;  // left/safe margin as % of width
-};
-export const BRAND: Theme = {
-  font: "Inter, system-ui, sans-serif",
-  bar: "rgba(12,14,22,0.86)",
-  name: "#FFFFFF",
-  role: "#6EE7F0",     // single brand accent
-  radius: 10,
-  marginPct: 5,
-};
-
-export type LowerThirdProps = {
-  name: string;
-  role: string;
-  theme?: Theme;
-  holdSeconds?: number; // readable dwell, default 4s
-};
-
-// Staggered enter via spring; exit via a quick fade/slide near the end.
-const useEnterExit = (delayFrames: number, holdSeconds: number) => {
-  const frame = useCurrentFrame();
-  const { fps, durationInFrames } = useVideoConfig();
-
-  // ENTER: spring 0→1, offset by delayFrames (the cascade)
-  const enter = spring({
-    frame: frame - delayFrames,
-    fps,
-    config: { damping: 200, stiffness: 180, mass: 0.6 },
-  });
-
-  // EXIT: faster than enter — last 10 frames of the clip
-  const exitStart = durationInFrames - 10;
-  const exit = interpolate(frame, [exitStart, durationInFrames], [1, 0], {
-    extrapolateLeft: "clamp",
-    extrapolateRight: "clamp",
-  });
-
-  const opacity = enter * exit;
-  const x = interpolate(enter, [0, 1], [-32, 0]); // slide in from left
-  return { opacity, x };
-};
-
-const Line: React.FC<{
-  delay: number; holdSeconds: number; children: React.ReactNode;
-  size: number; weight: number; color: string; tracking?: number;
-}> = ({ delay, holdSeconds, children, size, weight, color, tracking = 0 }) => {
-  const { opacity, x } = useEnterExit(delay, holdSeconds);
-  return (
-    <div style={{
-      opacity,
-      transform: `translateX(${x}px)`,
-      fontSize: size, fontWeight: weight, color,
-      letterSpacing: tracking, lineHeight: 1.15, whiteSpace: "nowrap",
-    }}>
-      {children}
-    </div>
-  );
-};
-
-export const LowerThird: React.FC<LowerThirdProps> = ({
-  name, role, theme = BRAND, holdSeconds = 4,
-}) => {
-  const { width, height } = useVideoConfig();
-  const bar = useEnterExit(0, holdSeconds); // bar leads the cascade
-
-  const left = (width * theme.marginPct) / 100;
-  const baseline = height * 0.80;            // sit ~80% down, inside title-safe
-
-  return (
-    <AbsoluteFill style={{ fontFamily: theme.font }}>
-      <div style={{
-        position: "absolute", left, top: baseline,
-        opacity: bar.opacity,
-        transform: `translateX(${bar.x}px)`,
-      }}>
-        {/* panel behind text guarantees legibility over any plate */}
-        <div style={{
-          background: theme.bar, borderRadius: theme.radius,
-          padding: "14px 22px 16px",
-          borderLeft: `4px solid ${theme.role}`,   // accent rule ties to brand
-          backdropFilter: "blur(6px)",
-        }}>
-          <Line delay={4}  holdSeconds={holdSeconds} size={46} weight={800} color={theme.name} tracking={-0.5}>
-            {name}
-          </Line>
-          <Line delay={8}  holdSeconds={holdSeconds} size={26} weight={500} color={theme.role}>
-            {role}
-          </Line>
-        </div>
-      </div>
-    </AbsoluteFill>
-  );
-};
-```
-
-Why each choice matters:
- **`spring` per line, offset by `delay`** gives the bar→name→role cascade. Same offsets everywhere keep titles consistent.
- **Exit derived from `durationInFrames`** means any clip length exits cleanly without per-instance tuning, and it's quicker than the enter (10f vs the spring's settle).
- **`whiteSpace: nowrap` + left anchor** keeps long and short names pinned to the same edge — no awkward re-centering across a roster.
- **`borderLeft` accent + semi-opaque panel** is the brand tie plus the legibility guarantee over unknown footage.
-
-### Roster → many instances (one design, a whole panel)
-
-Sequence the same component down a list. Each person gets a slot; only the text changes.
-
-```tsx
-// Roster.tsx
-import { Series } from "remotion";
-import { LowerThird, BRAND } from "./LowerThird";
-
-const ROSTER = [
-  { name: "Ada Lovelace", role: "Founder, Analytical Engines" },
-  { name: "Grace Hopper", role: "Rear Admiral, US Navy" },
-  { name: "Alan Turing",  role: "Mathematician" },
-];
-
-export const Roster: React.FC = () => (
-  <Series>
-    {ROSTER.map((p) => (
-      <Series.Sequence key={p.name} durationInFrames={150 /* ~5s @30fps */}>
-        <LowerThird name={p.name} role={p.role} theme={BRAND} />
-      </Series.Sequence>
-    ))}
-  </Series>
-);
-```
-
-### Batch: one branded clip per person
-
-Make the roster an input prop and render once per row, so each speaker becomes a standalone overlay clip — identical animation and brand, only the text differs.
-
-```bash
-#!/usr/bin/env bash
-# render one transparent-friendly lower-third clip per person in roster.json
-# roster.json: [{"name":"Ada Lovelace","role":"Founder, Analytical Engines"}, ...]
-set -euo pipefail
-mkdir -p out
-jq -c '.[]' roster.json | while read -r row; do
-  slug=$(echo "$row" | jq -r '.name' | tr '[:upper:] ' '[:lower:]-')
-  npx remotion render LowerThird "out/${slug}.mp4" --props="$row"
-done
-```
-
-For overlay-ready output with transparency, render the `LowerThird` composition (transparent background) to a codec that keeps alpha, e.g. `--codec=prores --prores-profile=4444`, or `--image-format=png` for a PNG sequence.
-
---
-
-## 2. CSS / HTML version (no dependencies)
-
-The same design without a framework — for the web, OBS browser sources, or a fast look-test. Includes both a **slide+fade** default and a **mask-reveal** name, plus a **wipe-bar** variant.
-
-```html
-<div class="lt" style="--accent:#6EE7F0">
-  <div class="lt-bar">
-    <div class="lt-name">Ada Lovelace</div>
-    <div class="lt-role">Founder, Analytical Engines</div>
-  </div>
-</div>
-
-<style>
-:root { font-family: Inter, system-ui, sans-serif; }
-
-.lt {
-  position: absolute; left: 5%; top: 80%;   /* title-safe, left-anchored */
-}
-.lt-bar {
-  display: inline-block;
-  background: rgba(12,14,22,0.86);
-  backdrop-filter: blur(6px);
-  border-left: 4px solid var(--accent);
-  border-radius: 10px;
-  padding: 14px 22px 16px;
-  /* bar leads the cascade: slide + fade in, then a faster fade out */
-  animation: lt-in .5s cubic-bezier(.22,1,.36,1) both,
-             lt-out .3s ease-in 4.5s forwards;     /* hold ~4s, exit faster */
-}
-.lt-name {
-  font-size: 46px; font-weight: 800; color: #fff; letter-spacing: -.5px;
-  line-height: 1.15; white-space: nowrap;
-  /* MASK REVEAL: letters wipe on left→right, staggered after the bar */
-  clip-path: inset(0 100% 0 0);
-  animation: lt-wipe .5s cubic-bezier(.22,1,.36,1) .12s forwards;
-}
-.lt-role {
-  font-size: 26px; font-weight: 500; color: var(--accent);
-  line-height: 1.15; white-space: nowrap;
-  opacity: 0;
-  animation: lt-fade .4s ease-out .22s forwards;   /* role arrives last */
-}
-
-@keyframes lt-in   { from { opacity: 0; transform: translateX(-32px); }
-                     to   { opacity: 1; transform: none; } }
-@keyframes lt-out  { to   { opacity: 0; transform: translateX(-16px); } }
-@keyframes lt-wipe { to   { clip-path: inset(0 0 0 0); } }
-@keyframes lt-fade { to   { opacity: 1; } }
-
-/* Mobile/9:16: lift the band above the bottom UI/caption zone */
-@media (max-aspect-ratio: 1/1) { .lt { top: 70%; } }
-</style>
-```
-
-### Wipe-bar variant (broadcast feel)
-
-Swap the bar animation so a colored bar sweeps in and the text rides behind it:
-
-```css
-.lt-bar.wipe {
-  position: relative; overflow: hidden;
-  animation: lt-in .45s cubic-bezier(.22,1,.36,1) both,
-             lt-out .3s ease-in 4.5s forwards;
-}
-.lt-bar.wipe::before {
-  content: ""; position: absolute; inset: 0;
-  background: var(--accent);
-  transform-origin: left;
-  animation: lt-sweep .55s cubic-bezier(.76,0,.24,1) both;  /* sweep across, then reveal */
-}
-@keyframes lt-sweep { 0% { transform: scaleX(0); } 60% { transform: scaleX(1); }
-                      100% { transform: scaleX(0); transform-origin: right; } }
-```
-
-The CSS clock (`animation`) is fine for live/web playback. For a deterministic MP4, prefer the Remotion path above — a frame renderer and CSS timers disagree, which causes flicker or desync at export.
-
---
-
-## Quick reference
-
-| Need | Knob |
-|---|---|
-| Slower/faster reveal | enter duration 12–18f / `.5s` |
-| Longer dwell | `holdSeconds` / the `4.5s` exit delay |
-| Bigger name dominance | name `fontSize` (keep ≥1.6× the role) |
-| Rebrand everything | the `BRAND` theme object / `--accent` |
-| 9:16 placement | `baseline 0.80→0.70` / the media query |
-
---
-## Built by the team behind iart.ai
-
-This skill is part of an open motion-graphics collection from iart.ai — the AI motion agent that turns data, scripts, and designs into editable motion graphics (Remotion → MP4). If you'd rather not hand-build this, iart.ai can generate branded lower-thirds from a list of names/titles, one-click — change the text/data and re-export. → [iart.ai](https://iart.ai/?utm_source=github&utm_medium=reference&utm_campaign=tiktok-video-skills&utm_content=ref_footer&utm_term=lower-thirds)
@@ -1,24 +0,0 @@
-# Short-Form Video
-
-Engineer a 9:16 video that survives the swipe. Short-form is a retention machine, not a small launch film: a hook that earns the first second, pattern interrupts that reset attention every few seconds, and often a loop that buys watch-time past 100%. The craft is timing, not polish. For creators making Reels, TikToks, and YouTube Shorts (7–60s, vertical).
-
-## When it activates
-
- "Make a Reels/TikTok/YouTube Shorts video" or "build a short-form video template."
- "Write a hook for a short" or "fix the first 3 seconds."
- "Edit for retention," "add pattern interrupts," or "pace cuts for a vertical video."
- "Make a video loop" or "set up 9:16 safe areas."
-
-## Example prompts
-
- "Build a reusable 9:16 short-form template — one design, many topics."
- "Fix the drop-off in this Reel: tighten pacing and add pattern interrupts."
- "Write three hook options for a 30-second educational short."
-
-## What's inside
-
- `SKILL.md` — the retention arc, hook grammar, and pacing rules.
- `references/retention-pacing.md` — deeper guidance on retention editing and pacing.
-
---
-Part of **[Short-Form Video Skills](../../)** · Built by **[iart.ai](https://iart.ai/?utm_source=github&utm_medium=readme&utm_campaign=tiktok-video-skills&utm_content=skill_footer&utm_term=short-form-video)** — the AI motion agent for editable, on-brand motion graphics.
@@ -1,155 +0,0 @@
---
-name: short-form-video
-description: This skill should be used when the user asks to "make a Reels/TikTok/YouTube Shorts video", "build a short-form video template", "write a hook for a short", "edit for retention", "add pattern interrupts", "make a video loop", "fix the first 3 seconds", "pace cuts for a vertical video", or "set up 9:16 safe areas". Covers the hook→retention→loop grammar of vertical short-form (distinct from a launch hype film).
-version: 0.1.0
---
-
-# Short-Form Video
-
-Engineer a 9:16 video that survives the swipe. Short-form is not a small launch film — it is a retention machine: a hook that earns the first second, pattern interrupts that reset attention every few seconds, and often a loop that buys watch-time past 100%. The craft is timing, not polish.
-
-## When to use
-
- Reels / TikTok / YouTube Shorts (7–60s, vertical 9:16).
- Retention editing: fixing drop-off, adding pattern interrupts, tightening pacing.
- Hooks, seamless loops, repeatable short-form templates (one design, many topics).
-
-## Story structure (the retention contract)
-
-Short-form storytelling is a contract with the viewer's thumb: every second must re-earn the next one. The narrative is shaped *backwards from the retention curve*, not forwards from an intro. Lock these before touching the timeline.
-
- **One idea per video.** A short carries exactly one payoff. A second idea splits attention and the curve sags in the middle — make it a second video instead. If you can't name the single takeaway in a sentence, you don't have a short yet.
- **Open a loop in the first ~3s, close it last.** The hook poses a question or gap (the open loop); the payoff answers it. The viewer stays because the loop is open — so never answer it early, and never bury the payoff under setup.
- **No dead air.** Every beat either advances the idea or resets attention. Cut anything that does neither. Silence, slow ramps, throat-clearing intros ("hey guys, in this video…") are where viewers swipe.
- **Why the curve, not the cut, is the unit of work.** The algorithm distributes whatever holds the per-second retention curve flat; a "good" edit that flattens the curve loses to an ugly one that keeps it up. You are editing the *curve*, and the hook gates everything after it — fix it first.
-
-The narrative spine (the `Hook → Setup → Body → Payoff/loop` arc is budgeted in the table below):
-
-| Move | Story job | Failure if missed |
-|---|---|---|
-| Hook | Open the loop; promise the payoff | Swipe in first 3s |
-| Tension hold | Keep the gap open through the body | Flat middle, mid-drop |
-| Payoff | Close the loop — the one idea, delivered | "Wasted my time," no share |
-| Loop / CTA | Feed back to frame 0, or one clear ask | No re-watch, no action |
-
-(`The retention arc` table below assigns seconds to each move; this section is the narrative logic and ordering behind it. `Hook grammar` lists the hook archetypes.)
-
-## The one metric that drives everything
-
-**Retention, not production value.** The algorithm distributes whatever holds viewers; ~87% decide to stay or swipe inside 3 seconds, and the threshold for distribution sits near **70%+ average view-through** (Shorts ~73%, TikTok ~78%, Reels ~65%). Every decision below trades against that curve. A flawless shot that bores at 0:04 loses to an ugly one that holds.
-
-## The retention arc
-
-| Beat | Job | Budget (of a 20s short) |
-|---|---|---|
-| Hook (0–1s) | One frame + one line that creates an open loop | 0–1s |
-| Setup | Pay off *why watch* — promise, stakes, or the gap | 1–4s |
-| Body | Deliver value in beats; one idea per beat | 4–17s |
-| Payoff / loop | Close the loop — or feed it back to frame 0 | 17–20s |
-
-Scale the *body*, never the hook. A 60s short has a longer body and more beats — the same 1-second hook.
-
-## Hook grammar (first ~1s)
-
-The hook is a sentence + a visual that opens a curiosity gap the brain needs closed. Pick one pattern and commit:
-
-| Hook type | Shape | Best for |
-|---|---|---|
-| Open loop | "The reason your X keeps Y…" (answer delayed) | most content |
-| Direct promise | "3 ways to ___ in 30 seconds" | educational / listicle |
-| Pattern interrupt | snap-zoom / whip-pan / visual mismatch in frame 1 | entertainment |
-| Negation | "Stop doing ___" / "You're ___ wrong" | strong opinions |
-
-Two rules: the hook line is **on-screen as text by frame 1** (85% watch muted), and the most striking *visual* is also the first frame — never a slow ramp-in. Hold a strong opening frame; do not fade up from black.
-
-## Pattern interrupts & cut rhythm
-
-A pattern interrupt is any change that resets attention: a hard cut, zoom punch, b-roll insert, sound effect, caption pop, or angle change. In short-form, density is high — a *visual change every ~2–4 seconds*; videos with an interrupt roughly every 4s hold ~58% vs ~41% for a static talking head. The killer is a flat middle: TikTok throttles distribution when the watch-through curve flattens, so never stitch the body from low-energy takes.
-
-```js
-// Drive every interrupt off the FRAME, not wall-clock — renders deterministically.
-import { useCurrentFrame } from "remotion";
-const fps = 30;
-const cuts = [0, 1.2, 3.0, 5.4, 8.0, 11.2, 14.0]; // seconds — uneven on purpose
-const frame = useCurrentFrame();
-const shot = cuts.findIndex((t, i) => frame < (cuts[i + 1] ?? Infinity) * fps);
-```
-
-Vary the interval — a metronome reads as boredom; uneven cuts read as momentum. A punch-in zoom is the cheapest interrupt that needs no new footage:
-
-```jsx
-import { useCurrentFrame, interpolate, spring, useVideoConfig } from "remotion";
-const PunchIn = ({ at, children }) => {
-  const frame = useCurrentFrame(); const { fps } = useVideoConfig();
-  const s = spring({ frame: frame - at * fps, fps, config: { damping: 12, stiffness: 200 } });
-  const scale = interpolate(s, [0, 1], [1, 1.12]); // snap to 112% on the beat
-  return <div style={{ transform: `scale(${scale})`, transformOrigin: "50% 45%" }}>{children}</div>;
-};
-```
-
-## Captions
-
-Most viewers watch muted, so on-screen captions are not optional — they carry the content and double as a pattern interrupt when each phrase pops in. Keep 4–7 words per line, high contrast, inside the safe area. **Do not re-implement caption animation here** — use the `caption-animation` skill for word-by-word timing, karaoke highlight, and styling; this skill only places captions on the retention timeline and inside the 9:16 safe zone.
-
-## Loops & re-watch
-
-A seamless loop counts each re-watch as fresh watch-time — a clean 8s loop watched 3× is 300% view-through, the strongest possible signal. Two techniques: match the **last frame to the first** (same composition, position, color) so the cut is invisible, and write a **sentence loop** — phrase the hook so the payoff feeds back into frame 0 ("…and that's why I never — " → loops to the start). Best length for re-watch is ~7–15s.
-
-## 9:16 safe areas
-
-Compose inside the universal safe zone so platform UI never covers text or faces.
-
-| Zone | Pixels (1080×1920) | Avoid |
-|---|---|---|
-| Universal safe (all platforms) | center **900×1400** | anything critical outside it |
-| Top | keep clear ~120px | profile / sound UI |
-| Bottom | keep clear ~320px | captions, CTA, hashtags, audio bar |
-| Right | keep clear ~120px | like / comment / share rail |
-
-Put the hook text and key subject in the center 900×1400 box. Reserve the bottom ~320px even if it looks empty in the editor — that is where the platform paints its own captions and buttons.
-
-## Output checklist
-
- Hook line is on-screen text by frame 1; strongest visual is the first frame (no fade-up).
- One open loop / promise set in the first ~4s.
- A visual pattern interrupt every ~2–4s; intervals uneven; no flat middle.
- Captions present (via `caption-animation`), 4–7 words, inside safe area.
- Loop closed — matched first/last frame or a sentence that feeds frame 0.
- Composed inside the 900×1400 center box; bottom 320px / top 120px / right 120px kept clear.
- Every animated value derived from `useCurrentFrame()` — no CSS/library timers.
-
-## Deliver & verify (rendered stills → MP4)
-
-> **Packaged helper** (`scripts/`): tile your stills with `scripts/contact-sheet.sh sheet.png f-hook.png f-mid.png f-end.png`, then assert the encode with `scripts/probe-mp4.sh out.mp4 [WxH] [fps]`. See `scripts/README.md`.
-
-The short ships as a Remotion composition (`<Composition>` + zod `schema` + `defaultProps`) — every cut, punch-in, and interrupt driven by `useCurrentFrame()`, never `Date.now()` / `Math.random()` / timers. Deliverable = `out/*.mp4` + the project (re-render per topic). 9:16 vertical (1080×1920) is the default.
-
-**Verify loop — render stills → inspect → encode.** Three frames test the three things that make or break retention: the hook, the pacing, and the loop seam.
-
-```bash
-# Stills at hook / mid-body / last frame — WITH SHIPPED PROPS (the real topic, not defaults)
-npx remotion still Short out/f-hook.png --frame=10  --props='{"topic":"...","hook":"..."}'   # ~first 3s reads instantly
-npx remotion still Short out/f-mid.png  --frame=N   --props='{"topic":"...","hook":"..."}'
-npx remotion still Short out/f-end.png  --frame=L   --props='{"topic":"...","hook":"..."}'   # L = durationInFrames-1
-
-# Inspect each PNG:
-#  - HOOK frame (~frame 0-ish / first 3s): hook line is on-screen text and reads instantly; strongest visual already up (no fade-up)
-#  - LOOP seam: compare f-hook(frame 0) vs f-end(last frame) — same composition/position/color for an invisible loop cut
-#  - 9:16 safe area: hook + key subject inside the center 900x1400 box; clear of top ~12%, bottom ~20-35% (captions/CTA/audio), right action rail
-
-npx remotion render Short out/short.mp4 --props='{"topic":"...","hook":"..."}'   # encode once stills verify
-npx remotion render Short out/demo.gif --codec=gif                                # README proof clip
-```
-
-**Per topic / batch**: verify ONE topic via stills *before* rendering all of them. Use `npx remotion compositions` for `durationInFrames`/`fps` to pick the mid + last frames.
-
-**Before you finish:**
-1. Stills render cleanly at the hook, mid, and last frame — no errors.
-2. The hook frame reads instantly (on-screen text + strongest visual up front, no fade-up); first vs last frame match for a clean loop seam.
-3. Hook + subject + captions sit inside the 9:16 center 900×1400 safe box at every checked frame.
-4. Frame-driven only — no `Date.now()` / `Math.random()` / timers; cuts uneven, no flat middle.
-5. A real topic's shipped props (not `defaultProps`) render correctly; MP4 encoded, GIF optional.
-
-## Reference files
-
- `references/retention-pacing.md` — a complete runnable Remotion `<Short>` composition: a frame-driven shot scheduler with uneven cuts, the PunchIn pattern interrupt, an on-screen hook, a 9:16 safe-area overlay, and a seamless first/last-frame loop. Plus a hook-pattern library, a retention-curve debugging method, per-platform safe-zone maps, and the template×topic batch-render pattern.
@@ -1,209 +0,0 @@
-# Retention Pacing — Short-Form Video Reference
-
-Deep reference for the `short-form-video` skill: a full runnable Remotion short, a hook library, a retention-debugging method, per-platform safe zones, and batch output. All timing is frame-driven so renders are deterministic.
-
-## 1. A complete `<Short>` composition
-
-One self-contained vertical short: frame-driven shot scheduler with uneven cuts, a punch-in pattern interrupt, an on-screen hook, a 9:16 safe-area overlay (dev only), and a seamless loop. Topic content is a prop, so the same file renders many shorts.
-
-```tsx
-// Short.tsx — 1080×1920, 30fps. Register at 600 frames (20s) for a clean loop.
-import {
-  AbsoluteFill, useCurrentFrame, useVideoConfig,
-  interpolate, spring, Sequence, Img,
-} from "remotion";
-
-type Beat = { at: number; text: string; src?: string };  // at = seconds
-export type ShortProps = {
-  hook: string;                 // on-screen by frame 1
-  beats: Beat[];                // body, one idea each
-  loopText: string;             // sentence that feeds back to frame 0
-};
-
-// --- frame-driven shot scheduler: uneven cuts read as momentum ---
-const useShot = (cuts: number[]) => {
-  const { fps } = useVideoConfig();
-  const frame = useCurrentFrame();
-  let i = 0;
-  for (let k = 0; k < cuts.length; k++) if (frame >= cuts[k] * fps) i = k;
-  const startF = cuts[i] * fps;
-  const endF = (cuts[i + 1] ?? cuts[i] + 2) * fps;
-  const local = (frame - startF) / (endF - startF); // 0→1 within shot
-  return { index: i, local, startF };
-};
-
-// --- punch-in: the cheapest pattern interrupt, snaps on the cut ---
-const PunchIn: React.FC<{ startF: number; to?: number; children: React.ReactNode }> = ({
-  startF, to = 1.1, children,
-}) => {
-  const frame = useCurrentFrame();
-  const { fps } = useVideoConfig();
-  const s = spring({ frame: frame - startF, fps, config: { damping: 13, stiffness: 220 } });
-  const scale = interpolate(s, [0, 1], [1, to]);
-  return <AbsoluteFill style={{ transform: `scale(${scale})`, transformOrigin: "50% 45%" }}>{children}</AbsoluteFill>;
-};
-
-// --- hook: text present from frame 0, micro-overshoot, no fade-up ---
-const Hook: React.FC<{ text: string }> = ({ text }) => {
-  const frame = useCurrentFrame();
-  const { fps } = useVideoConfig();
-  const pop = spring({ frame, fps, config: { damping: 9, stiffness: 260 } });
-  const scale = interpolate(pop, [0, 1], [0.9, 1]);
-  return (
-    <div style={{
-      position: "absolute", top: 360, left: 90, right: 90, // inside 900-wide safe box
-      transform: `scale(${scale})`, transformOrigin: "0 0",
-      fontFamily: "Inter, sans-serif", fontWeight: 800, fontSize: 76, lineHeight: 1.05,
-      color: "#fff", textShadow: "0 4px 24px rgba(0,0,0,.55)",
-    }}>{text}</div>
-  );
-};
-
-export const Short: React.FC<ShortProps> = ({ hook, beats, loopText }) => {
-  const { fps, durationInFrames } = useVideoConfig();
-  const frame = useCurrentFrame();
-  const cuts = [0, ...beats.map((b) => b.at)];     // hook shot + one per beat
-  const { index, startF } = useShot(cuts);
-  const current = index === 0 ? null : beats[index - 1];
-
-  // seamless loop: match the LAST 0.5s back toward the opening frame
-  const tailF = durationInFrames - frame;
-  const loopFade = interpolate(tailF, [0, fps * 0.5], [0, 1], { extrapolateLeft: "clamp", extrapolateRight: "clamp" });
-
-  return (
-    <AbsoluteFill style={{ backgroundColor: "#0b0b0f" }}>
-      <PunchIn startF={startF}>
-        {current?.src && <Img src={current.src} style={{ width: "100%", height: "100%", objectFit: "cover" }} />}
-      </PunchIn>
-
-      {index === 0 && <Hook text={hook} />}
-
-      {/* body caption — placement only; styling/word-timing belongs to caption-animation */}
-      {current && (
-        <div style={{
-          position: "absolute", left: 90, right: 90, bottom: 380, // above the 320px bottom UI band
-          fontFamily: "Inter, sans-serif", fontWeight: 700, fontSize: 60, color: "#fff",
-          textAlign: "center", textShadow: "0 3px 18px rgba(0,0,0,.6)",
-        }}>{current.text}</div>
-      )}
-
-      {/* loop sentence rises as the clip ends, easing the eye back to frame 0 */}
-      <div style={{
-        position: "absolute", left: 90, right: 90, bottom: 380, opacity: 1 - loopFade,
-        fontFamily: "Inter, sans-serif", fontWeight: 800, fontSize: 64, color: "#fff", textAlign: "center",
-      }}>{loopText}</div>
-
-      <SafeZone />{/* remove for final render */}
-    </AbsoluteFill>
-  );
-};
-```
-
-Register it with a duration that *is* the loop length:
-
-```ts
-// Root.tsx
-import { Composition } from "remotion";
-import { Short } from "./Short";
-export const Root = () => (
-  <Composition
-    id="Short" component={Short}
-    durationInFrames={600} fps={30} width={1080} height={1920}
-    defaultProps={{
-      hook: "You're editing Shorts wrong —",
-      beats: [
-        { at: 1.2, text: "Cut every 2–4 seconds", src: "b1.jpg" },
-        { at: 4.0, text: "Never on a fixed grid", src: "b2.jpg" },
-        { at: 7.5, text: "Kill the flat middle", src: "b3.jpg" },
-        { at: 11.0, text: "Match last frame to first", src: "b4.jpg" },
-      ],
-      loopText: "…and that's why mine loop forever",
-    }}
-  />
-);
-```
-
-## 2. The 9:16 safe-area overlay (dev-only)
-
-Render this on top while editing; delete it before the final export.
-
-```tsx
-import { AbsoluteFill } from "remotion";
-export const SafeZone: React.FC = () => (
-  <AbsoluteFill style={{ pointerEvents: "none" }}>
-    {/* universal safe box: center 900×1400 in 1080×1920 */}
-    <div style={{ position: "absolute", left: 90, top: 260, width: 900, height: 1400, outline: "2px dashed #39d", opacity: .6 }} />
-    {/* platform UI bands to keep clear */}
-    <div style={{ position: "absolute", top: 0, left: 0, right: 0, height: 120, background: "rgba(255,0,0,.12)" }} />
-    <div style={{ position: "absolute", bottom: 0, left: 0, right: 0, height: 320, background: "rgba(255,0,0,.12)" }} />
-    <div style={{ position: "absolute", bottom: 320, top: 120, right: 0, width: 120, background: "rgba(255,128,0,.10)" }} />
-  </AbsoluteFill>
-);
-```
-
-## 3. Hook pattern library
-
-The hook is a sentence that opens a gap the brain must close, plus the most striking frame as frame 0. Copyable shapes:
-
-| Pattern | Template | Note |
-|---|---|---|
-| Open loop | "The real reason your ___ keeps ___ …" | answer withheld until payoff |
-| Direct promise | "___ in 30 seconds, no ___ needed" | name the payoff + the timebox |
-| Negation | "Stop ___. You're doing it backwards." | strong-opinion content |
-| Pattern interrupt | snap-zoom / whip / hard visual mismatch | entertainment, no text needed |
-| Stakes | "This ___ cost me $___ — don't repeat it" | story / case-study |
-| Listicle | "3 ___ that ___ (the 3rd one ___ )" | tees up a forward reference |
-
-Rules that matter more than the wording: (1) the hook text is on-screen by frame 1 — most viewers are muted; (2) frame 0 is the best frame, never a fade-up from black; (3) one gap only — stacking two hooks closes neither.
-
-## 4. Retention-curve debugging
-
-Treat the per-second retention graph (TikTok Analytics, YT Studio "Audience retention", Reels) as a profiler.
-
-| Symptom on the curve | Likely cause | Fix |
-|---|---|---|
-| Cliff at 0:00–0:02 | weak hook / slow first frame | new hook line; cut the ramp-in; lead with the best frame |
-| Steady gentle decline | normal — leave it | — |
-| Flat-then-drop in the middle | low-energy body, cuts too sparse | add interrupts; tighten cut spacing to 2–4s |
-| Bump back up near the end | viewers are looping | lean in — tighten the loop, shorten total length |
-| Spike at one timestamp | a re-watched moment | front-load that beat or make it the hook |
-
-Target ≥70% average view-through. Iterate the hook first — it moves the curve more than any other edit because it gates everything after it.
-
-## 5. Per-platform safe zones
-
-All on a 1080×1920 canvas. The universal box (center 900×1400) is the intersection; design inside it and one master fits every platform.
-
-| Platform | Top clear | Bottom clear | Right clear | Notes |
-|---|---|---|---|---|
-| Universal (use this) | ~120px | ~320px | ~120px | center 900×1400 holds on all |
-| TikTok | ~108px | ~320px | ~120px | caption + button rail at bottom-right |
-| Instagram Reels | ~120px | ~310px | ~84px | audio bar + caption bottom |
-| YouTube Shorts | ~120px | ~300px | ~60px | channel + subscribe bottom band |
-| TikTok Ads | ~108px | ~370px | ~120px | extra room for the CTA button |
-
-When unsure, design to the *largest* margin (TikTok Ads bottom 370px) and nothing ever clips.
-
-## 6. Template × topic — batch output
-
-The payoff of code-driven shorts: lock the design once, swap only the props, render N videos. Make topic content a prop (already done above), keep one theme object, and loop over JSON files.
-
-```jsx
-// theme.ts — one source of truth so 50 shorts stay on-brand
-export const theme = { font: "Inter", hookSize: 76, bodySize: 60, bg: "#0b0b0f", fg: "#fff", accent: "#39d" };
-```
-
-```bash
-# render the same Short template for every topic file in /topics
-for f in topics/*.json; do
-  name=$(basename "$f" .json)
-  npx remotion render Short "out/$name.mp4" --props="$f"
-done
-```
-
-Each `topics/*.json` is one `ShortProps` object (`hook`, `beats`, `loopText`). Keep the hook line, cut points, and loop sentence per-topic; everything else stays fixed so the series reads as one brand.
-
---
-## Built by the team behind iart.ai
-
-This skill is part of an open motion-graphics collection from iart.ai — the AI motion agent that turns data, scripts, and designs into editable motion graphics (Remotion → MP4). If you'd rather not hand-build this, iart.ai can batch-produce short-form videos from one template × data — change the text/data and re-export. → [iart.ai](https://iart.ai/?utm_source=github&utm_medium=reference&utm_campaign=tiktok-video-skills&utm_content=ref_footer&utm_term=short-form-video)
@@ -0,0 +1,196 @@
+---
+name: testimonial-video
+description: This skill should be used when the user asks to "make an animated testimonial", "create a quote video", "build a review video", "turn a customer testimonial into a graphic", "animate a customer review", "make a social proof video", "add an animated star rating", or "turn a list of reviews into videos". Covers quote typography, staggered line reveals, kinetic emphasis on key phrases, animated star ratings, the author block (name/role/avatar/company), and templating one card across many quotes.
+version: 0.1.0
+---
+
+# Testimonial Video
+
+Animate a written quote, review, or testimonial into a short, trustworthy social-proof clip. The craft is typographic, not flashy: a clean quote card where the words land in reading order, the key phrase gets emphasis exactly when it should, the stars fill to the real score, and the author signs off. One card design, driven by props, becomes a video for every review on the list.
+
+## When to use
+
+- Customer review → a 6–12s vertical/feed clip (the headline use case).
+- A pull-quote or testimonial graphic with author name, role, avatar, company.
+- An animated star rating (including half/fractional scores like 4.5).
+- A batch: a list/CSV of reviews → one video each, same template.
+
+Do **not** reach here for sale/discount promos or generic ad creative — this skill is strictly the quote / social-proof angle.
+
+## The one rule: trust before motion
+
+A testimonial earns its job by feeling *real*, not produced. Restraint reads as credibility; over-animation reads as an ad people skip.
+
+1. **Reveal in reading order.** The eye must finish a line before the next arrives. Stagger lines (or clauses), never all words at once, and never reorder for visual flair.
+2. **Quote the words exactly.** Do not paraphrase, trim mid-sentence, or invent a rating. If you emphasize a phrase, it must be the customer's phrase.
+3. **The author is the proof.** A quote with no attributable human is just a slogan. Name + role + company (and avatar if real) is non-negotiable.
+
+## The anatomy of a quote card
+
+| Element | Job | Timing |
+|---|---|---|
+| Quote mark motif | Signals "this is a quote" before words read | Frame 0, scales/fades in first |
+| Quote body | The testimonial, revealed line-by-line | Staggered, ~6–10 frames apart |
+| Emphasis span | The one phrase that sells | Lands *after* its line settles |
+| Star rating | The score, filled to the real value | Fills left→right after the quote |
+| Author block | Name / role / company / avatar | Signs off last, slides up |
+
+Build in that order; reveal in that order. The viewer reads the quote, believes it, sees the score, then learns who said it.
+
+## Staggered line reveal
+
+Split the quote into lines (or clauses), then offset each one's entrance. In Remotion, drive every line off `useCurrentFrame()` so it renders deterministically — never a CSS transition or a JS timer, which desync from the frame renderer.
+
+```jsx
+import { useCurrentFrame, spring, useVideoConfig } from "remotion";
+
+const QuoteBody = ({ lines, startAt = 8, stagger = 6 }) => {
+  const frame = useCurrentFrame();
+  const { fps } = useVideoConfig();
+  return (
+    <blockquote>
+      {lines.map((line, i) => {
+        const enter = spring({ frame: frame - startAt - i * stagger, fps,
+          config: { damping: 200 } });           // 0→1, no overshoot
+        return (
+          <span key={i} style={{ display: "block",
+            opacity: enter,
+            transform: `translateY(${(1 - enter) * 14}px)` }}>
+            {line}
+          </span>
+        );
+      })}
+    </blockquote>
+  );
+};
+```
+
+Keep one motion language: same easing, same 14px rise, every line. Speed reads as confidence only when it's consistent. See `references/quote-card.md` for the full composition.
+
+## Kinetic emphasis on the key phrase
+
+Pick the single phrase that carries the testimonial ("saved us 10 hours a week") and let it arrive *after* its line has settled — a highlight sweep, a weight shift, or a color pop. Emphasis competing with the reveal cancels both.
+
+```jsx
+const sweep = interpolate(frame, [hlStart, hlStart + 10], [0, 100],
+  { extrapolateLeft: "clamp", extrapolateRight: "clamp" });
+// a highlighter wiping in behind the phrase, left→right
+<mark style={{ background:
+  `linear-gradient(90deg, var(--accent) ${sweep}%, transparent ${sweep}%)`,
+  color: "inherit", padding: "0 .08em" }}>{phrase}</mark>
+```
+
+Emphasize at most one span per quote. Two highlights is no highlight.
+
+## Animated star rating (fractional)
+
+Render the real score, including halves. Use one full row of star glyphs as a mask, then wipe a filled layer to `rating / max` width — this handles 4.5 as cleanly as 5.0, with no half-star sprite.
+
+```jsx
+const StarRating = ({ rating, max = 5, fillStart = 30, fillDur = 14 }) => {
+  const frame = useCurrentFrame();
+  const target = (rating / max) * 100;
+  const w = interpolate(frame, [fillStart, fillStart + fillDur], [0, target],
+    { extrapolateLeft: "clamp", extrapolateRight: "clamp" });
+  return (
+    <div className="stars" role="img" aria-label={`${rating} out of ${max} stars`}>
+      <div className="track">★★★★★</div>
+      <div className="fill" style={{ width: `${w}%` }}>★★★★★</div>
+    </div>
+  );
+};
+```
+
+```css
+.stars { position: relative; display: inline-block; font-size: 40px; letter-spacing: 4px; }
+.track { color: rgba(255,255,255,.22); }
+.fill  { position: absolute; inset: 0; overflow: hidden; white-space: nowrap;
+         color: var(--accent); }   /* clipped by width → fractional fill */
+```
+
+Fill left→right after the quote reads. Never animate stars before the words — the score must feel earned, not pre-loaded. Always set `aria-label` to the real value.
+
+## The author block
+
+Sign off last. The block slides up under the stars and holds still — stillness is what makes attribution read as fact.
+
+```jsx
+<figcaption className="author">
+  {avatar && <img src={avatar} alt="" className="avatar" />}
+  <div>
+    <span className="name">{name}</span>
+    <span className="role">{role}{company && `, ${company}`}</span>
+  </div>
+</figcaption>
+```
+
+Use a real avatar or none — a generic placeholder face actively destroys trust. Name is the loudest line in the block; role/company is secondary weight.
+
+## Template × reviews — one video per quote
+
+The payoff: make every field a prop, hardcode nothing, then render once per review.
+
+```jsx
+export const Testimonial = ({ quote, highlight, rating, name, role, company, avatar }) => { /* … */ };
+```
+```bash
+for f in reviews/*.json; do
+  npx remotion render Testimonial "out/$(basename "$f" .json).mp4" --props="$f"
+done
+```
+
+Keep colors/fonts/quote-mark/layout in one theme object so 50 testimonials stay brand-locked and only the words and score change. See `references/batch-and-typography.md` for the review schema, CSV→props parsing, quote-typography craft (smart quotes, hanging punctuation, line-splitting, orphans), and the batch script.
+
+## Output checklist
+
+- Lines reveal in reading order; one consistent enter motion, ~6–10 frame stagger.
+- The quote is verbatim; exactly one emphasized span, landing after its line settles.
+- Stars fill to the *real* score (halves supported) after the quote, with a correct `aria-label`.
+- Author block (name + role + company, real avatar or none) signs off last and holds still.
+- Every animated value derives from `useCurrentFrame()` — no CSS/JS timers.
+- Every field is a prop; one template renders every review in the folder.
+
+## Deliver & verify (rendered stills → MP4)
+
+> **Packaged helper** (`scripts/`): tile your stills with `scripts/contact-sheet.sh sheet.png f-hook.png f-mid.png f-end.png`, then assert the encode with `scripts/probe-mp4.sh out.mp4 [WxH] [fps]`. See `scripts/README.md`.
+
+**Output contract:**
+- A Remotion `Testimonial` registered as `<Composition>` (+ zod `schema` + `defaultProps`), every value frame-driven (no CSS transitions / JS timers / `Date.now()` / `Math.random()`).
+- Deliverable = the rendered `out/*.mp4` per review per aspect (plus the project + review data, so the user re-renders on new quotes).
+
+**Verify loop — render stills → inspect → encode.** Cheap PNGs first; render with the **shipped** review's props, not just `defaultProps`.
+
+```bash
+# Frame-exact stills across the reveal order: quote → stars → author
+npx remotion still Testimonial out/f-quote.png  --frame=30  --props=reviews/r1.json  # lines in reading order, emphasis span
+npx remotion still Testimonial out/f-stars.png  --frame=48  --props=reviews/r1.json  # stars filled to the REAL score (e.g. 4.5)
+npx remotion still Testimonial out/f-author.png --frame=215 --props=reviews/r1.json  # author block signed off, holding still
+# inspect each: fidelity (quote VERBATIM, exactly one emphasized span, star fill matches rating, name/role/company exact)
+#   AND artifacts (text overflow/orphans, off-canvas, author in the 9:16 bottom third, missing font, broken avatar)
+```
+
+**Multi-aspect / batch — verify one review in EACH target aspect before batch-rendering the list.** A layout bug (overflowing quote, clipped author) repeats across every review × aspect; catch it once.
+
+```bash
+for ar in 9x16 1x1 16x9; do                                  # one representative review, every aspect
+  npx remotion still Testimonial "out/r1-${ar}.png" --frame=215 \
+    --props=reviews/r1.json --props-merge="{\"aspect\":\"${ar}\"}"
+done
+# stills clean in all aspects? → then batch-render the list:
+for f in reviews/*.json; do id=$(basename "$f" .json); for ar in 9x16 1x1 16x9; do
+  npx remotion render Testimonial "out/${id}-${ar}.mp4" --props="$f" --props-merge="{\"aspect\":\"${ar}\"}"
+done; done
+npx remotion render Testimonial out/demo.gif --codec=gif --props=reviews/r1.json   # README demo
+```
+
+**Before you finish:**
+1. `npx remotion still` renders cleanly at quote / stars / author — no errors, no missing fonts/avatar.
+2. Quote is verbatim with one emphasized span; stars fill to the real score; name/role/company exact and inside the safe zone (clear of the 9:16 bottom third).
+3. Frame-driven only — no CSS/JS timers, `Date.now()`, or `Math.random()`.
+4. Shipped review's props render correctly (not just `defaultProps`); `aria-label` carries the real rating.
+5. One review verified in 9:16 + 1:1 + 16:9 before the batch; MP4s play; (optional) GIF for the README.
+
+## Reference files
+
+- `references/quote-card.md` — a complete runnable Remotion `Testimonial` composition: staggered line reveal, key-phrase highlight sweep, fractional star fill, author block, theme object, and the timing map for a 9:16 card. Plus a dependency-free HTML/CSS variant.
+- `references/batch-and-typography.md` — the review prop schema, CSV/JSON→props parsing and validation, quote typography craft (smart quotes, hanging quotation marks, line/clause splitting, orphan control, legibility in motion), star-rating accessibility, and the template×reviews batch render script for N videos.
@@ -0,0 +1,140 @@
+# Batch & Typography
+
+How to feed many reviews into one card design, plus the quote-typography craft that separates a credible testimonial from a sloppy one.
+
+## Review prop schema
+
+One object per testimonial. Keep it flat so a CSV row maps to it directly.
+
+```ts
+type Review = {
+  quote: string;        // verbatim — never paraphrased or trimmed mid-sentence
+  highlight?: string;   // EXACT substring of `quote`; one phrase only
+  rating: number;       // 0–max, halves allowed (4.5)
+  max?: number;         // default 5
+  name: string;         // required — a quote with no name is not social proof
+  role?: string;
+  company?: string;
+  avatar?: string;      // real photo URL, or omit (never a stock face)
+};
+```
+
+### Validation (fail loud, before rendering 50 videos)
+
+```ts
+function validate(r: Review): string[] {
+  const errs: string[] = [];
+  if (!r.quote?.trim()) errs.push("quote is empty");
+  if (!r.name?.trim()) errs.push("name is required (no anonymous testimonials)");
+  const max = r.max ?? 5;
+  if (r.rating < 0 || r.rating > max) errs.push(`rating ${r.rating} out of 0–${max}`);
+  if (r.highlight && !r.quote.includes(r.highlight))
+    errs.push(`highlight "${r.highlight}" is not a substring of the quote`);
+  return errs;
+}
+```
+
+The `highlight ⊂ quote` check is the important one: it guarantees you only ever emphasize words the customer actually wrote. If the highlight isn't an exact substring, the emphasis silently disappears in the card — so block the render instead.
+
+## CSV → props
+
+Reviews usually arrive as a spreadsheet export. Map columns to the schema and coerce the rating.
+
+```js
+import { parse } from "csv-parse/sync";
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+
+// CSV columns: quote,highlight,rating,name,role,company,avatar
+const rows = parse(readFileSync("reviews.csv"), { columns: true, trim: true });
+mkdirSync("reviews", { recursive: true });
+
+rows.forEach((row, i) => {
+  const r = {
+    quote: row.quote,
+    highlight: row.highlight || undefined,
+    rating: Number(row.rating),
+    name: row.name,
+    role: row.role || undefined,
+    company: row.company || undefined,
+    avatar: row.avatar || undefined,
+  };
+  const errs = validate(r);
+  if (errs.length) { console.error(`Row ${i + 1} (${r.name}):`, errs); process.exit(1); }
+  writeFileSync(`reviews/${String(i).padStart(3, "0")}-${slug(r.name)}.json`,
+    JSON.stringify(r, null, 2));
+});
+
+const slug = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+```
+
+## Batch render — one video per review
+
+```bash
+mkdir -p out
+for f in reviews/*.json; do
+  name=$(basename "$f" .json)
+  npx remotion render Testimonial "out/$name.mp4" --props="$f"
+done
+```
+
+Everything visual lives in the single `theme` object in the composition (colors, fonts, quote-mark glyph, spacing). Because only the props change per render, 50 testimonials stay pixel-for-pixel brand-locked while the words and score vary. To re-theme the whole set, edit one object and re-run the loop.
+
+For multi-aspect (9:16 feed + 1:1 post + 16:9 site), register the composition at each size with a shared center-safe layout and loop over both `reviews/*.json` and the aspect list.
+
+## Quote typography craft
+
+Motion is the easy part; legible, well-set type is what makes the quote trustworthy.
+
+### Smart quotes, always
+
+Straight quotes (`"`) read as un-proofed. Convert to typographic quotes before rendering.
+
+```js
+const smarten = (s) => s
+  .replace(/(^|[\s([{])"/g, "$1“").replace(/"/g, "”")   // “ ”
+  .replace(/(^|[\s([{])'/g, "$1‘").replace(/'/g, "’")   // ‘ ’
+  .replace(/--/g, "—");                                       // em dash
+```
+
+### Hanging quotation marks
+
+A leading quote glyph indents the first line and breaks the flush-left edge. Hang it into the margin so the text block stays optically aligned — the gold standard for set quotes.
+
+```css
+blockquote { hanging-punctuation: first; }            /* Safari/WebKit */
+/* Cross-engine fallback: pull the opening mark left by its own width */
+blockquote::before { content: "\201C"; margin-left: -0.55em; color: var(--muted); }
+```
+
+When the card uses a large decorative quote mark (as in `quote-card.md`), drop the inline opening glyph so the mark isn't doubled.
+
+### Splitting into lines / clauses
+
+Reveal in reading order means splitting on meaning, not on a fixed character count. Prefer clause boundaries (`. ! ? , ; —`), then pack to a comfortable measure (~32–40 chars at card size). The `toLines` helper in `quote-card.md` does exactly this. Never split a short quote into one-word-per-line — that reads as a ransom note, not a testimonial.
+
+### Orphans & widows
+
+A single dangling word on the last line looks broken. Bind the last two words with a non-breaking space so they wrap together.
+
+```js
+const noOrphan = (s) => s.replace(/ ([^ ]+)\s*$/, " $1");
+```
+
+### Legibility in motion
+
+- Use a font that stays readable while moving — avoid thin weights and tight tracking; a serif or a humanist sans at 500–600 weight holds up best on a rising line.
+- Animate **opacity + a small translate** only. Blur, rotation, and scale on body text hurt readability mid-reveal.
+- Contrast: body text ≥ 4.5:1 against the card; the highlight accent should pass against both the card and the ink it sits behind.
+- One emphasized span per quote. A second highlight halves the weight of the first.
+
+## Star-rating accessibility & correctness
+
+- The visual stars are decorative; expose the value to assistive tech with `role="img"` and `aria-label="4.5 out of 5 stars"` on the container (already in `quote-card.md`).
+- For fractional scores, the width-clip method (`rating / max * 100%`) is exact for any decimal — no rounding to the nearest half-star, so 4.3 renders as 4.3.
+- Never animate the stars before the quote is read, and never show more filled stars than the data supports. A faked rating is the fastest way to lose the trust the testimonial was meant to build.
+- If a review has no rating, omit the star row entirely rather than defaulting to 5 — an invented score is worse than none.
+
+## Pacing notes
+
+- Hold the finished card still for the back half of the clip (≥3s) so it's screenshot-able and re-shareable — shares are the whole point of social proof.
+- For a sequence of testimonials in one video, give each card a full read (~3–4s) and hard-cut between them; cross-dissolving quotes makes both unreadable.
@@ -0,0 +1,241 @@
+# Quote Card — complete runnable component
+
+A full testimonial card you can drop into a Remotion project, plus a zero-dependency HTML/CSS variant for non-Remotion pipelines. Both reveal in reading order, emphasize one phrase, fill stars to the real score, and sign off with the author.
+
+## Timing map (9:16, 30fps, ~10s)
+
+| Frame | Beat |
+|---|---|
+| 0–8 | Quote mark scales in; card settles |
+| 8–48 | Quote body, line-by-line (8 + i×6) |
+| 44–54 | Key-phrase highlight sweep (after its line settles) |
+| 56–70 | Stars fill left→right to `rating/max` |
+| 72–88 | Author block slides up, holds |
+| 88–300 | Everything holds still (screenshot-able) |
+
+The card holds motionless for the back half — stillness is what makes a testimonial read as a fact rather than an ad.
+
+## Remotion composition
+
+```tsx
+import {
+  AbsoluteFill, useCurrentFrame, useVideoConfig, spring, interpolate, Img,
+} from "remotion";
+
+export type Review = {
+  quote: string;          // verbatim testimonial
+  highlight?: string;     // exact substring of `quote` to emphasize
+  rating: number;         // e.g. 4.5
+  max?: number;           // default 5
+  name: string;
+  role?: string;
+  company?: string;
+  avatar?: string;        // real photo URL, or omit
+};
+
+const theme = {
+  bg: "#0E1116",
+  ink: "#F5F7FA",
+  muted: "rgba(245,247,250,.55)",
+  accent: "#FFC24B",
+  font: "Inter, system-ui, sans-serif",
+  quoteFont: "'Newsreader', Georgia, serif",
+  quoteMark: "“",     // left double quotation mark
+};
+
+// Split a quote into clauses for reading-order reveal.
+// Prefer sentence/clause boundaries; fall back to ~32-char wraps.
+const toLines = (q: string): string[] => {
+  const parts = q.match(/[^.!?,;]+[.!?,;]?\s*/g) ?? [q];
+  const lines: string[] = [];
+  let buf = "";
+  for (const p of parts) {
+    if ((buf + p).length > 34 && buf) { lines.push(buf.trim()); buf = p; }
+    else buf += p;
+  }
+  if (buf.trim()) lines.push(buf.trim());
+  return lines;
+};
+
+// Render a line, wrapping the highlight substring in <mark> if present.
+const Line: React.FC<{ text: string; highlight?: string; sweep: number }> = ({
+  text, highlight, sweep,
+}) => {
+  if (!highlight || !text.includes(highlight)) return <>{text}</>;
+  const [before, after] = text.split(highlight);
+  return (
+    <>
+      {before}
+      <mark
+        style={{
+          background: `linear-gradient(90deg, ${theme.accent} ${sweep}%, transparent ${sweep}%)`,
+          color: "inherit",
+          padding: "0 .08em",
+          borderRadius: 3,
+          WebkitBoxDecorationBreak: "clone",
+        }}
+      >
+        {highlight}
+      </mark>
+      {after}
+    </>
+  );
+};
+
+export const Testimonial: React.FC<Review> = ({
+  quote, highlight, rating, max = 5, name, role, company, avatar,
+}) => {
+  const frame = useCurrentFrame();
+  const { fps } = useVideoConfig();
+  const lines = toLines(quote);
+
+  // Quote mark
+  const markIn = spring({ frame, fps, config: { damping: 14 } });
+
+  // Highlight sweep, after the body has revealed
+  const hlStart = 8 + lines.length * 6 + 4;
+  const sweep = interpolate(frame, [hlStart, hlStart + 10], [0, 100], {
+    extrapolateLeft: "clamp", extrapolateRight: "clamp",
+  });
+
+  // Stars fill, after the quote
+  const fillStart = hlStart + 14;
+  const target = (rating / max) * 100;
+  const starW = interpolate(frame, [fillStart, fillStart + 14], [0, target], {
+    extrapolateLeft: "clamp", extrapolateRight: "clamp",
+  });
+
+  // Author block slides up last
+  const authStart = fillStart + 16;
+  const auth = spring({ frame: frame - authStart, fps, config: { damping: 200 } });
+
+  return (
+    <AbsoluteFill style={{ background: theme.bg, fontFamily: theme.font,
+      padding: 120, justifyContent: "center", color: theme.ink }}>
+      <div
+        aria-hidden
+        style={{ fontFamily: theme.quoteFont, fontSize: 200, lineHeight: .6,
+          color: theme.accent, opacity: markIn, transform: `scale(${markIn})`,
+          transformOrigin: "left top" }}
+      >
+        {theme.quoteMark}
+      </div>
+
+      <blockquote style={{ fontFamily: theme.quoteFont, fontSize: 64,
+        lineHeight: 1.25, margin: "24px 0 48px", fontWeight: 500 }}>
+        {lines.map((line, i) => {
+          const enter = spring({ frame: frame - (8 + i * 6), fps,
+            config: { damping: 200 } });
+          return (
+            <span key={i} style={{ display: "block", opacity: enter,
+              transform: `translateY(${(1 - enter) * 14}px)` }}>
+              <Line text={line} highlight={highlight} sweep={sweep} />
+            </span>
+          );
+        })}
+      </blockquote>
+
+      {/* Stars */}
+      <div role="img" aria-label={`${rating} out of ${max} stars`}
+        style={{ position: "relative", display: "inline-block", fontSize: 52,
+          letterSpacing: 6, marginBottom: 56 }}>
+        <div style={{ color: "rgba(245,247,250,.20)" }}>{"★".repeat(max)}</div>
+        <div style={{ position: "absolute", inset: 0, overflow: "hidden",
+          whiteSpace: "nowrap", width: `${starW}%`, color: theme.accent }}>
+          {"★".repeat(max)}
+        </div>
+      </div>
+
+      {/* Author */}
+      <figcaption style={{ display: "flex", alignItems: "center", gap: 20,
+        opacity: auth, transform: `translateY(${(1 - auth) * 16}px)` }}>
+        {avatar && (
+          <Img src={avatar} alt=""
+            style={{ width: 88, height: 88, borderRadius: "50%", objectFit: "cover" }} />
+        )}
+        <div style={{ display: "flex", flexDirection: "column" }}>
+          <span style={{ fontSize: 38, fontWeight: 700 }}>{name}</span>
+          <span style={{ fontSize: 30, color: theme.muted }}>
+            {[role, company].filter(Boolean).join(", ")}
+          </span>
+        </div>
+      </figcaption>
+    </AbsoluteFill>
+  );
+};
+```
+
+Register it with a duration long enough for the back-half hold:
+
+```tsx
+<Composition id="Testimonial" component={Testimonial}
+  durationInFrames={300} fps={30} width={1080} height={1920}
+  defaultProps={{
+    quote: "We shipped in days, not months. Onboarding saved us 10 hours a week.",
+    highlight: "saved us 10 hours a week",
+    rating: 4.5, name: "Dana Reyes", role: "Head of Ops", company: "Northwind",
+  }} />
+```
+
+## Why these choices
+
+- **`spring` with `damping: 200`** gives a clean rise with no overshoot — testimonials should feel composed, not bouncy. The quote mark uses lighter damping (14) for a touch of life on the one decorative element.
+- **Highlight as a gradient `<mark>`** wipes a real highlighter behind the phrase without a second element or a mask, and survives line wraps via `box-decoration-break: clone`.
+- **Stars as two stacked glyph rows clipped by width** render any fractional score (4.5, 4.3) with no half-star asset, and the filled row inherits the brand accent.
+- **Author after stars** matches reading psychology: claim → proof → who. Reordering weakens trust.
+
+## Zero-dependency HTML/CSS variant
+
+For pipelines that capture a headless-browser timeline (or just a web embed). Animations are CSS `@keyframes` with per-line `animation-delay`; if rendering frame-exact video, prefer the Remotion version above so frames stay deterministic.
+
+```html
+<figure class="card" style="--accent:#FFC24B; --rating:4.5; --max:5">
+  <div class="qmark" aria-hidden="true">&ldquo;</div>
+  <blockquote>
+    <span style="--i:0">We shipped in days, not months.</span>
+    <span style="--i:1">Onboarding <mark>saved us 10 hours a week.</mark></span>
+  </blockquote>
+  <div class="stars" role="img" aria-label="4.5 out of 5 stars">
+    <div class="track">★★★★★</div><div class="fill">★★★★★</div>
+  </div>
+  <figcaption>
+    <img src="dana.jpg" alt="" class="avatar">
+    <div><b>Dana Reyes</b><small>Head of Ops, Northwind</small></div>
+  </figcaption>
+</figure>
+```
+
+```css
+.card { --bg:#0E1116; --ink:#F5F7FA; background:var(--bg); color:var(--ink);
+  font-family:Inter,system-ui,sans-serif; padding:120px; max-width:1080px; }
+.qmark { font:200px/.6 'Newsreader',Georgia,serif; color:var(--accent);
+  animation:pop .4s cubic-bezier(.22,1,.36,1) both; }
+blockquote { font:500 64px/1.25 'Newsreader',Georgia,serif; margin:24px 0 48px; }
+blockquote span { display:block; opacity:0;
+  animation:rise .5s cubic-bezier(.22,1,.36,1) both;
+  animation-delay:calc(.27s + var(--i) * .2s); }
+mark { background:linear-gradient(90deg,var(--accent) 100%,transparent 100%);
+  color:inherit; padding:0 .08em; border-radius:3px;
+  -webkit-box-decoration-break:clone; box-decoration-break:clone;
+  animation:sweep .35s ease-out both; animation-delay:1s; }
+@keyframes sweep { from { background-size:0 100% } to { background-size:100% 100% } }
+.stars { position:relative; display:inline-block; font-size:52px; letter-spacing:6px; }
+.track { color:rgba(245,247,250,.20); }
+.fill { position:absolute; inset:0; overflow:hidden; white-space:nowrap;
+  color:var(--accent); width:0; animation:fill .5s ease-out 1.3s forwards; }
+@keyframes fill { to { width:calc(var(--rating) / var(--max) * 100%) } }
+figcaption { display:flex; align-items:center; gap:20px; margin-top:56px;
+  opacity:0; animation:rise .5s ease-out 1.8s both; }
+.avatar { width:88px; height:88px; border-radius:50%; object-fit:cover; }
+figcaption b { font-size:38px; } figcaption small { display:block; font-size:30px;
+  color:rgba(245,247,250,.55); }
+@keyframes pop  { from { opacity:0; transform:scale(.7) } to { opacity:1; transform:none } }
+@keyframes rise { from { opacity:0; transform:translateY(14px) } to { opacity:1; transform:none } }
+```
+
+The CSS `mark` sweep uses `background-size` (animatable) rather than a gradient color-stop, since color-stop percentages don't animate in CSS. The star `--rating/--max` math is the same fractional fill as the Remotion version.
+
+---
+## Built by the team behind iart.ai
+
+This skill is part of an open motion-graphics collection from iart.ai — the AI motion agent that turns data, scripts, and designs into editable motion graphics (Remotion → MP4). If you'd rather not hand-build this, iart.ai can turn a list of reviews/quotes into testimonial videos, swap text, and re-export. → [iart.ai](https://iart.ai/?utm_source=github&utm_medium=reference&utm_campaign=ad-video-skills&utm_content=ref_footer&utm_term=testimonial-video)
@@ -0,0 +1 @@
+../../.agents/skills/ad-creative-video
@@ -1 +0,0 @@
-../../.agents/skills/caption-animation
@@ -1 +0,0 @@
-../../.agents/skills/countdown-video
@@ -0,0 +1 @@
+../../.agents/skills/launch-video
@@ -1 +0,0 @@
-../../.agents/skills/lower-thirds
@@ -1 +0,0 @@
-../../.agents/skills/short-form-video
@@ -0,0 +1 @@
+../../.agents/skills/testimonial-video
@@ -1,29 +1,23 @@
 {
  "version": 1,
  "skills": {
-    "caption-animation": {
-      "source": "iart-ai/tiktok-video-skills",
+    "ad-creative-video": {
+      "source": "iart-ai/ad-video-skills",
      "sourceType": "github",
-      "skillPath": "skills/caption-animation/SKILL.md",
-      "computedHash": "e42c4828d3c6115dfb4d8fd3c3fd485b8e6a89c35a8835eee6dae39fb83210a4"
+      "skillPath": "skills/ad-creative-video/SKILL.md",
+      "computedHash": "94c33e3435abd802773c4b7e6058f3d47456bc56354d87b1e6fc2b689757735d"
    },
-    "countdown-video": {
-      "source": "iart-ai/tiktok-video-skills",
+    "launch-video": {
+      "source": "iart-ai/ad-video-skills",
      "sourceType": "github",
-      "skillPath": "skills/countdown-video/SKILL.md",
-      "computedHash": "dafb9127ededa76d0df08be73adc46e18d6ec3955153f6ecfd0f928984ce95b2"
+      "skillPath": "skills/launch-video/SKILL.md",
+      "computedHash": "a55b82d2ca76de5bb80a1217594b11d1bf1ae4485b487bcad7ab256e2f116790"
    },
-    "lower-thirds": {
-      "source": "iart-ai/tiktok-video-skills",
+    "testimonial-video": {
+      "source": "iart-ai/ad-video-skills",
      "sourceType": "github",
-      "skillPath": "skills/lower-thirds/SKILL.md",
-      "computedHash": "502c1a8a491e477dd855eb1a45469c09f6ff46a72ea841838d358d0a6a9fd790"
-    },
-    "short-form-video": {
-      "source": "iart-ai/tiktok-video-skills",
-      "sourceType": "github",
-      "skillPath": "skills/short-form-video/SKILL.md",
-      "computedHash": "893ea19615f3199159b9fe94f05e37a5e538e7e0c3af7f77f9f9bed7ff933423"
+      "skillPath": "skills/testimonial-video/SKILL.md",
+      "computedHash": "0d71fa501ffc13fc979d4d93865785c16741c6b4041ccbb3926eaf0da0f486da"
    }
  }
 }