Editar vídeos con Remotion y Claude Code: la skill que transcribe, corta y anima sola

Un editor de vídeo no tarda horas por cortar mal. Tarda horas porque desde que le llega el clip hasta que lo entrega hace cuatro trabajos distintos: transcribir, poner subtítulos, recortar y animar. Y casi nadie cuenta el quinto, que es volver a hacerlo todo cuando el cliente dice "cámbiame esto".

Yo hago ese proceso con una skill de Claude Code. Le paso el archivo grabado, miro el resultado, le digo qué quiero cambiar y decido. Un vídeo que antes me llevaba cuatro o cinco horas lo cierro en unos quince minutos. La parte que lo hace posible es Remotion: las animaciones son código, así que Claude las escribe, las ajusta y las vuelve a renderizar sin que yo abra una línea de tiempo.

Esta página es el desglose de cómo funciona y, al final, la skill entera para que la copies.

La idea en una frase

El modelo no "entiende" el vídeo. Decide dónde va cada cosa. Quien hace el trabajo es una tubería de herramientas muy normales: ffmpeg para cortar, faster-whisper para transcribir, un script que mide el audio y Remotion para pintar.

MOV del móvil
  → audio de la pista buena
  → transcripción por palabras
  → tomas repetidas descartadas
  → cortes medidos sobre el audio
  → un clip por tramo + sus palabras en JSON
  → una escena de Remotion por tramo
  → render y revisión de fotogramas

Paso 1: la pista de audio correcta

Los MOV del iPhone traen dos pistas de audio. La segunda es audio espacial y no sirve para medir silencios, así que todo se extrae con la primera:

ffmpeg -nostdin -y -i IMG_6816.MOV -map 0:a:0 -ac 1 -ar 16000 audio.wav

Parece un detalle, pero es la causa de "no detecta ningún silencio" que más se repite.

Paso 2: transcribir por palabras y quedarse con la última toma buena

Se transcribe con faster-whisper, modelo large-v3, pidiendo marcas de tiempo por palabra. Con eso se agrupa el texto por pausas de más de 0,6 segundos y, de golpe, se ven las tomas repetidas: cuando grabas la misma frase tres veces, el agrupado te enseña tres bloques casi iguales.

La regla es quedarse con la última toma buena. Y para destapar las repeticiones que Whisper esconde alargando una palabra, se vuelve a transcribir solo cada ventana elegida por separado.

Paso 3: cortar con el audio, no con Whisper

Este es el punto en el que más tiempo he perdido y el que más se nota al ver el vídeo.

Whisper adelanta la primera palabra de cada bloque que viene tras un silencio largo. En mis grabaciones lo hace entre 0,3 y 0,5 segundos: si cortas donde él dice, el vídeo empieza con medio segundo de aire muerto y tu voz entra tarde.

La solución es medir la energía del audio cada 10 milisegundos y buscar el primer momento en que se mantiene por encima de un umbral:

import wave, numpy as np

w = wave.open("audio.wav"); sr = w.getframerate()
a = np.frombuffer(w.readframes(w.getnframes()), dtype=np.int16).astype(np.float32)
hop = int(sr * 0.01)
n = len(a) // hop
rms = 20 * np.log10(np.sqrt((a[:n * hop].reshape(n, hop) ** 2).mean(1)) + 1e-6) - 90

def inicio_de_voz(t0, margen=2.5, umbral=-47):
    for i in range(int(t0 / 0.01), int((t0 + margen) / 0.01)):
        if rms[i] > umbral and rms[i + 1] > umbral and rms[i + 2] > umbral:
            return i * 0.01

Con eso, las reglas de corte quedan así:

• Entrada: unos 0,12 segundos antes del primer cruce del umbral. En la intro del vídeo, solo 0,02, porque la voz tiene que empezar en el segundo cero.
• Salida: donde la energía baja de unos −50 dB, más una cola de 0,14 a 0,35 segundos. Cortar justo al acabar la última palabra suena a mordisco.
• Pausas dentro de una frase: si hay un hueco largo entre dos palabras, se puede quitar dejando unos 0,4 segundos para no romper el ritmo.

Una advertencia que me costó un vídeo: no cosas dos tomas distintas dentro de un sintagma. Aunque el texto salga bien, suena a tartamudeo porque son dos cadencias pegadas. Se corta solo en pausas que existen en la toma.

Paso 4: un clip por tramo y sus palabras en JSON

Cada tramo se recorta, se pasa a vertical y se guarda junto a un fichero con las palabras relativas al inicio del tramo:

ffmpeg -ss 71.53 -t 8.39 -i IMG_6817.MOV \
  -vf "crop=min(iw\,ih*9/16):ih,scale=1080:1920,fps=30" \
  -c:v h264_nvenc -cq 18 -c:a aac A.mp4

{
  "id": "A",
  "dur": 8.39,
  "mode": "split",
  "words": [
    { "text": "El", "start": 0.0, "end": 0.16 },
    { "text": "problema", "start": 0.16, "end": 0.42 }
  ]
}

El campo mode decide el formato del tramo: split (lienzo blanco arriba con la animación y tu cara abajo), full (blanco entero, para la idea clave) o face (solo tú, para el cierre).

Paso 5: cada tramo es una escena de Remotion

Aquí es donde cambia todo respecto a editar a mano. Cada tramo es un componente de React que recibe el tiempo y pinta lo que toca. Los tiempos de cada golpe visual se leen del JSON, así que una animación cae justo en la palabra que la nombra.

La composición principal es una lista de Sequence, una por tramo:

{SEGS.map((s, i) => (
  <Sequence key={s.id} from={Math.round(STARTS[i] * fps)} durationInFrames={Math.round(s.dur * fps)} premountFor={fps}>
    <AbsoluteFill>
      <OffthreadVideo src={staticFile(`n16/${s.id}.mp4`)} />
      <Escena />
      <Subs seg={s} />
    </AbsoluteFill>
  </Sequence>
))}

Y dentro de cada escena, todo son dos herramientas: spring para lo que llega y curvas de easing para lo que se mueve.

const S = (at: number, cfg = { damping: 14, stiffness: 160 }) =>
  spring({ frame: frame - Math.round(at * fps), fps, config: cfg });

const EO  = Easing.bezier(0.16, 1, 0.3, 1);   // sale rápido, llega suave
const EIO = Easing.bezier(0.65, 0, 0.35, 1);  // arranca y frena suave
const e = (t, a, b, ez = EIO) => interpolate(t, [a, b], [0, 1], { extrapolateLeft: "clamp", extrapolateRight: "clamp", easing: ez });

Con eso se construye casi todo: una tarjeta que entra con rebote es S(1.4), un contador que sube es e(t, 2, 3.5), una onda de choque es un círculo cuyo radio sigue e(t, 6.7, 7.4).

La regla que lo hace parecer profesional

Nada aparece: todo llega. Ningún elemento hace un corte de opacidad. Entra con un muelle, reacciona cuando algo le cae encima y se mueve siguiendo una curva. Un fundido plano es lo que delata a un vídeo hecho con prisa.

Y la segunda: la animación enseña, no repite. Si la voz dice "te llega un recordatorio", el subtítulo ya lo pone. La imagen no vuelve a escribirlo: enseña el móvil vibrando con la notificación. Solo se rotulan datos que la imagen no puede decir, como una hora o una cantidad.

Paso 6: sonido solo cuando puntúa

Los efectos (un pop, un tick, un ping) van en una tabla de pares tramo-segundo-nombre, cada uno confirmando algo que ocurre en pantalla, muy por debajo de la voz. Si un sonido no corresponde a un evento visible, sobra. Es la diferencia entre un vídeo con ritmo y uno que suena a máquina tragaperras.

Paso 7: revisar fotogramas antes de dar nada por bueno

Se renderiza el vídeo entero y se saca una hoja de contactos de cada tramo. Los fallos de tipografía, de contraste y de posición no se ven en ningún log: se ven mirando.

npx remotion render src/index.ts Nichos16 salida.mp4 --codec=h264 --crf=17

# un fotograma en tamaño real del lienzo de arriba
ffmpeg -ss 12.4 -i salida.mp4 -frames:v 1 -vf "crop=1080:806:0:0" fotograma.png

# pantallas que se quedan congeladas más de 0,6 s
ffmpeg -i salida.mp4 -vf "crop=1080:806:0:0,freezedetect=n=0.002:d=0.6" -f null -

Cuando algo se ve corrido, no se ajusta la constante a ojo: se miden los píxeles del fotograma renderizado. Casi siempre hay una causa medible detrás.

Lo que sí conviene saber de Remotion

• Todo tiene que depender solo del tiempo. Nada de Math.random ni de estado entre fotogramas, o el render saldrá distinto a la vista previa.
• Los fotogramas se renderizan de uno en uno. Por eso OffthreadVideo y no Video: extrae el fotograma exacto con ffmpeg en vez de reproducir.
• premountFor en cada Sequence precarga el siguiente tramo un segundo antes y evita parpadeos en los cortes.
• Las fuentes se cargan una vez, con loadFont de @remotion/fonts, y los subtítulos se ajustan al ancho con fitText de @remotion/layout-utils.
• Un mismo componente sirve para varios vídeos. La app que sale en mis vídeos es un solo sistema de diseño (iPhone, pantallas, transiciones y un dedo que toca) que reutilizo escena tras escena.

Lo que todavía no hace bien

No decide qué contar, ni si el gancho funciona, ni qué te favorece en pantalla. Tampoco escucha: no sabe si un empalme suena a tartamudeo, así que lo que depende del oído se evita en vez de afinarse. Y los vídeos con mucho texto en pantalla piden más revisión que los de personajes y escenas.

Corta bien, anima con criterio y renderiza rápido. Las decisiones siguen siendo tuyas, que es donde quieres seguir.

La skill completa

Cópiala en ~/.claude/skills/editar-video/SKILL.md (en Windows, C:\Users\TU_USUARIO\.claude\skills\editar-video\SKILL.md). Ajusta las rutas de tu proyecto de Remotion y listo: la invocas escribiendo /editar-video y pasándole el archivo.

---
name: editar-video
description: Edita vídeos verticales para TikTok e Instagram montados en Remotion, con formato partido (animación arriba, cara abajo). Úsala cuando te pasen un vídeo grabado y pidan transcribir, cortar, subtitular, animar o exportar.
---

# editar-video

Un vídeo se monta como una lista de tramos. Cada tramo es un clip recortado,
sus palabras con tiempos y una escena de Remotion que pinta la animación.

## Flujo

1. **Audio.** Extrae siempre la primera pista:
   `ffmpeg -nostdin -y -i INPUT.MOV -map 0:a:0 -ac 1 -ar 16000 audio.wav`
   (los MOV de iPhone traen una segunda pista espacial que no sirve).
2. **Transcribe por palabras** con faster-whisper large-v3 y marcas por palabra.
   Corrige nombres de producto antes de cortar.
3. **Agrupa por pausas de más de 0,6 s.** Así se ven las tomas repetidas.
   Quédate con la última toma buena y retranscribe solo esas ventanas.
4. **Mide los bordes con RMS (ventanas de 10 ms), no con Whisper.**
   - Entrada: primer cruce sostenido de −47 dB, menos 0,12 s. En el primer
     tramo del vídeo, menos 0,02 s: la voz debe empezar en el segundo 0.
   - Salida: donde el RMS baja de −50 dB, más 0,14–0,35 s de cola.
   - Revisa también la última sílaba: puede llegar 0,2 s más allá de lo
     que marca la transcripción.
5. **Corta cada tramo** a 1080x1920 y 30 fps y guarda un JSON con las palabras
   relativas al inicio del tramo (`id`, `dur`, `mode`, `words`).
6. **Pregunta antes de construir** si hay algo por decidir: el gancho, el
   cierre, qué va a pantalla completa. No construyas con dudas abiertas.
7. **Escribe una escena por tramo** y regístrala en la composición.
8. **Renderiza y revisa fotogramas** (hoja de contactos y recortes a tamaño
   real) antes de enseñar nada.

## Formatos de tramo

- `split`: lienzo blanco arriba (806 px) con la animación; la cara abajo.
- `full`: blanco entero. Una sola idea clave por vídeo.
- `face`: solo la cara, para el cierre.

## Reglas de animación

- **Nada aparece: todo llega.** Entradas con muelle (`spring`), movimientos con
  curvas de easing, reacciones con onda y sacudida. Sin fundidos planos.
- **La imagen enseña, no repite.** No pongas chips que digan lo mismo que la
  voz. Rotula solo datos: horas, cantidades, sellos.
- **Cada golpe cae en la palabra que lo nombra.** Lee los tiempos del JSON.
- **Todo depende solo del tiempo.** Sin `Math.random`, sin estado entre
  fotogramas.
- **Personajes y decorado con continuidad.** El problema y el resultado pasan
  en el mismo escenario.
- **Pantallas completas quietas.** Solo se mueven los elementos que entran.

## Subtítulos y zona segura

- Blancos y planos sobre el vídeo, en negro sobre fondos claros. Sin placa.
- Nada importante por encima del 14 % ni por debajo del 88 % de la altura.

## Sonido

Efectos cortos (pop, tick, ping) solo cuando confirman algo visible, muy por
debajo de la voz. Si un sonido no tiene evento en pantalla, quítalo.

## Cuando algo se ve descentrado

Mide los píxeles del fotograma renderizado. No ajustes la constante a ojo.

## Lo que no se puede verificar

Tú no oyes el audio. Lo que dependa del oído (empalmes, ritmo, tono) no se da
por bueno: se evita, no se afina. No empalmes dos tomas dentro de un sintagma.

Cómo lo uso en la práctica

Grabo, paso el MOV, pido la edición y reviso. Si algo no me convence ("más abajo", "que el cierre entre antes", "el móvil más grande"), lo digo con palabras y Claude toca el código de la escena y vuelve a renderizar. La conversación es la interfaz.