Communitygithub.com

ericrisco/rsc-harness

Utilisez cette compétence lorsque vous devez générer un fichier vidéo réel avec Remotion — compositions React, graphe Composition/Sequence/TransitionSeries, transitions, sous-titres mot par mot brûlés dans l'image à partir d'un transcript, suppression automatique des silences, incrustations de B-roll, rendus CI headless, et un fichier MP4 ou MOV final.

Qu'est-ce que rsc-harness ?

Cette compétence est destinée aux développeurs utilisant Remotion pour produire des vidéos à partir de code React. Elle prend en charge l'échafaudage de projets Remotion, la définition de compositions avec des dimensions et des images par seconde fixes, la création de séquences et de transitions animées (glissement, fondu, essuyage, retournement, essuyage circulaire), ainsi que le pipeline complet de sous-titres brûlés : transcription via Whisper.cpp, conversion en objets `Caption` via `toCaptions()`, et regroupement en pages avec `createTikTokStyleCaptions()`. Elle intègre également la suppression automatique des silences en amont avec `auto-editor`, l'incrustation de B-roll avec `OffthreadVideo`, et le rendu final via `npx remotion render`. La compétence insiste sur la reproductibilité des images (déterministe, pas de `Date.now()` ou `Math.random()` non ensemencé) et fournit des vérifications via `scripts/verify.sh` ainsi que des références détaillées pour les pipelines avancés. Elle est conçue pour être utilisée avec Claude Code, Cursor, Codex et d'autres agents IA, et fonctionne sur macOS 15+, Node 16+ (ou Bun 1.0.3+).

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

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Vidéo Remotion — Encoder les Images Réelles

Vous êtes l'encodeur et le moteur de rendu. Vous prenez des actifs — un enregistrement, une voix off, un B-roll, un transcript — ainsi que du code React, et vous émettez un fichier réel : out/video.mp4. Vos compétences sœurs écrivent des mots et des plans ; vous êtes le seul à produire des pixels. La rigueur ici est celle des images reproductibles : mêmes entrées, même sortie déterministe, vérifiée par un rendu que ffprobe peut lire.

Vous possédez l'échafaudage du projet Remotion, le graphe <Composition> / <Sequence> / <TransitionSeries>, le pipeline de sous-titres (Whisper.cpp → toCaptions → createTikTokStyleCaptions), le passage de suppression du silence, et l'invocation npx remotion render avec ses indicateurs de codec et de concurrence.

La seule décision : images ou mots ?

Si la demande est de produire un fichier, vous êtes au bon endroit. Si c'est pour produire du texte ou un plan, redirigez avant d'écrire un seul .tsx.

La demandeVa versPourquoi
Produire un MP4/MOV, transitions, sous-titres brûlés, renduiciCe sont des pixels et des images
Écrire le script, l'accroche, les beats, le texte des sous-titres à l'écran, la feuille de décision de montage../video-shorts/SKILL.mdCe sont des mots ; les décisions de coupe, pas l'exécution de la coupe
Masteriser l'audio vers une cible LUFS, produire des chapitres + un <item> RSS../podcast/SKILL.mdMasterisation audio et flux, pas encodage vidéo
Structurer l'arc narratif de la leçon/vidéo et le flux../course-storytelling/SKILL.mdArchitecture narrative, pas rendu
Concevoir l'image miniature../youtube-thumbnails/SKILL.mdUne image fixe, pas une vidéo

Limite en une ligne : video-shorts décide des coupes et écrit le texte des sous-titres ; vous exécutez les coupes en code et brûlez les sous-titres dans les images.

Échafauder le projet

npx create-video@latest --yes --blank my-video
cd my-video
npm i
npm run dev        # ouvre Remotion Studio dans le navigateur

La ligne stable actuelle de Remotion est la 4.0.471 ; elle nécessite Node 16+ (ou Bun 1.0.3+), et le rendu local cible macOS 15 (Sequoia)+. Depuis janvier 2026, Remotion fournit des compétences pour agents — npx skills add remotion-dev/skills connecte des conseils conscients de Remotion dans Claude Code. Exécutez-le à l'intérieur d'un projet Remotion lorsque vous souhaitez que la propre compétence du framework soit chargée en parallèle de celle-ci.

Figez les fps et les dimensions sur <Composition> en premier, et ne les changez jamais en cours de projet. Pourquoi : chaque durée en aval est mesurée en images, et images = secondes * fps. Si vous changez les fps après avoir écrit les durées, chaque timing se décale silencieusement. Les vidéos verticales sont en 1080×1920 @ 30 ; le paysage est en 1920×1080 @ 30.

Le graphe de composition

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

export const RemotionRoot: React.FC = () => {
  return (
    <Composition
      id="MyVideo"            // l'id que vous passez à `remotion render`
      component={MyVideo}
      durationInFrames={300}  // 10s à 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})` }}>{/* scène 1 */}</AbsoluteFill>
      </Sequence>
      <Sequence from={90} durationInFrames={210}>{/* scène 2 */}</Sequence>
    </AbsoluteFill>
  );
};

Animez en utilisant useCurrentFrame() avec interpolate() et spring() uniquement. Ne lisez jamais l'heure système (Date.now()) et n'appelez pas Math.random() non ensemencé à l'intérieur d'une composition. Pourquoi : le rendu est parallèle et adressable par image — chaque image est calculée indépendamment, donc toute entrée non-image produit un pixel différent lors d'un nouveau rendu et brise la garantie "mêmes entrées, même sortie". Si vous avez besoin d'aléatoire, utilisez random(seed) de Remotion.

Transitions

Utilisez @remotion/transitions (disponible depuis la v4.0.53). <TransitionSeries> entrelace .Sequence (un clip, avec durationInFrames) et .Transition (une presentation + un timing). La durée de la transition est soustraite du total, donc les séquences adjacentes se chevauchent pendant le fondu.

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

Chaque présentation est une sous-importation (@remotion/transitions/slide, /fade, /wipe, /flip, /clockWipe, /none).

PrésentationSens / Quand
slideLa scène pousse la suivante ; momentum directionnel entre les beats
fadeFondu enchaîné doux ; changement de scène calme et neutre
wipeUn bord dur balaie ; énergique, "sujet suivant"
flipRetournement 3D de carte ; ludique, pour les révélations
clockWipeBalayage radial ; comptes à rebours, "temps qui passe"
noneUne coupe franche sans mouvement, mais toujours en tant que nœud TransitionSeries

linearTiming pour des coupes prévisibles et exactes en images ; springTiming pour un mouvement organique. Pourquoi : linear est déterministe en durée, vous pouvez donc budgétiser les images exactement ; spring dépasse et se stabilise, ce qui donne un rendu naturel mais nécessite durationRestThreshold pour que le rendu sache quand il a terminé.

Sous-titres animés brûlés dans l'image

Le package natif @remotion/captions a été livré dans la v4.0.216 (la même version qui a déprécié l'ancienne aide convertToCaptions()). Le pipeline s'exécute une fois sur un serveur Node, puis la composition lit les sous-titres :

  1. Transcrire. @remotion/install-whisper-cpp télécharge Whisper.cpp et un modèle (medium.en fait ~1,5 Go) et transcrit l'audio sur un serveur Node en JSON Whisper.
  2. Convertir. toCaptions() de @remotion/install-whisper-cpp transforme ce JSON en un Caption[] avec des horodatages par token. (convertToCaptions() est l'ancien alias — déprécié depuis la v4.0.216 ; utilisez toCaptions().)
  3. Segmenter en pages. createTikTokStyleCaptions({ captions, combineTokensWithinMilliseconds }) de @remotion/captions groupe les tokens en "pages" qui apparaissent ensemble.

La valeur combineTokensWithinMilliseconds est le cadran de taille de page. Pourquoi : une valeur faible (~200ms) garde chaque mot sur sa propre page → animation d'apparition mot par mot ; une valeur élevée (~1200ms) regroupe une phrase par page. Faible ms = énergie TikTok mot par mot ; élevé ms = phrases lisibles. Choisissez selon le format, pas par défaut.

L'installation complète de Whisper.cpp, le serveur de transcription et le composant de rendu des sous-titres avec surbrillance des tokens (avec style de zone de sécurité) se trouvent dans references/captions-pipeline.md — lisez-le avant de construire la couche de sous-titres.

Suppression automatique du silence

Le passage de silence s'exécute sur l'audio/vidéo source AVANT d'entrer dans Remotion, pas à l'intérieur d'une composition. Pourquoi : Remotion rend les images que vous lui donnez ; couper le silence ambiant est une modification en amont sur l'actif, et le faire en premier signifie que chaque numéro d'image en aval reflète déjà la chronologie resserrée.

Utilisez auto-editor (un moteur Python + ffmpeg) pour un premier passage qui coupe les espaces morts en fonction du volume audio :

auto-editor input.mp4 --margin 0.2s --edit audio:threshold=4% -o tightened.mp4
  • --margin rembourre chaque région conservée pour que les coupes n'écrètent pas la parole.
  • --edit audio:threshold=4% définit le seuil de volume en dessous duquel une région est considérée comme "silence".
  • --export premiere émet un EDL/XML au lieu d'un fichier, pour le réimporter dans un NLE.

La distribution pip est obsolète/arrêtée — installez via le binaire officiel ou pipx, pas pip install. Pourquoi : le paquet PyPI est en retard et peut ne pas correspondre aux indicateurs documentés. Lorsque auto-editor n'est pas disponible, la solution de repli de bas niveau est les filtres silencedetect / silenceremove de ffmpeg. Les deux, avec la matrice complète des indicateurs, se trouvent dans references/render-and-pipeline.md.

Incrustations de B-roll

Empilez l'incrustation au-dessus de la vidéo principale en superposant <OffthreadVideo> (ou <Img>) à l'intérieur d'un <AbsoluteFill>, contrôlé par un <Sequence from> :

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

const fps = 30;
const broll = { start: 4.0, duration: 3.0 }; // secondes
<AbsoluteFill>
  <OffthreadVideo src={staticFile("main.mp4")} />        {/* couche de base */}
  <Sequence from={Math.round(broll.start * fps)} durationInFrames={Math.round(broll.duration * fps)}>
    <AbsoluteFill style={{ /* par ex. encart pour picture-in-picture */ }}>
      <OffthreadVideo src={staticFile("broll.mp4")} />    {/* couche d'incrustation */}
    </AbsoluteFill>
  </Sequence>
</AbsoluteFill>

Convertissez chaque timecode en images avec Math.round(secondes * fps), une fois, à la limite. Pourquoi : un signal de B-roll à 4,0s est l'image 120 à 30fps mais l'image 240 à 60fps — gardez les secondes dans vos données et multipliez par fps depuis useVideoConfig() pour que le changement de fps ne désynchronise jamais les incrustations. Utilisez <OffthreadVideo> (pas le DOM <video> ou <Video>) pour un décodage précis à l'image près pendant le rendu.

Rendu

# test de région d'abord : 1-2 secondes, valide le pipeline à moindre coût
npx remotion render MyVideo out/test.mp4 --frames=0-45

# puis le rendu complet
npx remotion render MyVideo out/video.mp4

Omettez l'id de composition pour obtenir un sélecteur interactif. Configurez via @remotion/cli/config dans remotion.config.ts, ou passez des indicateurs sur la CLI (les indicateurs l'emportent) :

// remotion.config.ts
import { Config } from "@remotion/cli/config";
Config.setConcurrency(8);
Config.setCodec("h264");
CodecUtilisationIndicateur
h264Par défaut pour le web/YouTube ; large compatibilité(par défaut)
h265Fichiers plus petits, même qualité ; lecture moins universelle--codec=h265
proresMaster de qualité montage, gros fichiers, réimport dans un NLE--codec=prores --prores-profile=4444 --pixel-format=yuva444p10le --image-format=png
vp8 / gifPrévisualisations alpha web ou en boucle--codec=vp8 / --codec=gif

Effectuez toujours un rendu d'une région de 1 à 2 s (--frames=0-45) avant le rendu complet. Pourquoi : un rendu complet d'une composition de plusieurs minutes coûte du temps et du CPU réels ; un test de région révèle une couche de sous-titres cassée ou un actif manquant en quelques secondes. Pour les rendus headless/CI, les règles de sortie déterministe et la matrice codec/qualité complète, voir references/render-and-pipeline.md.

Anti-patrons

MauvaisPourquoi ça casseBon
Coder en dur les durées en secondes dans le JSXRemotion raisonne en images ; les secondes se désynchronisent dès que les fps changentStockez les secondes dans les données, Math.round(secondes * fps) à la limite
Date.now() / Math.random() non ensemencé dans une compositionLes images se rendent en parallèle et lors d'un nouveau rendu → pixels non déterministesPilotez tout avec useCurrentFrame() ; utilisez random(seed)
Changer fps après avoir écrit les duréesChaque nombre d'images en aval se décale silencieusementFigez fps + dimensions sur <Composition> au départ, laissez-les
Re-télécharger le modèle Whisper à chaque exécutionLe téléchargement de ~1,5 Go medium.en se répète et bloque le pipelineTéléchargez une fois, mettez en cache le chemin du modèle, réutilisez-le
Commit du modèle Whisper de 1,5 Go dans gitGonfle le dépôt ; le modèle est un actif de build.gitignore le répertoire du modèle ; récupérez-le dans setup/CI
Rendre la vidéo complète pour tester une modificationMinutes de rendu gaspillées pour trouver une couche casséeTest de région --frames=0-45, puis rendu complet
Écrire la copie du sous-titre ou l'accroche iciC'est le script, pas l'encodageRedirigez vers ../video-shorts/SKILL.md ; vous ne faites que le brûler
<video> / <Video> simple pour le B-roll dans un renduPas précis à l'image près ; déchirures ou sauts lors du rendu<OffthreadVideo> pour un décodage exact à l'image
Exécuter la suppression du silence à l'intérieur de la compositionCouper le silence ambiant est une modification d'actif en amontauto-editor sur le fichier source avant Remotion

Vérification et références

  • bash scripts/verify.sh <project-dir> — vérifie que le projet Remotion est bien formé et rend. Avec Node + ffmpeg présents, il exécute npx remotion compositions pour confirmer qu'un id de composition existe, effectue un court rendu de région vers un MP4 temporaire, et utilise ffprobe pour confirmer un flux vidéo avec les dimensions/fps attendus. Sans les deux, il se rabat sur une vérification statique : au moins un fichier .tsx de composition existe et le script de rendu référence un id de composition réel et un chemin de sortie. En lecture seule par défaut ; sort avec 0 sur une cible vide/propre.
  • references/captions-pipeline.md — installation complète de Whisper.cpp + serveur de transcription, toCaptions, le composant de rendu des sous-titres avec surbrillance des tokens, et les notes de style/zone de sécurité des sous-titres.
  • references/render-and-pipeline.md — commandes silence de auto-editor + ffmpeg, la matrice complète des indicateurs de rendu, le rendu headless/CI, la table des codecs, et la vérification ffprobe.

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`).

Skills associés