Storyboard de Video
Haz esto ANTES de que se anime un solo fotograma. Un video demo vive o muere por su plan: el orden incorrecto, un gancho faltante o una duración de 40 segundos lo matan, sin importar lo limpio que sea el movimiento. Eres la capa artesanal que decide qué escenas existen, en qué orden, por cuánto tiempo y qué dice cada una; luego entrega un plan de escenas concreto al paquete de mecánicas (remotion-setup, remotion-compose, remotion-render) para que lo construyan.
Actúa con entusiasmo ante intenciones de planificación: "storyboardea mi demo", "planifica el video", "qué escenas necesito", "traza el video de lanzamiento", "divide esta función en escenas." Si el usuario salta directamente a "anima esto", igualmente ejecuta la hoja de ritmos primero; un storyboard lleva dos minutos y evita un re-renderizado.
Trabaja con un ejemplo durante todo el proceso: un video de lanzamiento de 30 segundos para una herramienta de revisión de código con IA llamada Sentinel que señala diferencias riesgosas antes de la fusión.
Procedimiento operativo
Ejecuta estos pasos en orden. No escribas el texto antes de que los ritmos estén fijos, ni establezcas duraciones antes de que existan los ritmos; el ritmo es una función de la estructura, y no al revés.
Paso 1: Fijar el objetivo de una línea y la plataforma
Antes de los ritmos, fija dos cosas:
- La única conclusión. Una oración que el espectador debe recordar: "Sentinel detecta el error que pasó desapercibido para tu revisor." Si no puedes decirlo en una línea, el video no tiene columna vertebral. Todo lo que sigue sirve a esta línea.
- Plataforma y relación de aspecto. Horizontal 16:9 (1920×1080) para un héroe de sitio web o YouTube; vertical 9:16 (1080×1920) para redes sociales/Shorts; cuadrado 1:1 para feeds. Esto establece el lienzo que
remotion-composecreará y limita la duración: las redes sociales quieren 15-30s, un bucle héroe 20-40s, un tutorial de función hasta 60s.
Paso 2: Colocar la hoja de ritmos (la columna vertebral de cinco ritmos)
Cada demo, anuncio y video de lanzamiento es una versión de estos cinco ritmos. Omite un ritmo solo con una razón; nunca reordenes antes del gancho.
- Gancho (primeros 3 segundos). Los 3 segundos más importantes del video: aquí los espectadores deciden si seguir viendo. Abre con el resultado, la tensión o una afirmación audaz, NO con tu logotipo. "Tu revisor acaba de aprobar un error" vence a "Presentamos Sentinel." El logotipo puede estar en la esquina; no es el gancho.
- Problema. Nombra el dolor concreto que el espectador ya siente. "Las diferencias riesgosas se escapan de la revisión un viernes a las 5 p. m." Un ritmo, un dolor.
- Revelación. Presenta el producto como el punto de inflexión. Aquí es donde aparece el nombre y la mecánica central. Muestra la cosa haciendo la cosa.
- Prueba. Haz creíble la afirmación: un antes/después real, un número real, una pantalla real. Este es el ritmo que la mayoría de los videos omiten y el que convierte. Usa datos reales del producto, nunca métricas inventadas.
- CTA. Una acción, una URL. "Prueba Sentinel gratis → sentinel.dev." Nunca dos peticiones.
Para un tutorial más largo, los ritmos de Revelación y Prueba se repiten por función (revelar función 1 → prueba, revelar función 2 → prueba). El gancho, el problema y la CTA se mantienen únicos.
Paso 3: Asignar un tipo de escena y una duración objetivo a cada ritmo
Cada ritmo se convierte en una o más escenas. El tipo de escena determina el ritmo: el texto necesita tiempo de lectura, una demo de interfaz de usuario necesita tiempo de permanencia, un logotipo es rápido. Usa estos objetivos (a 30 fps; durationInFrames = segundos × fps):
| Tipo de escena | Duración objetivo | Por qué |
|---|---|---|
| Gancho / título | 2.5-3.5s | Suficientemente largo para leer una línea, lo suficientemente corto para mantener la apertura ajustada |
| Declaración de texto | 2.5-4s | Velocidad de lectura ~2.5 palabras/segundo; una línea de 7 palabras necesita ~3s en pantalla |
| Interfaz de usuario / demo de producto | 4-6s | El ojo necesita tiempo de permanencia para analizar una pantalla y el movimiento dentro de ella |
| Prueba / datos | 3-5s | Un número o un antes/después necesita un tiempo para registrarse |
| Logotipo / CTA final | 2.5-4s | Leer la URL, dejarla respirar, terminar |
Regla de ritmo: el gancho es el corte más rápido, la prueba es el más lento. Si la duración total se alarga, corta una escena; no aceleres cada escena. Una demo apresurada se lee como nerviosa.
Paso 4: Escribir la lista de tomas (texto + visual por escena)
Para cada escena, fija cuatro campos: el ritmo al que sirve, el tipo de escena, el texto en pantalla (las palabras reales: pregunta al usuario, nunca inventes afirmaciones) y una descripción visual de una línea que le indique a remotion-compose qué renderizar. Este es el entregable. La línea visual es un resumen, no código: "el terminal escribe una diferencia de git, una línea riesgosa se resalta en rojo" – remotion-compose decide las mecánicas de interpolate/spring.
Paso 5: Emitir el plan JSON de escenas
Ejecuta el generador a continuación para convertir la lista de tomas en un scene-plan.json estructurado. Este es el artefacto que se entrega: remotion-compose lo lee como el plan de escenas (un <Sequence> por escena, from/durationInFrames ya calculados), y la pista de motion por escena es donde una decisión de motion-design-principles o motion-color-and-light se conecta. Guárdalo junto al proyecto para que el paquete de mecánicas pueda recogerlo.
Paso 6: Entrega
Entrégale al usuario la hoja de ritmos, la tabla de lista de tomas y el JSON. Luego entrega explícitamente: "Aquí está el plan de escenas. remotion-setup si el proyecto aún no está armado, luego remotion-compose convertirá este JSON en la composición y remotion-render lo exportará. ¿Quieres que ajuste el ritmo o el texto antes de que animemos?" Si el video es específicamente una demo de producto y quieres una mirada de director sobre qué mostrar en pantalla por escena, combínalo con product-demo-director. Los tratamientos cinéticos de títulos van a kinetic-typography; la banda sonora y los cortes sincronizados con el ritmo van a sound-and-music-sync; un recorte vertical para redes sociales va a social-video-formatter.
Barra de calidad
Un storyboard es A+ solo cuando se cumplen todos:
- El gancho aterriza en los primeros 3 segundos y NO es el logotipo: abre con resultado, tensión o afirmación.
- Los cinco ritmos están presentes, o cada ritmo faltante tiene una razón declarada (un avance puede omitir legítimamente la Prueba).
- Cada escena tiene una línea de texto real y un resumen visual concreto: nada de "alguna interfaz aquí," nada de métricas inventadas.
- La duración total se ajusta al límite de la plataforma, y las duraciones siguen la tabla de tipos de escena (gancho rápido, prueba lenta), no un corte plano cada 3 s.
- La CTA es una acción única con una URL única.
- El JSON se valida y sus duraciones sumadas son iguales al total de la composición que
remotion-composeregistrará; un desajuste es la #1 sorpresa de renderizado.
NO HAGAS
- NO abras con un logotipo o un título de fundido lento: pierdes al espectador antes del gancho.
- NO inventes números, testimonios o afirmaciones de producto para el ritmo de Prueba; pide datos reales o elimina el ritmo.
- NO escribas el
.tsx, elijas rangos deinterpolateo establezcasdampingdespringaquí; eso es pararemotion-compose. Esta habilidad produce un plan, no código. - NO des el mismo ritmo a cada escena; un corte plano de 3 s hace que la demo se sienta como una presentación de diapositivas.
- NO apiles dos CTA o dos URL; una petición convierte, dos dividen la atención.
- NO dejes que la duración supere el límite de la plataforma para incluir más; mejor corta una escena.
Generador
Script de Node autónomo. Guárdalo como scene_plan.js, edita el array beats para el video en cuestión y ejecuta node scene_plan.js > scene-plan.json. Sin dependencias. Calcula los desplazamientos de fotogramas, valida el total y emite el plan que consume remotion-compose.
// Storyboard -> plan de escenas. Edita `meta` y `beats`, luego:
// node scene_plan.js > scene-plan.json
const meta = {
title: 'Sentinel Launch',
fps: 30,
width: 1920, // 1080 para 9:16 vertical, 1080 cuadrado
height: 1080, // 1920 para 9:16 vertical, 1080 cuadrado
}
// Una fila por escena. `seconds` sigue la tabla de tipos de escena.
// `motion` es una pista para motion-design-principles / motion-color-and-light;
// es un resumen, no código.
const beats = [
{ beat: 'hook', type: 'title', seconds: 3.0, copy: 'Tu revisor acaba de aprobar un error.', visual: 'Pantalla oscura, una línea de código se escribe; una línea se vuelve roja.', motion: 'rápido, baja amortiguación en la bandera roja' },
{ beat: 'problem', type: 'text', seconds: 3.5, copy: 'Las diferencias riesgosas se escapan de la revisión un viernes a las 5 p. m.', visual: 'Motivo de calendario/reloj, un PR marcado como fusionado.', motion: 'fundido tranquilo, sin sobrepaso' },
{ beat: 'reveal', type: 'ui', seconds: 5.0, copy: 'Sentinel revisa cada diferencia antes de la fusión.', visual: 'Sentinel escanea la misma diferencia, muestra la línea riesgosa con una razón.', motion: 'barrido de escaneo, luego asentamiento' },
{ beat: 'proof', type: 'proof', seconds: 4.5, copy: 'Detectado en PR reales. Antes de que se enviara.', visual: 'Antes/después: bandera roja -> diferencia corregida, captura de pantalla real.', motion: 'disolución cruzada lenta, mantener' },
{ beat: 'cta', type: 'cta', seconds: 3.0, copy: 'Prueba Sentinel gratis -> sentinel.dev', visual: 'Logotipo + URL en color de marca.', motion: 'pop suave, final limpio' },
]
const fps = meta.fps
let from = 0
const scenes = beats.map((b, i) => {
const durationInFrames = Math.round(b.seconds * fps)
const scene = {
id: `${i + 1}-${b.beat}`,
beat: b.beat,
type: b.type,
from,
durationInFrames,
seconds: b.seconds,
copy: b.copy,
visual: b.visual,
motion: b.motion,
}
from += durationInFrames
return scene
})
const durationInFrames = from
const totalSeconds = durationInFrames / fps
const hook = scenes[0]
const warnings = []
if (hook.beat !== 'hook') warnings.push('La primera escena no es el gancho.')
if (hook.seconds > 3.5) warnings.push('El gancho dura más de 3.5 s: ajusta la apertura.')
if (scenes.filter((s) => s.beat === 'cta').length > 1) warnings.push('Más de una CTA.')
if (!scenes.some((s) => s.beat === 'proof')) warnings.push('No hay ritmo de prueba: es posible que la afirmación no convierta.')
if (totalSeconds > 60) warnings.push(`Duración ${totalSeconds}s supera el límite de 60 s: corta una escena.`)
const plan = {
composition: {
id: meta.title.replace(/[^A-Za-z0-9]/g, ''),
fps,
width: meta.width,
height: meta.height,
durationInFrames, // remotion-compose registra exactamente esto en el <Composition>
},
scenes,
meta: { totalSeconds, sceneCount: scenes.length, warnings },
}
process.stdout.write(JSON.stringify(plan, null, 2) + '\n')
if (warnings.length) console.error('ADVERTENCIAS:\n - ' + warnings.join('\n - '))
Ejemplo de salida del ejemplo trabajado
Con los beats anteriores, el script escribe scene-plan.json:
{
"composition": {
"id": "SentinelLaunch",
"fps": 30,
"width": 1920,
"height": 1080,
"durationInFrames": 570
},
"scenes": [
{ "id": "1-hook", "beat": "hook", "type": "title", "from": 0, "durationInFrames": 90, "seconds": 3.0, "copy": "Tu revisor acaba de aprobar un error.", "visual": "Pantalla oscura, una línea de código se escribe; una línea se vuelve roja.", "motion": "rápido, baja amortiguación en la bandera roja" },
{ "id": "2-problem", "beat": "problem", "type": "text", "from": 90, "durationInFrames": 105, "seconds": 3.5, "copy": "Las diferencias riesgosas se escapan de la revisión un viernes a las 5 p. m.", "visual": "Motivo de calendario/reloj, un PR marcado como fusionado.", "motion": "fundido tranquilo, sin sobrepaso" },
{ "id": "3-reveal", "beat": "reveal", "type": "ui", "from": 195, "durationInFrames": 150, "seconds": 5.0, "copy": "Sentinel revisa cada diferencia antes de la fusión.", "visual": "Sentinel escanea la misma diferencia, muestra la línea riesgosa con una razón.", "motion": "barrido de escaneo, luego asentamiento" },
{ "id": "4-proof", "beat": "proof", "type": "proof", "from": 345, "durationInFrames": 135, "seconds": 4.5, "copy": "Detectado en PR reales. Antes de que se enviara.", "visual": "Antes/después: bandera roja -> diferencia corregida, captura de pantalla real.", "motion": "disolución cruzada lenta, mantener" },
{ "id": "5-cta", "beat": "cta", "type": "cta", "from": 480, "durationInFrames": 90, "seconds": 3.0, "copy": "Prueba Sentinel gratis -> sentinel.dev", "visual": "Logotipo + URL en color de marca.", "motion": "pop suave, final limpio" }
],
"meta": { "totalSeconds": 19, "sceneCount": 5, "warnings": [] }
}
Léelo: 5 escenas, 570 fotogramas = 19 s a 30 fps, muy por debajo del límite de redes sociales. El gancho dura 3 s y abre con tensión, no con un logotipo. El ritmo de prueba (4.5 s) es el corte más lento; el gancho y la CTA (3 s) son los más ajustados. Sin advertencias, por lo que está listo para remotion-compose, que registra un <Composition durationInFrames={570}> y un <Sequence from={…} durationInFrames={…}> por escena, leyendo from y durationInFrames directamente de este archivo.
Plantilla: lista de tomas
Usa esta cuando quieras la tabla legible para humanos junto con el JSON. Reemplaza los campos LLENAR con el video real.
STORYBOARD DE VIDEO. [LLENAR: nombre del video]. [LLENAR: plataforma / relación de aspecto]
Objetivo (una línea): [LLENAR: la única conclusión]
Duración objetivo: [LLENAR: 15-30 s redes sociales / 20-40 s héroe / hasta 60 s tutorial]
RITMO TIPO DE ESCENA DURACIÓN TEXTO EN PANTALLA (palabras reales) RESUMEN VISUAL
Gancho título [LLENAR]s [LLENAR: resultado/tensión/afirmación] [LLENAR]
Problema texto [LLENAR]s [LLENAR: un dolor concreto] [LLENAR]
Revelación interfaz [LLENAR]s [LLENAR: producto + mecánica central] [LLENAR]
Prueba prueba [LLENAR]s [LLENAR: número real / antes-después] [LLENAR]
CTA cta [LLENAR]s [LLENAR: una acción + una URL] [LLENAR]
(repite Revelación + Prueba por función para un tutorial)
TOTAL: [LLENAR]s (debe ser igual a composition.durationInFrames / fps del JSON)
ENTREGA: scene-plan.json -> remotion-compose
referencias/por-que-los-primeros-3-segundos
Los espectadores deciden si seguir viendo en los primeros ~3 segundos, por lo que el gancho no es el lugar para tu logotipo o un fundido lento. Abre con el resultado o la tensión: el error que se envió, el número que cayó, la afirmación que detiene el desplazamiento. El logotipo puede estar en una esquina todo el tiempo; convertirlo en la apertura gasta tus segundos más valiosos en el contenido menos persuasivo. Si solo logras un ritmo, logra este.
referencias/ritmo-por-tipo-de-escena
Diferentes escenas necesitan diferentes tiempos en pantalla, y un corte plano cada N segundos se lee como una presentación de diapositivas:
- Título/gancho - rápido. Una línea, entrada rápida, corta antes de que se vuelva obsoleto.
- Texto - da tiempo de lectura. Las personas leen ~2.5 palabras/segundo; una línea de 7 palabras necesita ~3 s, una línea de 12 palabras ~5 s. Subestimar el tiempo del texto es el error más común de ritmo.
- Interfaz de usuario / demo - da tiempo de permanencia. El ojo necesita ~4-6 s para analizar una pantalla, encontrar el movimiento y entenderlo.
- Prueba / datos - el corte más lento. Un número o una comparación necesita un momento para registrarse; apresurarlo socava la credibilidad.
- CTA - velocidad media. Suficiente para leer la URL, no tanto como para que se sienta plana.
El patrón de advertencia: si cada escena dura exactamente 3.0 s, probablemente tengas un problema de ritmo. El gancho y la CTA pueden ser 3 s; la prueba debería ser más larga.
referencias/por-que-una-sola-cta
Dos llamadas a la acción dividen la atención; la persona promedio solo puede sostener una intención a la vez después de un video. "Regístrate" + "Síguenos" = el espectador no hace ninguna. Una CTA con una URL: "Prueba Sentinel gratis → sentinel.dev" convierte a una tasa más alta que cualquier par. Si necesitas dos destinos, prioriza el primario y pon el secundario en la descripción del video (por ejemplo, "Más información en docs.sentinel.dev") – pero en el bucle de cierre del video, una acción.