Communitygithub.com

rizadaniel2-cozy-ritual/remotion-dev

Das **Remotion Claude Skill** ist ein umfassendes TypeScript-Modul, das die programmatische Videocrstellung und -wiedergabe direkt in Claude AI ermöglicht. Es bietet eine intuitive API zum Erstellen, Verwalten und Rendern von Videokompositionen mit React-Komponenten.

Was ist remotion-dev?

Das Remotion Claude Skill ist ein leistungsstarkes TypeScript-Modul, das es Entwicklern und KI-Agenten wie Claude ermöglicht, Videos programmatisch zu erstellen, zu verwalten und zu rendern, wobei React-Komponenten als Grundlage dienen. Es bietet eine vollständige API zur Definition von Videoprojekten, zur Registrierung von Kompositionen, zur Verwaltung einer Render-Warteschlange und zur Unterstützung mehrerer Ausgabeformate wie h264, h265, ProRes und PNG-Sequenzen. Das Skill ist für die Verwendung mit Remotion konzipiert und kann in Claude AI integriert werden, um interaktive Videocrstellung zu ermöglichen, z. B. durch Echtzeit-Modifikation von Komponenten oder das Vergleichen verschiedener Versionen. Es umfasst außerdem ein Templatesystem, eine Komponentenbibliothek (z. B. TextOverlay) und umfassende TypeScript-Typensicherheit, was es ideal für Developer Tools und KI-gestützte Workflows macht.

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

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Remotion Claude Skill Dokumentation

Überblick

Das Remotion Claude Skill ist ein umfassendes TypeScript-Modul, das die programmatische Videocrstellung und -wiedergabe direkt in Claude AI ermöglicht. Es bietet eine intuitive API zum Erstellen, Verwalten und Rendern von Videokompositionen mit React-Komponenten.

Funktionen

  • ✅ Videokompositionen erstellen - Videoprojekte mit React-Komponenten definieren
  • ✅ Kompositionen verwalten - Videokompositionen registrieren, abrufen und organisieren
  • ✅ Render-Warteschlangenverwaltung - Kompositionen für das Batch-Rendering in die Warteschlange stellen
  • ✅ Mehrere Ausgabeformate - Unterstützung für h264, h265, VP8, VP9, ProRes, PNG-Sequenzen
  • ✅ Templatesystem - Vorgefertigte Vorlagen für gängige Videomuster
  • ✅ Komponentenbibliothek - Fertige Komponenten wie TextOverlay und Animationen
  • ✅ Typsicherheit - Vollständige TypeScript-Unterstützung mit umfassenden Schnittstellen

Installation

# Klone das Remotion-Repository
git clone https://github.com/remotion-dev/remotion.git
cd remotion

# Installiere Abhängigkeiten
bun install

# Das Skill befindet sich unter:
packages/skills-evals/remotion-claude-skill.ts

Schnellstart

1. Eine Skill-Instanz erstellen

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

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

2. Eine React-Komponente erstellen

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. Eine Komposition registrieren

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

4. Für das Rendern in die Warteschlange stellen

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

5. Metadaten abrufen

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

API-Referenz

RemotionClaudeSkill-Klasse

Konstruktor

constructor(config: RemotionSkillConfig)

Erstellt eine neue Skill-Instanz mit der bereitgestellten Konfiguration.

Parameter:

  • config: Konfigurationsobjekt mit width, height, fps, durationInFrames, projectName

Methoden

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

Erstellt und registriert eine neue Komposition.

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

Registriert eine bereits definierte Komposition.

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

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

Gibt alle registrierten Kompositionen zurück.

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

Ruft eine bestimmte Komposition anhand ihrer ID ab.

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

Stellt eine Komposition für das Rendern in die Warteschlange.

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

Gibt alle in der Warteschlange befindlichen Render-Jobs zurück.

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

Leert alle in der Warteschlange befindlichen Render-Jobs.

skill.clearRenderQueue();
getMetadata(): object

Gibt Skill-Metadaten und Statistiken zurück.

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

Generiert eine Vorlage für eine Videokomponente.

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

Schnittstellen

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;
}

Integrierte Komponenten

TextOverlay

Eine einfache Text-Overlay-Komponente.

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

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

Animations-Hilfsfunktionen

createFadeInAnimation

Generiert CSS für eine Einblend-Animation.

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

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

Vorlagen

Intro-Vorlage

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

Erstellt einen einfachen Texttitel, der auf schwarzem Hintergrund angezeigt wird.

Animationsvorlage

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

Zeigt Federanimationen und Skalierungseffekte.

Diashow-Vorlage

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

Zeigt, wie mehrere Sequenzen für einen Diashow-Effekt erstellt werden.

Vollständiges Beispiel

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

// Skill-Instanz erstellen
const skill = createRemotionSkill({
  projectName: 'demo',
  width: 1920,
  height: 1080,
  fps: 30,
  durationInFrames: 300,
});

// Komponente definieren
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>
  );
};

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

// Für das Rendern in die Warteschlange stellen
skill.queueForRender('demo', {
  codec: 'h264',
  outputLocation: './output/demo.mp4',
  crf: 18,
  overwrite: true,
});

// Metadaten überprüfen
console.log(skill.getMetadata());

Erweiterte Funktionen

Mehrere Kompositionen

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

// Alle für das Rendern in die Warteschlange stellen
for (const comp of skill.getCompositions()) {
  skill.queueForRender(comp.id, {
    codec: 'h264',
    outputLocation: `./videos/${comp.id}.mp4`,
    overwrite: true,
  });
}

Benutzerdefinierte Props

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

const MyVideo: React.FC<VideoProps> = ({ title, subtitle, duration }) => {
  // Component code
};

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

Bedingtes Rendern

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

Best Practices

  1. TypeScript verwenden - Nutzen Sie die vollständige Typsicherheit für Komponenten und Props
  2. Wiederverwendbare Komponenten erstellen - Bauen Sie eine Bibliothek von Komponenten für gängige Muster auf
  3. Leistung optimieren - Verwenden Sie Memoisierung für rechenintensive Operationen
  4. Batch-Rendering - Stellen Sie mehrere Kompositionen in die Warteschlange, um den Start-Overhead zu reduzieren
  5. Fehler behandeln - Verwenden Sie errorFn in RenderOptions für die Fehlerbehandlung
  6. Props validieren - Validieren Sie immer Standard-Props und Benutzereingaben

Fehlerbehebung

Komposition nicht gefunden

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

Render-Warteschlangenverwaltung

// Warteschlange leeren, bevor neue Jobs hinzugefügt werden
skill.clearRenderQueue();

// Warteschlangenlänge überprüfen
console.log(`Pending renders: ${skill.getRenderQueue().length}`);

Konfigurationsvalidierung

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`);

Integration mit Claude

In Claude-Gesprächen

  1. Verweisen Sie auf das Skill, um interaktiv Videos zu erstellen
  2. Ändern Sie Komponenten in Echtzeit
  3. Stellen Sie mehrere Versionen zum Vergleich in die Warteschlange
  4. Exportieren Sie die Konfiguration als JSON

Beispiel einer Claude-Interaktion

Benutzer: "Erstelle ein Intro-Video für meinen Podcast"

Claude: Ich erstelle ein Intro-Video mit dem 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',
  },
});

Ressourcen-Links

Lizenz

Dieses Skill unterliegt derselben Lizenz wie Remotion. Siehe LICENSE.md für Details.

Mitwirken

Um Verbesserungen an diesem Skill beizutragen:

  1. Forken Sie das Repository
  2. Erstellen Sie einen Feature-Branch
  3. Nehmen Sie Ihre Änderungen vor
  4. Reichen Sie einen Pull-Request ein

Weitere Informationen finden Sie in CONTRIBUTING.md.

Support

Verwandte Skills