Communitygithub.com

Video-Storyboard

Zeigt einem Agenten, wie ein 'Video-Storyboard' geplant, erstellt oder geschnitten wird, sodass die konkrete Ausgabe ein Beat-Sheet und eine Shot-Liste ist. Das Verfahren durchläuft das Video-Storyboard, die Betriebsanleitung und Schritt 1 – Festlegung des einzeiligen Ziels und der Plattform. Verwende es, wenn eine neue Aufgabe dieses Handwerk erfordert.

Was ist Video-Storyboard?

Dieses Skill ermöglicht es einem KI-Agenten, detaillierte Video-Storyboards zu erstellen, bevor mit der Animation begonnen wird. Es wandelt die Absicht für ein Demovideo in einen strukturierten Ablaufplan um, der aus einem fünfschrittigen Beat-Sheet (Hook, Problem, Enthüllung, Beweis, CTA) und einer Shot-Liste mit Szenentypen, Zielzeiten und konkreten visuellen Anweisungen besteht. Das Skill unterstützt die Planung für verschiedene Plattformen (YouTube, sozial, hero) und Aspektverhältnisse und produziert einen standardisierten JSON-Szenenplan (`scene-plan.json`) zur direkten Verwendung mit Remotion-Compose. Es setzt Qualitätsstandards wie einen schnellen 3-Sekunden-Hook, keinen Start mit einem Logo, und eine präzise, emittierte Szenenstruktur und eignet sich sowohl für schnelle Demos als auch für ausführliche Produktvorführungen.

Funktioniert mit~Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/ensinohi-lab/thesis-skills/tree/HEAD/video-storyboard

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Was macht Video-Storyboard?

Mache dies, BEVOR ein einziges Bild animiert wird. Ein Demovideo lebt oder stirbt mit seinem Plan: Die falsche Reihenfolge, ein fehlender Aufhänger oder eine Laufzeit von 40 Sekunden ruinieren es, egal wie sauber die Bewegung ist. Du bist die Handwerksschicht, die entscheidet, welche Szenen es gibt, in welcher Reihenfolge, wie lange und was jede einzelne sagt – und übergibst dann einen konkreten Szenenplan an das Mechanik-Paket (remotion-setup, remotion-compose, remotion-render), um es tatsächlich zu bauen.

Reagiere sofort auf Absichten zur Planung: "storyboarde mein Demo", "plane das Video", "welche Szenen brauche ich", "skizziere das Launch-Video", "unterteile diese Funktion in Szenen". Springt der Nutzer direkt zu "animiere das", erstelle trotzdem zuerst das Beat-Sheet – ein Storyboard dauert zwei Minuten und erspart ein erneutes Rendern.

Arbeite ein durchgängiges Beispiel durch: ein 30-Sekunden-Launch-Video für ein KI-Code-Review-Tool namens Sentinel, das riskante Diffs vor dem Merge markiert.

Betriebsanleitung

Führe diese Schritte in der angegebenen Reihenfolge aus. Schreibe keinen Text, bevor die Beats festgelegt sind, und setze keine Dauern, bevor die Beats existieren – Tempo ist eine Funktion der Struktur, nicht umgekehrt.

Schritt 1 – Lege das einzeilige Ziel und die Plattform fest

Bevor es um die Beats geht, fixiere zwei Dinge:

  1. Die einzelne Kernbotschaft. Ein Satz, den der Zuschauer sich merken muss: "Sentinel fängt den Fehler, den dein Reviewer übersehen hat." Wenn du es nicht in einer Zeile sagen kannst, hat das Video kein Rückgrat. Alles Weitere dient dieser Zeile.
  2. Plattform und Seitenverhältnis. Querformat 16:9 (1920×1080) für einen Site-Hero oder YouTube; Hochformat 9:16 (1080×1920) für soziale Medien/Shorts; quadratisch 1:1 für den Feed. Dies legt die Leinwand fest, die remotion-compose erstellt, und begrenzt die Laufzeit – soziale Medien wollen 15-30s, ein Hero-Loop 20-40s, eine Feature-Walkthrough bis zu 60s.

Schritt 2 – Lege das Beat-Sheet an (das Fünf-Beat-Rückgrat)

Jedes Demo, jede Ankündigung und jedes Launch-Video ist eine Version dieser fünf Beats. Lasse einen Beat nur mit Grund weg; ordne nie vor dem Hook um.

  1. Hook (erste 3 Sekunden). Die wichtigsten 3 Sekunden des Videos – hier entscheiden Zuschauer, ob sie weitersehen. Starte mit dem Ergebnis, der Spannung oder einer kühnen Behauptung, NICHT mit deinem Logo. "Dein Reviewer hat gerade einen Bug genehmigt" schlägt "Wir stellen Sentinel vor." Das Logo kann in der Ecke mitlaufen; es ist nicht der Hook.
  2. Problem. Nenne den Schmerz, den der Zuschauer bereits fühlt, konkret. "Riskante Diffs schlüpfen am Freitag um 17 Uhr durch das Review." Ein Beat, ein Schmerz.
  3. Enthüllung. Stelle das Produkt als Wendepunkt vor. Hier landen der Name und der Kernmechanismus. Zeige, wie das Ding das Ding macht.
  4. Beweis. Mach die Behauptung glaubwürdig – ein echtes Vorher/Nachher, eine echte Zahl, ein echter Bildschirm. Dieser Beat wird in den meisten Videos übersprungen, und genau dieser konvertiert. Verwende echte Produktdaten, niemals erfundene Metriken.
  5. CTA. Eine Aktion, eine URL. "Teste Sentinel kostenlos → sentinel.dev." Niemals zwei Fragen.

Bei einer längeren Walkthrough wiederholen sich die Beats Enthüllung und Beweis pro Funktion (Enthüllung Funktion 1 → Beweis, Enthüllung Funktion 2 → Beweis). Der Hook, das Problem und der CTA bleiben einmalig.

Schritt 3 – Weise jedem Beat einen Szenentyp und eine Zieldauer zu

Jeder Beat wird zu einer oder mehreren Szenen. Der Szenentyp bestimmt das Tempo – Text braucht Lesezeit, ein UI-Demo braucht Verweildauer, ein Logo ist schnell. Verwende diese Zielvorgaben (bei 30fps; durationInFrames = Sekunden × fps):

SzenentypZieldauerWarum
Hook / Titelbild2,5-3,5sLang genug, um eine Zeile zu lesen, kurz genug, um den Einstieg straff zu halten
Texterklärung2,5-4s~2,5 Wörter/s Lesegeschwindigkeit; eine 7-Wörter-Zeile braucht ~3s auf dem Bildschirm
UI / Produkt-Demo4-6sDas Auge braucht Verweildauer, um einen Bildschirm und die darin enthaltene Bewegung zu erfassen
Beweis / Daten3-5sEine Zahl oder ein Vorher/Nachher braucht einen Moment, um registriert zu werden
Logo / CTA-Abspann2,5-4sLies die URL, lass sie wirken, Ende

Temporegel: Der Hook ist der schnellste Schnitt, der Beweis der langsamste. Wenn die Gesamtzeit zu lang wird, schneide eine Szene – beschleunige nicht jede Szene. Ein gehetztes Demo wirkt nervös.

Schritt 4 – Schreibe die Shot-Liste (Text + Visuelles pro Szene)

Lege für jede Szene vier Felder fest: den Beat, dem sie dient, den Szenentyp, den On-Screen-Text (die echten Wörter – frage den Nutzer, erfinde niemals Behauptungen) und eine einzeilige visuelle Beschreibung, die remotion-compose sagt, was zu rendern ist. Dies ist das Ergebnis. Die visuelle Zeile ist eine Kurzbeschreibung, kein Code: "Terminal gibt ein Git-Diff aus, eine riskante Zeile leuchtet rot auf" – remotion-compose entscheidet über die interpolate/spring-Mechanik.

Schritt 5 – Gib den JSON-Szenenplan aus

Führe den untenstehenden Generator aus, um die Shot-Liste in ein strukturiertes scene-plan.json zu verwandeln. Dies ist das Artefakt, das übergeben wird: remotion-compose liest es als Szenenplan (ein <Sequence> pro Szene, from/durationInFrames bereits berechnet), und der pro Szene angegebene motion-Hinweis ist der Ort, an dem Entscheidungen aus motion-design-principles oder motion-color-and-light einfließen. Speichere es neben dem Projekt, damit das Mechanik-Paket es aufnehmen kann.

Schritt 6 – Übergabe

Gib dem Nutzer das Beat-Sheet, die Shot-Liste-Tabelle und das JSON. Übergib dann explizit: "Hier ist der Szenenplan. remotion-setup, falls das Projekt noch nicht aufgesetzt ist, dann wird remotion-compose dieses JSON in die Komposition verwandeln und remotion-render exportiert es. Möchtest du vor der Animation Tempo oder Text anpassen?" Wenn das Video speziell ein Produkt-Demo ist und du einen Regisseur brauchst, der entscheidet, was auf dem Bildschirm pro Szene gezeigt wird, kombiniere mit product-demo-director. Kinetische Titelbehandlungen gehen an kinetic-typography; die Klangkulisse und beat-synchrone Schnitte gehen an sound-and-music-sync; ein vertikaler Neuschnitt für soziale Medien geht an social-video-formatter.

Qualitätsbarriere

Ein Storyboard ist nur dann A+, wenn alles zutrifft:

  • Der Hook landet in den ersten 3 Sekunden und ist NICHT das Logo – er öffnet mit Ergebnis, Spannung oder Behauptung.
  • Alle fünf Beats sind vorhanden, oder jeder fehlende Beat hat einen genannten Grund (ein Teaser kann beispielsweise den Beweis weglassen).
  • Jede Szene hat eine echte Textzeile und eine konkrete visuelle Kurzbeschreibung – kein "irgendein UI hier", keine erfundenen Metriken.
  • Die Gesamtlaufzeit passt zum Plattform-Maximum, und die Dauern folgen der Szenentyp-Tabelle (Hook schnell, Beweis langsam), nicht einem flachen Schnitt alle 3s.
  • Der CTA ist eine einzelne Aktion mit einer einzelnen URL.
  • Das JSON validiert und seine summierten Dauern entsprechen der Kompositions-Gesamtzahl, die remotion-compose registrieren wird – ein Ungleichgewicht ist die #1 Rendering-Überraschung.

TUE NICHT

  • Öffne NICHT mit einem Logo oder einem langsamen Einblendungstitel – du verlierst den Zuschauer vor dem Hook.
  • Erfinde KEINE Zahlen, Erfahrungsberichte oder Produktbehauptungen für den Beweis-Beat; frage nach echten Daten oder streiche den Beat.
  • Schreibe NICHT den .tsx, wähle interpolate-Bereiche oder setze spring-Dämpfung hier – das macht remotion-compose. Dieses Skill gibt einen Plan aus, keinen Code.
  • Setze NICHT jede Szene gleich schnell; ein flacher 3s-Schnitt lässt das Demo wie eine Diashow wirken.
  • Stapele NICHT zwei CTAs oder zwei URLs; eine Frage konvertiert, zwei teilen die Aufmerksamkeit.
  • Lass die Laufzeit NICHT über das Plattform-Maximum hinausgehen, um mehr unterzubringen – schneide stattdessen eine Szene.

Generator

In sich geschlossenes Node-Skript. Speichere es als scene_plan.js, bearbeite das beats-Array für das betreffende Video und führe node scene_plan.js > scene-plan.json aus. Keine Abhängigkeiten. Es berechnet Frame-Offsets, validiert die Gesamtsumme und gibt den Plan aus, den remotion-compose konsumiert.

// Storyboard -> Szenenplan. Bearbeite `meta` und `beats`, dann:
//   node scene_plan.js > scene-plan.json
const meta = {
  title: 'Sentinel Launch',
  fps: 30,
  width: 1920,   // 1080 für 9:16 hoch, 1080 quadratisch
  height: 1080,  // 1920 für 9:16 hoch, 1080 quadratisch
}

// Eine Zeile pro Szene. `seconds` folgt der Szenentyp-Tabelle.
// `motion` ist ein Hinweis für motion-design-principles / motion-color-and-light;
// es ist eine Kurzbeschreibung, kein Code.
const beats = [
  { beat: 'hook',    type: 'title',   seconds: 3.0, copy: 'Your reviewer just approved a bug.', visual: 'Dark screen, line of code types in; one line snaps red.', motion: 'snappy, low damping on the red flag' },
  { beat: 'problem', type: 'text',    seconds: 3.5, copy: 'Risky diffs slip through review at 5pm on a Friday.', visual: 'Calendar/clock motif, a PR marked merged.', motion: 'calm fade, no overshoot' },
  { beat: 'reveal',  type: 'ui',      seconds: 5.0, copy: 'Sentinel reviews every diff before merge.', visual: 'Sentinel scans the same diff, surfaces the risky line with a reason.', motion: 'scan sweep, then settle' },
  { beat: 'proof',   type: 'proof',   seconds: 4.5, copy: 'Caught on real PRs. Before it shipped.', visual: 'Before/after: red flag -> fixed diff, real screenshot.', motion: 'slow cross-dissolve, hold' },
  { beat: 'cta',     type: 'cta',     seconds: 3.0, copy: 'Try Sentinel free -> sentinel.dev', visual: 'Logo + URL on brand color.', motion: 'gentle pop, end clean' },
]

const fps = meta.fps
let from = 0
const scenes = beats.map((b, i) => {
  const durationInFrames = Math.round(b.seconds * fps)
  const scene = {
    id: `${i + 1}-${b.beat}`,
    beat: b.beat,
    type: b.type,
    from,
    durationInFrames,
    seconds: b.seconds,
    copy: b.copy,
    visual: b.visual,
    motion: b.motion,
  }
  from += durationInFrames
  return scene
})

const durationInFrames = from
const totalSeconds = durationInFrames / fps
const hook = scenes[0]
const warnings = []
if (hook.beat !== 'hook') warnings.push('First scene is not the hook.')
if (hook.seconds > 3.5) warnings.push('Hook is longer than 3.5s - tighten the open.')
if (scenes.filter((s) => s.beat === 'cta').length > 1) warnings.push('More than one CTA.')
if (!scenes.some((s) => s.beat === 'proof')) warnings.push('No proof beat - claim may not convert.')
if (totalSeconds > 60) warnings.push(`Runtime ${totalSeconds}s exceeds 60s ceiling - cut a scene.`)

const plan = {
  composition: {
    id: meta.title.replace(/[^A-Za-z0-9]/g, ''),
    fps,
    width: meta.width,
    height: meta.height,
    durationInFrames, // remotion-compose registriert genau dies auf dem <Composition>
  },
  scenes,
  meta: { totalSeconds, sceneCount: scenes.length, warnings },
}

process.stdout.write(JSON.stringify(plan, null, 2) + '\n')
if (warnings.length) console.error('WARNINGS:\n  - ' + warnings.join('\n  - '))

Ausgabe des durchgearbeiteten Beispiels

Mit den obigen beats schreibt das Skript scene-plan.json:

{
  "composition": {
    "id": "SentinelLaunch",
    "fps": 30,
    "width": 1920,
    "height": 1080,
    "durationInFrames": 570
  },
  "scenes": [
    { "id": "1-hook",    "beat": "hook",    "type": "title", "from": 0,   "durationInFrames": 90,  "seconds": 3.0, "copy": "Your reviewer just approved a bug.", "visual": "Dark screen, line of code types in; one line snaps red.", "motion": "snappy, low damping on the red flag" },
    { "id": "2-problem", "beat": "problem", "type": "text",  "from": 90,  "durationInFrames": 105, "seconds": 3.5, "copy": "Risky diffs slip through review at 5pm on a Friday.", "visual": "Calendar/clock motif, a PR marked merged.", "motion": "calm fade, no overshoot" },
    { "id": "3-reveal",  "beat": "reveal",  "type": "ui",    "from": 195, "durationInFrames": 150, "seconds": 5.0, "copy": "Sentinel reviews every diff before merge.", "visual": "Sentinel scans the same diff, surfaces the risky line with a reason.", "motion": "scan sweep, then settle" },
    { "id": "4-proof",   "beat": "proof",   "type": "proof", "from": 345, "durationInFrames": 135, "seconds": 4.5, "copy": "Caught on real PRs. Before it shipped.", "visual": "Before/after: red flag -> fixed diff, real screenshot.", "motion": "slow cross-dissolve, hold" },
    { "id": "5-cta",     "beat": "cta",     "type": "cta",   "from": 480, "durationInFrames": 90,  "seconds": 3.0, "copy": "Try Sentinel free -> sentinel.dev", "visual": "Logo + URL on brand color.", "motion": "gentle pop, end clean" }
  ],
  "meta": { "totalSeconds": 19, "sceneCount": 5, "warnings": [] }
}

Lies es: 5 Szenen, 570 Frames = 19s bei 30fps, deutlich unter der sozialen Obergrenze. Der Hook hat 3s und öffnet mit Spannung, nicht mit einem Logo. Der Beweis-Beat (4,5s) ist der langsamste Schnitt; der Hook und der CTA (3s) sind die straffsten. Keine Warnungen, also bereit für remotion-compose – das eine <Composition durationInFrames={570}> und eine <Sequence from={…} durationInFrames={…}> pro Szene registriert, wobei from und durationInFrames direkt aus dieser Datei gelesen werden.

Vorlage: Shot-Liste

Verwende dies, wenn du die menschenlesbare Tabelle neben dem JSON haben möchtest. Ersetze die FILL-Felder mit dem echten Video.

VIDEO-STORYBOARD. [FILL: Videoname]. [FILL: Plattform / Seitenverhältnis]
Ziel (eine Zeile):  [FILL: die einzelne Kernbotschaft]
Ziellaufzeit:        [FILL: 15-30s sozial / 20-40s Hero / bis zu 60s Walkthrough]

BEAT      SZENENTYP    DAUER     ON-SCREEN-TEXT (echte Wörter)          VISUELLE KURZBESCHREIBUNG
Hook      title        [FILL]s   [FILL: Ergebnis/Spannung/Behauptung]  [FILL]
Problem   text         [FILL]s   [FILL: ein konkreter Schmerz]        [FILL]
Enthüllung ui          [FILL]s   [FILL: Produkt + Kernmechanismus]    [FILL]
Beweis    proof        [FILL]s   [FILL: echte Zahl / Vorher-Nachher]   [FILL]
CTA       cta          [FILL]s   [FILL: eine Aktion + eine URL]       [FILL]
  (wiederhole Enthüllung + Beweis pro Funktion für eine Walkthrough)

GESAMT:   [FILL]s   (muss gleich JSON composition.durationInFrames / fps sein)
ÜBERGABE: scene-plan.json -> remotion-compose

Referenzen/Warum-die-ersten-3-Sekunden

Zuschauer entscheiden in den ersten ~3 Sekunden, ob sie weitersehen, daher ist der Hook nicht der Ort für dein Logo oder eine langsame Einblendung. Öffne mit dem Ergebnis oder der Spannung: der Fehler, der ausgeliefert wurde, die Zahl, die gefallen ist, die Behauptung, die den Scroll stoppt. Das Logo kann die ganze Zeit in einer Ecke leben; es zum Eröffnungs-Beat zu machen, verbraucht deine wertvollsten Sekunden für den am wenigsten überzeugenden Inhalt. Wenn du nur einen Beat nageln kannst, dann diesen.

Referenzen/Tempo-nach-Szenentyp

Verschiedene Szenen brauchen unterschiedliche Zeit auf dem Bildschirm, und ein flacher Schnitt alle N Sekunden wirkt wie eine Diashow:

  • Titel/Hook - schnell. Eine Zeile, schneller Einstieg, Schnitt bevor er abläuft.
  • Text - gib Lesezeit. Menschen lesen ~2,5 Wörter/s; eine 7-Wörter-Zeile braucht ~3s, eine 12-Wörter-Zeile ~5s. Zu kurze Textzeiten sind der häufigste Fehler, der Zuschauer verlieren lässt.
  • UI-Demo - gib Verweildauer. Ein neuer Bildschirm, eine Interaktion, ein Hover – all das braucht Zeit, um verarbeitet zu werden. 4-6s ist ein Minimum; wenn die Szene einen Dialog oder mehrere Schritte enthält, dehne sie aus.
  • Beweis - der langsamste Schnitt. Zahlen und Vorher/Nachher brauchen den meisten Verdauungsmoment. Ein kurzer Beweis-Beat fühlt sich wie ein Ausweichen an.
  • CTA/Logo - kurz aber nicht gehetzt. Die URL lesen, einen Moment innehalten, Ende.

Individual skills in this repo

This repo contains 2 individual skills — each has its own dedicated page.

Verwandte Skills