Communitygithub.com

rizadaniel2-cozy-ritual/remotion-dev

A **Remotion Claude Skill** é um módulo TypeScript abrangente que permite a criação e renderização programática de vídeos diretamente no Claude AI. Ele fornece uma API intuitiva para criar, gerenciar e renderizar composições de vídeo usando componentes React.

O que é remotion-dev?

A **Remotion Claude Skill** é um módulo TypeScript projetado para integrar criação de vídeos programáticos com o Claude AI. Ela permite que desenvolvedores e usuários do Claude definam composições de vídeo usando componentes React, gerenciem filas de renderização e gerem saídas em múltiplos formatos como h264, ProRes e sequências PNG. A skill suporta sistemas de templates pré-construídos para padrões comuns (intros, animações, slideshows) e inclui componentes prontos como `TextOverlay` e utilitários de animação. Completa com tipagem TypeScript, a skill é ideal para fluxos de automação de vídeo onde o Claude AI orquestra a criação de conteúdo visual. A documentação inclui exemplos práticos de uso, referência detalhada da API e práticas recomendadas para desempenho e tratamento de erros.

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

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Documentação da Remotion Claude Skill

Visão Geral

A Remotion Claude Skill é um módulo TypeScript abrangente que permite a criação e renderização programática de vídeos diretamente no Claude AI. Ela fornece uma API intuitiva para criar, gerenciar e renderizar composições de vídeo usando componentes React.

Funcionalidades

  • ✅ Criar Composições de Vídeo - Defina projetos de vídeo com componentes React
  • ✅ Gerenciar Composições - Registre, recupere e organize composições de vídeo
  • ✅ Gerenciamento de Fila de Renderização - Enfileire composições para renderização em lote
  • ✅ Múltiplos Formatos de Saída - Suporte para h264, h265, VP8, VP9, ProRes, sequências PNG
  • ✅ Sistema de Templates - Templates pré-construídos para padrões comuns de vídeo
  • ✅ Biblioteca de Componentes - Componentes prontos para uso como TextOverlay e animações
  • ✅ Segurança de Tipos - Suporte completo TypeScript com interfaces abrangentes

Instalação

# Clone o repositório do Remotion
git clone https://github.com/remotion-dev/remotion.git
cd remotion

# Instale as dependências
bun install

# A skill está disponível em:
packages/skills-evals/remotion-claude-skill.ts

Início Rápido

1. Criar uma Instância da Skill

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

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

2. Criar um Componente React

import React from 'react';

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

3. Registrar uma Composição

skill.createComposition(
  'meu-video',
  'Título do Meu Vídeo',
  MeuVideo,
  {
    durationInFrames: 150,
    fps: 30,
    width: 1920,
    height: 1080,
    defaultProps: { titulo: 'Olá Mundo' },
  }
);

4. Enfileirar para Renderização

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

5. Obter Metadados

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

Referência da API

Classe RemotionClaudeSkill

Construtor

constructor(config: RemotionSkillConfig)

Cria uma nova instância da skill com a configuração fornecida.

Parâmetros:

  • config: Objeto de configuração com largura, altura, fps, duraçãoEmFrames, nomeDoProjeto

Métodos

createComposition(id, nome, componente, opcoes?): CompositionDefinition

Cria e registra uma nova composição.

skill.createComposition(
  'intro',
  'Sequência de Introdução',
  ComponenteIntro,
  {
    durationInFrames: 200,
    fps: 60,
    width: 1920,
    height: 1080,
    defaultProps: { subtitulo: 'Meu Projeto' },
  }
);
registerComposition(definicao): void

Registra uma composição já definida.

const composicao: CompositionDefinition = {
  id: 'outro',
  name: 'Sequência de Encerramento',
  component: ComponenteOutro,
  durationInFrames: 150,
  fps: 30,
  width: 1920,
  height: 1080,
};

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

Retorna todas as composições registradas.

const todas = skill.getCompositions();
console.log(`Total de composições: ${todas.length}`);
getComposition(id): CompositionDefinition | undefined

Obtém uma composição específica pelo ID.

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

Enfileira uma composição para renderização.

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

Retorna todos os trabalhos de renderização enfileirados.

const fila = skill.getRenderQueue();
console.log(`Trabalhos na fila: ${fila.length}`);
clearRenderQueue(): void

Limpa todos os trabalhos de renderização enfileirados.

skill.clearRenderQueue();
getMetadata(): object

Retorna metadados e estatísticas da skill.

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

Gera um template para um componente de vídeo.

// Opções: '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

Um componente simples de sobreposição de texto.

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

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

Utilitários de Animação

createFadeInAnimation

Gera CSS para uma animação de fade-in.

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

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

Templates

Template de Introdução

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

Cria um título de texto simples exibido sobre um fundo preto.

Template de Animação

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

Demonstra animações spring e efeitos de redimensionamento.

Template de Slideshow

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

Mostra como criar múltiplas sequências para um efeito de slideshow.

Exemplo Completo

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

// Criar instância da skill
const skill = createRemotionSkill({
  projectName: 'demo',
  width: 1920,
  height: 1080,
  fps: 30,
  durationInFrames: 300,
});

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

// Registrar composição
skill.createComposition('demo', 'Vídeo de Demonstração', VideoDemonstracao, {
  durationInFrames: 300,
  fps: 30,
  width: 1920,
  height: 1080,
  defaultProps: { mensagem: 'Bem-vindo ao Remotion + Claude' },
});

// Enfileirar para renderização
skill.queueForRender('demo', {
  codec: 'h264',
  outputLocation: './output/demo.mp4',
  crf: 18,
  overwrite: true,
});

// Verificar metadados
console.log(skill.getMetadata());

Funcionalidades Avançadas

Múltiplas Composições

skill.createComposition('intro', 'Introdução', ComponenteIntro, {...});
skill.createComposition('principal', 'Conteúdo Principal', ComponentePrincipal, {...});
skill.createComposition('outro', 'Encerramento', ComponenteOutro, {...});

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

Props Personalizados

interface PropsVideo {
  titulo: string;
  subtitulo: string;
  duracao: number;
}

const MeuVideo: React.FC<PropsVideo> = ({ titulo, subtitulo, duracao }) => {
  // Código do componente
};

skill.createComposition('personalizado', 'Vídeo Personalizado', MeuVideo, {
  defaultProps: {
    titulo: 'Meu Título',
    subtitulo: 'Meu Subtítulo',
    duracao: 5,
  },
});

Renderização Condicional

const VideoCondicional: React.FC<{ mostrarSubtitulo?: boolean }> = ({ mostrarSubtitulo }) => {
  return (
    <div>
      <h1>Conteúdo Principal</h1>
      {mostrarSubtitulo && <h2>Subtítulo</h2>}
    </div>
  );
};

Melhores Práticas

  1. Use TypeScript - Aproveite a segurança total de tipos para componentes e props
  2. Crie Componentes Reutilizáveis - Construa uma biblioteca de componentes para padrões comuns
  3. Otimize o Desempenho - Use memoização para cálculos pesados
  4. Renderização em Lote - Enfileire múltiplas composições para reduzir a sobrecarga de inicialização
  5. Lide com Erros - Use errorFn em RenderOptions para tratamento de erros
  6. Valide Props - Sempre valide props padrão e entradas do usuário

Solução de Problemas

Composição Não Encontrada

try {
  skill.queueForRender('inexistente', {...});
} catch (error) {
  console.error('Composição não encontrada:', error.message);
}

Gerenciamento da Fila de Renderização

// Limpar fila antes de adicionar novos trabalhos
skill.clearRenderQueue();

// Verificar tamanho da fila
console.log(`Renderizações pendentes: ${skill.getRenderQueue().length}`);

Validação de Configuração

const config = skill.getMetadata();
console.log('Configuração Atual:');
console.log(`- Resolução: ${config.config.width}x${config.config.height}`);
console.log(`- FPS: ${config.config.fps}`);
console.log(`- Duração: ${config.config.durationInFrames} quadros`);

Integração com Claude

Em Conversas com Claude

  1. Referencie a skill para criar vídeos interativamente
  2. Modifique componentes em tempo real
  3. Enfileire múltiplas versões para comparação
  4. Exporte a configuração como JSON

Exemplo de Interação com Claude

Usuário: "Crie um vídeo de introdução para meu podcast"

Claude: Vou criar um vídeo de introdução usando a Remotion Claude Skill.

skill.createComposition('intro-podcast', 'Introdução do Podcast', IntroducaoPodcast, {
  durationInFrames: 180,
  fps: 30,
  width: 1920,
  height: 1080,
  defaultProps: {
    nomePodcast: 'Nome do Seu Podcast',
    slogan: 'Conversas que Importam',
  },
});

Links de Recursos

Licença

Esta skill segue a mesma licença do Remotion. Consulte LICENSE.md para detalhes.

Contribuição

Para contribuir com melhorias nesta skill:

  1. Faça um fork do repositório
  2. Crie um branch de funcionalidade
  3. Faça suas alterações
  4. Envie um pull request

Consulte CONTRIBUTING.md para mais informações.

Suporte

Habilidades Relacionadas