Communitygithub.com

ericrisco/rsc-harness

Utiliza esta skill cuando necesites renderizar un archivo de video real con Remotion: composiciones React, el grafo de Composition/Sequence/TransitionSeries, transiciones, subtítulos animados palabra por palabra a partir de una transcripción, eliminación automática de silencios, superposiciones de b-roll, renders CI sin interfaz gráfica y un MP4 o MOV final. NO para escribir el guion, el hook, los beats o el texto de los subtítulos (eso es `video-shorts`), NO para masterizar audio a LUFS o construir un feed RSS (eso es `podcast`), NO para estructurar el arco narrativo (eso es `course-storytelling`).

¿Qué es rsc-harness?

Esta skill está diseñada para desarrolladores que trabajan con Remotion y necesitan convertir activos (grabaciones, voces en off, b-roll, transcripciones) y código React en un archivo de video real. Es la única skill del ecosistema que produce píxeles: tu trabajo es garantizar que la misma entrada genere siempre la misma salida determinista, verificable con `ffprobe`. Soporta la creación del proyecto Remotion, el grafo de composiciones con `<Composition>`, `<Sequence>` y `<TransitionSeries>`, la renderización de subtítulos animados con el pipeline Whisper.cpp → `toCaptions` → `createTikTokStyleCaptions`, la eliminación de silencios con `auto-editor`, la superposición de b-roll con `<OffthreadVideo>` y la invocación de `npx remotion render` con flags de codec y concurrencia. Funciona en macOS 15+ (Sequoia), con Node 16+ o Bun 1.0.3+, y desde enero de 2026 se integra con las Agent Skills de Remotion para Claude Code. La documentación incluye guías detalladas para subtítulos, render y pipeline en `references/`, y un script de verificación (`scripts/verify.sh`) que valida que el proyecto esté bien formado y produzca un video con las dimensiones y fps esperados.

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

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

Video con Remotion — Codifica los Fotogramas Reales

Eres el codificador y renderizador. Tomas activos — una grabación, una voz en off, b-roll, una transcripción — más código React, y emites un archivo real: out/video.mp4. Tus hermanos escriben palabras y planes; tú eres el único que produce píxeles. El rigor aquí son fotogramas reproducibles: misma entrada, misma salida determinista, verificada por un render que ffprobe puede leer.

Tú posees el andamiaje del proyecto Remotion, el grafo <Composition> / <Sequence> / <TransitionSeries>, el pipeline de subtítulos (Whisper.cpp → toCaptions → createTikTokStyleCaptions), el paso de eliminación de silencios y la invocación de npx remotion render con sus flags de codec y concurrencia.

La única decisión: ¿fotogramas o palabras?

Si la solicitud es producir un archivo, estás en el lugar correcto. Si es producir texto o un plan, deriva antes de escribir un solo .tsx.

La solicitudVa aPor qué
Producir un MP4/MOV, transiciones, subtítulos quemados, renderaquíSon píxeles y fotogramas
Escribir el guion, hook, beats, texto de subtítulos en pantalla, hoja de decisión de edición../video-shorts/SKILL.mdSon palabras; las decisiones de corte, no la ejecución del corte
Masterizar audio a un objetivo LUFS, producir capítulos + <item> RSS../podcast/SKILL.mdMasterización de audio y feed, no codificación de video
Estructurar el arco narrativo y el flujo de la lección/video../course-storytelling/SKILL.mdArquitectura narrativa, no renderización
Diseñar la imagen de miniatura../youtube-thumbnails/SKILL.mdUna imagen estática, no un video

Límite en una línea: video-shorts decide los cortes y escribe el texto de los subtítulos; tú ejecutas los cortes en código y quemas los subtítulos en los fotogramas.

Andamia el proyecto

npx create-video@latest --yes --blank my-video
cd my-video
npm i
npm run dev        # abre Remotion Studio en el navegador

La línea estable actual de Remotion es 4.0.471; necesita Node 16+ (o Bun 1.0.3+), y el renderizado local funciona en macOS 15 (Sequoia)+. Desde enero de 2026 Remotion incluye Agent Skills — npx skills add remotion-dev/skills conecta la guía consciente de Remotion en Claude Code. Ejecútalo dentro de un proyecto Remotion cuando quieras que la skill del framework se cargue junto con esta.

Fija fps y dimensiones en <Composition> primero, y nunca los cambies a mitad del proyecto. Por qué: cada duración aguas abajo se mide en fotogramas, y fotogramas = segundos * fps. Cambiar fps después de haber escrito duraciones cambia silenciosamente todas las temporizaciones. Los cortos verticales son 1080×1920 @ 30; paisaje es 1920×1080 @ 30.

El grafo de composición

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

export const RemotionRoot: React.FC = () => {
  return (
    <Composition
      id="MyVideo"            // el id que pasas a `remotion render`
      component={MyVideo}
      durationInFrames={300}  // 10s a 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})` }}>{/* escena 1 */}</AbsoluteFill>
      </Sequence>
      <Sequence from={90} durationInFrames={210}>{/* escena 2 */}</Sequence>
    </AbsoluteFill>
  );
};

Anima usando useCurrentFrame() con interpolate() y spring() solamente. Nunca leas la hora del reloj (Date.now()) ni llames a Math.random() sin semilla dentro de una composición. Por qué: el renderizado es paralelo y direccionable por fotograma — cada fotograma se calcula de forma independiente, por lo que cualquier entrada que no sea el fotograma produce un píxel diferente al volver a renderizar y rompe la garantía de "misma entrada, misma salida". Si necesitas aleatoriedad, usa random(seed) de Remotion.

Transiciones

Usa @remotion/transitions (disponible desde v4.0.53). <TransitionSeries> intercala .Sequence (un clip, con durationInFrames) y .Transition (un presentation + un timing). La duración de la transición se resta del total, por lo que las secuencias adyacentes se superponen durante la transición.

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

Cada presentación es una subimportación (@remotion/transitions/slide, /fade, /wipe, /flip, /clockWipe, /none).

PresentaciónSensación / Cuándo
slideLa escena empuja a la siguiente; impulso direccional entre beats
fadeFundido cruzado suave; cambio de escena tranquilo y neutro
wipeUn borde duro barre la pantalla; enérgico, "siguiente tema"
flipGiro 3D de tarjeta; divertido, para revelaciones
clockWipeBarrido radial; cuentas atrás, "paso del tiempo"
noneUn corte brusco sin movimiento, pero aún como nodo TransitionSeries

linearTiming para cortes predecibles y exactos en fotogramas; springTiming para movimiento orgánico. Por qué: linear es determinista en duración, por lo que puedes presupuestar fotogramas exactamente; spring sobrepasa y se asienta, lo que se lee como natural pero necesita durationRestThreshold para que el render sepa cuándo ha terminado.

Subtítulos animados quemados

El paquete nativo @remotion/captions se lanzó en v4.0.216 (la misma versión que eliminó el antiguo helper convertToCaptions()). El pipeline se ejecuta una vez en un servidor Node, luego la composición lee los subtítulos:

  1. Transcribe. @remotion/install-whisper-cpp descarga Whisper.cpp y un modelo (medium.en es ~1.5 GB) y transcribe el audio en un servidor Node a JSON de Whisper.
  2. Convierte. toCaptions() de @remotion/install-whisper-cpp convierte ese JSON en un Caption[] con marcas de tiempo por token. (convertToCaptions() es el alias heredado — obsoleto desde v4.0.216; usa toCaptions().)
  3. Segmenta en páginas. @remotion/captions createTikTokStyleCaptions({ captions, combineTokensWithinMilliseconds }) agrupa tokens en "páginas" que aparecen juntas.

El valor de combineTokensWithinMilliseconds es el dial del tamaño de página. Por qué: un valor bajo (~200ms) mantiene cada palabra en su propia página → animación de palabra por palabra al estilo TikTok; un valor alto (~1200ms) empaqueta una frase por página. ms bajo = energía palabra por palabra de TikTok; ms alto = frases legibles. Elige según el formato, no por defecto.

La instalación completa de Whisper.cpp, el servidor de transcripción y el componente renderizador de subtítulos con resaltado de tokens (con estilo de zona segura) están en references/captions-pipeline.md — léelo antes de construir la capa de subtítulos.

Eliminación automática de silencios

El paso de silencio se ejecuta en el audio/video fuente ANTES de que entre en Remotion, no dentro de una composición. Por qué: Remotion renderiza los fotogramas que le das; recortar el silencio es una edición ascendente del activo, y hacerlo primero significa que cada número de fotograma aguas abajo ya refleja la línea de tiempo ajustada.

Usa auto-editor (un motor de Python + ffmpeg) para un primer pase que corta el espacio muerto según el volumen del audio:

auto-editor input.mp4 --margin 0.2s --edit audio:threshold=4% -o tightened.mp4
  • --margin rellena cada región conservada para que los cortes no corten el habla.
  • --edit audio:threshold=4% establece el umbral de volumen por debajo del cual una región es "silencio".
  • --export premiere emite un EDL/XML en lugar de un archivo, para reimportarlo en un NLE.

La distribución pip está desactualizada/descontinuada — instálala mediante el binario oficial o pipx, no con pip install. Por qué: el paquete PyPI va por detrás y puede no coincidir con los flags documentados. Cuando auto-editor no está disponible, la alternativa de bajo nivel son los filtros silencedetect / silenceremove de ffmpeg. Ambos, con la matriz completa de flags, están en references/render-and-pipeline.md.

Superposiciones de b-roll

Apila la superposición encima del video principal colocando <OffthreadVideo> (o <Img>) dentro de un <AbsoluteFill>, controlado por un <Sequence from>:

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

const fps = 30;
const broll = { start: 4.0, duration: 3.0 }; // segundos
<AbsoluteFill>
  <OffthreadVideo src={staticFile("main.mp4")} />        {/* capa base */}
  <Sequence from={Math.round(broll.start * fps)} durationInFrames={Math.round(broll.duration * fps)}>
    <AbsoluteFill style={{ /* p. ej. recuadro para imagen en imagen */ }}>
      <OffthreadVideo src={staticFile("broll.mp4")} />    {/* capa de superposición */}
    </AbsoluteFill>
  </Sequence>
</AbsoluteFill>

Convierte cada código de tiempo a fotogramas con Math.round(segundos * fps), una vez, en el borde. Por qué: una señal de b-roll a 4.0s es el fotograma 120 a 30fps pero el fotograma 240 a 60fps — mantén los segundos en tus datos y multiplícalos por fps de useVideoConfig() para que cambiar fps nunca desincronice las superposiciones. Usa <OffthreadVideo> (no el <video> del DOM ni <Video>) para una decodificación precisa de fotogramas durante el renderizado.

Renderizar

# prueba de región primero: 1-2 segundos, valida el pipeline de forma económica
npx remotion render MyVideo out/test.mp4 --frames=0-45

# luego el render completo
npx remotion render MyVideo out/video.mp4

Omite el id de composición para obtener un selector interactivo. Configura mediante @remotion/cli/config en remotion.config.ts, o pasa flags en la CLI (los flags ganan):

// remotion.config.ts
import { Config } from "@remotion/cli/config";
Config.setConcurrency(8);
Config.setCodec("h264");
CódecUsoFlag
h264Predeterminado para web/YouTube; amplia compatibilidad(predeterminado)
h265Archivos más pequeños, misma calidad; reproducción menos universal--codec=h265
proresMaster de calidad de edición, archivos grandes, reimportación a un NLE--codec=prores --prores-profile=4444 --pixel-format=yuva444p10le --image-format=png
vp8 / gifVista previa con alfa web o en bucle--codec=vp8 / --codec=gif

Siempre renderiza una región de 1–2s (--frames=0-45) antes del render completo. Por qué: un render completo de una composición de minutos consume tiempo real y CPU; una prueba de región detecta una capa de subtítulos rota o un activo faltante en segundos. Para renders sin interfaz gráfica/CI, reglas de salida determinista y la matriz completa de códec/calidad, consulta references/render-and-pipeline.md.

Anti-patrones

MaloPor qué se rompeBueno
Hardcodear duraciones en segundos dentro de JSXRemotion piensa en fotogramas; los segundos se desincronizan en cuanto fps cambiaAlmacena segundos en datos, Math.round(segundos * fps) en el borde
Date.now() / Math.random() sin semilla en una composiciónLos fotogramas se renderizan en paralelo y al re-renderizar → píxeles no deterministasConduce todo con useCurrentFrame(); usa random(seed)
Cambiar fps después de escribir duracionesCada conteo de fotogramas aguas abajo se desplaza silenciosamenteFija fps + dimensiones en <Composition> desde el principio, déjalos
Redescargar el modelo Whisper cada ejecuciónLa descarga de ~1.5 GB de medium.en se repite y ralentiza el pipelineDescarga una vez, almacena en caché la ruta del modelo, reutilízalo
Subir el modelo Whisper de 1.5 GB a gitInfla el repositorio; el modelo es un activo de construcción.gitignore el directorio del modelo; obténlo en setup/CI
Renderizar el video completo para probar un cambioMinutos de render desperdiciados para encontrar una capa rotaPrueba de región --frames=0-45, luego render completo
Escribir el texto del subtítulo o hook aquíEso es el guion, no la codificaciónDeriva a ../video-shorts/SKILL.md; tú solo lo quemas
<video> / <Video> simple para b-roll en un renderNo es preciso en fotogramas; se rompe o salta en el render<OffthreadVideo> para decodificación exacta de fotogramas
Ejecutar la eliminación de silencios dentro de la composiciónRecortar silencio es una edición ascendente del activoauto-editor en el archivo fuente antes de Remotion

Verifica y referencias

  • bash scripts/verify.sh <project-dir> — comprueba que el proyecto Remotion esté bien formado y renderice. Con Node + ffmpeg presentes ejecuta npx remotion compositions para confirmar que existe un id de composición, hace un render de región corta a un MP4 temporal y usa ffprobe para confirmar un flujo de video con las dimensiones/fps esperados. Sin ellos, recurre a una comprobación estática: al menos un archivo .tsx de composición existe y el script de render referencia un id de composición real y una ruta de salida. Solo lectura por defecto; termina con 0 en un objetivo vacío/limpio.
  • references/captions-pipeline.md — instalación completa de Whisper.cpp + servidor de transcripción, toCaptions, componente renderizador de subtítulos con resaltado de tokens y notas de estilo/zona segura.
  • references/render-and-pipeline.md — comandos de silencio de auto-editor + ffmpeg, matriz completa de flags de render, render sin interfaz gráfica/CI, tabla de códecs y verificación con 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 relacionados