agentleFS
looties-iolooties-io/looties-skills/changelog-to-video/SKILL.md

changelog-to-video

Skill1 starsChanged 54 days agoMITView on GitHub

Use when turning a changelog, release notes, or a list of shipped features into a polished feature-showcase video (weekly changelog video, release recap, \"what's new\" reel, launch montage) and you want each feature shown as a REAL animated mock-up instead of a generic text card. Triggers include \"our changelog videos all look like the same card\", deduping overlapping entries, and rendering HTML/GSAP motion to MP4.

The file

We split this skill into the rules it gives an agent

4 rules. About 0 are common, 4 are distinctive, and 0 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈4

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 0

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Not for: a single talking-head recut, or a one-feature launch film (use a product-launch flow).

    line 24
  2. Distinctive:

    Before building scenes, group entries by feature and merge related ones into a single scene at the latest state: "X is live" + "X now …

    line 41
  3. Distinctive:

    Always-card trap: no asset pipeline + strict slot validation → every feature degrades to the card.

    line 71
  4. Distinctive:

    Capturing logged-in pages first: start with public routes only.

    line 75

≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Changelog to Video

Overview

Turn a changelog into a feature-showcase video where every feature gets a real mock-up — a screenshot, recording, or faithful UI illustration — not a generic text card. The default failure mode of these systems is that every scene degrades to the same card; the fix is an explicit asset waterfall that exhausts real-mockup options before ever falling back, plus deduping overlapping entries.

Engine-dependent: this pairs with an HTML-to-video engine (HyperFrames or Remotion). For the motion layer, use the cinematic-hyperframes skill.

When to use

  • A weekly/periodic changelog or "what's new" video.
  • A release recap or feature-launch reel from release notes / shipped PRs.
  • Symptom: your generated videos all look like the same neon card with a title and no real UI.

Not for: a single talking-head recut, or a one-feature launch film (use a product-launch flow).

The asset waterfall (the core)

For each feature, walk these rungs in order — first hit wins — and only fall back when truly stuck:

#RungUse whenSource
①Reusea prior/approved mock-up of this feature already exists (especially "improvement" re-mentions)a small committed registry, keyed by feature
②Live capturethe feature has a public page (product / catalog / social / content)Playwright screenshot of the public route → render as a framed image
③Syntheticno asset, but you know the feature's shapea simple, faithful UI mock built from the description / codebase
④Cardgenuinely nothing to showthe generic motion card — last resort ONLY

Principle: the context of the feature decides the rung. Product, social, and content features almost always have real assets — use them. The card is a fallback, never the default.

Dedup related entries

Before building scenes, group entries by feature and merge related ones into a single scene at the latest state: "X is live" + "X now supports Y" → one "X (now with Y)" scene. One scene per feature.

Render-safe motion

Whichever engine, keep scene motion deterministic and GPU-cheap — animate only opacity / x / y / scale (and scaleX/Y). No animated CSS filters, no Math.random, no Date.now, no network at render time. This keeps frames reproducible and the renderer fast.

Pipeline

  1. Parse the changelog into entries {date, tag, title, desc}.
  2. Dedup by feature (above).
  3. Per feature, resolve the asset waterfall into an asset_plan (reuse | capture | synthetic | card) plus an archetype.
  4. Resolve plans into real image files: reuse copies from the registry; capture screenshots the public route; failures downgrade one rung (never crash the render).
  5. Compose intro → per-feature scenes (real mock-ups) → outro, with kinetic transitions.
  6. Render both 16:9 and 9:16.

Mock vocabulary (archetypes)

A scene archetype maps structured slots → a .mock illustration. A useful set:

  • asset-grid — real screenshots in a 1/2/3-column grid
  • product-card — one framed hero screenshot
  • flow — a multi-step UI recreation (e.g. a moderation/checkout flow)
  • duration-timeline — a before/after metric bar
  • artifact-card — a code-styled card for a shipped repo / skill / API
  • card — the generic motion card (fallback)

Every archetype your router can pick MUST exist. A router that routes to an unimplemented archetype silently falls back to a card — the #1 cause of "always generic cards".

Common mistakes

  • Always-card trap: no asset pipeline + strict slot validation → every feature degrades to the card. Build the waterfall; make the card the last rung.
  • Phantom archetypes: routing to asset-grid/product-card that were never implemented → instant card. Implement every archetype the router references, and wire the real-asset lookup (don't hardcode "no assets available").
  • No dedup: "X is live" and "X now supports Y" render as two near-identical scenes.
  • Non-deterministic motion: filter/random/time-based animation breaks reproducible rendering.
  • Capturing logged-in pages first: start with public routes only; authenticated capture is a separate, heavier concern (seeded test account + secrets).

Reference architecture

A working implementation separates into four modules, whichever language you build it in:

  • archetypes: one renderer per archetype (asset-grid, product-card, flow, and so on), so the router can only route to something that exists.
  • registry: the reuse rung, a small committed index mapping feature to a previously approved mock-up.
  • capture: the public-route Playwright waterfall, where a failure downgrades one rung rather than crashing the render.
  • build: composes the resolved plan into scenes, emitting the generic card only when the plan explicitly says so.

Pair it with an HTML-to-video engine (HyperFrames or Remotion) plus GSAP for motion. Run capture and render in a render-only CI job with read-only repository permissions, since the pipeline needs no write access.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.