Communitygithub.com

ericrisco/rsc-harness

Verwenden Sie dieses Skill, wenn Sie mit Remotion ein tatsächliches Videodatei rendern müssen – React-Kompositionen, den Composition/Sequence/TransitionSeries-Graphen, Übergänge, eingebrannte Wort-für-Wort-Untertitel aus einem Transkript, automatische Stille-Entfernung, B-Roll-Overlays, Headless-CI-Renderings und ein endgültiges MP4 oder MOV. NICHT zum Schreiben des Skripts, des Aufhängers, der Beats oder des Untertiteltextes (das ist `video-shorts`), NICHT zum Mastern von Audio auf LUFS oder zum Erstellen eines RSS-Feeds (das ist `podcast`), NICHT zum Strukturieren des narrativen Bogens (das ist `course-storytelling`).

Was ist rsc-harness?

Dieses Skill ist der exklusive Encoder und Renderer im Remotion-Ökosystem. Es nimmt Assets wie Aufnahmen, Voiceovers, B-Roll und Transkripte entgegen, kombiniert sie mit React-Code und erzeugt eine fertige Videodatei (`out/video.mp4`). Im Gegensatz zu anderen Skills, die sich mit Skripterstellung oder Audio-Mastering befassen, ist dies das einzige Skill, das tatsächlich Pixel produziert – mit dem strengen Anspruch reproduzierbarer Frames: gleiche Eingabe, gleiche deterministische Ausgabe, verifiziert durch einen Render, den `ffprobe` lesen kann. Der Skill verwaltet das gesamte Remotion-Projekt-Scaffold, den `<Composition>`/`<Sequence>`/`<TransitionSeries>`-Graphen, die Untertitel-Pipeline (Whisper.cpp → `toCaptions` → `createTikTokStyleCaptions`), den Pass zur Stille-Entfernung und den `npx remotion render`-Aufruf mit Codec- und Concurrency-Flags. Es arbeitet mit `@remotion/transitions` für Übergänge (Slide, Fade, Wipe, Flip, ClockWipe, None) und `@remotion/captions` für Word-by-Word-Untertitel. Die Schlüsselentscheidung liegt zwischen Frames und Wörtern: Wenn die Aufgabe die Erzeugung einer Datei ist, sind Sie hier richtig. Wenn es um Text oder einen Plan geht, leiten Sie vor dem Schreiben einer `.tsx`-Datei an das Skill `video-shorts` weiter. Das Skill setzt auf bewährte Anti-Patterns, wie Hardcodierung von Dauern in Sekunden oder Verwendung von `Date.now()`, und bietet stattdessen Remotion-native Werkzeuge wie `interpolate()`, `spring()` und `random(seed)`. Plattformen: Claude Code, Remotion Studio, Headless/CI-Umgebungen. Voraussetzung: Node 16+ (oder Bun 1.0.3+), macOS 15+. Empfohlen wird die Installation mit `npx skills add remotion-dev/skills` innerhalb eines Remotion-Projekts.

Funktioniert mit✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ericrisco/rsc-harness/tree/HEAD/skills/remotion-video

In Ihrer bevorzugten KI fragen

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

Dokumentation

Remotion-Video — Die tatsächlichen Frames codieren

Du bist der Encoder und Renderer. Du nimmst Assets — eine Aufnahme, einen Voiceover, B-Roll, ein Transkript — plus React-Code entgegen und erzeugst eine echte Datei: out/video.mp4. Deine Geschwister schreiben Worte und Pläne; du bist der Einzige, der Pixel produziert. Die Strenge hier sind reproduzierbare Frames: gleiche Eingabe, gleiche deterministische Ausgabe, verifiziert durch einen Render, den ffprobe lesen kann.

Dir gehört das Remotion-Projekt-Scaffold, der <Composition> / <Sequence> / <TransitionSeries>-Graph, die Untertitel-Pipeline (Whisper.cpp → toCaptions → createTikTokStyleCaptions), der Pass zur Stille-Entfernung und der npx remotion render-Aufruf mit seinen Codec- und Concurrency-Flags.

Die eine Entscheidung: Frames oder Wörter?

Wenn die Anforderung darin besteht, eine Datei zu erzeugen, bist du hier richtig. Wenn es darum geht, Text oder einen Plan zu erzeugen, leite weiter, bevor du eine einzige .tsx schreibst.

Die AnforderungGeht zuGrund
Ein MP4/MOV erzeugen, Übergänge, eingebrannte Untertitel, rendernhierDies sind Pixel und Frames
Das Skript, den Aufhänger, die Beats, den eingeblendeten Untertitel-Text, den Schnittentscheidungsbogen schreiben../video-shorts/SKILL.mdDas sind Wörter; die Schnittentscheidungen, nicht die Schnittausführung
Audio auf ein LUFS-Ziel mastern, Kapitel + RSS <item> erzeugen../podcast/SKILL.mdAudio-Mastering und Feed, nicht Video-Encoding
Den narrativen Bogen und Ablauf der Lektion/des Videos strukturieren../course-storytelling/SKILL.mdNarrative Architektur, nicht Rendering
Das Thumbnail-Bild entwerfen../youtube-thumbnails/SKILL.mdEin Standbild, kein Video

Grenze in einem Satz: video-shorts entscheidet über die Schnitte und schreibt den Untertiteltext; du führst die Schnitte im Code aus und brennst die Untertitel in die Frames ein.

Baugerüst des Projekts

npx create-video@latest --yes --blank my-video
cd my-video
npm i
npm run dev        # öffnet Remotion Studio im Browser

Remotions aktuelle stabile Linie ist 4.0.471; es benötigt Node 16+ (oder Bun 1.0.3+), und lokales Rendern erfordert macOS 15 (Sequoia)+. Seit Januar 2026 liefert Remotion Agent Skills — npx skills add remotion-dev/skills verdrahtet Remotion-bewusste Anleitung in Claude Code. Führe es in einem Remotion-Projekt aus, wenn du das framework-eigene Skill zusätzlich zu diesem laden möchtest.

Setze fps und Abmessungen zuerst auf <Composition> fest und ändere sie niemals mitten im Projekt. Warum: jede nachgelagerte Dauer wird in Frames gemessen, und frames = seconds * fps. Wenn du fps änderst, nachdem du Dauern geschrieben hast, verschiebt sich jede Zeitangabe stillschweigend. Vertikale Shorts sind 1080×1920 @ 30; Querformat ist 1920×1080 @ 30.

Der Kompositionsgraph

// src/Root.tsx
import { Composition } from "remotion";
import { MyVideo } from "./MyVideo";

export const RemotionRoot: React.FC = () => {
  return (
    <Composition
      id="MyVideo"            // die id, die du an `remotion render` übergibst
      component={MyVideo}
      durationInFrames={300}  // 10s bei 30fps
      fps={30}
      width={1080}
      height={1920}
    />
  );
};
// src/MyVideo.tsx
import { AbsoluteFill, Sequence, useCurrentFrame, interpolate, spring, useVideoConfig } from "remotion";

export const MyVideo: React.FC = () => {
  const frame = useCurrentFrame();
  const { fps } = useVideoConfig();
  const opacity = interpolate(frame, [0, 30], [0, 1], { extrapolateRight: "clamp" });
  const scale = spring({ frame, fps, config: { damping: 200 } });
  return (
    <AbsoluteFill style={{ backgroundColor: "black" }}>
      <Sequence from={0} durationInFrames={90}>
        <AbsoluteFill style={{ opacity, transform: `scale(${scale})` }}>{/* Szene 1 */}</AbsoluteFill>
      </Sequence>
      <Sequence from={90} durationInFrames={210}>{/* Szene 2 */}</Sequence>
    </AbsoluteFill>
  );
};

Animieren mit useCurrentFrame(), interpolate() und spring() nur. Lies niemals die Wanduhrzeit (Date.now()) oder rufe ungesäht Math.random() innerhalb einer Komposition auf. Warum: Rendern ist parallel und frame-adressierbar — jeder Frame wird unabhängig berechnet, daher erzeugt jede Nicht-Frame-Eingabe ein anderes Pixel bei einem erneuten Rendern und bricht die Garantie "gleiche Eingabe, gleiche Ausgabe". Wenn du Zufälligkeit benötigst, verwende Remotions random(seed).

Übergänge

Verwende @remotion/transitions (verfügbar seit v4.0.53). <TransitionSeries> fügt .Sequence (einen Clip, mit durationInFrames) und .Transition (eine presentation + ein timing) ineinander. Die Übergangsdauer wird von der Gesamtdauer abgezogen, sodass benachbarte Sequenzen während des Wipes überlappen.

import { TransitionSeries, linearTiming, springTiming } from "@remotion/transitions";
import { slide } from "@remotion/transitions/slide";
import { fade } from "@remotion/transitions/fade";
import { Easing } from "remotion";

<TransitionSeries>
  <TransitionSeries.Sequence durationInFrames={90}>{/* Szene A */}</TransitionSeries.Sequence>
  <TransitionSeries.Transition
    presentation={slide({ direction: "from-left" })}
    timing={springTiming({ config: { damping: 200 }, durationInFrames: 30, durationRestThreshold: 0.001 })}
  />
  <TransitionSeries.Sequence durationInFrames={120}>{/* Szene B */}</TransitionSeries.Sequence>
  <TransitionSeries.Transition
    presentation={fade()}
    timing={linearTiming({ durationInFrames: 15, easing: Easing.inOut(Easing.ease) })}
  />
  <TransitionSeries.Sequence durationInFrames={90}>{/* Szene C */}</TransitionSeries.Sequence>
</TransitionSeries>

Jede Präsentation ist ein Unterimport (@remotion/transitions/slide, /fade, /wipe, /flip, /clockWipe, /none).

PräsentationGefühl / Wann
slideSzene schiebt die nächste herein; direktionale Dynamik zwischen Beats
fadeSanfter Crossfade; ruhiger, neutraler Szenenwechsel
wipeEine harte Kante fegt quer; energiegeladen, "nächstes Thema"
flip3D-Karten-Flip; verspielt, für Enthüllungen
clockWipeRadialer Sweep; Countdowns, "Zeit vergeht"
noneEin harter Schnitt ohne Bewegung, aber dennoch als TransitionSeries-Knoten

linearTiming für vorhersagbare, frame-genaue Schnitte; springTiming für organische Bewegung. Warum: Linear ist deterministisch in der Dauer, sodass du Frames genau budgetieren kannst; Spring überschwingt und beruhigt sich, was natürlich wirkt, aber durationRestThreshold benötigt, damit der Render weiß, wann er fertig ist.

Animierte eingebrannte Untertitel

Das native Paket @remotion/captions wurde in v4.0.216 ausgeliefert (der gleiche Release, der den alten convertToCaptions()-Helfer deprecated hat). Die Pipeline läuft einmal auf einem Node-Server, dann liest die Komposition die Untertitel:

  1. Transkribieren. @remotion/install-whisper-cpp lädt Whisper.cpp und ein Modell herunter (medium.en ist ~1,5 GB) und transkribiert das Audio auf einem Node-Server in Whisper-JSON.
  2. Konvertieren. toCaptions() aus @remotion/install-whisper-cpp wandelt dieses JSON in ein Caption[] mit Zeitstempeln pro Token um. (convertToCaptions() ist der Legacy-Alias — deprecated seit v4.0.216; verwende toCaptions().)
  3. In Seiten segmentieren. @remotion/captions createTikTokStyleCaptions({ captions, combineTokensWithinMilliseconds }) gruppiert Token in "Seiten", die gemeinsam erscheinen.

Der Wert combineTokensWithinMilliseconds ist der Seiten-Größen-Regler. Warum: Ein niedriger Wert (~200ms) behält jedes Wort auf seiner eigenen Seite → Wort-für-Wort-Pop-Animation; ein hoher Wert (~1200ms) packt eine Phrase pro Seite. Niedrige ms = TikTok-Wort-für-Wort-Energie; hohe ms = lesbare Phrasen. Wähle basierend auf dem Format, nicht auf dem Standardwert.

Die vollständige Whisper.cpp-Installation, der Transkriptionsserver und die Token-Highlight-Untertitel-Renderer-Komponente (mit Safe-Zone-Styling) befinden sich in references/captions-pipeline.md — lies es, bevor du die Untertitelebene erstellst.

Automatische Stille-Entfernung

Der Stille-Pass läuft auf dem Quell-Audio/-Video VOR dem Eintritt in Remotion, nicht innerhalb einer Komposition. Warum: Remotion rendert Frames, die du ihm gibst; das Beschneiden von toter Luft ist eine vorgelagerte Bearbeitung des Assets, und wenn du es zuerst machst, spiegelt jede nachgelagerte Frame-Nummer bereits die gestraffte Timeline wider.

Verwende auto-editor (eine Python + ffmpeg-Engine) für einen ersten Durchlauf, der tote Stellen anhand der Lautstärke des Audios beschneidet:

auto-editor input.mp4 --margin 0.2s --edit audio:threshold=4% -o tightened.mp4
  • --margin polstert jeden beibehaltenen Bereich, damit Schnitte die Sprache nicht abschneiden.
  • --edit audio:threshold=4% setzt die Lautstärke-Schwelle, unterhalb derer ein Bereich als "Stille" gilt.
  • --export premiere gibt eine EDL/XML-Datei aus, statt einer Videodatei, um sie in ein NLE zu reimportieren.

Die pip-Distribution ist veraltet/eingestellt — installiere über das offizielle Binary oder pipx, nicht mit pip install. Warum: Das PyPI-Paket hinkt hinterher und entspricht möglicherweise nicht den dokumentierten Flags. Wenn auto-editor nicht verfügbar ist, ist der Low-Level-Fallback die ffmpeg-Filter silencedetect / silenceremove. Beide, mit der vollständigen Flag-Matrix, befinden sich in references/render-and-pipeline.md.

B-Roll-Overlays

Staple das Overlay über das Hauptvideo, indem du <OffthreadVideo> (oder <Img>) innerhalb eines <AbsoluteFill> schichtest, gesteuert durch ein <Sequence from>:

import { AbsoluteFill, Sequence, OffthreadVideo, staticFile } from "remotion";

const fps = 30;
const broll = { start: 4.0, duration: 3.0 }; // Sekunden
<AbsoluteFill>
  <OffthreadVideo src={staticFile("main.mp4")} />        {/* Basisebene */}
  <Sequence from={Math.round(broll.start * fps)} durationInFrames={Math.round(broll.duration * fps)}>
    <AbsoluteFill style={{ /* z.B. Inset für Bild-im-Bild */ }}>
      <OffthreadVideo src={staticFile("broll.mp4")} />    {/* Overlay-Ebene */}
    </AbsoluteFill>
  </Sequence>
</AbsoluteFill>

Konvertiere jede Zeitangabe mit Math.round(seconds * fps) in Frames, einmal, an der Grenze. Warum: Ein B-Roll-Cue bei 4,0 s ist Frame 120 bei 30fps, aber Frame 240 bei 60fps — behalte Sekunden in deinen Daten und multipliziere mit fps aus useVideoConfig(), sodass eine Änderung der fps niemals Overlays desynchronisiert. Verwende <OffthreadVideo> (nicht das DOM <video> oder <Video>) für frame-genaues Decodieren während des Renderns.

Rendern

# Region zuerst testen: 1-2 Sekunden, validiert die Pipeline kostengünstig
npx remotion render MyVideo out/test.mp4 --frames=0-45

# dann der vollständige Render
npx remotion render MyVideo out/video.mp4

Lasse die Kompositions-ID weg, um einen interaktiven Auswähler zu erhalten. Konfiguriere über @remotion/cli/config in remotion.config.ts oder übergib Flags auf der CLI (Flags gewinnen):

// remotion.config.ts
import { Config } from "@remotion/cli/config";
Config.setConcurrency(8);
Config.setCodec("h264");
CodecVerwendungFlag
h264Standard für Web/YouTube; breite Kompatibilität(Standard)
h265Kleinere Dateien, gleiche Qualität; weniger universelle Wiedergabe--codec=h265
proresEditierfähiges Master, große Dateien, Re-Import in ein NLE--codec=prores --prores-profile=4444 --pixel-format=yuva444p10le --image-format=png
vp8 / gifWeb-Alpha oder Loop-Vorschauen--codec=vp8 / --codec=gif

Rendere immer zuerst eine 1–2s-Region (--frames=0-45) vor dem vollständigen Render. Warum: Ein vollständiger Render einer Minuten-langen Komposition kostet echte Zeit und CPU; ein Region-Test deckt eine kaputte Untertitel-Ebene oder ein fehlendes Asset in Sekunden auf. Für Headless/CI-Renderings, deterministische Ausgaberegeln und die vollständige Codec/Qualitäts-Matrix, siehe references/render-and-pipeline.md.

Anti-Patterns

SchlechtWarum es brichtGut
Hardcodieren von Dauern in Sekunden innerhalb von JSXRemotion denkt in Frames; Sekunden desynchronisieren, sobald fps sich ändertSpeichere Sekunden in Daten, Math.round(seconds * fps) an der Grenze
Date.now() / ungesähtes Math.random() in einer KompositionFrames rendern parallel und bei erneutem Rendern → nicht-deterministische PixelTreibe alles mit useCurrentFrame() an; verwende random(seed)
Ändern von fps nach dem Schreiben von DauernJede Frame-Anzahl verschiebt sich stillschweigend nachgelagertSetze fps + Abmessungen auf <Composition> zu Beginn fest, lasse sie unverändert
Erneutes Herunterladen des Whisper-Modells bei jedem LaufDer ~1,5 GB medium.en-Download wiederholt sich und blockiert die PipelineLade einmal herunter, cache den Modellpfad, verwende ihn wieder
Das 1,5 GB Whisper-Modell in git committenBläht das Repository auf; das Modell ist ein Build-Asset.gitignore das Modellverzeichnis; lade es in Setup/CI herunter
Vollständiges Video rendern, um eine Änderung zu testenMinuten verschwendeten Render, um eine kaputte Ebene zu finden--frames=0-45 Region-Test, dann vollständiger Render
Den Untertitel-Text oder Aufhänger hier schreibenDas ist das Skript, nicht das EncodingLeite an ../video-shorts/SKILL.md weiter; du brennst es nur ein
Gewöhnliches <video> / <Video> für B-Roll in einem RenderNicht frame-genau; reißt oder überspringt beim Rendern<OffthreadVideo> für frame-exaktes Decodieren
Stille-Entfernung innerhalb der Komposition ausführenDas Beschneiden von toter Luft ist eine vorgelagerte Asset-Bearbeitungauto-editor auf der Quelldatei vor Remotion

Verifizieren & Referenzen

  • bash scripts/verify.sh <project-dir> — prüft, ob das Remotion-Projekt wohlgeformt ist und rendert. Wenn Node + ffmpeg vorhanden sind, führt es npx remotion compositions aus, um zu bestätigen, dass eine Kompositions-ID existiert, rendert eine kurze Region in ein temporäres MP4 und verwendet ffprobe, um einen Videostream mit den erwarteten Abmessungen/fps zu bestätigen. Mit keinem von beiden fällt es auf eine statische Prüfung zurück: mindestens eine Kompositions-.tsx-Datei existiert und das Render-Skript referenziert eine echte Kompositions-ID und einen Ausgabepfad. Standardmäßig schreibgeschützt; beendet mit 0 bei einem leeren/sauberen Ziel.
  • references/captions-pipeline.md — vollständige Whisper.cpp-Installation + Transkriptionsserver, toCaptions, die Token-Highlight-Untertitel-Renderer-Komponente und Untertitel-Styling/Safe-Zone-Notizen.
  • references/render-and-pipeline.md — auto-editor + ffmpeg-Stille-Befehle, die vollständige Render-Flag-Matrix, Headless/CI-Render, die Codec-Tabelle und ffprobe-Verifikation.

Individual skills in this repo

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

ericrisco/rsc-harness

Use when writing the words on a single conversion page — the hero headline and subhead, the offer, the proof and testimonials, and one primary CTA — or diagnosing a page that gets traffic and does not convert, as a copy problem rather than a layout one. NOT the paid ad that drives the click (that is `ads`), NOT the visual layout the words sit in (that is `design`), NOT the experiment that picks the winning variant (that is `ab-testing`).

ericrisco/rsc-harness

Use when you have raw 9:16 footage and need it cut into a post-ready vertical short — dead air removed, fast jump cuts, karaoke word-by-word burned-in captions from a transcript, cuts and zooms snapped to the music beat, safe-area placement so captions clear the platform UI, and a platform-correct MP4 export. NOT writing the script, hook, beats or caption text (that is `video-shorts`), NOT building a Remotion React composition codebase (that is `remotion-video`), NOT deciding when or where to post (that is `social-publisher`).

ericrisco/rsc-harness

Use when a Reels/TikTok/Shorts account needs its next video ideas scored into a ranked backlog, grounded in its own performance log plus dated trending sounds, each bet logged so its outcome feeds the next batch. NOT scripting a chosen idea (that is `video-shorts`), NOT pillars or cadence (that is `shortform-strategy`), NOT packaging a finished cut (that is `shortform-packaging`).

ericrisco/rsc-harness

Use when a vertical short is shot or scripted and you need the upload-form copy and cover that win the feed — the hook line, the first-frame on-screen text, the search-led caption, a tight hashtag set, and the cover frame; it learns from what performed via the 02-DOCS log. NOT inventing the idea (that is `shortform-ideation`), NOT scripting or directing the cuts (that is `video-shorts`), NOT executing the edit (that is `shortform-editing`), NOT scheduling the post (that is `social-publisher`).

ericrisco/rsc-harness

Use when the unit of work is a TikTok/Reels account, not one clip: positioning, sustainable cadence and format mix, ride-or-skip on a trend or sound, recurring series, diagnosing a flat account, and the dated learning loop. NOT the single script or hook variants (that is `video-shorts`), NOT the idea backlog (that is `shortform-ideation`).

ericrisco/rsc-harness

Use when planning a posting schedule, building a multi-platform content calendar, or reshaping one source asset into channel-native posts across X, LinkedIn, Instagram, Threads, Bluesky, TikTok, Facebook or YouTube — cadence, best-time slots, per-platform format limits, API publish caps, and a dated CSV or JSON calendar a scheduler can import. NOT the brand voice the posts speak in (that is `brand-voice`), NOT the editorial strategy of what to make (that is `content-engine`).

ericrisco/rsc-harness

Use when connecting a real TikTok account to code via the Content Posting, Display and Business Account APIs — OAuth, chunked video publish with status polling, and pulling views, watch time and impression sources, then logging that performance into the wiki as a dated feedback record. Covers short-lived tokens breaking a cron, unverified pull-from-URL ownership, and rate limits. NOT what to post or how to package it (that is `shortform-strategy` and `shortform-packaging`).

ericrisco/rsc-harness

Use when scripting or directing the edit of a single vertical short that has to hold attention from the first frame — turning a topic, a clip or a long video into a shot-by-shot script and an edit decision sheet, fixing a hook that dies in second three, generating hook variants to test, and planning cuts and on-screen text. NOT scheduling or cross-platform cadence (that is `social-publisher`), NOT running the editorial calendar (that is `content-engine`), NOT defining the durable brand tone (that is `brand-voice`).

ericrisco/rsc-harness

Use to judge whether a short-form clip is worth publishing — scores a reel, short or podcast excerpt 0-100 on ten weighted criteria with automatic penalties, then ranks a batch and says where the cut-off falls. Run it on transcript candidates before rendering. NOT writing the hook or caption (that is `shortform-packaging`), NOT inventing the idea (that is `shortform-ideation`), NOT executing the edit (that is `shortform-editing`).

Verwandte Skills