Guía 06 · Video · Claude Code · Remotion · 2026
Sin After Effects · sin timeline

Le hablo. Él escribe el código.
Sale un MP4.

Cómo hago un video desde cero con Claude Code y la skill de Remotion. Sin After Effects, sin timeline, sin mover keyframes a mano.

~2 minutos de setup · 1 comando para empezar · 0€ por video.

El recorrido
Empezá acá

Qué es Remotion.
Y qué hace la skill.

Remotion es un framework para hacer videos escribiendo código React. En vez de arrastrar clips en un timeline, escribís JSX, definís escenas, y exportás un MP4 desde la terminal.

Un video deja de ser "un archivo que editás" y se convierte en "un componente que renderizás". Eso significa: versionable en Git, parametrizable (1 plantilla = 100 videos) y, lo importante, escribible por un agente como Claude Code.

Pero Claude solo no escribe Remotion bien. Mete CSS animations que rompen al renderizar, calcula timing en milisegundos cuando debería ser en frames, y se inventa APIs que no existen. Por eso existe la Agent Skill de Remotion: 28 archivos de reglas que Claude carga sola al detectar un proyecto Remotion.

Sin la Skill
Claude improvisa.
Mezcla CSS keyframes con código React, calcula mal los frames, los renders fallan o salen bruscos.
Con la Skill
Claude usa Remotion bien.
Usa interpolate y spring, mide en frames, compone con Sequence. Sale a la primera.
Paso 01 · Setup

Un comando.
Y a correr.

Pre-requisitos: Node 18+ instalado y Claude Code. Nada más.

Opción A · Proyecto nuevo (recomendada)

terminal · proyecto nuevo
# elige tu package manager: npm, pnpm, yarn o bun
$ bun create video

# o: npm create video · pnpm create video · yarn create video

# te pregunta:
? Project name: my-video
? Template: blank
? TypeScript: Yes
? Add Agent Skills? Yes        # ← ESTO
? Install dependencies: Yes

Opción B · Ya tenés proyecto Remotion

terminal · proyecto existente
$ cd mi-proyecto-remotion

# instala las skills en .claude/skills/
$ npx skills add remotion-dev/skills

# o desde dentro de Remotion:
$ npx remotion skills add

Verificá que se instaló

terminal · verificar
$ ls .claude/skills/
remotion-best-practices/         # ← aquí está

$ ls .claude/skills/remotion-best-practices/
SKILL.md
rules/                           # 28 archivos de reglas
— La skill viaja con el proyecto
Vive en .claude/skills/, dentro del repo. Eso significa que se versiona en Git, que el equipo entero la usa igual, y que cada proyecto tiene SUS propias reglas.
Paso 02 · Anatomía

Qué hay dentro
del proyecto.

El comando te crea una estructura predecible. Lo importante son tres sitios: dónde vive la skill, dónde vive el código del video, y dónde sale el MP4.

my-video/ · estructura tras bun create video
my-video/
│
├── .claude/
│   └── skills/
│       └── remotion-best-practices/    # ← LA SKILL
│           ├── SKILL.md
│           └── rules/
│               ├── animations.md
│               ├── audio.md
│               ├── compositions.md
│               ├── subtitles.md
│               └── ... (24 más)
│
├── src/
│   ├── Root.tsx           # el "compositor": registra videos
│   ├── Composition.tsx    # el video en sí (JSX)
│   └── index.ts           # entry point
│
├── public/                # imágenes, audio, fuentes
├── out/                   # aquí saldrán los MP4
│
├── remotion.config.ts     # config de render
└── package.json

Los 3 archivos que vas a tocar

src/Composition.tsx · Aquí vive el video. Es un componente React. Claude lo edita por vos.
src/Root.tsx · Registra qué composiciones existen. Si añadís un video nuevo, aquí se anota.
remotion.config.ts · Formato de salida (codec, resolución). Casi nunca lo tocás.
Paso 03 · Mental model

El video se mide en frames,
no en segundos.

Esta es la idea que cambia todo. Si tu video va a 30 fps (frames por segundo), el frame 90 es el segundo 3. La animación nunca se piensa en "que dure 2 segundos". Se piensa en "que dure 60 frames".

La skill instala esa lógica en Claude. Por eso deja de mezclar CSS animations (que se miden en ms) con código de render (que se mide en frames).

Las 4 piezas que la skill le enseña a Claude

<Composition>
Define un video.
id, fps, width, height, durationInFrames. Todo fijo, declarativo.
<Sequence>
Escena con timing.
"Esto aparece en frame 30 y dura 60." Componés el video como Lego.
useCurrentFrame()
El frame actual.
Hook que devuelve qué frame se renderiza ahora. Toda animación parte de aquí.
interpolate + spring
Animaciones reales.
interpolate para movimiento lineal, spring para físico (rebote, aceleración natural).
— Lo que la skill prohíbe
Cero CSS animations (@keyframes, transition, animation). Cero setTimeout. Cero medir tiempo en milisegundos. Esto es lo que hace que los renders dejen de fallar.

Flujo mental

Paso 01
Defino duración
en frames
Paso 02
Compongo escenas
<Sequence>
Paso 03
Animo cada una
interpolate / spring
Paso 04
Renderizo
remotion render
Paso 04 · El prompt

Cómo le pido
un video real.

Abro Claude Code dentro de la carpeta del proyecto. La skill se carga sola en cuanto detecta el proyecto Remotion. No tengo que invocar nada.

El prompt no es "hacé un video chulo". Es específico: duración, escenas, ángulo. Cuanto más concreto, menos itera.

claude code · prompt template
Crea un video vertical de 20 segundos a 30 fps
(formato 1080×1920, para Reels/TikTok).

Composición se llama "hook-skills". Tres escenas:

Escena 1 · 0-180 frames (6 seg)
- Fondo crema (#F2EDE2)
- Texto centrado: "La mayoría usa Claude con un prompt suelto."
- Aparece con spring desde y=20 a y=0
- Tipografía: Inter, weight 800, color #1A1A1A

Escena 2 · 180-420 frames (8 seg)
- Mismo fondo
- Texto: "Yo tengo skills. Y dejé de pegar el mismo prompt 50×/día."
- Aparece línea a línea con stagger de 15 frames

Escena 3 · 420-600 frames (6 seg · CTA)
- Texto: "Comenta SKILLS y te paso las 5"
- Pulsa con spring cada 60 frames

Reglas:
- usa interpolate y spring, nunca CSS animations
- saca todo en frames, no en ms
- crea el componente en src/HookSkills.tsx
  y regístralo en src/Root.tsx
- si necesitas fuente, usa @remotion/google-fonts

Bien · y mal

Bien: duración en frames, fps explícito, dónde guardar el archivo, prohibir CSS animations.
Mal: "que dure unos 20 segundos", no decir dónde va el componente, asumir que Claude sabe la marca.
Paso 05 · El output

Esto es lo que
acaba escribiendo.

No tenés que escribir esto a mano. Claude lo hace solo. Lo dejo aquí para que veas cómo se ve un componente Remotion bien hecho. El tipo de código que la skill obliga a producir.

src/HookSkills.tsx · output de Claude Code
import {
  AbsoluteFill, Sequence, interpolate, spring,
  useCurrentFrame, useVideoConfig
} from "remotion";

export const HookSkills: React.FC = () => {
  return (
    <AbsoluteFill style={{ backgroundColor: "#F2EDE2" }}>
      <Sequence from={0} durationInFrames={180}>
        <Scene1 />
      </Sequence>
      <Sequence from={180} durationInFrames={240}>
        <Scene2 />
      </Sequence>
      <Sequence from={420} durationInFrames={180}>
        <Scene3CTA />
      </Sequence>
    </AbsoluteFill>
  );
};

// Escena 1 · texto entra con spring
const Scene1 = () => {
  const frame = useCurrentFrame();
  const { fps } = useVideoConfig();

  const y = spring({ frame, fps, from: 20, to: 0 });
  const opacity = interpolate(frame, [0, 15], [0, 1], {
    extrapolateRight: "clamp"
  });

  return (
    <AbsoluteFill style={{
      justifyContent: "center",
      alignItems: "center",
      transform: `translateY(${y}px)`,
      opacity,
    }}>
      <h1 style={{
        fontFamily: "Inter",
        fontWeight: 800,
        fontSize: 72,
        textAlign: "center",
        padding: "0 80px",
        color: "#1A1A1A",
      }}>
        La mayoría usa Claude
      </h1>
    </AbsoluteFill>
  );
};

// Scene2 y Scene3CTA siguen el mismo patrón
// con spring + interpolate.
— Lo que está bien
Medido en frames, animaciones con spring e interpolate, escenas separadas con <Sequence>. Cero CSS animations. Es lo que la skill obliga.
Paso 06 · Render

Del preview
al MP4 final.

Mientras Claude trabaja, dejo el preview corriendo en otra pestaña. Veo cada cambio en directo. Cuando me gusta, renderizo.

Preview en vivo · localhost:3000

terminal · preview
# abre Remotion Studio en el navegador
$ bun run dev          # o: npm run dev

# → http://localhost:3000
# → ves el video, scrubs por frames, ajustás mientras Claude edita

Render a MP4

terminal · render
# básico · saca el MP4 a out/hook-skills.mp4
$ npx remotion render hook-skills out/hook-skills.mp4

# vertical para Reels/TikTok (1080×1920)
$ npx remotion render hook-skills out/reel.mp4 \
    --width=1080 --height=1920

# calidad alta (CRF más bajo = más calidad, archivo más grande)
$ npx remotion render hook-skills out/hd.mp4 --crf=18

# como GIF para preview rápido
$ npx remotion render hook-skills out/preview.gif --codec=gif

# mismo video, distinto texto (parametrizado)
$ npx remotion render hook-skills out/v2.mp4 \
    --props='{"hook":"Otro hook diferente"}'
— Atajo · 1 plantilla = 100 videos
El último comando es la magia real. Si parametrizás tu Composition (le pasás el texto del hook como prop), tirás un script que renderiza 100 versiones distintas con 100 hooks distintos en una noche. Eso separa "hago videos" de "tengo un sistema".
Debug

Lo que se rompe
la primera vez.

No es que vaya a salir mal. Es que va a salir mal de una de estas formas concretas. Aquí tenés el desbloqueo de cada una.

01
"Claude no usa la skill, da código mediocre"
Pasa cuando la skill se instaló global pero el proyecto está en local. Fuérzala dentro de Claude Code con /skill remotion-best-practices, o nómbrala en el prompt: "Usando las reglas de remotion-best-practices, crea...".
02
"El render falla con error raro de Chrome"
Casi siempre son CSS animations que Claude metió a pesar de la skill. Buscalas con grep -rn "@keyframes\|animation:\|transition:" src/ y pedile reescribirlas con interpolate y spring.
03
"El video va a tirones, no fluye"
Casi siempre Claude usó interpolate donde debía usar spring. interpolate es lineal y los humanos vemos lineal como rígido. spring imita física natural.
04
"Quiero música pero no sé dónde meterla"
Ponés el archivo en public/audio.mp3 y le decís a Claude: "añade audio.mp3 al video con fade in de 30 frames y fade out de 30 frames al final, usando <Audio> y volumen interpolado". La skill sabe el patrón.
— Regla rápida · spring vs interpolate
Movimiento (entrar, salir, escalar): spring. Cambios suaves de valor (opacidad de 0 a 1, color, número que cuenta): interpolate. Si dudás, probá spring primero.
El truco

Esto solo no sirve.
Combínalo con lo demás.

Un video Remotion suelto es un MP4 chulo en una carpeta. Donde se vuelve sistema es cuando lo enchufás con las otras skills que ya tenés.

Combo 01 · IDEA → GUION
brand-voice → prompt
Pedís un guion de 20s a brand-voice. Lo pegás tal cual al prompt de Remotion. El video sale en tu voz.
Combo 02 · 1 VIDEO → 4 PIEZAS
render → repurpose
Sacás el MP4. Le das el guion a content-repurpose. Tenés carrusel + tweet + email del mismo ángulo.
Ver la skill de carruseles →
Combo 03 · ESCALA
1 plantilla → 50 reels
Parametrizás la Composition con un campo hook. Tirás un script que llama npx remotion render 50 veces con 50 hooks distintos. Te despertás con 50 reels listos.
— El último consejo · el de verdad
El primer video va a salir feo. El segundo, decente. El cuarto, ya enseñable. La skill no te hace senior en Remotion. Te hace operativo. Lo que separa los videos buenos de los regulares no es la skill: es el guion. Trabajá el guion antes que la animación. Siempre.
— el siguiente paso

La guía te enseña.
La comunidad te lo monta con vos.

Dentro de la comunidad: skills nuevas cada semana, plantillas parametrizadas listas para tirar 50 videos en una noche, sesiones de guion para tus reels, y casos reales de gente publicando con Claude todos los días.

Ver todas las guías →