Communitygithub.com

rizadaniel2-cozy-ritual/remotion-dev

El **Remotion Claude Skill** es un módulo TypeScript completo que permite la creación y renderización programática de videos directamente dentro de Claude AI, ofreciendo una API intuitiva para crear, gestionar y renderizar composiciones de video usando componentes React.

¿Qué es remotion-dev?

Este skill permite a Claude AI crear y renderizar videos programáticamente mediante componentes React. Proporciona una API completa para definir composiciones de video (con resolución, FPS y duración personalizables), gestionar una cola de renderizado con múltiples codecs de salida (h264, h265, VP8, VP9, ProRes, secuencias PNG), y utilizar componentes preconstruidos como TextOverlay y animaciones. Está diseñado para entornos como Claude Code o Cursor, y su documentación incluye ejemplos detallados de integración, plantillas para intros, animaciones y presentaciones de diapositivas, así como buenas prácticas para optimizar el rendimiento y manejar errores. El skill está disponible en el repositorio de Remotion y se despliega como un módulo TypeScript con tipado completo, facilitando la creación de videos de forma interactiva dentro de conversaciones con Claude.

Compatible con✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/rizadaniel2-cozy-ritual/remotion-dev/tree/HEAD

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

Documentación del Skill Remotion Claude

Resumen

El Remotion Claude Skill es un módulo TypeScript completo que permite la creación y renderización programática de videos directamente dentro de Claude AI. Proporciona una API intuitiva para crear, gestionar y renderizar composiciones de video usando componentes React.

Características

  • ✅ Crear composiciones de video - Define proyectos de video con componentes React
  • ✅ Gestionar composiciones - Registra, recupera y organiza composiciones de video
  • ✅ Gestión de cola de renderizado - Encola composiciones para renderizado por lotes
  • ✅ Múltiples formatos de salida - Soporte para h264, h265, VP8, VP9, ProRes, secuencias PNG
  • ✅ Sistema de plantillas - Plantillas predefinidas para patrones comunes de video
  • ✅ Librería de componentes - Componentes listos para usar como TextOverlay y animaciones
  • ✅ Seguridad de tipos - Soporte completo de TypeScript con interfaces exhaustivas

Instalación

# Clona el repositorio de Remotion
git clone https://github.com/remotion-dev/remotion.git
cd remotion

# Instala las dependencias
bun install

# El skill está disponible en:
packages/skills-evals/remotion-claude-skill.ts

Inicio rápido

1. Crea una instancia del skill

import { createRemotionSkill } from './remotion-claude-skill';

const skill = createRemotionSkill({
  projectName: 'my-video-project',
  width: 1920,
  height: 1080,
  fps: 30,
  durationInFrames: 150,
});

2. Crea un componente React

import React from 'react';

export const MyVideo: React.FC<{ title: string }> = ({ title }) => {
  return (
    <div style={{
      flex: 1,
      backgroundColor: '#000',
      display: 'flex',
      justifyContent: 'center',
      alignItems: 'center',
      fontSize: 100,
      color: '#fff',
      fontWeight: 'bold',
    }}>
      {title}
    </div>
  );
};

3. Registra una composición

skill.createComposition(
  'my-video',
  'My Video Title',
  MyVideo,
  {
    durationInFrames: 150,
    fps: 30,
    width: 1920,
    height: 1080,
    defaultProps: { title: 'Hello World' },
  }
);

4. Encuela para renderizado

skill.queueForRender('my-video', {
  codec: 'h264',
  outputLocation: './output/my-video.mp4',
  overwrite: true,
});

5. Obtén metadatos

const metadata = skill.getMetadata();
console.log(metadata);
// {
//   name: 'Remotion Claude Skill',
//   version: '1.0.0',
//   compositionsCount: 1,
//   queueLength: 1,
//   ...
// }

Referencia de la API

Clase RemotionClaudeSkill

Constructor

constructor(config: RemotionSkillConfig)

Crea una nueva instancia del skill con la configuración proporcionada.

Parámetros:

  • config: Objeto de configuración con width, height, fps, durationInFrames, projectName

Métodos

createComposition(id, name, component, options?): CompositionDefinition

Crea y registra una nueva composición.

skill.createComposition(
  'intro',
  'Intro Sequence',
  IntroComponent,
  {
    durationInFrames: 200,
    fps: 60,
    width: 1920,
    height: 1080,
    defaultProps: { subtitle: 'My Project' },
  }
);
registerComposition(definition): void

Registra una composición ya definida.

const composition: CompositionDefinition = {
  id: 'outro',
  name: 'Outro Sequence',
  component: OutroComponent,
  durationInFrames: 150,
  fps: 30,
  width: 1920,
  height: 1080,
};

skill.registerComposition(composition);
getCompositions(): CompositionDefinition[]

Devuelve todas las composiciones registradas.

const all = skill.getCompositions();
console.log(`Total compositions: ${all.length}`);
getComposition(id): CompositionDefinition | undefined

Obtiene una composición específica por ID.

const intro = skill.getComposition('intro');
if (intro) {
  console.log(`Found: ${intro.name}`);
}
queueForRender(compositionId, options): void

Encuela una composición para su renderizado.

skill.queueForRender('intro', {
  codec: 'h264',
  outputLocation: './videos/intro.mp4',
  crf: 18,
  concurrency: 4,
  overwrite: true,
});
getRenderQueue(): RenderOptions[]

Devuelve todos los trabajos de renderizado encolados.

const queue = skill.getRenderQueue();
console.log(`Queued jobs: ${queue.length}`);
clearRenderQueue(): void

Limpia todos los trabajos de renderizado encolados.

skill.clearRenderQueue();
getMetadata(): object

Devuelve metadatos y estadísticas del skill.

const metadata = skill.getMetadata();
console.log(metadata.capabilities);
generateTemplate(type?): string

Genera una plantilla para un componente de video.

// Opciones: 'intro' | 'animation' | 'slideshow'
const template = skill.generateTemplate('animation');
console.log(template);

Interfaces

RemotionSkillConfig

interface RemotionSkillConfig {
  projectName: string;
  width: number;
  height: number;
  fps: number;
  durationInFrames: number;
}

CompositionDefinition

interface CompositionDefinition {
  id: string;
  name: string;
  component: React.ComponentType;
  durationInFrames: number;
  fps: number;
  width: number;
  height: number;
  defaultProps?: Record<string, unknown>;
}

RenderOptions

interface RenderOptions {
  codec: 'h264' | 'h265' | 'vp8' | 'vp9' | 'prores' | 'png';
  pixelFormat?: 'yuv420p' | 'yuv422p' | 'yuv444p';
  crf?: number;
  audioBitrate?: string;
  videoBitrate?: string;
  outputLocation: string;
  concurrency?: number;
  overwrite?: boolean;
  logFn?: (message: string) => void;
  errorFn?: (error: Error) => void;
}

Componentes integrados

TextOverlay

Un componente simple de superposición de texto.

import { TextOverlay } from './remotion-claude-skill';

export const MyVideo = () => (
  <TextOverlay
    text="Hello Claude!"
    fontSize={80}
    color="#fff"
    backgroundColor="rgba(0,0,0,0.7)"
  />
);

Utilidades de animación

createFadeInAnimation

Genera CSS para una animación de aparición gradual.

import { createFadeInAnimation } from './remotion-claude-skill';

const animation = createFadeInAnimation(150, 30);
// Returns: "@keyframes fadeIn { ... }"

Plantillas

Plantilla de introducción

const template = skill.generateTemplate('intro');

Crea un título de texto simple sobre un fondo negro.

Plantilla de animación

const template = skill.generateTemplate('animation');

Demostración de animaciones tipo resorte y efectos de escala.

Plantilla de presentación de diapositivas

const template = skill.generateTemplate('slideshow');

Muestra cómo crear múltiples secuencias para un efecto de presentación.

Ejemplo completo

import React from 'react';
import { createRemotionSkill, TextOverlay } from './remotion-claude-skill';
import { useCurrentFrame, useVideoConfig } from 'remotion';

// Crea instancia del skill
const skill = createRemotionSkill({
  projectName: 'demo',
  width: 1920,
  height: 1080,
  fps: 30,
  durationInFrames: 300,
});

// Define el componente
const DemoVideo: React.FC<{ message: string }> = ({ message }) => {
  const frame = useCurrentFrame();
  const { durationInFrames, fps } = useVideoConfig();
  
  const progress = frame / durationInFrames;
  const opacity = Math.min(progress * 2, 1);
  
  return (
    <div style={{
      flex: 1,
      backgroundColor: '#1a1a2e',
      display: 'flex',
      justifyContent: 'center',
      alignItems: 'center',
      opacity,
    }}>
      <TextOverlay
        text={message}
        fontSize={100}
        color="#00d4ff"
        backgroundColor="rgba(0,0,0,0.8)"
      />
    </div>
  );
};

// Registra la composición
skill.createComposition('demo', 'Demo Video', DemoVideo, {
  durationInFrames: 300,
  fps: 30,
  width: 1920,
  height: 1080,
  defaultProps: { message: 'Welcome to Remotion + Claude' },
});

// Encuela para renderizado
skill.queueForRender('demo', {
  codec: 'h264',
  outputLocation: './output/demo.mp4',
  crf: 18,
  overwrite: true,
});

// Revisa metadatos
console.log(skill.getMetadata());

Funcionalidades avanzadas

Múltiples composiciones

skill.createComposition('intro', 'Intro', IntroComponent, {...});
skill.createComposition('main', 'Main Content', MainComponent, {...});
skill.createComposition('outro', 'Outro', OutroComponent, {...});

// Encuela todas para renderizado
for (const comp of skill.getCompositions()) {
  skill.queueForRender(comp.id, {
    codec: 'h264',
    outputLocation: `./videos/${comp.id}.mp4`,
    overwrite: true,
  });
}

Props personalizadas

interface VideoProps {
  title: string;
  subtitle: string;
  duration: number;
}

const MyVideo: React.FC<VideoProps> = ({ title, subtitle, duration }) => {
  // Código del componente
};

skill.createComposition('custom', 'Custom Video', MyVideo, {
  defaultProps: {
    title: 'My Title',
    subtitle: 'My Subtitle',
    duration: 5,
  },
});

Renderizado condicional

const ConditionalVideo: React.FC<{ showSubtitle?: boolean }> = ({ showSubtitle }) => {
  return (
    <div>
      <h1>Main Content</h1>
      {showSubtitle && <h2>Subtitle</h2>}
    </div>
  );
};

Buenas prácticas

  1. Usa TypeScript - Aprovecha la seguridad de tipos completa para componentes y props
  2. Crea componentes reutilizables - Construye una librería de componentes para patrones comunes
  3. Optimiza el rendimiento - Usa memoización para cálculos pesados
  4. Renderizado por lotes - Encuela múltiples composiciones para reducir la sobrecarga de inicio
  5. Maneja errores - Usa errorFn en RenderOptions para el manejo de errores
  6. Valida props - Siempre valida las props predeterminadas y las entradas del usuario

Solución de problemas

Composición no encontrada

try {
  skill.queueForRender('nonexistent', {...});
} catch (error) {
  console.error('Composition not found:', error.message);
}

Gestión de la cola de renderizado

// Limpia la cola antes de agregar nuevos trabajos
skill.clearRenderQueue();

// Revisa la longitud de la cola
console.log(`Pending renders: ${skill.getRenderQueue().length}`);

Validación de configuración

const config = skill.getMetadata();
console.log('Current Configuration:');
console.log(`- Resolution: ${config.config.width}x${config.config.height}`);
console.log(`- FPS: ${config.config.fps}`);
console.log(`- Duration: ${config.config.durationInFrames} frames`);

Integración con Claude

En conversaciones con Claude

  1. Referencia el skill para crear videos de forma interactiva
  2. Modifica componentes en tiempo real
  3. Encuela múltiples versiones para comparación
  4. Exporta la configuración como JSON

Ejemplo de interacción con Claude

Usuario: "Crea un video de introducción para mi podcast"

Claude: Crearé un video de introducción usando el Remotion Claude Skill.

skill.createComposition('podcast-intro', 'Podcast Intro', PodcastIntro, {
  durationInFrames: 180,
  fps: 30,
  width: 1920,
  height: 1080,
  defaultProps: {
    podcastName: 'Your Podcast Name',
    tagline: 'Conversations that Matter',
  },
});

Enlaces de recursos

Licencia

Este skill sigue la misma licencia que Remotion. Consulta LICENSE.md para más detalles.

Contribuciones

Para contribuir mejoras a este skill:

  1. Haz un fork del repositorio
  2. Crea una rama de funcionalidad
  3. Realiza tus cambios
  4. Envía una solicitud de extracción

Consulta CONTRIBUTING.md para más información.

Soporte

Skills relacionados