Communitygithub.com

blixvip/skills

Le vocabulaire du mouvement qui sépare une animation premium du « slop » IA — effet pop-blur-fade texte, décalages séquentiels, caméras toujours en mouvement avec easing, entrées d'objets, et les tables de timing/easing qui les sous-tendent. Inclut du code prêt pour Remotion (interpolate/spring) et HyperFrames (GSAP). À utiliser lors de l'animation de trames conçues, lorsque le mouvement semble « rigide », « rebondissant », « saccadé », « trop rapide », « trop uniforme », ou lors de l'écriture de code de timing/easing pour la vidéo.

Qu'est-ce que skills ?

Ce skill fournit une bibliothèque complète de principes de mouvement et de recettes de code prêtes à l'emploi pour créer des animations vidéo au rendu professionnel et coûteux, en évitant les artefacts communs de l'animation générée par IA. Il définit quatre lois fondamentales de l'animation (pas de mouvement linéaire, entrées décalées, caméra toujours en mouvement, durées variées) et une table de timing détaillée spécifiant les durées, les décalages (stagger) et les fonctions d'easing pour les mots, les lignes de texte, les icônes, les panneaux, les objets héroïques et les traits. Le skill inclut des implémentations complètes pour deux frameworks : Remotion, avec des extraits de code TypeScript utilisant `interpolate`, `spring`, et `Easing` ; et HyperFrames/GSAP, avec des exemples de timelines JavaScript et des règles strictes de structure HTML/CSS. Il est particulièrement utile lorsqu'une animation semble mécanique, manque de personnalité ou présente des artefacts comme des images statiques (manque de mouvement de caméra), des éléments qui arrivent tous en même temps, ou des mouvements qui s'arrêtent et démarrent brusquement. Le skill met également l'accent sur le déterminisme (interdit `Math.random()`, `Date.now()`, et les boucles infinies) et inclut des règles anti-saccades et une section d'auto-vérification. Il est conçu pour des développeurs utilisant des outils d'agent IA comme Claude Code, Cursor ou Codex qui travaillent sur des compositions vidéo.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/blixvip/skills/tree/HEAD/motion-animate

Demander à votre IA préférée

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

Documentation

motion-animate

Le design décide si une trame est bonne. Le mouvement décide si elle a l'air chère. La même composition animée avec un easing linéaire et des entrées simultanées se lit comme générée ; animée avec le vocabulaire ci-dessous, elle se lit comme créée.

Recettes moteur : Annexe A, Annexe B.

Les quatre lois

  1. Rien n'est linéaire. Chaque propriété bouge avec un ease. Le mouvement linéaire n'existe pas dans le monde physique et l'œil le sait instantanément.
  2. Rien n'arrive en même temps. Les éléments arrivent dans un ordre délibéré avec 60–120ms entre eux. L'entrée simultanée est le signe le plus fort d'une animation générée.
  3. La caméra n'est jamais complètement immobile. Une poussée ou une dérive lente et continue sous chaque composition. Les images statiques se lisent comme des diapositives.
  4. Rien n'est métronomique. Variez les durées et l'espacement des coupes. Des battements uniformes de 1s semblent automatisés, peu importe la qualité de chaque battement.

Table de timing

Valeurs à 30 ips ; à adapter pour 60 ips. Temps en ms.

ÉlémentDuréeDécalageEase
Mot dans une ligne de texte400–55060–90out-expo / power3.out
Ligne de texte (comme unité)500–650120–180out-cubic / power2.out
Icône / petit élément d'interface350–45080–120out-back (dépassement ≤1.06)
Panneau / carte550–700140–200out-quint / power4.out
Objet héroïque (entrée par échelle)700–900—out-expo
Objet héroïque (entrée par glissement)650–850—out-quint
Trait / dessin de ligne600–1000—in-out-cubic
Poussée de caméra (par scène)durée totale de la scène—out-sine, ou quasi-linéaire si très lent
Sortie (tout élément)250–35040–60in-cubic

Les sorties sont toujours plus rapides que les entrées, environ de moitié. Une animation de sortie symétrique semble lente.

Les mouvements de base

Texte — pop-blur-fade, mot par mot

Le mouvement signature. Chaque propriété s'anime ensemble, par mot, avec décalage.

y:       +18px → 0
blur:    12px  → 0
opacity: 0     → 1
ease:    out-expo,  durée 480ms,  décalage 70ms

Ajoutez éventuellement scale: 0.96 → 1. N'ajoutez pas de rotation. Ne rebondissez pas.

Pour une longue ligne, décalez par mot, pas par caractère — le décalage par caractère ressemble à un gadget de machine à écrire et prend trop de temps. Réservez le décalage par caractère pour un seul mot d'accent court.

Mot d'accent

Effectue le même mouvement mais retardé de 120 à 200 ms après ses voisins et avec une propriété supplémentaire — un changement de couleur, une augmentation d'échelle à 1.04, ou une barre de surbrillance qui apparaît derrière lui. Il doit arriver en dernier et arriver différemment.

Icônes et interface utilisateur

Pop-fade : scale 0.7 → 1, opacity 0 → 1, out-back avec dépassement limité à 1.06. Tout dépassement supérieur à 1.1 ressemble à un rebond bon marché.

Règle séquentielle : l'élément d'ancrage entre en premier, puis ses dépendants. Une carte entre, puis son icône, puis son étiquette. Jamais l'inverse, jamais ensemble.

Panneaux / cartes / verre

y: +40 → 0, opacity 0 → 1, out-quint, 600ms, décalés de 160ms à travers une pile. Ajoutez un surbrillance lumineuse qui balaie le panneau 150ms après son arrivée — le panneau arrive, puis il attrape la lumière.

Objet héroïque

Deux options, choisissez selon l'archétype :

  • Entrée par échelle : scale 1.25 → 1.00 avec rotate 3° → 0°, out-expo, 800ms. Donne l'impression de se poser.
  • Entrée par glissement : depuis hors-cadre avec une inclinaison de 2° qui se résout à 0°, out-quint, 750ms. Donne l'impression d'être livré.

L'ombre portée et la texture découpée doivent être parentées à l'objet héroïque pour qu'elles bougent avec lui. Des ombres non parentées glissant indépendamment est un échec.

Trait / dessin de ligne

Animez la longueur du chemin 0 → 100%, in-out-cubic, 600–1000ms. Ease à l'entrée et à la sortie — un dessin qui commence à pleine vitesse semble mécanique. Utilisez-le pour connecter une étiquette à un sujet, souligner un mot d'accent, ou tracer un graphique.

Caméra

Sous chaque composition, l'un des éléments suivants :

  • Poussée avant : scale 1.00 → 1.08 sur toute la durée du battement, out-sine.
  • Poussée arrière : scale 1.12 → 1.00, plus rapide au début, puis se stabilisant.
  • Dérive : translation x ou y de 2–4% sur le battement.

Contrat anti-saccades :

  • Animez un élément wrapper, jamais l'élément qui possède la mise en page ou le clip.
  • Utilisez uniquement transform — jamais top/left/width/height.
  • Mettez à l'échelle la couche en mouvement d'environ 6% au-delà du cadre pour que les bords ne soient jamais révélés.
  • Définissez will-change: transform et forcez la composition GPU.
  • Gardez le déplacement total faible. Les grands mouvements de caméra amplifient chaque erreur d'arrondi.

Transitions entre les battements

  • Coupe franche masquée par un effet sonore — la valeur par défaut. Les fondus enchaînés entre des trames conçues brouillent les deux.
  • Passage par échelle — un élément s'agrandit pour remplir le cadre et la scène suivante est révélée à l'intérieur.
  • Fondu par une forme — un cercle ou un panneau s'agrandit au-delà du bord du cadre, portant la scène suivante.

Ne faites pas de fondu enchaîné entre deux compositions conçues. N'utilisez pas de préréglage de transition standard.

Interdit

  • Easing linéaire sur quoi que ce soit de visible.
  • Dépassement de rebond >1.1 (exception : un style SaaS/produit intentionnellement ludique, et alors de manière cohérente).
  • Tous les éléments entrant sur la même trame.
  • Longueurs de battement uniformes à travers un montage.
  • repeat: -1 ou toute boucle infinie — les rendus sont échantillonnés par trame et doivent être déterministes.
  • Math.random(), Date.now(), ou des requêtes réseau à l'intérieur d'une composition. La même entrée doit produire la même trame à chaque fois.
  • Mouvement appliqué à un wrapper que le framework contrôle déjà (voir Annexe B §règle de clip).

Auto-vérification

Parcourez le rendu à 0.25× la vitesse. Demandez :

  • Quelque chose commence-t-il et s'arrête-t-il brusquement ? → ease manquant.
  • Tout arrive-t-il en même temps ? → décalage manquant.
  • La trame reste-t-elle complètement immobile ? → caméra manquante.
  • Les battements consécutifs semblent-ils un battement de tambour ? → durées trop uniformes.
  • Les bords d'une couche en mouvement sont-ils jamais révélés ? → pas assez mis à l'échelle.

Annexe A — Recettes Remotion

Basé sur les trames, déterministe par construction. Tout timing dérive de useCurrentFrame().

Aide : temps en ms, pas en trames

Créer en trames fige votre fps. Convertissez.

import {useVideoConfig, useCurrentFrame, interpolate, Easing} from 'remotion';

const useMs = () => {
  const {fps} = useVideoConfig();
  return (ms: number) => (ms / 1000) * fps;
};

Table de correspondance des easings

Les noms dans la table de timing, en termes Remotion :

Easing.out(Easing.exp)                    // out-expo
Easing.out(Easing.cubic)                  // out-cubic
Easing.out(Easing.quad)                   // out-quad
Easing.out(Easing.poly(4))                // out-quint-ish
Easing.inOut(Easing.cubic)                // in-out-cubic
Easing.out(Easing.sin)                    // out-sine
Easing.in(Easing.cubic)                   // in-cubic  (sorties)
Easing.bezier(0.16, 1, 0.3, 1)            // le cheval de bataille — out de type expo

Pour le dépassement, préférez un spring à Easing.back — il est plus facile de rester subtil.

import {spring} from 'remotion';
const s = spring({frame, fps, config: {damping: 200, stiffness: 120, mass: 0.6}});
// damping 200 = aucun dépassement visible. Abaissez à ~14 pour une petite stabilisation.

Texte — pop-blur-fade, mot par mot

const Words: React.FC<{text: string; delay?: number}> = ({text, delay = 0}) => {
  const frame = useCurrentFrame();
  const ms = useMs();
  const STAGGER = ms(70);
  const DUR = ms(480);

  return (
    <span style={{display: 'inline-flex', flexWrap: 'wrap', gap: '0.28em'}}>
      {text.split(' ').map((word, i) => {
        const local = frame - ms(delay) - i * STAGGER;
        const p = interpolate(local, [0, DUR], [0, 1], {
          extrapolateLeft: 'clamp',
          extrapolateRight: 'clamp',
          easing: Easing.bezier(0.16, 1, 0.3, 1),
        });
        return (
          <span
            key={i}
            style={{
              display: 'inline-block',
              opacity: p,
              filter: `blur(${(1 - p) * 12}px)`,
              transform: `translateY(${(1 - p) * 18}px)`,
              willChange: 'transform, filter, opacity',
            }}
          >
            {word}
          </span>
        );
      })}
    </span>
  );
};

Le mot d'accent est le même composant avec delay réglé 120–200ms plus tard plus sa propre couleur et un scale(1.04).

Caméra — poussée toujours active

Enveloppez toute la scène. Mettez à l'échelle au-delà pour que les bords ne soient jamais révélés.

const Camera: React.FC<{children: React.ReactNode; durationInFrames: number}> = ({
  children, durationInFrames,
}) => {
  const frame = useCurrentFrame();
  const scale = interpolate(frame, [0, durationInFrames], [1.0, 1.08], {
    extrapolateRight: 'clamp',
    easing: Easing.out(Easing.sin),
  });
  return (
    <AbsoluteFill style={{transform: `scale(${scale})`, willChange: 'transform'}}>
      {children}
    </AbsoluteFill>
  );
};

Placez la caméra au-dessus de la couche de fond et en dessous de tout élément qui doit rester épinglé au bord du cadre.

Pile de cartes décalées

const cards = ['Un', 'Deux', 'Trois'];
const ms = useMs();

{cards.map((label, i) => {
  const local = frame - i * ms(160);
  const p = interpolate(local, [0, ms(600)], [0, 1], {
    extrapolateLeft: 'clamp', extrapolateRight: 'clamp',
    easing: Easing.out(Easing.poly(4)),
  });
  return (
    <div key={i} style={{
      opacity: p,
      transform: `translateY(${(1 - p) * 40}px)`,
    }}>{label}</div>
  );
})}

Sortie — la moitié de l'entrée

const exitStart = durationInFrames - ms(300);
const out = interpolate(frame, [exitStart, durationInFrames], [1, 0], {
  extrapolateLeft: 'clamp', extrapolateRight: 'clamp',
  easing: Easing.in(Easing.cubic),
});

Structure

Utilisez <Sequence from={...} durationInFrames={...}> par battement, piloté directement par la table motion-plan. Un Sequence par ligne. Les durées des battements proviennent du plan, pas de nombres ronds.

<Series>
  <Series.Sequence durationInFrames={ms(5200)}><BeatTwo /></Series.Sequence>
  <Series.Sequence durationInFrames={ms(2100)}><BeatThree /></Series.Sequence>
</Series>

Déterminisme

  • Jamais Math.random() — si vous avez besoin de dispersion, déduisez-la de l'index de l'élément.
  • Jamais Date.now() ou new Date().
  • Jamais de requête à l'intérieur d'un composant. Préchargez avec staticFile() / delayRender().
  • <Video>/<Audio> doit être <OffthreadVideo> dans la mesure du possible pour la correction du rendu.

Pièges

  • filter: blur() sur plusieurs éléments simultanés est coûteux — limitez le nombre de nœuds flous simultanés, ou pré-floutez dans l'actif.
  • Chargement de polices : utilisez @remotion/google-fonts ou delayRender autour d'un FontFace.load() local, sinon les premières trames s'afficheront dans une police de secours.
  • interpolate lève une exception si la plage d'entrée n'est pas monotone croissante — protégez les plages calculées.
  • Passez toujours extrapolateLeft/extrapolateRight: 'clamp' sauf si vous voulez spécifiquement que la valeur dépasse la plage.

Annexe B — Recettes HyperFrames / GSAP

HyperFrames compose HTML + GSAP et rend en échantillonnant les trames d'un navigateur sans tête. Le déterminisme est obligatoire.

Exécutez npx hyperframes docs pour l'API actuelle. Ce fichier est le standard de mouvement par-dessus — voir le skill hyperframes pour le pipeline (init → preview → lint → render).

La règle de clip (cas de rendu cassé si violée)

Chaque élément temporisé a besoin de data-start, data-duration, data-track-index et class="clip". Le framework possède la visibilité et la transformation sur .clip.

Ne jamais GSAPer l'élément .clip lui-même. Animez un wrapper enfant.

<div class="clip" data-start="4.2" data-duration="5.2" data-track-index="2">
  <div class="cam">           <!-- les mouvements de caméra ici -->
    <div class="inner">       <!-- les mouvements d'élément ici -->
      <h1 class="headline">…</h1>
    </div>
  </div>
</div>

Enregistrement de la timeline

const tl = gsap.timeline({paused: true});
window.__timelines['main'] = tl;   // l'id doit correspondre à data-composition-id

En pause, toujours. Le renderer la cherche.

Table de correspondance des easings

Nom dans la tableGSAP
out-expoexpo.out
out-cubicpower2.out
out-quintpower4.out
out-back (limité)back.out(1.2)
in-out-cubicpower2.inOut
out-sinesine.out
in-cubic (sorties)power2.in

Texte — pop-blur-fade, mot par mot

Divisez en spans de mots au moment de la création (ne comptez pas sur un séparateur en cours d'exécution — il peut dépasser la première trame échantillonnée).

<h1 class="headline">
  <span class="w">Ce</span> <span class="w">qui</span>
  <span class="w accent">ressemble</span> <span class="w">à</span> <span class="w">de</span> <span class="w">la</span> <span class="w">discipline</span>
</h1>
tl.from('.headline .w', {
  y: 18,
  opacity: 0,
  filter: 'blur(12px)',
  duration: 0.48,
  ease: 'expo.out',
  stagger: 0.07,
}, 0);

// le mot d'accent arrive en dernier et différemment
tl.from('.headline .accent', {
  scale: 0.96,
  color: 'var(--surface)',
  duration: 0.5,
  ease: 'expo.out',
}, 0.18);

Caméra

Animez .cam, jamais .clip.

tl.fromTo('.cam',
  {scale: 1.0},
  {scale: 1.08, duration: 5.2, ease: 'sine.out', force3D: true},
0);
.cam { will-change: transform; transform: translateZ(0); }

Mettez à l'échelle la couche en mouvement d'environ 6% au-delà du cadre pour que les bords ne soient jamais révélés lors d'une poussée arrière ou d'une dérive.

Pile de cartes décalées

tl.from('.card', {
  y: 40, opacity: 0,
  duration: 0.6, ease: 'power4.out', stagger: 0.16,
}, 1.2);

// le balayage lumineux arrive 150ms après le panneau
tl.fromTo('.card .sweep', {xPercent: -140}, {
  xPercent: 140, duration: 0.7, ease: 'power2.inOut', stagger: 0.16,
}, 1.35);

Dessin de trait

tl.fromTo('.connector', {drawSVG: '0%'}, {drawSVG: '100%', duration: 0.8, ease: 'power2.inOut'});
// pas de DrawSVGPlugin ? utilisez stroke-dasharray/offset :
tl.fromTo('.connector', {strokeDashoffset: 1000}, {strokeDashoffset: 0, duration: 0.8, ease: 'power2.inOut'});

Règles strictes

  1. Déterministe seulement — pas de Math.random(), pas de Date.now(), pas de fetch, pas de repeat: -1.
  2. 9:16 = 1080×1920. Définissez #root { container-type: size; } et dimensionnez tout en cqw/cqh (1cqw = 10.8px), jamais vw/vh.
  3. Les clips adjacents sur la même piste ne doivent pas se toucher. Les maths flottantes font que 3.2 + 0.35 = 3.5500000000000003, ce qui chevauche un clip commençant à 3.55 et déclenche overlapping_clips_same_track. Laissez un espace, ou utilisez des durées comme 0.34.
  4. Audio : les vidéos sont muted ; utilisez une seule piste <audio> maître pré-mixée (VO + effets sonores mixés avec ffmpeg adelay + amix) sur un data-track-index dédié élevé. Plusieurs <audio> entraînent une dérive de la timeline lors du rendu. Ajoutez des blancs de 0.5s en début de piste audio pour un rendu stable.
  5. Contrat "Mouvement sans saccades" : force3D:true, will-change: transform, mise à l'échelle du repère de +6% sur toutes les couches animables, et les animations xPercent/yPercent uniquement sur la couche .cam — jamais sur les enfants.

Individual skills in this repo

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

blixvip/skills

Source, generate, and prepare the real assets that keep a motion-graphics edit from looking generated — sampling the palette from the footage, collecting style references, pulling 3D models/Lottie/SVG/textures/SFX, generating AI stills and b-roll, and the mandatory conform pass that grades every asset into one palette. Use when a scene needs an icon, logo, 3D object, texture, background, screenshot, chart source, sound effect, or generated image/video, and whenever output "looks flat", "looks stocky", "looks AI", or assets came from different places and no longer match.

blixvip/skills

Design the actual frames for motion graphics and generated UI — palette derived from the footage, type pairing, one of five scene archetypes, and the layering order that produces depth instead of flat AI slop. Use when building scenes in Remotion, HyperFrames, After Effects, or any generated-image pipeline (Nano Banana / GPT Image / Seedream), and whenever output "looks AI-generated", "looks flat", "looks like a template", or needs to match a creator's branding.

blixvip/skills

The end-to-end runbook for turning raw footage plus a script into a finished, non-sloppy edit — stage order, quality gates, on-disk artifact layout, engine choice, parallel shot builds, and the ship checklist. Use this as the FIRST skill whenever the ask is "edit this video", "make me a video", "add motion graphics to this", "one-shot this edit", or any request that spans more than a single isolated animation. It sequences motion-plan, motion-assets, motion-design and motion-animate; do not run those ad hoc when a whole edit is in scope.

blixvip/skills

Turn a script or timestamped transcript into a shot-by-shot motion plan — which lines earn an on-screen visual, which stay bare A-roll rest, what each visual must show, and how long it holds. Use BEFORE designing or animating anything in Remotion, HyperFrames, or After Effects. Triggers on "plan this edit", "what should be on screen", "storyboard this script", "beat map", "where do the animations go", or any request to animate a video that arrives without a shot list.

Skills associés