Communitygithub.com

principes-de-design-de-mouvement

Guide un agent pour planifier, créer ou affiner des « principes de design de mouvement » afin que le résultat concret soit une feuille de route et une liste de plans.

Qu'est-ce que principes-de-design-de-mouvement ?

Cette compétence permet à un agent de maîtriser le jugement sur le mouvement en design, qu'il s'agisse d'interfaces UI, de vidéos produit ou d'animations. Elle décompose le processus en six étapes : diagnostiquer le problème (linéaire/flottant/saccadé/mort), choisir la courbe d'easing adaptée, définir le timing et l'espacement, construire l'arc anticipation‑action‑suivi, appliquer les principes Disney pertinents et livrer le cahier des charges. Chaque étape est directement opérationnelle avec des règles concrètes (par exemple, les entrées utilisent `ease-out`, les sorties `ease-in`, le physique utilise un `spring()`). La compétence distingue clairement les rôles : elle ne produit pas le code ni le rendu final – elle génère la spécification de mouvement qui sera consommée par d'autres compétences comme **product-demo-director** ou les transitions CSS/JS. Un script Node.js pratique `motion_pick.js` est fourni pour calculer automatiquement la courbe, la durée, et le choix spring vs interpolate pour chaque élément.

Compatible avec~Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/ensinohi-lab/thesis-skills/tree/HEAD/motion-design-principles

Demander à votre IA préférée

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

Documentation

Principes de design de mouvement

C'est la couche de la sensation. Elle décide comment un élément doit bouger pour paraître soigné et intentionnel, au lieu d'être saccadé, flottant ou bon marché. Elle n'écrit pas le code qui joue le mouvement : une fois que vous avez choisi la courbe, le timing et l'arc, cette décision est l'entrée d'une compétence de mise en scène/rendu (pour une vidéo produit, transmettez-la à product-demo-director ou à vos transitions CSS/JS pour l'UI). Gardez les deux tâches séparées : cette compétence possède le jugement ; la compétence de réalisation possède l'orchestration et la mécanique.

Déclenchez-la pour tout ce qui concerne la sensation du mouvement : « rends ça moins saccadé », « plus fluide », « plus soigné », « plus vivant », « l'easing est mauvais », « ça a l'air cheap », « dois-je utiliser ease-in ou ease-out », « spring ou interpolation ».

Quand utiliser une compétence voisine à la place

Cette compétence est le jugement exclusif sur la courbe/timing/arc. Déléguez quand la vraie question est :

  • Quels plans, ordre des scènes ou liste de plans → video-storyboard.
  • Réaliser une démo produit complète – mouvements de curseur, captures d'écran, annotations de fonctionnalités, assemblage de séquence → product-demo-director. (Cette compétence produit la spécification de mouvement qu'elle consomme.)
  • Animer du texte ou des lettres – texte qui vole/construit/révèle → kinetic-typography.
  • Caler le mouvement sur un rythme, une partition ou un effet sonore → sound-and-music-sync.
  • Recadrer ou recadrer pour une plateforme (9:16, 1:1, zones de sécurité) → social-video-formatter.
  • Lumière, exposition, lueur ou mouvement de couleur → motion-color-and-light.

Procédure opératoire

Diagnostiquez avant de prescrire. La plupart des mouvements « saccadés » correspondent à l'un des quatre problèmes nommés ci-dessous, et chacun a une solution spécifique. Travaillez les étapes dans l'ordre : la correction d'easing est inutile si le timing est mauvais, et la correction de timing est inutile si l'élément n'a pas d'arc.

Étape 1 : Nommez ce qui ne va pas

Observez le mouvement (ou la description) et classez-le. Presque chaque plainte correspond à l'un de ces cas :

  • Linéaire / robotique – vitesse constante, arrêt brusque. Pas d'easing. Correction à l'étape 2.
  • Flottant / mou – trop lent, ou easing entrant et sortant quand il faudrait un snap. Mauvaise durée ou mauvaise courbe. Correction aux étapes 2 et 3.
  • Saccadé / à-coups – entrée et sortie à la même vitesse, ou chaque propriété s'anime sur la même timeline plate sans décalage. Espacement et arc manquants. Correction aux étapes 3 et 4.
  • Mort / sans vie – techniquement correct mais ennuyeux : pas d'anticipation, pas de dépassement, pas de suivi. Arc et mouvement secondaire manquants. Correction aux étapes 4 et 5.

Notez le diagnostic en une ligne avant de toucher à quoi que ce soit. « La modale est flottante parce qu'elle apparaît avec un fondu en 600ms en ease-in-out » est une correction ; « rends-la plus jolie » ne l'est pas.

Étape 2 : Choisissez la courbe d'easing

L'easing est la forme vitesse/temps du mouvement. La courbe porte presque toute la qualité perçue. Faites correspondre la courbe à ce que fait l'élément :

  • ease-out (départ rapide, ralentissement progressif) – valeur par défaut pour les entrées et pour tout ce que l'utilisateur a déclenché. Il donne une sensation de réactivité car le mouvement commence immédiatement, puis décélère jusqu'à la position. Utilisez-le pour : les éléments qui apparaissent, les menus déroulants qui s'ouvrent, un bouton qui répond après un tap, un contenu qui glisse. En cas de doute, optez pour ease-out.
  • ease-in (départ lent, sortie rapide) – pour les sorties. L'élément accélère pour disparaître de l'écran. Utilisé seul sur une entrée, il donne une sensation de lenteur et de décalage, ce qui est la cause n°1 des « flottants ». Utilisez-le pour : les rejets, les fermetures, les sorties.
  • ease-in-out (lent, rapide, lent) – pour déplacer un élément déjà à l'écran d'un point A à un point B : réorganisation de cartes, avancement d'un carrousel, glissement d'un interrupteur. Les deux extrémités sont ancrées, donc un easing aux deux bouts donne une sensation de contrôle. Ne l'utilisez pas pour les entrées : le démarrage lent tue la réactivité.
  • spring (physique : masse, raideur, amortissement – dépasse puis se stabilise) – pour les mouvements qui doivent paraître vivants et physiques : une modale qui surgit, un bouton à bascule, un bouton « j'aime », une notification qui tombe. Le léger dépassement est ce qui rend le mouvement « vivant ». Réglez l'amortissement pour la personnalité : un amortissement plus faible donne plus de rebond et de jeu, un amortissement plus élevé donne plus de rigidité et de professionnalisme.

Le choix spring() vs interpolate() (quand utiliser l'un ou l'autre dans le code) est dans la barre de qualité et l'artefact exécutable ci-dessous. En résumé : spring pour les transformations physiques/vivantes, interpolate pour les valeurs précises calibrées image par image comme les fondus d'opacité, les couleurs et les barres de progression.

Étape 3 : Définissez le timing et l'espacement

Timing = durée totale. Espacement = comment la distance est répartie sur cette durée – l'espacement est l'easing rendu littéral (un ease-out a des images regroupées à la fin). Deux règles :

  • La durée dépend de la distance et de la taille, pas du goût. Un petit élément qui se déplace sur une courte distance doit être rapide (UI : ~150 – 250 ms). Un grand élément ou un long trajet nécessite plus de temps (~300 – 500 ms) sinon il téléporte. Les grands mouvements plein écran / héros dans une vidéo peuvent durer plus longtemps. Même mouvement, distance plus longue → durée plus longue.
  • L'entrée et la sortie ne sont pas symétriques. Les sorties doivent être plus rapides que les entrées (~0,7 – 0,8×) – l'utilisateur en a fini avec l'élément, donc dégagez-le. Des durées entrée/sortie égales sont une source classique de « saccadé ».

Pour une vidéo produit, convertissez en images dès que vous quittez cette compétence : images = round(secondes * fps). Ces nombres d'images sont l'entrée littérale que vous transmettez à product-demo-director (qui les transforme en plan de scène temporel).

Étape 4 : Construisez l'arc anticipation → action → suivi

Un mouvement réaliste est rarement un simple déplacement. Le mouvement le plus riche, le plus « vivant » a trois temps :

  1. Anticipation – un tout petit mouvement préparatoire dans la direction opposée avant le mouvement principal (un bouton s'enfonce légèrement avant de surgir, une carte recule avant de glisser dehors). Cela prépare l'œil et rend l'action intentionnelle. Restez léger et rapide ; trop d'anticipation ressemble à un bug.
  2. Action – le mouvement principal, avec l'easing de l'étape 2 et la durée de l'étape 3. C'est là que vit l'espacement.
  3. Suivi – l'élément dépasse sa cible puis revient (le dépassement du spring), et tout élément attaché/secondaire prend un léger retard sur le leader (un libellé qui rattrape la carte sur laquelle il se trouve). C'est ce qui vend le poids et la vie.

Toutes les micro-interactions n'ont pas besoin des trois : une infobulle de 150 ms n'est que l'action. Mais quand quelque chose semble « mort », c'est presque toujours qu'il manque l'anticipation ou le suivi. Ajoutez l'arc avant d'ajouter des fioritures.

Étape 5 : Appliquez les principes Disney pertinents

Les 12 principes de l'animation de Disney s'appliquent directement à l'UI et au mouvement produit. Vous ne les appliquez pas tous ; vous utilisez ceux qui corrigent le problème diagnostiqué. La cartographie complète est dans references/twelve-principles. Les plus importants :

  • Slow in & slow out → easing (étape 2). Le levier de qualité le plus puissant.
  • Anticipation → le préparatif (étape 4).
  • Follow-through & overlapping action → dépassement + éléments secondaires en retard (étape 4). La différence entre « correct » et « vivant ».
  • Timing → durée et espacement (étape 3).
  • Squash & stretch → échelle subtile à la pression/impact pour suggérer la masse ; dans l'UI, limitez-vous à quelques pourcents sinon ça fait jouet.
  • Staging → déplacez une chose à la fois pour que l'œil sache où regarder ; n'animez jamais six propriétés en même temps sur la même courbe.
  • Secondary action → un petit mouvement d'accompagnement (une ombre qui s'assombrit quand une carte se soulève) qui renforce le mouvement principal sans lui faire compétition.
  • Exaggeration → poussez la pose clé légèrement au-delà du réaliste ; mesuré dans l'UI, plus libre dans une vidéo produit punchy.

Étape 6 : Transmettez le cahier des charges

Remplissez le template de spécification de mouvement ci-dessous – courbe, durée (et images), les temps de l'arc, et le choix spring vs interpolate par propriété. Ce template rempli est l'artefact de transmission : pour une scène vidéo produit, il va directement dans product-demo-director ; pour l'UI, il devient vos valeurs de transition/keyframe. Associez-le avec motion-color-and-light si la scène a besoin de mouvement de lumière/exposition, kinetic-typography si du texte est animé, et sound-and-music-sync si le timing doit tomber sur un temps.

Barre de qualité

Le mouvement est A+ seulement quand tous ces points sont vrais :

  • Le diagnostic est nommé (linéaire / flottant / saccadé / mort), et chaque changement en découle. Pas de « rendu plus joli » sans raison.
  • Les entrées sont en ease-out, les sorties en ease-in, les A→B à l'écran en ease-in-out, le vivant/physique utilise spring. Aucun mouvement linéaire brut n'est livré sauf les boucles à vitesse constante intentionnelles (un spinner, un marquee).
  • La durée dépend de la distance/taille, et la sortie est plus rapide que l'entrée.
  • L'appel à spring() vs interpolate() est explicite par propriété : spring pour les transformations physiques (scale, translate, le pop/slide/posé – vous voulez le dépassement) ; interpolate pour les valeurs temporelles précises (fondus d'opacité, couleur, progression, tout ce pour quoi un dépassement serait mauvais). Un fondu piloté par un spring, ou un pop de logo piloté par un interpolate linéaire, est un défaut.
  • Au moins une anticipation ou un suivi est présent sur le mouvement héros / signature ; un mouvement sans vie manque exactement ces éléments.
  • Une chose mène à la fois (staging) ; les propriétés sont décalées plutôt que de toutes déclencher sur une seule timeline plate.
  • La courbe, la durée et le nombre d'images sont écrits et prêts à être transmis à product-demo-director ou à une transition – cette compétence ne laisse jamais la décision implicite.

À NE PAS FAIRE

  • NE LIVREZ PAS d'easing linéaire pour les entrées ou sorties – c'est le défaut robotique et cela donne l'impression d'un travail non terminé. La vitesse constante est seulement pour les boucles intentionnelles.
  • NE FAITES PAS d'ease-in sur une entrée ni d'ease-out sur une sortie – c'est la sensation flottante/lente inversée. Les entrées sont en ease-out, les sorties en ease-in.
  • N'UTILISEZ PAS des durées d'entrée et de sortie égales ; les sorties doivent être ~0,7 – 0,8× plus rapides.
  • NE PILOTEZ PAS un fondu, une couleur ou une barre de progression avec un spring – le dépassement fait dépasser les valeurs de leur plage et provoque des flashs. Utilisez interpolate pour les valeurs temporelles.
  • NE PILOTEZ PAS un pop/glissement/échelle vivant avec un interpolate linéaire quand vous voulez qu'il paraisse vivant – utilisez un spring pour le dépassement.
  • N'ANIMEZ PAS plusieurs propriétés sur une seule timeline plate ; espacez et décalez-les.
  • NE SURESTIMEZ PAS l'anticipation ou le dépassement dans l'UI – quelques pixels / quelques pourcents. Les grands préparatifs et rebonds ressemblent à un bug ou un jouet.
  • NE PLANIFIEZ PAS l'ordre des plans ni n'assemblez la démo ici – transmettez le cahier des charges à product-demo-director ; l'ordre du storyboard est dans video-storyboard.

Sélecteur d'easing et de spring

Script Node.js autonome. Sauvegardez-le sous motion_pick.js et exécutez-le avec node motion_pick.js. Modifiez le tableau requests pour les éléments que vous animez ; il retourne la courbe, une durée adaptée à la distance (ms et images), la durée de sortie, et le choix spring vs interpolate. Aucune dépendance.

// Motion picker. Edit `requests`, then: node motion_pick.js
const fps = 30 // for product video; UI ignores the frame column

// role: 'enter' | 'exit' | 'move' | 'lively'
// distancePx: how far it travels (drives duration). sizePx: rough element size.
const requests = [
  { name: 'Modal pop-in',    role: 'lively', property: 'scale',   distancePx: 0,   sizePx: 600 },
  { name: 'Modal backdrop',  role: 'enter',  property: 'opacity', distancePx: 0,   sizePx: 1920 },
  { name: 'Toast slide-in',  role: 'enter',  property: 'translate', distancePx: 320, sizePx: 360 },
  { name: 'Toast dismiss',   role: 'exit',   property: 'translate', distancePx: 320, sizePx: 360 },
  { name: 'Card reorder',    role: 'move',   property: 'translate', distancePx: 140, sizePx: 280 },
  { name: 'Progress fill',   role: 'move',   property: 'width',     distancePx: 800, sizePx: 800 },
]

function curveFor(role) {
  if (role === 'enter') return 'ease-out'
  if (role === 'exit') return 'ease-in'
  if (role === 'move') return 'ease-in-out'
  return 'spring' // lively
}

// Duration scales with travel distance and element size. Floor + slope, clamped.
function durationMs(role, distancePx, sizePx) {
  const reach = Math.max(distancePx, sizePx * 0.4)
  let ms = 140 + reach * 0.45
  ms = Math.min(Math.max(ms, 140), 600)
  if (role === 'exit') ms *= 0.75 // exits are faster
  return Math.round(ms)
}

// spring for physical transforms; interpolate for timed values.
function driver(role, property) {
  const physical = property === 'scale' || property === 'translate'
  if (role === 'lively') return 'spring()  // want the overshoot'
  if (physical && role !== 'move') return 'spring()  // physical, lively settle'
  return 'interpolate()  // precise, timed-to-frame'
}

const pad = (s, n) => String(s).padEnd(n)
console.log(pad('ELEMENT', 18), pad('CURVE', 12), pad('MS', 6), pad('FRAMES', 8), 'DRIVER')
for (const r of requests) {
  const curve = curveFor(r.role)
  const ms = durationMs(r.role, r.distancePx, r.sizePx)
  const frames = Math.round((ms / 1000) * fps)
  console.log(pad(r.name, 18), pad(curve, 12), pad(ms, 6), pad(frames, 8), driver(r.role, r.property))
}

Exemple de sortie

Avec les requêtes ci-dessus, le script imprime :

ELEMENT            CURVE       MS     FRAMES   DRIVER
Modal pop-in       spring      252    8        spring()  // want the overshoot
Modal backdrop     ease-out    600    18       interpolate()  // precise, timed-to-frame
Toast slide-in     ease-out    284    9        spring()  // physical, lively settle
Toast dismiss      ease-in     213    6        interpolate()  // precise, timed-to-frame
Card reorder       ease-in-out 203    6        interpolate()  // precise, timed-to-frame
Progress fill      ease-in-out 500    15       interpolate()  // precise, timed-to-frame

Lisez-le : la modale pop avec un spring (dépassement = vivant) tandis que son fond fond avec un interpolate temporel – deux pilotes différents sur le même composant, exactement comme l'exige la barre de qualité. Le toast entre en 284 ms et disparaît plus vite en 213 ms (règle de sortie 0,75×), et son glissement est physique donc il arrive avec un spring mais ressort en interpolate. La barre de progression est une valeur de largeur précise – jamais un spring, sinon le remplissage tremblerait.

Template de spécification de mouvement

Copiez ce bloc pour chaque élément en mouvement et remplissez-le. Le résultat rempli est ce que vous transmettez.

ÉLÉMENT : [nom]
  Propriété : [scale | translate | opacity | color | width | ...]
  Rôle : [entrer | sortir | déplacer | vivant]
  Courbe : [ease-out | ease-in | ease-in-out | spring]
  Pilote : [spring() | interpolate()]
  Durée : [ms] → [images à fps]
  Anticipation : [oui/non] → [petite description, ms]
  Suivi : [oui/non] → [petite description, ms]

Individual skills in this repo

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

Skills associés