Edición de video con Claude Code

Tiempo: ~25 min de teoría + 40 min de práctica

Lo esencial

Editar video sin editor suena a ciencia ficción. Pero Claude Code sabe manejar FFmpeg (una herramienta para trabajar con video y audio) mediante comandos, trabajar con DaVinci Resolve a través de MCP (Model Context Protocol) y generar videos programáticos con Remotion. Para un canal de YouTube, anuncios o material educativo, esto cambia todo el proceso de producción.

🎨 Imagínalo así: sin Claude Code, editar es como armar un mueble de IKEA a mano siguiendo el instructivo. Con Claude Code y FFmpeg es como una impresora 3D: dices lo que quieres y ella lo hace. Sin armar nada tú.

Conceptos clave

FFmpeg: herramienta de línea de comandos para video y audio (gratuita, potente, está en todas partes)
DaVinci Resolve MCP: controlar un editor profesional a través de Claude
Remotion: crear video con código mediante React/JavaScript
Edición por pipeline: procesamiento secuencial con comandos (un pipeline es una cadena de pasos)
Batch processing: procesamiento masivo de archivos de video (por lotes)

Teoría

FFmpeg + Claude: edición automática

FFmpeg es la herramienta gratuita más potente para video. El problema: miles de opciones (flags) imposibles de memorizar. Claude Code las conoce todas.

🎨 Imagínalo así: FFmpeg es como el tablero de control de una central nuclear. Miles de botones, cada uno importante. Claude Code es el operador experimentado que sabe cuál presionar. Tú dices el resultado y él presiona los botones.

Instalar FFmpeg:

bash

# macOS
brew install ffmpeg

# Ubuntu/Debian
sudo apt install ffmpeg

# Verificar
ffmpeg -version

Operaciones básicas (pídeselas a Claude Code):

bash

# Convertir formatos
ffmpeg -i input.mov -c:v libx264 -crf 23 output.mp4

# Recortar por tiempo
ffmpeg -i input.mp4 -ss 00:00:30 -to 00:02:00 -c copy clip.mp4

# Cambiar el tamaño
ffmpeg -i input.mp4 -vf "scale=1920:1080" output.mp4

# Comprimir para YouTube
ffmpeg -i raw.mp4 -c:v libx264 -preset slow -crf 18 \
       -c:a aac -b:a 320k youtube-ready.mp4

# Unir varios videos
cat > list.txt << EOF
file 'clip1.mp4'
file 'clip2.mp4'
file 'clip3.mp4'
EOF
ffmpeg -f concat -safe 0 -i list.txt -c copy merged.mp4

# Agregar subtítulos
ffmpeg -i video.mp4 -i subtitles.srt -c copy -c:s mov_text with-subs.mp4

# Extraer la pista de audio
ffmpeg -i video.mp4 -vn -acodec copy audio.m4a

# Agregar música de fondo (bajando el volumen del original)
ffmpeg -i video.mp4 -i music.mp3 \
       -filter_complex "[0:a]volume=1.0[orig];[1:a]volume=0.3[bg];[orig][bg]amix=inputs=2" \
       -c:v copy output.mp4

Pipeline para YouTube: de la grabación a la publicación

🎨 Imagínalo así: antes, un video de YouTube era como una pizza hecha a mano. Cada paso a mano: masa, salsa, ingredientes, horno. Claude Code + FFmpeg es una pizzería con banda transportadora. Pones la masa y al final sale la pizza lista.

bash

#!/usr/bin/env bash
# youtube-pipeline.sh — pipeline completo del video crudo a YouTube

set -euo pipefail

INPUT_FILE="$1"
VIDEO_TITLE="$2"
OUTPUT_DIR="./youtube-ready"

mkdir -p "$OUTPUT_DIR"

echo "🎬 Procesando: $INPUT_FILE"

# Paso 1: Transcribir el audio con Whisper
# La API acepta archivos de hasta 25 MB, así que primero extraemos una pista de audio ligera
# (para grabaciones muy largas, corta el audio en partes)
echo "📝 Transcribiendo..."
ffmpeg -i "$INPUT_FILE" -vn -ac 1 -ar 16000 -b:a 48k "$OUTPUT_DIR/audio.mp3" -y -loglevel error
# whisper-1 puede devolver subtítulos listos (srt); para texto simple OpenAI recomienda modelos más nuevos
curl -s -X POST "https://api.openai.com/v1/audio/transcriptions" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -F file="@$OUTPUT_DIR/audio.mp3" \
  -F model="whisper-1" \
  -F language="es" \
  -F response_format="srt" \
  --output "$OUTPUT_DIR/subtitles.srt"

# Paso 2: Optimización para YouTube con Claude
echo "🤖 Generando metadatos..."
DESCRIPTION=$(cat "$OUTPUT_DIR/subtitles.srt" | claude -p "
Con base en esta transcripción, escribe:
1. Una descripción para YouTube (300-500 palabras, con marcas de tiempo)
2. 15-20 hashtags para nuestro nicho
3. Etiquetas separadas por comas (20-30 etiquetas)
Tema del video: $VIDEO_TITLE
")

# Paso 3: Convertir al formato óptimo para YouTube
echo "📹 Convirtiendo el video..."
ffmpeg -i "$INPUT_FILE" \
  -c:v libx264 -preset slow -crf 18 \
  -c:a aac -b:a 320k \
  -vf "scale=1920:1080" \
  "$OUTPUT_DIR/${VIDEO_TITLE// /_}.mp4" \
  -y

# Paso 4: Miniaturas a partir de un cuadro del inicio y otro de la mitad
ffmpeg -i "$INPUT_FILE" -ss 00:00:05 -vframes 1 "$OUTPUT_DIR/thumbnail-start.jpg"
ffmpeg -i "$INPUT_FILE" -ss $(ffprobe -v error -show_entries format=duration -of csv=p=0 "$INPUT_FILE" | awk '{print int($1/2)}') \
  -vframes 1 "$OUTPUT_DIR/thumbnail-middle.jpg"

# Paso 5: Guardar la descripción
echo "$DESCRIPTION" > "$OUTPUT_DIR/description.txt"

echo "✅ ¡Listo! Archivos en $OUTPUT_DIR/"
echo "Video: ${VIDEO_TITLE// /_}.mp4"
echo "Subtítulos: subtitles.srt"
echo "Descripción: description.txt"
echo "Miniaturas: thumbnail-start.jpg, thumbnail-middle.jpg"

DaVinci Resolve MCP: edición profesional a través de Claude

DaVinci Resolve es un editor de video profesional (la versión gratuita es muy potente). Existe un servidor MCP para él que permite controlar el editor desde Claude Code.

🎨 Imagínalo así: DaVinci Resolve MCP es como controlar con la voz un estudio de edición profesional. Antes hacía falta un editor que conociera miles de funciones. Ahora dices "agrega corrección de color, quita el ruido de fondo, agrega una intro" y Claude lo traduce en acciones dentro de Resolve.

Instalar el MCP (a octubre de 2026):

bash

# Inicio rápido con el lanzador de npm
npx davinci-resolve-mcp setup

# O desde el código fuente (requiere Python 3.10+)
git clone https://github.com/samuelgursky/davinci-resolve-mcp.git
cd davinci-resolve-mcp
python install.py

El instalador agrega por sí solo las entradas necesarias en la configuración del cliente MCP. Requiere DaVinci Resolve 18.5 o más reciente. El control externo mediante la Scripting API oficial funciona por completo en la versión Studio; en la versión gratuita los scripts externos están limitados y el acceso es por el menú Workspace → Scripts dentro de Resolve (revisa las condiciones en el README del repositorio).

Qué puede hacer DaVinci Resolve MCP:

Crear proyectos y líneas de tiempo nuevos
Importar clips desde el media pool
Agregar clips a la línea de tiempo
Aplicar corrección de color (LUT, Primary)
Ajustar el audio (volumen, reducción de ruido)
Renderizar en el formato que necesites
Manejar marcadores y puntos de corte

python

# Ejemplo de trabajo con DaVinci Resolve a través de Claude
# Una vez conectado el MCP, Claude puede ejecutar:

"""
Crea un proyecto nuevo llamado "YouTube_EP15"
Importa todos los archivos mp4 de la carpeta ~/raw-footage/
Agrégalos a la línea de tiempo en orden alfabético
Aplica el espacio de color Rec.709
Baja el volumen a -12 LUFS
Renderiza en H.264 1080p para YouTube
"""

Importante: DaVinci Resolve MCP funciona a través de la API de Lua/Python de Resolve (una API es una interfaz de programación). DaVinci Resolve debe estar abierto en la misma computadora.

Remotion: crear video con código

Remotion es una biblioteca para crear video con React. Escribes un componente JSX y obtienes un MP4. Remotion tiene Agent Skills y plugins para trabajar con agentes de programación. Licencia a octubre de 2026: gratis para personas y equipos de hasta 3 personas; las empresas de 4 personas o más necesitan una licencia de pago (condiciones en remotion.dev).

🎨 Imagínalo así: Remotion es como un estudio de animación donde el diseñador describe la animación con código. No "dibuja una flecha a la izquierda", sino <Arrow direction="left" duration={30} />. Es programar video.

Instalación:

bash

npx create-video@latest
cd my-video
npm start  # Abre la vista previa en el navegador

Ejemplo simple: un título animado:

tsx

// src/Root.tsx
import { Composition } from 'remotion';
import { TitleCard } from './TitleCard';

export const RemotionRoot = () => {
  return (
    <Composition
      id="TitleCard"
      component={TitleCard}
      durationInFrames={150}  // 5 segundos a 30fps
      fps={30}
      width={1920}
      height={1080}
      defaultProps={{
        title: "Cómo funcionan los agentes de IA",
        subtitle: "Curso de Claude Code",
      }}
    />
  );
};

tsx

// src/TitleCard.tsx
import { AbsoluteFill, spring, useCurrentFrame, useVideoConfig, interpolate } from 'remotion';

interface Props {
  title: string;
  subtitle: string;
}

export const TitleCard = ({ title, subtitle }: Props) => {
  const frame = useCurrentFrame();
  const { fps } = useVideoConfig();
  
  // Animación de aparición (spring: rebote con física)
  const titleOpacity = spring({
    frame,
    fps,
    config: { damping: 200 },
  });
  
  // Deslizamiento de abajo hacia arriba
  const titleY = interpolate(frame, [0, 20], [50, 0], {
    extrapolateRight: 'clamp',
  });
  
  const subtitleOpacity = spring({
    frame: frame - 15,  // Aparece 0.5 s después
    fps,
    config: { damping: 200 },
  });
  
  return (
    <AbsoluteFill
      style={{
        background: 'linear-gradient(135deg, #1a1a2e 0%, #16213e 50%, #0f3460 100%)',
        display: 'flex',
        flexDirection: 'column',
        alignItems: 'center',
        justifyContent: 'center',
      }}
    >
      <h1
        style={{
          color: 'white',
          fontSize: 80,
          fontWeight: 'bold',
          opacity: titleOpacity,
          transform: `translateY(${titleY}px)`,
          textAlign: 'center',
        }}
      >
        {title}
      </h1>
      <p
        style={{
          color: '#64b5f6',
          fontSize: 40,
          opacity: subtitleOpacity,
          marginTop: 20,
        }}
      >
        {subtitle}
      </p>
    </AbsoluteFill>
  );
};

Renderizar a MP4:

bash

# Renderizar un video
npx remotion render TitleCard output.mp4

# Renderizar con parámetros (para contenido dinámico)
npx remotion render TitleCard output.mp4 \
  --props='{"title":"Siguiente tema","subtitle":"Módulo final"}'

# Renderizado en paralelo (más rápido)
npx remotion render TitleCard output.mp4 --concurrency=4

Procesamiento por lotes: 100 videos de una vez

🎨 Imagínalo así: el procesamiento por lotes es como una línea de producción en una fábrica. No "procesa un video", sino "pon 100 videos en la fila y procésalos todos mientras duermo".

bash

#!/usr/bin/env bash
# batch-process.sh — procesamiento masivo de archivos de video

INPUT_DIR="./raw"
OUTPUT_DIR="./processed"
mkdir -p "$OUTPUT_DIR"

# Contador
TOTAL=$(find "$INPUT_DIR" -name "*.mp4" | wc -l)
CURRENT=0

find "$INPUT_DIR" -name "*.mp4" | while read -r file; do
  CURRENT=$((CURRENT + 1))
  FILENAME=$(basename "$file" .mp4)
  
  echo "[$CURRENT/$TOTAL] Procesando: $FILENAME"
  
  # Convertimos para redes sociales (varios formatos)
  
  # YouTube (16:9, 1080p)
  ffmpeg -i "$file" \
    -c:v libx264 -preset fast -crf 22 \
    -c:a aac -b:a 192k \
    -vf "scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080" \
    "$OUTPUT_DIR/${FILENAME}_youtube.mp4" \
    -y -loglevel error
  
  # Instagram Reels/TikTok (9:16, 1080x1920)
  ffmpeg -i "$file" \
    -c:v libx264 -preset fast -crf 22 \
    -c:a aac -b:a 192k \
    -vf "scale=1080:1920:force_original_aspect_ratio=increase,crop=1080:1920" \
    "$OUTPUT_DIR/${FILENAME}_vertical.mp4" \
    -y -loglevel error
  
  # Miniatura (cuadro del segundo 5)
  ffmpeg -i "$file" \
    -ss 5 -vframes 1 \
    -vf "scale=1280:720" \
    "$OUTPUT_DIR/${FILENAME}_thumb.jpg" \
    -y -loglevel error
  
  echo "  ✅ Listo: YouTube + Vertical + Miniatura"
done

echo "✅ Procesamiento por lotes terminado: $TOTAL videos"

Claude Code para escribir comandos de FFmpeg

El workflow más simple es pedirle a Claude que escriba el comando que necesitas:

Escribe esto en el chat

Necesito:
- Tomar video.mp4 (4 horas, 4K)
- Cortar el fragmento de 01:15:30 a 01:45:00
- Bajarlo a 1080p
- Agregar subtítulos de subs.srt
- Guardarlo como clip.mp4

Escribe el comando de FFmpeg.

Claude Code te responderá con el comando exacto y la explicación de cada opción.

Práctica

Instala FFmpeg: brew install ffmpeg
Toma cualquier video → pídele a Claude Code el comando para convertirlo a formato YouTube 1080p
Crea un script que corte un video en clips de un minuto
Instala Remotion: npx create-video@latest → crea una tarjeta de título animada
(avanzado) Instala DaVinci Resolve + DaVinci Resolve MCP y prueba a controlarlo desde Claude

Herramientas y recursos

FFmpeg: sitio oficial, documentación de todas las opciones
DaVinci Resolve MCP: repositorio en GitHub (instrucciones de instalación y limitaciones de la versión gratuita de Resolve)
DaVinci Resolve: descarga gratuita
Remotion: video con código mediante React; licencia: remotion.dev/docs/license

Ideas clave

FFmpeg + Claude Code = edición por comandos. Si no conoces las opciones, Claude sí. Dices lo que necesitas y recibes el comando listo.

Remotion = video programático. Presentaciones animadas, datos en movimiento, contenido con tu marca: sin saber motion design, con React.

DaVinci Resolve MCP es para quienes ya usan Resolve. Claude controla un editor profesional vía MCP: corrección de color, edición y render con comandos de texto.

Siguiente lección

→ Trading algorítmico con Claude Code: Alpaca MCP y gestión de riesgos