Communitygithub.com

science-video

Erstelle animierte Erklärvideos mit Code für Wissenschaft, Sprachen, Alltagswissen, Produktvorstellungen und mehr. Du gibst die Idee vor (Text, URL, Code, Referenzvideo), der Skill recherchiert und liefert drei Stilrichtungen (A: Flash-Animation, B: Pixel-Cartridge, C: themenbasiert) mit Vorschauen. Nach deiner Wahl entsteht ein detailliertes Briefing und ein vollständiges, taktgenaues MP4-Video inklusive Cover.

Was ist science-video?

Dieser Skill verwandelt Wissen und Ideen in professionelle, animierte Erklärvideos – komplett mit Code erstellt (Remotion für die Animation, Python für die Audioproduktion). Er ist ideal für Entwickler:innen und Content Creator, die ohne manuelle Videobearbeitung schnell hochwertige, dynamische Videos zu beliebigen Themen (Wissenschaft, Sprachen, Produkte, Alltagswissen) produzieren möchten. Der Skill arbeitet in klaren Schritten: Zunächst fragt er nach dem Thema und den Materialien (Artikel, Website, Code-Repository, Referenzvideo, Hintergrundmusik). Er recherchiert selbstständig Fakten (mit Quellenangabe) und erstellt drei klar unterschiedliche Style-Varianten (A: Flash-Animation mit flachen SVG-Illustrationen, B: Pixel-Cartridge-Stil mit Retro-Game-Ästhetik, C: vom Skill vorgeschlagen, basierend auf dem Thema). Zu jedem Stil erzeugt er einen Vorschau-Keyframe oder ein kurzes Sample-Video. Nach deiner Auswahl und Bestätigung wird ein detailliertes `brief.md` erstellt, das als Grundlage für die gesamte Produktion dient. Die eigentliche Filmproduktion erfolgt Szene für Szene, mit automatischer Taktanpassung an die Hintergrundmusik, selbst synthetisierten Soundeffekten und abschließendem Rendering als MP4 sowie der Erstellung von 3:4- und 4:3-Covern. Der Skill unterstützt horizontale (1920×1080) und vertikale (1080×1920) Formate und ist speziell für die Plattformen Claude Code, Cursor und Codex optimiert, die in ähnlichen Kontexten eingesetzt werden.

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/dominoeffect/science-video-skill/tree/HEAD

In Ihrer bevorzugten KI fragen

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

Dokumentation

Code-Animation-Erklärvideos

Alle Grafiken werden rein mit Code in Remotion gezeichnet, Soundeffekte werden mit Python synthetisiert. Zuerst werden drei Konzepte mit Vorschauen präsentiert, nach der Auswahl des Users wird ein brief.md erstellt und anschließend Szene für Szene produziert.

Harte Regeln

  • Nur die Workflows dieses Skills verwenden. Keine anderen Workflows oder Methoden aus anderen Projekten als Ersatz für die hier beschriebenen Schritte.
  • Quellen müssen echt sein und einen Link haben. Jede Quelle muss persönlich geöffnet oder heruntergeladen und überprüft werden. Nicht überprüfbare Quellen mit „nicht verifiziert“ kennzeichnen. Sekundärinterpreationen müssen klar als solche benannt werden. Keine Zahlen erfinden, keine unbelegten Behauptungen aufstellen.
  • Jeder Schritt muss vom User bestätigt werden, bevor es weitergeht: Quellenliste → Drei Konzepte und Vorschauen → Sound-Pegel → Cover. Nach dem Schreiben des brief.md dem User mitteilen, wo es abgelegt ist.
  • Kein Voice-Over (es sei denn, der User wünscht es). Informationen werden ausschließlich durch Text im Bild vermittelt. Hintergrundmusik wird vom User bereitgestellt (der User muss die Rechte zur Nutzung haben). Soundeffekte werden selbst synthetisiert und auf den Takt abgestimmt. Das Repository enthält keine Musikdateien.
  • Text: Nicht überlappend, lesbar, ausreichend lange eingeblendet, keine langen Textblöcke. Das Bild muss abwechslungsreich sein, Hauptfiguren (Menschen, Tiere oder Objekte) müssen detailreich und ansprechend gezeichnet sein.
  • Standard-Spezifikation: Querformat 1920×1080, 30fps; bei User-Wunsch nach Hochformat/Douyin/Short-Video: 1080×1920 (style in scenes.json auf "vflash" setzen). Die Dauer entspricht der Länge der Hintergrundmusik (falls keine Musik vorhanden, können Dauer und BPM angegeben werden).

Arbeitsverzeichnis

<Thema>/                    Beispiel: ~/videos/<Thema>
  demo.mp3 / demo.mp4       Vom User bereitgestellte Hintergrundmusik, Referenzvideo (optional)
  source/                   sources.md (Quellenliste), ref-notes.md (Referenzvideo-Analyse), Rohmaterialien
  previews/                 plan-a.png, plan-b.mp4, plan-c.png (Vorschauen der drei Konzepte)
  brief.md                  Bestätigtes Gesamtkonzept, auch ein wiederverwendbarer Prompt
  video/                    Remotion-Projekt (generiert von new_project.py oder new_project.ps1)
  qa/                       Standbilder pro Szene, Einzelbilder des gesamten Films, review_log.md
  <Filmtitel>.mp4           Fertiger Film
  cover/                    Cover_3zu4_Hochformat.jpg, Cover_4zu3_Querformat.jpg

Schritt 0: Projekt erstellen

python <skill>/scripts/new_project.py --project "<Themenverzeichnis>"
# Ohne Hintergrundmusik: ... --no-music --duration 60 --bpm 120

Unter Windows kann auch scripts/new_project.ps1 verwendet werden. Dieses Skript führt nacheinander folgende Schritte aus:

  1. Umgebungsprüfung (scripts/check_env.py). Fehlende Komponenten werden ausgegeben; vor der Installation muss die Zustimmung des Users eingeholt werden.
  2. Arbeitsverzeichnis erstellen.
  3. Vorlage kopieren.
  4. Schriftarten kopieren.
  5. npm install ausführen.
  6. Takt messen und in src/grid.json schreiben.
  7. Erste Version des Mixes erstellen.

Der gesamte Vorgang dauert 1–3 Minuten. In Umgebungen, in denen lange Befehle im Hintergrund laufen müssen, bitte im Hintergrund starten und die Ausgabe abfragen (siehe references/pitfalls.md).

Die Vorlage enthält ein universelles Platzhalter-Beispiel von etwa 12 Sekunden, um zu bestätigen, dass das Projekt rendern kann. Nach der Themenfestlegung müssen Szenen, Untertitel und Soundeffekte neu geschrieben werden. Ein vollständiges Multi-Szenen-Beispiel findet sich in examples/bait-color/ (optional als Referenz, nicht als Standardinhalt).

Schritt 1: Klären, was gemacht werden soll

Der User kann beliebige der folgenden Rohmaterialien bereitstellen, auch gemischt:

  • Idee: Ein Ein-Satz-Thema reicht.
  • Originalinhalt: Artikel, Skript, Produkt-URL, Code-Repository, Datentabelle.
  • Referenzvideo, Hintergrundmusik.

Maximal 3 Rückfragen stellen, nur solche, die das Konzept beeinflussen: Dauer, Seitenverhältnis, Voice-Over, bestimmte Markenfarben oder Schriftarten. Was der User nicht angibt, wird mit Standardwerten belegt und im Konzept vermerkt, damit der User es ändern kann.

Rohmaterialien verarbeiten:

  • Wissenschaftliche, sachliche Themen: Nach references/research.md recherchieren, überprüfen, in source/sources.md festhalten und dem User zur Bestätigung vorlegen.
  • Artikel, Skripte: Kerninformationen, Zielgruppe und zwingend erforderliche Fakten extrahieren. Fakten dürfen nur aus den Rohmaterialien stammen; Unsicheres nicht aufnehmen.
  • Produkt-URLs: Seite lesen, Produktname, Funktionen, Slogan und Markenfarben notieren. Für Screenshots vorher um Erlaubnis fragen.
  • Code-Repositories: README und Schlüsseldateien lesen, Funktionen extrahieren, keine Funktionen erfinden.
  • Referenzvideos:
    • Vor dem Herunterladen eines Links die Zustimmung des Users einholen.
    • Spezifikationen mit ffprobe messen.
    • Szenenwechsel mit ffmpeg -vf "select='gt(scene,0.3)',showinfo" finden.
    • Jede Sekunde ein Einzelbild extrahieren und zu einer Kontaktansicht zusammensetzen.
    • Szenenstruktur, Rhythmus, Farbgebung, Schriftarten und Techniken in source/ref-notes.md festhalten.
    • Nur die Struktur und Techniken übernehmen, nicht das Material oder den Text.
  • Hintergrundmusik: Das Projekterstellungsskript hat bereits den Takt gemessen und gibt BPM, Abschnittsgrenzen und Drift aus. Konzept und Storyboard richten sich danach.

Schritt 2: Drei Konzepte liefern

Nach references/plans.md schreiben, die Aufteilung der drei Konzepte ist festgelegt:

KonzeptStilTechnikErzählweise
AFLASH-Animationsstil (flache Illustration)Remotion + SVG-Komponenten für flache IllustrationenSicher: Frage → Experiment/Daten → Schlussfolgerung → Drei Dinge merken
BPixel-Cartridge-Stil (Retro-Spielkonsole + CRT-Röhrenfernseher)Canvas 2D Pixel-Leinwand → WebGL CRT-ShaderSpielerisch: Cartridge auswählen = Level auswählen, HUD zeigt Daten, Dialogbox präsentiert Schlussfolgerungen, Abschlussbildschirm zeigt Ergebnisse
CThemenbezogener Vorschlag: Aus der Kandidatenliste in plans.md den passendsten auswählen oder einen eigenen vorschlagen, der mit Remotion umsetzbar istAnders als A und BAndere Erzählweise: Eine einzige Kamerafahrt, eine durchgehende Hauptfigur, Rückblende, eine einzige Metapher

Jedes Konzept muss enthalten: Name, Ein-Satz-Zusammenfassung, Stil (Farbwerte und Schriftart), Spezifikationen, Technikkombination, Szenenübersicht mit Zeitangaben, Sound, geschätzte Renderzeit, Schwierigkeiten und Risiken sowie warum es zu diesem Rohmaterial passt.

Die drei Konzepte müssen sich in Stil, Technik und Erzählweise deutlich unterscheiden, nicht nur in der Farbgebung.

Schritt 3: Vorschauen für jedes Konzept erstellen

  1. In video/src/preview/PlanA.tsx, PlanB.tsx und PlanC.tsx jeweils eine möglichst repräsentative Szene des Konzepts aufbauen, die bei Zeit 0 beginnt und 2–4 Sekunden lang ist. Die drei Dateien in der Vorlage sind universelle Platzhalter und müssen entsprechend geändert werden:
    • A verwendet SVG-Komponenten aus src/art/ und src/ui/.
    • B verwendet die src/pixel/-Engine und zeichnet in PixelStage.
    • C wird neu geschrieben, orientiert sich an PlanC.tsx: Die Darstellung wird nur durch t bestimmt, eine Szene wird komplett aufgebaut.
  2. Ausführen:
    node tools/preview.mjs --out ../previews --estimate A:2.4 B:2.5 C:3.9
    
    • Standardmäßig wird pro Konzept ein Keyframe ausgegeben, die Zahl nach dem Doppelpunkt gibt die Sekunde für das Bild an.
    • Liegt der Schwerpunkt auf Bewegung, wird als B:clip ein 3-Sekunden-Clip ausgegeben.
    • Das Skript gibt die Dauer pro Frame und eine Schätzung der gesamten Renderzeit aus; diese Zahl wird in das Konzept eingetragen.
  3. Die Vorschaubilder selbst überprüfen: Läuft Text über? Sind Elemente zu dicht? Ist das Bild zu leer? Sind die drei Stile wirklich deutlich unterschiedlich? Erst korrigieren, dann dem User präsentieren.
  4. Die Texte der drei Konzepte zusammen mit den Vorschaubildern dem User präsentieren (die Bilder in die Antwort einbetten; die Vorgehensweise variiert je nach Assistent). Der User kann eines auswählen, eine Mischung wünschen oder Änderungen verlangen; bei Änderungen zu Schritt 2 oder 3 zurückgehen, bis der User bestätigt.

Schritt 4: brief.md schreiben

Nach der Bestätigung des Users wird nach der Vorlage references/brief-template.md die Datei <Thema>/brief.md erstellt. Sie besteht aus sieben Blöcken: <role> <inputs> <direction> <structure> <build> <gotchas> <start>. Alle bestätigten Inhalte werden konkret festgehalten, bei Verwendung von Standardwerten wird dies vermerkt. Nach dem Schreiben dem User den Dateipfad mitteilen.

Die weitere Produktion erfolgt streng nach dem Brief. Bei Änderungen während der Produktion zuerst das Brief aktualisieren, dann den Code. Der User kann dieses Brief später für andere Themen oder in anderen Tools direkt verwenden.

Schritt 5: Szene für Szene produzieren

  1. Zuerst src/scenes.json schreiben:

    • style auf "flash" oder "pixel" setzen, Root wählt darauf basierend die Darstellung.
    • Szenentabelle mit Taktangaben schreiben, Szenenwechsel an Abschnittsgrenzen.
  2. Für jede Szene Folgendes schreiben:

    • FLASH-Stil: Komponente in src/scenes/*.tsx schreiben, dann in src/scenes/index.ts registrieren.
    • Pixel-Stil: Zeichenfunktion (c, f) => void in PIXEL_SCENES in src/pixel/scenes.ts schreiben.
    • C-Stil: Nach dem Vorschau-Code aus Schritt 3 erweitern, in Film.tsx einbinden oder analog zu PixelFilm.tsx eine eigene vollständige Filmkomponente schreiben.
    • Alle Texte in src/captions.json, alle Soundeffekte in src/sfx.json schreiben, jeweils mit denselben Taktangaben.
  3. Nach jeder fertigen Szene nacheinander ausführen:

    • npm run typecheck
    • npm run check (Untertitelprüfung, muss 0 Probleme ergeben)
    • node tools/stills.mjs --out ../qa <Eintrittssekunde> <Hauptaktionssekunde> <Austrittssekunde>

    Dann jedes Bild einzeln betrachten und auf Überlappungen, Bildausschnitt, Text-Gesichts-Überlagerungen und Textüberlappungen prüfen. Erst korrigieren, dann die nächste Szene machen.

  4. Bei Filmlängen über 30 Sekunden nach Fertigstellung aller Szenen zuerst eine Low-Res-Vorschau rendern: node tools/render.mjs --scale 0.5 --out out/draft.mp4. Rhythmus und Übergänge prüfen, dann Details verfeinern.

  5. Stilregeln in references/style-flash.md und references/style-pixel.md beachten, allgemeine Regeln in references/craft.md.

Schritt 6: Sound

Regeln in references/audio.md:

  • Soundeffekte und Bildaktionen auf demselben Takt notieren.
  • Im Pixel-Stil chip_*-Chip-Sounds verwenden.
  • Schreibmaschineneffekt mit dem rep-Feld für sich wiederholende Soundeffekte.
  • Der Standardpegel ist der endgültige Wert.
  • Wenn der User „zu laut", „zu leise" oder „scharf" sagt, mit --music-db und --sfx-db mehrere Pegelvergleichsdateien erstellen lassen. Nur die Tonspur wechseln, das Bild nicht neu rendern.

Schritt 7: Rendern und Abnahme

  1. Rendern: npm run sfx, dann npm run render. Die Dauer entspricht der Schätzung aus Schritt 3; bei 3200 Frames benötigt der FLASH-Stil ca. 1,8 Minuten, der Pixel-Stil ca. 6 Minuten.
  2. Mit ffprobe Auflösung, Bildrate, Bildanzahl und Dauer überprüfen, mit ebur128 die Lautstärke messen.
  3. Einzelbilder extrahieren: python tools/qa_sheet.py out/film.mp4 ../qa/final (unter Windows auch tools/qa_sheet.ps1). Es werden zwei Ausgaben erstellt: eine vollständige Kontaktansicht und eine für Mobilgeräte mit 360 Pixeln Breite pro Feld.
  4. Nach der Selbstcheckliste in references/craft.md bewerten, jede der 7 Kategorien muss mindestens 8 Punkte erreichen:
    • Die 3 schwerwiegendsten Probleme mit Zeitangaben auflisten.
    • Nur den problematischen Abschnitt neu rendern (node tools/render.mjs --frames Start-Ende), dann den gesamten Film zusammensetzen.
    • Die Punktzahlen und Probleme jeder Runde in qa/review_log.md festhalten.
  5. Den fertigen Film nach <Thema>/<Filmtitel>.mp4 kopieren.

Wichtig für vertikale Kurzvideos (style = vflash)

  • Gesamtfilm-Komponente in src/vfilm/: VFilm, VOverlay, universelle Karten und Tags, minimalistische Cover. Szenen in vfilm/scenes.tsx in VSCENE_MAP registrieren.
  • Sicherer Bereich für Untertitel: x 40–1040, y 240–1640; Textverweildauer standardmäßig ≥ 3,5 Sekunden, kurze Textkarten ≥ 3 Sekunden.
  • Quellenangaben nicht auf dem Bild überlagern, Quellen nur in source/sources.md angeben. Auf dem Bild maximal „Illustration“ vermerken.
  • Ende: Nummerierte Wiederholung/Abstimmung + Folgen-Aufforderung. Textregeln in references/publish-copy.md (Titel ≤ 30 Zeichen, Beschreibung ≤ 100 Zeichen inkl. Hashtags).
  • Lautstärke des fertigen Films: -16 LUFS, wahrer Spitzenwert ≤ -2 dBTP: python tools/loudnorm.py out/film.mp4. Die Hintergrundmusik muss deutlich hörbar sein.
  • Schnittpunkte auf dem ersten Schlag des Taktes: python tools/sync_check.py. Tempokurve wird von beat_grid.py in die segments von grid.json geschrieben.
  • Vertikales Cover: npm run vcover34 / vcover43.

Schritt 8: Cover

Für beide Stile gibt es jeweils 3:4- und 4:3-Cover; für vertikale Videos gibt es zusätzlich minimalistische Cover:

  • FLASH-Stil (Querformat-Komposition): npm run cover34, npm run cover43
  • Pixel-Stil: npm run pixelcover34, npm run pixelcover43
  • Vertikal minimalistisch: npm run vcover34, npm run vcover43

Alle werden in 2-facher Auflösung exportiert. Layout-Regeln in der entsprechenden Stil-Dokumentation und in references/publish-copy.md. Bei Kurzvideo-Covern die linke untere Ecke (Bereich für Aufrufzahlen) freihalten, keine Liste im unteren Farbbalken verwenden.

Lieferung

Dem User mitteilen:

  • Pfad des fertigen Films, Pfad des brief.md, Pfad des Projektverzeichnisses.
  • Die wichtigsten kreativen Entscheidungen dieser Produktion.
  • Bekannte Mängel.
  • Renderzeit.
  • Unsichere, vom User zu überprüfende Fakten separat auflisten.

Stil ändern, neuen Stil hinzufügen

  • Nur diesen Film ändern: Nur die Dateien im video/-Verzeichnis dieses Films ändern, nicht die Skill-Vorlage. Welche Teile in welcher Datei sind, siehe references/craft.md unter „Stilverteilung auf Dateien". Zuerst 4–6 repräsentative Standbilder zur Bestätigung des Stils präsentieren, dann den gesamten Film erstellen.
  • C-Stil zukünftig verwenden:
    1. Den Code in assets/template/src/<Stilname>/ ablegen.
    2. references/style-<Stilname>.md schreiben.
    3. In der Kandidatenliste von plans.md als „aufgenommen" markieren.
    4. Eine Zeile in der Konzepttabelle dieser Datei hinzufügen.
  • Nicht umsetzbare Stile: Dieser Workflow verwendet ausschließlich Code zum Zeichnen von Vektor- und Pixelgrafiken. Echtaufnahmen, fotorealistisches 3D und realistische Personen sind nicht möglich; dies muss dem User vorab mitgeteilt werden. Werden realistische Personen benötigt, kann der User zuerst mit einem Videomodell einen reinen Greenscreen-Clip generieren; der Code übernimmt dann nur die Szenerie und den Text.

Referenzdateien (bei Bedarf lesen)

DateiInhalt
references/plans.mdFormat der drei Konzepte, C-Kandidatenliste, Vorschauregeln, Präsentation beim User
references/brief-template.mdVorlage für die sieben Blöcke des brief.md
references/style-flash.mdFLASH-Animationsstil: Stilrichtlinien, Komponenten, Cover
references/style-pixel.mdPixel-Cartridge-Stil: Bildgestaltung, Palette, zwei Auflösungen, Bitmap-Schrift, Sprites, CRT, Cover
references/craft.mdStoryboard-Regeln, Untertitelregeln, Selbstprüfung pro Szene, Gesamtfilm-Selbstprüfung und Bewertung, Abnahmeliste, Stilverteilung auf Dateien
references/remotion-kit.mdVorlagenstruktur, Taktsystem, API der Komponenten, häufig verwendete Befehle
references/audio.mdTakt, Klangfarbentabelle (inkl. Chip-Sounds), Mischpegel-Endwerte, Abmischprozess
references/research.mdMethode zur Recherche und Überprüfung von Quellen
references/pitfalls.mdBekannte Fallstricke (vor Arbeitsbeginn lesen)
references/credits.mdQuellenangaben und Schriftarten-Lizenzen
references/publish-copy.mdVertikale Veröffentlichungstexte, Abstimmungsende, Sicherheitszone, Lautstärke
scripts/new_project.py, new_project.ps1, check_env.py, beat_grid.py, music_rms.py, qa_sheet.pyProjekt erstellen, Umgebung prüfen, Takt messen, Pegel messen, Einzelbilder extrahieren
assets/template/Remotion-Projektvorlage (enthält alle allgemeinen Komponenten und Platzhalter für beide Stile)
assets/fonts/Fusion Pixel 12px Bitmap-Schriftart (OFL)
examples/bait-color/Vollständiges Multi-Szenen-Beispiel (optional als Referenz, nicht als Standardvorlage)

Verwandte Skills