Communitygithub.com

Remotion Compose

Transforme un brief vidéo en langage naturel en une composition Remotion complète, prête à être prévisualisée. Ce skill extrait la durée, les scènes, les couleurs, le rapport d'aspect et le texte, planifie le budget d'images et génère du code React/TypeScript animé avec useCurrentFrame, interpolate, spring, AbsoluteFill et Sequence, le tout enregistré dans Root.tsx.

Qu'est-ce que Remotion Compose ?

Remotion Compose est un skill d'agent IA spécialisé dans la génération de compositions vidéo animées à l'aide de la bibliothèque Remotion. Il prend un brief en langage naturel (ex. "réalise une démo produit de 20 secondes") et produit un fichier `.tsx` complet, prêt à être utilisé dans Remotion Studio. L'agent extrait automatiquement les paramètres clés (durée, scènes, couleurs de marque, rapport d'aspect, texte) grâce à une série d'étapes structurées. Il construit ensuite un plan de scènes avec un budget d'images précis, en utilisant les composants de base de Remotion (`Sequence`, `useCurrentFrame`, `interpolate`, `spring`, `AbsoluteFill`) pour créer des animations fluides et réactives. Le code généré est entièrement basé sur les props, ce qui permet de modifier facilement le contenu ou les couleurs sans repasser par l'agent. Ce skill est idéal pour les démos produit, les vidéos marketing, les walkthroughs de fonctionnalités et tout autre contenu promotionnel animé. Il ne doit pas être utilisé pour le rendu final (MP4) – utilisez plutôt `remotion-render` – ni pour l'installation initiale du projet – utilisez `remotion-setup`.

Compatible avec~Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/SkillMedev/skills/tree/HEAD/skills/remotion-compose

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Que fait Remotion Compose ?

Vous transformez un brief en langage naturel en une composition Remotion complète, prête à être prévisualisée – du vrai code React/TypeScript avec animation basée sur les images. Le résultat est un fichier .tsx dans src/compositions/, enregistré dans src/Root.tsx, que l'utilisateur peut immédiatement parcourir dans Studio ou confier à remotion-render.

Déclenchez ce skill sur toute demande de création, génération, animation ou "écriture du code vidéo pour" une démo produit, un walkthrough, une mise en avant de fonctionnalité ou une animation marketing – y compris "construis une vidéo de 20 secondes montrant X."

Étape 1 – Extraire le brief

Ne commencez pas à coder tant que vous n'avez pas ces informations. Posez les questions en un seul bloc compact ; comblez les lacunes évidentes avec des valeurs par défaut judicieuses plutôt que de bloquer :

  1. Durée en secondes, et fps (par défaut 30 – la norme pour les vidéos produit et marketing, et la moitié du coût de rendu par rapport à 60. Utilisez 60fps uniquement pour animer des mouvements fins de curseur ou des interfaces défilantes où 30fps aurait des saccades visibles).
  2. Scènes – ce qui se passe, dans l'ordre. Incitez à obtenir une liste de séquences : "logo, puis trois fonctionnalités, puis un CTA" plutôt que "une démo de mon application".
  3. Marque – les couleurs hexadécimales primaire/accent/arrière-plan, et la police (un nom de famille de police @remotion/google-fonts).
  4. Rapport d'aspect / plateforme – 16:9 paysage (1920×1080), 9:16 portrait (1080×1920) pour les réseaux sociaux, ou 1:1 carré (1080×1080).
  5. Texte – les vrais titres/noms de fonctionnalités/texte CTA. N'inventez jamais de revendications produit ; demandez les mots réels.

Convertissez les secondes en images partout : durationInFrames = seconds * fps. Longueurs totales typiques : 15-60s pour une démo sociale/produit, 6-15s pour une publicité.

Étape 2 – Construire un plan de scènes

Un <Composition> par vidéo, un composant par scène, assemblés sur la timeline avec <Sequence>. Établissez le budget d'images avant d'écrire le code :

Total : 20s @ 30fps = 600 images
  Intro (logo)        images   0-90    (Sequence from=0   durationInFrames=90)
  Fonctionnalité 1    images  90-240   (Sequence from=90  durationInFrames=150)
  Fonctionnalité 2    images 240-390   (Sequence from=240 durationInFrames=150)
  Fonctionnalité 3    images 390-540   (Sequence from=390 durationInFrames=150)
  CTA outro           images 540-600   (Sequence from=540 durationInFrames=60)

Seuils de rythme lors de la budgétisation :

  • Accordez à chaque séquence qui porte du texte au moins 2 secondes (60 images à 30fps) – animation d'entrée plus maintien. Un titre a besoin d'environ 150-200 ms de maintien par mot pour être lisible ; un titre de 6 mots nécessite environ 1 seconde de maintien après son apparition.
  • Animations d'entrée : 10-20 images. Fondus et sorties : 12-15 images. Plus longues sont perçues comme lentes, plus courtes comme un défaut.
  • Aucune scène plus courte qu'environ 45 images sauf s'il s'agit d'un flash délibéré.

<Sequence from={F}> décale l'horloge locale d'un enfant de sorte qu'à l'intérieur de ce composant, useCurrentFrame() commence à 0. Animez chaque scène comme si elle commençait à l'image 0.

Étape 3 – Référence de l'API principale

  • useCurrentFrame() – l'image courante (l'horloge). Tout s'anime en fonction de cette valeur.
  • useVideoConfig() – { fps, width, height, durationInFrames }.
  • interpolate(frame, [inFrames], [outValues], opts) – mappage linéaire. Passez toujours { extrapolateLeft: "clamp", extrapolateRight: "clamp" } pour les entrées/sorties afin que les valeurs ne dépassent pas leur plage.
  • spring({ frame, fps, config }) – simulation physique de 0→1 (léger dépassement). À utiliser pour tout ce qui doit paraître vivant (apparitions, glissements, agrandissements).
  • AbsoluteFill – un div plein écran positionné en absolu ; la couche de base de chaque scène.
  • Sequence – décale et limite temporellement les enfants (le planificateur de scènes).
  • Series / Series.Sequence – scènes consécutives sans avoir à calculer manuellement les décalages from.
  • Img, staticFile – voir Étape 6.

Étape 4 – spring() vs interpolate()

Utilisez spring() quand…Utilisez interpolate() quand…
Le mouvement doit sembler physique – apparitions, rebonds, agrandissements, glissementsVous avez besoin d'un contrôle linéaire précis entre des images exactes
Vous voulez un atterrissage/dépassement naturelFondus (opacité 0→1), changements de couleur, barres de progression, tout ce qui est synchronisé à l'image
Entrées de cartes, logos, badgesFondus et sorties où un dépassement serait inesthétique

Modèle – pilotez une transformation avec un spring, une opacité avec interpolate :

const { fps } = useVideoConfig();
const frame = useCurrentFrame();
const pop = spring({ frame, fps, config: { damping: 200 } });   // 0 → 1, vivant
const opacity = interpolate(frame, [0, 15], [0, 1], { extrapolateRight: "clamp" });
const scale = interpolate(pop, [0, 1], [0.8, 1]);

damping: 200 est la configuration de travail – un atterrissage rapide avec un dépassement à peine perceptible. Un damping plus faible (~10-20) rebondit visiblement ; utilisez-le uniquement lorsque le rebond est le but.

Étape 5 – Structure standard de démo produit

Codez cette forme sauf indication contraire du brief : introduction logo/marque → N mises en avant de fonctionnalités → outro CTA. Rendez-la basée sur les données (Étape 6) pour que les variations soient gratuites.

// src/compositions/ProductDemo.tsx
import {
  AbsoluteFill, Sequence, useCurrentFrame, useVideoConfig,
  interpolate, spring,
} from "remotion";
import { loadFont } from "@remotion/google-fonts/Inter";

const { fontFamily } = loadFont();

export type Feature = { title: string; body: string };
export type ProductDemoProps = {
  brand: string;
  colors: { bg: string; fg: string; accent: string };
  logoText: string;
  features: Feature[];
  cta: string;
};

const Intro: React.FC<{ text: string; colors: ProductDemoProps["colors"] }> = ({ text, colors }) => {
  const frame = useCurrentFrame();
  const { fps } = useVideoConfig();
  const s = spring({ frame, fps, config: { damping: 200 } });
  const scale = interpolate(s, [0, 1], [0.7, 1]);
  const opacity = interpolate(frame, [0, 12], [0, 1], { extrapolateRight: "clamp" });
  return (
    <AbsoluteFill style={{ backgroundColor: colors.bg, justifyContent: "center", alignItems: "center" }}>
      <h1 style={{ fontFamily, fontSize: 120, color: colors.fg, transform: `scale(${scale})`, opacity }}>
        {text}
      </h1>
    </AbsoluteFill>
  );
};

const FeatureCallout: React.FC<{ feature: Feature; colors: ProductDemoProps["colors"] }> = ({ feature, colors }) => {
  const frame = useCurrentFrame();
  const { fps } = useVideoConfig();
  const slide = spring({ frame, fps, config: { damping: 200 } });
  const x = interpolate(slide, [0, 1], [-60, 0]);
  const opacity = interpolate(frame, [0, 15], [0, 1], { extrapolateRight: "clamp" });
  return (
    <AbsoluteFill style={{ backgroundColor: colors.bg, justifyContent: "center", paddingLeft: 160 }}>
      <div style={{ transform: `translateX(${x}px)`, opacity }}>
        <div style={{ fontFamily, fontSize: 32, color: colors.accent, fontWeight: 700, letterSpacing: 2 }}>
          {feature.title.toUpperCase()}
        </div>
        <div style={{ fontFamily, fontSize: 64, color: colors.fg, maxWidth: 1100, marginTop: 16 }}>
          {feature.body}
        </div>
      </div>
    </AbsoluteFill>
  );
};

const Outro: React.FC<{ cta: string; colors: ProductDemoProps["colors"] }> = ({ cta, colors }) => {
  const frame = useCurrentFrame();
  const opacity = interpolate(frame, [0, 18], [0, 1], { extrapolateRight: "clamp" });
  return (
    <AbsoluteFill style={{ backgroundColor: colors.accent, justifyContent: "center", alignItems: "center" }}>
      <h2 style={{ fontFamily, fontSize: 84, color: colors.bg, opacity }}>{cta}</h2>
    </AbsoluteFill>
  );
};

export const ProductDemo: React.FC<ProductDemoProps> = ({ colors, logoText, features, cta }) => {
  const intro = 90;
  const per = 150;
  const outro = 60;
  return (
    <AbsoluteFill>
      <Sequence durationInFrames={intro}>
        <Intro text={logoText} colors={colors} />
      </Sequence>
      {features.map((f, i) => (
        <Sequence key={i} from={intro + i * per} durationInFrames={per}>
          <FeatureCallout feature={f} colors={colors} />
        </Sequence>
      ))}
      <Sequence from={intro + features.length * per} durationInFrames={outro}>
        <Outro cta={cta} colors={colors} />
      </Sequence>
    </AbsoluteFill>
  );
};

Enregistrez-le dans src/Root.tsx, en calculant durationInFrames à partir des mêmes nombres et en fournissant defaultProps :

<Composition
  id="ProductDemo"
  component={ProductDemo}
  durationInFrames={90 + 3 * 150 + 60}
  fps={30}
  width={1920}
  height={1080}
  defaultProps={{
    brand: "Acme",
    colors: { bg: "#0B0B0F", fg: "#FFFFFF", accent: "#6C5CE7" },
    logoText: "Acme",
    features: [
      { title: "Fast", body: "Ship in seconds, not sprints." },
      { title: "Simple", body: "One prompt, one video." },
      { title: "Yours", body: "Your brand, your copy." },
    ],
    cta: "Start free →",
  }}
/>

Pour une vidéo verticale/réseaux sociaux, définissez width={1080} height={1920} ; pour un carré, 1080×1080. Gardez les composants identiques – seule la toile change.

Étape 6 – Props basées sur les données et ressources statiques

La composition ci-dessus est entièrement basée sur les données : chaque mot et chaque couleur est une prop. C'est le but – les variantes (nouveau texte, nouvelle palette, texte localisé) ne nécessitent aucune nouvelle sollicitation ; il suffit de passer des props différentes (remotion-render le fait à partir d'un fichier JSON pour les lots).

Les ressources statiques (logos, captures d'écran, audio) se trouvent dans public/assets/ et sont référencées avec staticFile() – jamais une importation ou un chemin brut :

import { Img, staticFile } from "remotion";
<Img src={staticFile("assets/logo.png")} />

Étape 7 – Résultat

Enregistrez le fichier final dans src/compositions/<VideoName>.tsx, enregistrez-le dans src/Root.tsx, et dites à l'utilisateur de prévisualiser avec npx remotion studio (http://localhost:3000). Puis passez le relai : "Parcourez-le dans Studio. Dites-moi quoi changer – trop rapide, mauvaise couleur, texte différent – et je modifierai et relancerai le rendu (remotion-render)."

À NE PAS FAIRE

  • N'animez PAS avec des transitions/animations CSS ou setTimeout/setInterval. Remotion rend les images de manière indépendante et en parallèle ; tout ce qui n'est pas dérivé de useCurrentFrame() est invisible ou incohérent dans le rendu final, même si cela semble correct dans l'aperçu du navigateur.
  • N'utilisez PAS Math.random() pour des effets de particules/dispersés – chaque worker de rendu obtient des valeurs différentes et les images ne correspondent plus. Utilisez random(seed) de Remotion pour un pseudo-aléatoire déterministe.
  • Ne récupérez PAS de données et n'attendez PAS de travail asynchrone sans delayRender() / continueRender() – le moteur de rendu capture l'image avant l'arrivée des données.
  • Ne codez PAS en dur fps, width ou height à l'intérieur des composants de scène – lisez-les depuis useVideoConfig() pour que le passage de 30 à 60fps ou du paysage au portrait ne casse pas tous les minutages et mises en page.
  • N'omettez PAS extrapolateLeft/Right: "clamp" sur les interpolations d'entrée/sortie – l'opacité dépasse 1 et les éléments dérivent hors du canvas après la fin de leur plage.
  • N'inventez PAS de titres, de revendications de fonctionnalités ou de CTA – utilisez le texte réel de l'utilisateur, et demandez-le s'il manque.

Barre de qualité

  • Chaque valeur animée est une fonction pure de useCurrentFrame() (plus les props) – le défilement arrière dans Studio est identique au défilement avant.
  • Le budget d'images dans le plan correspond exactement à durationInFrames dans Root.tsx, et aucun texte ne reste visible moins que son minimum de lisibilité.
  • Tout le texte et les couleurs arrivent via des props typées avec defaultProps fournis – pas de littéraux cachés dans les composants de scène.
  • Les ressources se chargent via staticFile() ; le fichier s'enregistre proprement et s'affiche dans Studio sans erreur de console.

Individual skills in this repo

This repo contains 19 individual skills — each has its own dedicated page.

SkillMedev/skills

Designs REST API surfaces - resource naming, HTTP method and status-code semantics, error shapes, pagination, and filtering - and delivers an endpoint spec a consumer can build against without asking questions. Use when someone asks "how should I name this endpoint", "what status code should this return", "should this be PUT or PATCH", "how do I paginate this list", or is reviewing an API before it ships to external consumers. Do NOT use for planning breaking-change rollouts and deprecation windows - use api-versioning-strategist instead; for GraphQL type and resolver design - use graphql-schema instead; for generating client SDKs from an existing spec - use api-client-generator instead; for designing inbound webhook endpoints - use webhook-receiver-hardener instead.

SkillMedev/skills

Produce an accurate, properly timed caption track (SRT or WebVTT) from a video's audio - transcribing or aligning to the voiceover script, timing cues to speech, and enforcing line-length and reading-speed rules so captions are readable and in sync. Use when someone says "generate captions", "make subtitles from the audio", "transcribe and caption this", "export an SRT or VTT", "the captions are out of sync", or "the subtitles flash by too fast to read". Do NOT use to burn-in, style, reframe, or position an existing caption track for a platform (9:16, brand styling, safe areas) - that is social-video-formatter; do NOT use to animate text word-by-word as a motion graphic - that is kinetic-typography; do NOT use to write the spoken script in the first place - that is narration-script.

SkillMedev/skills

Turns data and charts into a decision-driving narrative structured as headline finding, trend, implication, and recommended action - with finding-led chart titles, context for every number, annotation guidance, and honest flags on any conclusion the data cannot support. Use when someone says "turn these numbers into a story", "what's the takeaway from this data", "help me present these results to leadership", or has charts but no narrative. Do NOT use for compressing a long document into a one-pager - use executive-summary instead - or for running the analysis that produces the findings - use eda-playbook instead.

SkillMedev/skills

Use when a task needs live or historical money data - "convert USD to EUR", "current/past exchange rate", "FX rate on this date / over this range", or "current price of Bitcoin/Ethereum, market cap, 24h change". Frankfurter (ECB reference rates, no key) is the FX default; CoinGecko's free keyless tier covers crypto. Do NOT use for stock quotes or equities - no keyless stock API survives verification, say so instead of guessing; do NOT use for country economic indicators like GDP or inflation series - use government-open-data instead; if the request is a vague "I need live data", route through public-data-api-picker.

SkillMedev/skills

Builds a driver-based FP&A operating model linking business inputs to P&L, balance sheet, and cash flow outputs. Use when building an annual plan, preparing investor materials, running scenario analysis, or stress-testing the business.

SkillMedev/skills

Use when a task needs live geographic lookups - "geocode this address", "what's at these coordinates" (reverse geocoding), "lat/lon for this city", "which country/state is this ZIP or postal code in", or "country facts: capital, currency, population, flag". Nominatim (OpenStreetMap) is the geocoding default; Zippopotam for postal codes; APICountries for country facts. All keyless. Do NOT use for weather at a location - use weather-climate instead; do NOT use for country-level statistics over time (GDP, population trends) - use government-open-data instead; if the request is a vague "I need live data", route through public-data-api-picker.

SkillMedev/skills

Runs the full Getting Things Done loop - capture, clarify, organize, reflect, engage - building a trusted system of context lists, a projects list with defined next actions, and a weekly review habit. Use when someone says "I'm overwhelmed and things are slipping through the cracks", "set up GTD for me", "help me do a brain dump and organize it", or "my to-do list is a mess". Do NOT use for just running the weekly review ritual itself - use weekly-review instead - or for clearing an email backlog - use inbox-zero.

SkillMedev/skills

Processes any email backlog to zero using the 4Ds - Delete, Delegate, Defer, Do - with a mass-archive strategy for the obvious, a touch-each-email-once discipline, and a keep-it-clear system of batched processing windows, ruthless unsubscribing, filters, and a minimal folder setup. Use when someone says "I have 5,000 unread emails", "help me get to inbox zero", "email is eating my whole day", or treats their inbox as a to-do list. Do NOT use for drafting the reply emails themselves or prioritization rules for an ongoing support queue - use email-triage instead - or for protecting focus time around the email windows - use deep-work-planner instead.

SkillMedev/skills

Write landing-page copy section by section - hero, social proof, features-as-benefits, objections, CTA - leading with one promise and proving it down the page. Use when someone asks "write my landing page", "improve my hero headline", "what should the homepage say", "turn these features into benefits", or is shipping a new page for a launch or campaign. Do NOT use for testing and optimizing an existing page's conversion rate - use landing-page-cro instead; for the one-line claim itself use positioning-statement; for the full message ladder use messaging-hierarchy.

SkillMedev/skills

Improves an existing landing page's conversion rate through evidence-first CRO - audit heatmaps and recordings, write structured hypotheses, prioritize with ICE scoring, and run one-variable tests to statistical significance. Use when someone asks "why isn't my landing page converting", "audit this page before we scale spend", "which A/B test should we run first", or after a CVR drop or ahead of a paid-traffic push. Do NOT use for writing a new landing page from scratch - use landing-page-copy instead. Do NOT use for auditing the ad accounts sending the traffic - use paid-acquisition-audit instead. Do NOT use for reading the results of a finished experiment - use ab-test-analyzer instead.

SkillMedev/skills

Runs structured coaching sessions using values clarification and the GROW model, ending every session with one committed action, a deadline, and an if-then plan for the likely obstacle. Use when someone says "I feel stuck in my life", "help me figure out what I want", "hold me accountable to my goals", or "coach me through this decision". Do NOT use for building a stress toolkit - use stress-management instead - or a journaling practice - use journal-framework; for a standing goal-tracking system, use goals-accountability. Coaching, not therapy: signs of clinical distress route to a licensed professional.

SkillMedev/skills

Adapts English content for a target language and region - swapping idioms, setting the right formality register, replacing cultural references, converting dates, units, and currency - and delivers the localized text with a notes column explaining each adaptation and flagging what needs a native reviewer. Use when someone asks "localize this copy for the Japanese market", "adapt our marketing copy for the Mexican market", "make this translation sound native instead of literal", or a literal translation reads foreign, stiff, or risky. Do NOT use for auditing in-product UI text quality - use ux-writing-audit instead.

SkillMedev/skills

Scaffolds a new Remotion video project wired for Claude Code Agent Skills - Node check, create-video scaffold, skills install, folder conventions, Google Fonts, and a smoke-test render. Use whenever someone wants to start making videos with Remotion and Claude, even just "make product videos with Claude.

SkillMedev/skills

Classifies incident severity (SEV1-4) using impact, scope, and urgency signals and decides who to page. Use when an alert fires or a report comes in and a severity call must be made quickly.

SkillMedev/skills

Use the Skill Me catalog from inside any conversation - discover, install, and manage Claude skills through the Skill Me MCP, and load installed skills automatically each session.

SkillMedev/skills

Write one platform-native caption from a topic and brand voice, with a front-loaded hook, native length, and a single earned CTA. Use when the user gives a topic (and optionally brand voice or a described image/video) and asks for an Instagram, LinkedIn, X/Twitter, or TikTok caption. Do NOT use when the user wants a dedicated standalone LinkedIn post - use linkedin-post-writer instead; or a multi-post X thread - use tweet-thread-builder instead; or to adapt one existing piece of content into versions for several channels - use cross-platform-reformatter instead.

SkillMedev/skills

Reframe and export a finished video for social platforms - 9:16 ↔ 16:9 cropping, burned-in captions, a platform-native first frame, loop design, and per-platform specs (aspect, length, safe areas) for TikTok, Reels, Shorts, X, and LinkedIn. Use when someone says "make this vertical", "crop to 9:16", "format for TikTok/Reels/Shorts", "add captions/subtitles", "why is my video cut off on mobile", "resize for Instagram", or "export for social". Do NOT use when the question is about the storyboard or shot order before any video exists (use video-storyboard); the animation craft of how elements move (use motion-design-principles); animated word-by-word caption styling (use kinetic-typography); palette, contrast, or lighting (use motion-color-and-light); directing the product-demo content and screen choreography (use product-demo-director); or scoring, beat-syncing, or audio (use sound-and-music-sync) - this is the craft layer that decides WHAT to format for the feed, then hands a concrete spec to remotion-compo...

SkillMedev/skills

Writes and tunes PySpark jobs - join strategy and broadcast size limits, shuffle-partition sizing, skew diagnosis and salting, UDF avoidance, caching, and output file layout - with concrete size and skew thresholds. Use when someone asks "why is my Spark job slow", "should I broadcast this join", "one task takes forever while the rest finish", "my job OOMs during a join", or is writing a new PySpark ETL job. Do NOT use for Kafka topic, consumer-group, or streaming-pipeline design - use kafka-pipelines instead; do NOT use for single-machine dataframe work that fits in memory - use pandas-expert instead.

SkillMedev/skills

Builds clean, performant, accessible SwiftUI views with correct state ownership, scoped invalidation, and smooth list scrolling, and reviews existing SwiftUI code against a concrete frame-time and re-render budget. Use when someone asks "why does my SwiftUI list stutter", "should this be @State or @Observable", "my whole screen re-renders when one row changes", "how do I animate this transition", or wants a SwiftUI view built or refactored. Do NOT use for cross-platform React Native apps - use react-native-pro instead; do NOT use for Flutter widget trees - use flutter-widget-architect instead; do NOT use for Android Compose UIs - use jetpack-compose-builder instead.

Skills associés