Communitygithub.com

ericrisco/rsc-harness

Use quando você precisa renderizar um arquivo de vídeo real com Remotion — compõe composições React, grafos de Composition/Sequence/TransitionSeries, transições, legendas animadas palavra por palavra a partir de uma transcrição, remoção automática de silêncio, sobreposições de b-roll, renders headless para CI e um MP4 ou MOV final. NÃO escreve o script, gancho, batidas ou texto das legendas (isso é `video-shorts`), NÃO masteriza áudio para LUFS ou constrói um feed RSS (isso é `podcast`), NÃO estrutura o arco narrativo (isso é `course-storytelling`).

O que é rsc-harness?

Esta skill capacita o agente a atuar como o codificador e renderizador de vídeos usando o framework Remotion, transformando ativos como gravações, narrações, b-roll e transcrições em um arquivo de vídeo real (out/video.mp4). Ela gerencia todo o ciclo de renderização determinística — mesmo input, mesma saída — garantindo que cada frame seja reproduzível. A skill é projetada para plataformas como Claude Code e Cursor, e oferece suporte a composições React, transições (slide, fade, wipe, flip, clockWipe), legendas animadas incorporadas via pipeline Whisper.cpp + toCaptions + createTikTokStyleCaptions, remoção de silêncio com auto-editor, e sobreposições de b-roll com <OffthreadVideo>. Ela enfatiza a conversão rigorosa de timecodes para frames, o uso exclusivo de useCurrentFrame() para animações (evitando Date.now() ou Math.random()), e a validação com renders de teste de região curta antes da renderização completa. Além disso, define claramente limites: não escreve scripts, hooks ou legendas (isso é da skill video-shorts), não masteriza áudio (podcast) e não estrutura narrativas (course-storytelling).

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

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Vídeo Remotion — Codifique os Quadros Reais

Você é o codificador e renderizador. Você pega ativos — uma gravação, uma narração, b-roll, uma transcrição — mais código React, e emite um arquivo real: out/video.mp4. Seus irmãos escrevem palavras e planos; você é o único que produz pixels. O rigor aqui é quadros reproduzíveis: mesma entrada, mesma saída determinística, verificada por uma renderização que o ffprobe pode ler.

Você possui o scaffold do projeto Remotion, o grafo <Composition> / <Sequence> / <TransitionSeries>, o pipeline de legendas (Whisper.cpp → toCaptions → createTikTokStyleCaptions), a passagem de remoção de silêncio e a invocação npx remotion render com suas flags de codec e concorrência.

A única decisão: quadros ou palavras?

Se a solicitação é produzir um arquivo, você está no lugar certo. Se é produzir texto ou um plano, desvie antes de escrever um único .tsx.

A solicitaçãoVai paraPor quê
Produzir um MP4/MOV, transições, legendas incorporadas, renderizaçãoaquiSão pixels e quadros
Escrever o script, gancho, batidas, texto das legendas na tela, folha de decisão de edição../video-shorts/SKILL.mdSão palavras; as decisões de corte, não a execução do corte
Masterizar áudio para um alvo LUFS, produzir capítulos + <item> RSS../podcast/SKILL.mdMasterização de áudio e feed, não codificação de vídeo
Estruturar o arco narrativo da lição/vídeo e o fluxo../course-storytelling/SKILL.mdArquitetura narrativa, não renderização
Projetar a miniatura../youtube-thumbnails/SKILL.mdUma imagem estática, não um vídeo

Fronteira em uma linha: video-shorts decide os cortes e escreve o texto das legendas; você executa os cortes em código e incorpora as legendas nos quadros.

Scaffold do projeto

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

A linha estável atual do Remotion é 4.0.471; precisa de Node 16+ (ou Bun 1.0.3+), e a renderização local tem como alvo macOS 15 (Sequoia)+. Desde janeiro de 2026, o Remotion entrega Skills de Agente — npx skills add remotion-dev/skills conecta orientação consciente do Remotion ao Claude Code. Execute isso dentro de um projeto Remotion quando quiser que a própria skill do framework seja carregada junto com esta.

Fixar fps e dimensões no <Composition> primeiro, e nunca mudá-los no meio do projeto. Por quê: toda duração downstream é medida em quadros, e quadros = segundos * fps. Mude o fps depois de escrever durações e toda temporização muda silenciosamente. Verticais curtos são 1080×1920 @ 30; paisagem é 1920×1080 @ 30.

O grafo de composição

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

export const RemotionRoot: React.FC = () => {
  return (
    <Composition
      id="MyVideo"            // o id que você passa para `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})` }}>{/* cena 1 */}</AbsoluteFill>
      </Sequence>
      <Sequence from={90} durationInFrames={210}>{/* cena 2 */}</Sequence>
    </AbsoluteFill>
  );
};

Anime usando useCurrentFrame() com interpolate() e spring() apenas. Nunca leia hora do relógio de parede (Date.now()) ou chame Math.random() sem semente dentro de uma composição. Por quê: a renderização é paralela e endereçável por quadro — cada quadro é calculado independentemente, portanto qualquer entrada não-quadro produz um pixel diferente na re-renderização e quebra a garantia de "mesma entrada, mesma saída". Se precisar de aleatoriedade, use o random(seed) do Remotion.

Transições

Use @remotion/transitions (disponível desde v4.0.53). <TransitionSeries> intercala .Sequence (um clipe, com durationInFrames) e .Transition (uma presentation + uma timing). A duração da transição é subtraída do total, então sequências adjacentes se sobrepõem durante o wipe.

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

Cada apresentação é uma sub-importação (@remotion/transitions/slide, /fade, /wipe, /flip, /clockWipe, /none).

ApresentaçãoSensação / quando
slideCena empurra a próxima para dentro; momentum direcional entre batidas
fadeCrossfade suave; mudança de cena calma e neutra
wipeUma borda dura varre; enérgico, "próximo tópico"
flipGiro 3D de cartão; divertido, para revelações
clockWipeVarredura radial; contagens regressivas, "passagem do tempo"
noneUm corte brusco sem movimento, mas ainda como um nó TransitionSeries

linearTiming para cortes previsíveis e exatos em quadros; springTiming para movimento orgânico. Por quê: linear é determinístico em duração, então você pode orçar quadros exatamente; spring ultrapassa e se estabiliza, o que parece natural, mas precisa de durationRestThreshold para que a renderização saiba quando terminou.

Legendas animadas incorporadas

O pacote nativo @remotion/captions foi enviado na v4.0.216 (o mesmo lançamento que descontinuou o antigo helper convertToCaptions()). O pipeline é executado uma vez em um servidor Node, então a composição lê as legendas:

  1. Transcrever. @remotion/install-whisper-cpp baixa o Whisper.cpp e um modelo (medium.en tem ~1.5 GB) e transcreve o áudio em um servidor Node para JSON do Whisper.
  2. Converter. toCaptions() de @remotion/install-whisper-cpp transforma esse JSON em um Caption[] com timestamps por token. (convertToCaptions() é o alias legado — descontinuado desde v4.0.216; use toCaptions().)
  3. Segmentar em páginas. @remotion/captions createTikTokStyleCaptions({ captions, combineTokensWithinMilliseconds }) agrupa tokens em "páginas" que aparecem juntas.

O valor combineTokensWithinMilliseconds é o dial do tamanho da página. Por quê: um valor baixo (~200ms) mantém cada palavra em sua própria página → animação pop palavra por palavra; um valor alto (~1200ms) empacota uma frase por página. Ms baixo = energia palavra por palavra ao estilo TikTok; ms alto = frases legíveis. Escolha pelo formato, não por padrão.

A instalação completa do Whisper.cpp, o servidor de transcrição e o componente renderizador de legendas com destaque de token (com estilização de zona segura) estão em references/captions-pipeline.md — leia antes de construir a camada de legendas.

Remoção automática de silêncio

A passagem de silêncio é executada no áudio/vídeo de origem ANTES de entrar no Remotion, não dentro de uma composição. Por quê: o Remotion renderiza os quadros que você fornece; aparar ar morto é uma edição upstream no ativo, e fazer isso primeiro significa que cada número de quadro downstream já reflete a linha do tempo apertada.

Use auto-editor (um mecanismo Python + ffmpeg) para uma primeira passagem que corta espaços mortos pela intensidade do áudio:

auto-editor input.mp4 --margin 0.2s --edit audio:threshold=4% -o tightened.mp4
  • --margin preenche cada região mantida para que os cortes não cortem a fala.
  • --edit audio:threshold=4% define o piso de intensidade abaixo do qual uma região é "silêncio".
  • --export premiere emite um EDL/XML em vez de um arquivo, para reimportar em um NLE.

A distribuição pip está desatualizada/descontinuada — instale via binário oficial ou pipx, não pip install. Por quê: o pacote PyPI está defasado e pode não corresponder às flags documentadas. Quando auto-editor não está disponível, a alternativa de baixo nível são os filtros silencedetect / silenceremove do ffmpeg. Ambos, com a matriz completa de flags, estão em references/render-and-pipeline.md.

Sobreposições de b-roll

Empilhe a sobreposição acima do vídeo principal colocando <OffthreadVideo> (ou <Img>) dentro de um <AbsoluteFill>, controlado por um <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")} />        {/* camada base */}
  <Sequence from={Math.round(broll.start * fps)} durationInFrames={Math.round(broll.duration * fps)}>
    <AbsoluteFill style={{ /* ex.: recuo para picture-in-picture */ }}>
      <OffthreadVideo src={staticFile("broll.mp4")} />    {/* camada de sobreposição */}
    </AbsoluteFill>
  </Sequence>
</AbsoluteFill>

Converta cada timecode para quadros com Math.round(segundos * fps), uma vez, na borda. Por quê: uma dica de b-roll em 4.0s é o quadro 120 a 30fps, mas quadro 240 a 60fps — mantenha segundos em seus dados e multiplique por fps de useVideoConfig() para que mudar o fps nunca dessincronize sobreposições. Use <OffthreadVideo> (não o <video> do DOM ou <Video>) para decodificação precisa de quadros durante a renderização.

Renderizar

# teste de região primeiro: 1-2 segundos, valida o pipeline de forma barata
npx remotion render MyVideo out/test.mp4 --frames=0-45

# depois a renderização completa
npx remotion render MyVideo out/video.mp4

Omita o id da composição para obter um seletor interativo. Configure via @remotion/cli/config em remotion.config.ts, ou passe flags na CLI (flags vencem):

// remotion.config.ts
import { Config } from "@remotion/cli/config";
Config.setConcurrency(8);
Config.setCodec("h264");
CodecUsoFlag
h264Padrão para web/YouTube; ampla compatibilidade(padrão)
h265Arquivos menores, mesma qualidade; reprodução menos universal--codec=h265
proresMaster de qualidade de edição, arquivos grandes, reimportar para um NLE--codec=prores --prores-profile=4444 --pixel-format=yuva444p10le --image-format=png
vp8 / gifWeb-alpha ou prévias em loop--codec=vp8 / --codec=gif

Sempre renderize uma região de 1-2s (--frames=0-45) antes da renderização completa. Por quê: uma renderização completa de uma composição de minutos custa tempo e CPU reais; um teste de região revela uma camada de legenda quebrada ou ativo faltando em segundos. Para renders headless/CI, regras de saída determinística e a matriz de codec/qualidade completa, veja references/render-and-pipeline.md.

Anti-padrões

RuimPor que quebraBom
Codificar durações em segundos dentro do JSXRemotion pensa em quadros; segundos dessincronizam quando o fps mudaArmazene segundos em dados, Math.round(segundos * fps) na borda
Date.now() / Math.random() sem semente em uma composiçãoQuadros renderizam em paralelo e na re-renderização → pixels não determinísticosDirija tudo a partir de useCurrentFrame(); use random(seed)
Mudar fps depois de escrever duraçõesCada contagem de quadro downstream muda silenciosamenteFixe fps + dimensões no <Composition> de início, deixe-os
Rebaixar o modelo Whisper toda execuçãoO download de ~1.5 GB medium.en repete e empaca o pipelineBaixe uma vez, armazene em cache o caminho do modelo, reutilize
Commit do modelo Whisper de 1.5 GB no gitInchação do repositório; o modelo é um ativo de build.gitignore o diretório do modelo; busque no setup/CI
Renderizar o vídeo completo para testar uma mudançaMinutos de renderização desperdiçados para encontrar uma camada quebradaTeste de região --frames=0-45, depois renderização completa
Escrever o texto da legenda ou gancho aquiIsso é o script, não a codificaçãoDirecione para ../video-shorts/SKILL.md; você só incorpora
<video> simples / <Video> para b-roll em uma renderizaçãoNão é preciso em quadros; rasga ou pula na renderização<OffthreadVideo> para decodificação exata de quadros
Executar remoção de silêncio dentro da composiçãoAparar ar morto é uma edição upstream do ativoauto-editor no arquivo de origem antes do Remotion

Verificar & referências

  • bash scripts/verify.sh <project-dir> — verifica se o projeto Remotion está bem formado e renderiza. Com Node + ffmpeg presentes, executa npx remotion compositions para confirmar que um id de composição existe, faz uma renderização curta de região para um MP4 temporário e usa ffprobe para confirmar um fluxo de vídeo com as dimensões/fps esperados. Sem nenhum dos dois, cai para uma verificação estática: pelo menos um .tsx de composição existe e o script de renderização referencia um id de composição real e um caminho de saída. Somente leitura por padrão; sai com 0 em um alvo vazio/limpo.
  • references/captions-pipeline.md — instalação completa do Whisper.cpp + servidor de transcrição, toCaptions, componente renderizador de legendas com destaque de token e notas de estilização/zona segura.
  • references/render-and-pipeline.md — comandos de silêncio do auto-editor + ffmpeg, matriz completa de flags de renderização, render headless/CI, tabela de codecs e verificação 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`).

Habilidades Relacionadas