Communitygithub.com

reanimate

Montre à un agent comment planifier, construire ou découper « reanimate » pour obtenir une vidéo finale montée. La procédure suit les étapes : définition du « fait », workflow, portée. Utilisez-la quand une nouvelle tâche nécessite ce savoir-faire.

Qu'est-ce que reanimate ?

Reanimate est une compétence spécialisée qui permet à un agent IA de cloner des animations avec une fidélité extrême, en suivant un workflow rigoureux allant de la capture de la référence à la vérification image par image. Elle est conçue pour les développeurs utilisant Claude Code, Cursor ou Codex, et s'appuie sur des outils comme Playwright, ffmpeg et des scripts automatisés (capture, comparaison, analyse d'easing). La compétence définit trois niveaux de fidélité (motion-faithful, pixel-faithful, mixed) et impose une spécification précise de la cible, de la destination et du niveau avant toute capture. Le processus en six étapes (cadrage, capture de la référence, écriture du spec, implémentation, vérification itérative, rapport) garantit que le résultat est vérifiable objectivement par des métriques et des feuilles de comparaison, éliminant les approximations subjectives. Chaque cycle de vérification produit des rapports chiffrés et des feuilles côte à côte, et l'agent doit boucler jusqu'à ce que toutes les lignes du spec passent, avec un seuil maximal de 5 cycles avant d'être signalé comme échec.

Compatible avec✓Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/PedroColbert/ai-skills-collection/tree/HEAD/reanimate

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 reanimate ?

Reconstruisez ce que l'utilisateur désigne pour que cela bouge comme la référence, prouvez-le avec une comparaison image par image et continuez jusqu'à ce que la comparaison réussisse. Le livrable est du code dans le projet de l'utilisateur, accompagné de preuves (chiffres et feuilles côte à côte), jamais « ça semble à peu près correct ».

Ce que « fait » signifie

Choisissez le niveau de fidélité à partir des mots de l'utilisateur et indiquez-le dans le premier message ; il détermine ce que vous vérifiez.

NiveauQuandDoit correspondrePeut différer
fidèle au mouvement (par défaut)« cloner cette animation », « faire que la nôtre ressemble à la leur », « même héro que X mais notre copie »déclencheur, séquence et ordre, décalage, timing de chaque étape (±80 ms), famille d'easing, direction et distance du mouvement par rapport à la taille de l'élément, proportions de la mise en pagecopie, couleurs, polices, images, détails de marque
fidèle au pixel« correspondre exactement », « pixel-parfait », « les détails doivent correspondre », « 1:1 »tout ce qui précède plus polices, tailles, couleurs, espacement, rayons, ombres, assets ; écart moyen par image ≤ 2 %rien que l'utilisateur n'a pas demandé de changer
mixte« cloner X et ajouter Y », « comme le leur mais avec nos niveaux de prix »les parties clonées à l'un des niveaux ci-dessusles ajouts, que vous décrivez et montrez mais vérifiez uniquement pour ne pas casser le mouvement cloné

L'utilisateur peut restreindre la cible à une section, un widget, une page ou une plage temporelle d'une vidéo (« les 3 premières secondes », « 0:12 à 0:15 »). Clonez exactement cela ; n'importez pas le reste de la page.

Workflow

Tout ce qui suit vit dans .reanimate/<nom>/ à l'intérieur du projet de l'utilisateur (ajoutez-le à .gitignore sauf s'il souhaite que les preuves soient versionnées). Conservez les artefacts de chaque cycle ; ils sont la preuve.

0. Cadrage

Écrivez trois lignes en haut de .reanimate/<nom>/spec.md avant toute capture :

  • Cible : ce qu'il faut cloner, aussi précisément que l'utilisateur l'a dit (URL + sélecteur / plage temporelle / « le bouton dans le gif »).
  • Destination : où va le code et dans quelle stack (lisez package.json, les composants existants et la bibliothèque d'animation déjà utilisée ; correspondez-y plutôt que d'en introduire une nouvelle).
  • Fidélité : fidèle au mouvement, fidèle au pixel ou mixte, plus la liste des ajouts pour le mixte.

Déduisez ce que vous pouvez de la demande et du dépôt. Ne demandez que lorsque deux lectures mènent à un travail différent (par exemple « le héro » sur une page avec deux sections candidates). Lorsqu'une référence est une page derrière un mur de connexion ou un lien YouTube/Loom que vous ne pouvez pas télécharger ici, demandez à l'utilisateur un enregistrement d'écran et continuez avec tout le reste en attendant.

1. Configuration

<skill> ci-dessous est le répertoire dans lequel se trouve ce SKILL.md. Les scripts nécessitent Bun ; la première exécution télécharge le Chromium de Playwright et un ffmpeg statique (environ 250 Mo).

bash <skill>/scripts/setup.sh      # installe playwright, ffmpeg, pixelmatch une fois ; affiche « ready »

Tous les scripts sont exécutés avec bun <skill>/scripts/<nom>.ts --help. Ils sont déterministes et partagent une règle : capturez la référence et le clone avec le même viewport, recadrage du sélecteur, déclencheur, durée et fps, sinon la comparaison mesure votre configuration au lieu de votre travail.

2. Capture de la référence

Lisez references/capture.md pour la recette adaptée à votre type de source. En résumé :

  • Site web : capture.ts --url … --out ref --selector <section> --trigger load|scroll|hover|click|none --duration … --track "<éléments mobiles>". Vous obtenez video.webm, frames/, inspect.json (animations déclarées, keyframes, styles calculés, polices, bibliothèques détectées) et track.json (position, taille, opacité, transformation de chaque élément suivi par image d'animation). Pour le mouvement CSS/WAAPI, inspect.json contient souvent les durées, délais et easings exacts : utilisez-les, cela vaut mieux que d'estimer.
  • Vidéo ou gif : frames.ts --in file --out ref/frames --fps 10..30 --start … --end … --crop …. Sondez d'abord avec --probe, puis visualisez quelques images pour trouver le recadrage du widget que vous clonez.
  • Canvas, WebGL, WebGPU, 3D (inspect.json › canvases en montre un, ou la page utilise three.js, Pixi, Babylon, Spline…) : ajoutez --clock virtual --gl --assets à la capture et lisez gl/summary.md (gl.ts summary <out>). Vous obtenez les sources des shaders, chaque constante uniforme, le graphe de scène, les passes de rendu, les textures et modèles, et chaque propriété uniforme ou d'objet animée comme un canal dans gl-track.json. L'horloge virtuelle rend chaque image exacte et chaque capture identique, particules aléatoires comprises. Lisez references/webgl.md.
  • Lottie / Rive / export de prototype : le fichier est le spec ; lisez-le, ne le déduisez pas des pixels.

Ensuite, construisez des feuilles étiquetées et regardez-les : sheet.ts filmstrip --frames ref/frames --out ref/sheets. Lisez chaque feuille avec le visualiseur d'images. C'est l'inspection image par image demandée par l'utilisateur ; ne la sautez pas et ne prélevez que la première feuille.

3. Écrire le spec de mouvement

Remplissez spec.md en utilisant le modèle dans references/analysis.md. Une ligne par élément par propriété : déclencheur, heure de début, durée, délai ou décalage, de → à, easing, notes. Obtenez les nombres, par ordre de préférence : les animations et keyframes de inspect.json → easing.ts sur track.json, ou sur gl-track.json --channel pour canvas → la lecture des images (première image où cela change, dernière image où cela change, dépassement ou non). Notez également les faits statiques dont dépend le mouvement : tailles et positions des éléments, ordre z, rognage par débordement, origines de transformation, et pour le travail pixel-fidèle, polices, couleurs, espacement et assets.

Le spec est le contrat entre la référence et le clone. Chaque ligne devient une vérification à l'étape 5. Si une ligne comporte un « ? », vous n'avez pas fini de lire les images.

4. Construction

Implémentez dans la stack de l'utilisateur en suivant references/implementation.md (tableaux d'easing, mathématiques de décalage, déclencheurs de défilement et de survol, mouvement réduit). Gardez la structure DOM proche de la structure de rôle de la référence afin que les sélecteurs suivis aient des équivalents. Pour le travail mixte, placez les ajouts dans des composants ou blocs clairement séparés et mentionnez-les dans spec.md sous « Ajouts ».

Donnez au clone un moyen d'être capturé de la même manière que la référence : une route ou une page statique qui rend le composant avec le viewport de la référence et le même déclencheur. Un serveur de développement convient (capture.ts --url http://localhost:5173/…) ; un fichier HTML autonome fonctionne aussi.

5. Vérifier, corriger, répéter

Capturez le clone avec la commande exacte utilisée pour la référence, en changeant seulement --url et --out clone-N, puis :

bun <skill>/scripts/compare.ts --ref ref/frames --clone clone-N/frames --out compare-N
bun <skill>/scripts/sheet.ts compare --ref ref/frames --clone clone-N/frames --diff compare-N/diff --out compare-N/sheets --every 2
bun <skill>/scripts/easing.ts --track clone-N/track.json --selector "<élément>" --prop <translateY|opacity|…> --compare-track ref/track.json

Pour le travail canvas, exécutez aussi gl.ts compare --ref ref --clone clone-N, qui vérifie les paramètres du canvas, la structure de dessin et chaque canal animé.

Lisez references/verify.md pour savoir comment lire le rapport, les critères de réussite pour chaque niveau de fidélité et les correctifs dont chaque type d'échec a généralement besoin. Regardez vous-même les feuilles de comparaison à chaque cycle ; les chiffres vous disent que quelque chose cloche, les feuilles vous disent quoi.

Bouclez jusqu'à ce que chaque ligne du spec réussisse. Chaque cycle : modifiez la plus petite chose que la preuve indique, re-capturez, re-comparez. Attendez-vous à 2 à 5 cycles. Si après 5 cycles une ligne échoue toujours, arrêtez-vous et rapportez-la avec ses chiffres et la raison (police manquante, shader ou modèle que l'utilisateur ne peut peut-être pas copier, ressort physique que vous avez approximé), n'abaissez pas silencieusement le seuil et ne supprimez pas la ligne.

6. Rapport

Le message final doit se suffire à lui-même :

  • Niveau de fidélité et ce qui a été cloné, ce qui a été ajouté.
  • Où se trouve le code (fichiers) et comment déclencher le mouvement.
  • Un court tableau du dernier cycle de comparaison : erreur de timing, écart moyen, correspondance d'easing par élément clé, réussi/échoué.
  • Chemins vers les dernières feuilles de comparaison, incorporées en tant qu'images lorsque l'environnement les affiche.
  • Écarts résiduels, chacun avec un chiffre et une raison.

Pièges qui font perdre des cycles

  • Viewport ou recadrage différent entre la référence et le clone : corrigez la capture avant de toucher au code.
  • Juger uniquement à partir de la première et de la dernière image : l'easing vit dans les images du milieu ; lisez les feuilles.
  • Polices : une police de secours différente change les pixels de chaque image. Pour le travail pixel-fidèle, chargez la même police (depuis les polices de inspect.json) avant de juger l'écart ; pour le travail fidèle au mouvement, ignorez les pixels de texte et lisez les colonnes de timing.
  • Référence enregistrée sur une page chargée vs clone capturé à froid : utilisez --wait-before, ou --trigger none avec un --pre-js qui redémarre l'animation, afin que les deux commencent au repos.
  • Mouvement piloté par le défilement : c'est une fonction de la position de défilement, pas du temps. Capturez les deux avec les mêmes --scroll-steps et --scroll-ms, et comparez par position de défilement (le scrollY de la piste), pas par seconde.
  • Bibliothèques JS (GSAP, Framer Motion springs) : --playback-rate ne les ralentit pas. Utilisez track.json et easing.ts (qui rapporte le dépassement et « ressemble à un ressort ») et ajustez les paramètres du ressort en fonction du dépassement et du temps de stabilisation.
  • Les vidéos de l'écran de quelqu'un d'autre ont un curseur, un chrome de navigateur et du bruit de compression : recadrez-les et augmentez un peu --pixel-threshold (0,15) plutôt que de chasser le bruit.
  • Canvas et WebGL capturés sur l'horloge réelle : des images sont perdues dans le logiciel GL et le contenu aléatoire diffère à chaque chargement, donc la comparaison mesure la machine. Capturez les deux côtés avec --clock virtual et la même --seed.
  • Reconstruire un shader à partir de captures d'écran : la trace a déjà sa source et chaque constante. Lisez gl/shaders/ et les uniforms fixes avant d'écrire du GLSL.

Individual skills in this repo

This repo contains 1 individual skill — each has its own dedicated page.

Skills associés