Communitygithub.com

mouvement-subtil

Ajoutez des animations subtiles et soignées à n'importe quel site web (HTML/CSS, React, Next, Vue, Svelte, Astro) pour une sensation de fluidité sans donner l'impression d'être « animé », tout en restant réactif et sans à-coups à 60 ips sur les téléphones bas de gamme.

Qu'est-ce que mouvement-subtil ?

Ce skill implémente les 12 principes d'animation de Disney adaptés à l'interface utilisateur, combinés aux lois d'UX pertinentes pour le mouvement (Fitts, Hick, Miller, Doherty, Postel, Jakob, fréquence d'utilisation). Il produit des animations qui paraissent naturelles et agréables, jamais tape-à-l'œil. Le skill fonctionne avec HTML/CSS brut, React, Next.js, Vue, Svelte et Astro, en utilisant uniquement CSS et JavaScript minimal. Il suit des règles strictes : n'animer que les propriétés `transform` et `opacity`, garder des durées courtes (<300 ms), respecter `prefers-reduced-motion`. La configuration consiste à analyser le site, classer les éléments par fréquence d'utilisation, choisir au maximum 5 points d'interaction, ajouter des variables CSS globales, appliquer des motifs éprouvés (pression des boutons, retour de formulaire, survol de carte, défilement, superposition/notification) et vérifier la conformité. Le résultat est un site au rendu fluide et professionnel, sans jamais donner l'impression de « bouger pour bouger ».

Compatible avec~Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/noni-was-taken/subtle-motion/tree/HEAD/skills/subtle-motion

Demander à votre IA préférée

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

Documentation

Mouvement subtil

Le mouvement, c'est l'assaisonnement. L'utilisateur doit ressentir que le site est « fluide », jamais remarquer « une animation ». Sources : The Illusion of Life de Disney, Laws of UX de Jon Yablonski, userinterface.wiki de Raphael Salaja, Emil Kowalski (fréquence d'utilisation).

Règles strictes (à ne jamais enfreindre)

  1. Animer uniquement transform et opacity (plus filter/clip-path avec parcimonie). Ne jamais animer width, height, top, left, margin, padding, la taille box-shadow ou font-size. Besoin de changer une ombre ? Animer par fondu l'opacity d'un pseudo-élément.
  2. Timing vif : animation de l'UI sous 300 ms. Pression 80–120 ms, survol 150 ms, entrée 200–300 ms, sortie ≈ 70 % de l'entrée. Seule une animation « hero » unique peut aller jusqu'à 500 ms.
  3. Petites distances. Translation de 2–16 px, échelle de 0.97–1.03, rotation ≤ 6°. Plus grand donne l'impression d'être « animé ».
  4. Ralentir au début et à la fin. Jamais de linear sur le mouvement. Ease-out pour entrer, ease-in pour sortir.
  5. Fréquence d'utilisation : plus c'est utilisé, moins ça anime. Navigation clavier, palettes de commandes, onglets utilisés 100 fois/jour, sélection dans une liste : instantané (0 ms) ou fondu ≤ 100 ms. Animer les moments rares, pas les répétés.
  6. Seuil de Doherty : répondre sous 100 ms, terminer sous 400 ms. Le feedback (état pressé, état en attente) commence sur la même image que l'entrée. Tout ce qui est plus lent que 400 ms affiche une progression.
  7. prefers-reduced-motion: reduce supprime le mouvement. Les fondus d'opacité peuvent rester.
  8. Effets de survol uniquement sous @media (hover: hover). Le tactile génère sinon des survols « collants ».
  9. CSS d'abord, pas de bibliothèque d'animation sauf si le projet en a déjà une. Pas de boucle JS quand le CSS peut le faire.
  10. Ne jamais retarder ni cacher le contenu. Les révélations ne doivent pas cacher le contenu si JS échoue, bloquer les clics ou animer l'élément LCP au chargement.
  11. Mise en scène : un mouvement focal à la fois. Max environ 5 points de mouvement par page ; jamais deux choses en compétition pour l'œil au même moment.
  12. will-change uniquement pendant l'animation (ou sur ≤ 3 éléments persistants).
  13. Interruptible par défaut. Un état qui peut basculer en plein vol (survol, bascule, ouverture/fermeture, indicateur d'onglet) utilise transition, qui se recentre depuis sa position actuelle. @keyframes seulement pour les moments uniques (secousse, sonnerie, envoi) qui redémarrent proprement.
  14. Adapter la durée à la taille et à l'initiateur. Les petits éléments plus rapides que les grands (icône 100 ms, carte 250 ms, panneau 300 ms). Action initiée par l'utilisateur = immédiat ; action initiée par le système (notification, mise à jour en arrière-plan) peut prendre la fin lente.
  15. Pas de clignotement > 3 ×/s ; tout ce qui boucle > 5 s doit avoir un contrôle de pause (ou ne pas boucler).

Les principes, en règles d'UI

Choisissez ceux qui correspondent au point d'interaction ; jamais tous à la fois. Chacun correspond à un motif ci-dessous.

#PrincipeEn UI, cela signifieMotif
1Étirement & compressionLes choses se compressent à l'impact, s'étirent en mouvement : le poidsPression, Bascule
2AnticipationLéger retrait avant un grand mouvement (envoi, soumission, déploiement)Bouton Envoyer
3Mise en scèneDiriger l'œil vers une chose : atténuer les voisins, un mouvement à la foisFocus de carte
4Pose à poseDéfinir les états de début/fin ; laisser le navigateur faire l'interpolationtransition, pas du JS image par image
5SuiviLes parties se stabilisent après l'arrêt du corps (petit dépassement)Notification, Badge
6Ralentir au début et à la finAccélérer et décélérer, jamais à vitesse constanteVariables
7ArcsLes éléments en mouvement se déplacent sur des courbes, pas des lignes droitesVol vers le panier
8Action secondairePetite fioriture qui soutient l'action principaleAnneau de succès
9Timing vifLa durée donne la sensation ; UI < 300 msVariables
10Feedback exagéréPousser au-delà du réel pour que le moment frappe (erreurs, succès)Secousse d'erreur
11Dessin solide / 3DDonner de la profondeur et du volume aux choses platesCarte inclinée
12AttraitLa somme de chaque détail, cohérent sur tout le sitePasse de vérification
Loi d'UXConséquence sur le mouvementMotif
Loi de FittsLes cibles plus grandes et plus proches sont plus rapides à atteindreZones de clic
Zones de clic plus grandesZone cliquable ≥ 44×44 px, même si le visuel est plus petitZones de clic
Loi de HickPlus de choix = décisions plus lentes ; ne pas animer beaucoup d'options à la foisLimite d'échelonnement
Loi de MillerRegrouper le contenu (~7 éléments) ; révéler en groupes, pas un par unLimite d'échelonnement
Seuil de DohertyFeedback < 100 ms, total < 400 ms, sinon afficher une progressionÉtat en attente
Loi de PostelAccepter une entrée désordonnée, retourner une sortie propre ; animer doucement le nettoyageFormat d'entrée
Loi de JakobUtiliser un mouvement conventionnel (menus qui descendent du déclencheur, modales qui apparaissent en fondu + échelle depuis le centre)Superposition
Fréquence d'utilisationFréquent = moins d'animationRègle 5

Flux de travail

  1. Lire d'abord le site. Framework, approche CSS (Tailwind, modules CSS, brut), mouvement et variables existants. Les réutiliser.
  2. Classer chaque élément interactif par fréquence : rare (inscription, paiement, succès), occasionnel (cartes, sections, modales), fréquent (navigation, onglets, palettes, lignes de liste). Fréquent obtient ≤ 100 ms ou rien.
  3. Choisir ≤ 5 points d'interaction, classés par rapport sensation/coût :
    1. Boutons/liens : compression à la pression + zone de clic (principes 1, Fitts)
    2. Retour de formulaire : secousse d'erreur, anneau de succès, état en attente (10, 8, Doherty)
    3. Cartes : soulèvement au survol, inclinaison optionnelle (11)
    4. Sections : révélation au défilement, échelonnement par groupes (6, Miller)
    5. Superpositions/notifications : entrée/sortie avec suivi (5, Jakob)
  4. Ajouter les variables une fois, globalement.
  5. Appliquer les motifs uniquement aux points d'interaction choisis.
  6. Vérifier (dernière section). Pas terminé avant vérification.
  7. Rapporter : chaque point d'interaction avec fichier:ligne, le principe appliqué et comment le voir.

Variables (ajouter une fois, globalement)

:root {
  --ease-out: cubic-bezier(.23, 1, .32, 1);       /* entrée, survol */
  --ease-in: cubic-bezier(.55, 0, 1, .45);        /* sortie */
  --ease-in-out: cubic-bezier(.65, 0, .35, 1);    /* déplacement à l'écran */
  --ease-settle: cubic-bezier(.34, 1.4, .64, 1);  /* suivi : ~4 % de dépassement */
  /* sensation de ressort, interruptible ; les navigateurs sans `linear()` utilisent `ease` */
  --ease-spring: linear(0, .07 3%, .29 9%, .62 18%, .86 28%, 1.01 40%, 1.03 50%, 1.015 65%, 1);
  --dur-press: 100ms;
  --dur-fast: 150ms;
  --dur-base: 250ms;
  --dur-slow: 300ms;
  --rise: 8px;
}
@media (prefers-reduced-motion: reduce) {
  :root { --rise: 0px; }
  *, *::before, *::after {
    animation-duration: 1ms !important;
    animation-iteration-count: 1 !important;
    transition-duration: 1ms !important;
    scroll-behavior: auto !important;
  }
}

Projet Tailwind ? Mettez ces valeurs dans @theme / tailwind.config extend plutôt que dans un nouveau fichier CSS.

Motifs

Pression : compression (1) + zone de clic (Fitts)

.btn {
  position: relative;
  transition: transform var(--dur-fast) var(--ease-out), background-color var(--dur-fast) var(--ease-out);
}
@media (hover: hover) { .btn:hover { transform: translateY(-1px); } }
.btn:active { transform: scale(.97); transition-duration: var(--dur-press); }

/* Petits boutons d'icône : agrandir la zone de clic, pas le visuel */
.icon-btn { position: relative; }
.icon-btn::before { content: ""; position: absolute; inset: 50% auto auto 50%; width: 44px; height: 44px; translate: -50% -50%; }

Bascule : compression & étirement (1)

Le bouton s'étire pendant le déplacement, se stabilise à l'arrivée.

.switch .knob { transition: transform var(--dur-base) var(--ease-settle); }
.switch[aria-checked="true"] .knob { transform: translateX(20px); }
.switch:active .knob { transform: scaleX(1.2); transform-origin: left; }
.switch[aria-checked="true"]:active .knob { transform: translateX(20px) scaleX(1.2); transform-origin: right; }

Envoyer / soumettre : anticipation (2)

Uniquement sur les actions « d'engagement » rares. Reculer de 2 px, puis partir.

@keyframes send { 0% { transform: none } 30% { transform: translate(-2px, 2px) } 100% { transform: translate(24px, -24px); opacity: 0 } }
.send.is-sending svg { animation: send 280ms var(--ease-in-out) forwards; }

Focus de carte : mise en scène (3)

@media (hover: hover) {
  .grid:has(.card:hover) .card:not(:hover) { opacity: .6; }
}
.grid .card { transition: opacity var(--dur-base) var(--ease-out); }

Utiliser uniquement sur des grilles denses où un choix compte. Ignorer sur le contenu que l'on lit.

Soulèvement de carte + inclinaison optionnelle : dessin solide (11)

.card { position: relative; transition: transform var(--dur-base) var(--ease-out); }
.card::after {
  content: ""; position: absolute; inset: 0; border-radius: inherit; pointer-events: none;
  box-shadow: 0 12px 32px -12px rgb(0 0 0 / .25);
  opacity: 0; transition: opacity var(--dur-base) var(--ease-out);
}
@media (hover: hover) {
  .card:hover { transform: translateY(-3px); }
  .card:hover::after { opacity: 1; }
}

Inclinaison (uniquement pour les éléments de démonstration comme un produit, un prix ou une carte de crédit ; ≤ 6°, pointeur uniquement, limité par rAF) :

if (matchMedia('(hover: hover) and (prefers-reduced-motion: no-preference)').matches) {
  for (const el of document.querySelectorAll('.tilt')) {
    let raf = 0;
    el.addEventListener('pointermove', (e) => {
      cancelAnimationFrame(raf);
      raf = requestAnimationFrame(() => {
        const r = el.getBoundingClientRect(); // lecture une fois par image, pas par transition
        const x = (e.clientX - r.left) / r.width - .5, y = (e.clientY - r.top) / r.height - .5;
        el.style.transform = `perspective(800px) rotateX(${-y * 6}deg) rotateY(${x * 6}deg)`;
      });
    });
    el.addEventListener('pointerleave', () => { cancelAnimationFrame(raf); el.style.transform = ''; });
  }
}

Notification / badge : suivi (5)

.toast { transition: transform var(--dur-slow) var(--ease-settle), opacity var(--dur-fast) var(--ease-out); }
.toast[data-state="closed"] { transform: translateY(12px); opacity: 0; transition-timing-function: var(--ease-in); }

Dépassement uniquement sur les choses qui arrivent (notifications, badges, compteurs), jamais sur la mise en page ou les blocs de texte.

Vol vers le panier : arcs (7)

Séparer X et Y sur deux éléments imbriqués avec des easings différents ; le chemin se courbe.

.fly-x { transition: transform 300ms linear; }
.fly-y { transition: transform 300ms var(--ease-in); }
.flying .fly-x { transform: translateX(var(--dx)); }
.flying .fly-y { transform: translateY(var(--dy)) scale(.4); }

Définir --dx/--dy à partir d'une lecture getBoundingClientRect() avant d'ajouter .flying.

Anneau de succès : action secondaire (8)

.btn.is-success::after {
  content: ""; position: absolute; inset: -4px; border-radius: inherit; border: 2px solid currentColor;
  animation: ring 400ms var(--ease-out) forwards; pointer-events: none;
}
@keyframes ring { from { opacity: .6; transform: scale(.95) } to { opacity: 0; transform: scale(1.15) } }

Secousse d'erreur : feedback exagéré (10)

@keyframes shake { 20%,60% { transform: translateX(-4px) } 40%,80% { transform: translateX(4px) } }
.field[aria-invalid="true"] { animation: shake 280ms var(--ease-in-out); }

Re-déclencher en supprimant et réajoutant l'attribut. Toujours associer à un message textuel (accessibilité).

État en attente : seuil de Doherty

Feedback de pression immédiatement ; si l'action prend > 400 ms, afficher un spinner/une progression à l'intérieur du bouton (garder sa largeur fixe pour éviter le décalage de mise en page). Préférer l'UI optimiste : afficher le résultat, annuler en cas d'erreur.

Entrée désordonnée → sortie propre : loi de Postel

Formater au blur (numéros de téléphone, numéros de carte, dates), pas à chaque frappe. Fondu enchaîné de la valeur avec un changement d'opacité de 150 ms, aucun mouvement.

Révélation au défilement : ralentir début/fin (6) + regroupement (Miller, Hick)

Contenu visible par défaut ; caché uniquement si JS confirme pouvoir le révéler.

.js .reveal {
  opacity: 0; transform: translateY(var(--rise));
  transition: opacity var(--dur-slow) var(--ease-out), transform var(--dur-slow) var(--ease-out);
  transition-delay: calc(min(var(--i, 0), 5) * 50ms);
}
.js .reveal.in { opacity: 1; transform: none; }
document.documentElement.classList.add('js');
const io = new IntersectionObserver((entries) => {
  for (const e of entries) if (e.isIntersecting) { e.target.classList.add('in'); io.unobserve(e.target); }
}, { rootMargin: '0px 0px -10% 0px' });
document.querySelectorAll('.reveal').forEach((el) => io.observe(el));
  • Échelonner avec style="--i: n" ; limité à 6 étapes (Miller). Les longues listes se révèlent en un seul groupe.
  • Révéler une fois. Ignorer tout ce qui est au-dessus de la ligne de flottaison.
  • Frameworks : même CSS ; exécuter l'observateur dans un effet de montage, déconnecter au démontage.

Superpositions : loi de Jakob

Mouvement conventionnel uniquement : les listes déroulantes grandissent depuis leur déclencheur (transform-origin du côté du déclencheur), les modales apparaissent en fondu + échelle 0.98→1 depuis le centre, les panneaux glissent depuis leur bord. Natif d'abord : <dialog> / popover avec @starting-style.

dialog, [popover] {
  opacity: 0; transform: translateY(4px) scale(.98);
  transition: opacity var(--dur-fast) var(--ease-in), transform var(--dur-fast) var(--ease-in),
              overlay var(--dur-fast) allow-discrete, display var(--dur-fast) allow-discrete;
}
dialog[open], [popover]:popover-open {
  opacity: 1; transform: none;
  transition-timing-function: var(--ease-out); transition-duration: var(--dur-base);
}
@starting-style {
  dialog[open], [popover]:popover-open { opacity: 0; transform: translateY(4px) scale(.98); }
}

Palette de commandes / menu ouvert au clavier plusieurs fois par jour : la fréquence d'utilisation impose de sauter la transition.

Onglets : surface de dossier qui glisse (pas un soulignement d'accentuation)

Le signe distinctif de l'IA/modèle est le mince soulignement d'accentuation, pas le mouvement. Utiliser une forme physique familière (Jakob) et laisser cette forme se déplacer :

  • Onglets dossier (recommandé) : la surface de l'onglet sélectionné fusionne avec le panneau et glisse vers l'onglet cliqué.
  • Contrôle segmenté : pour 2–4 options ; le segment enfoncé glisse de la même façon.

Faire en sorte que les onglets aient la même largeur pour que la surface n'ait besoin que de translateX (pas de largeur ou scaleX, qui déforme le rayon et la bordure). Utiliser une transition ≤ 150 ms pour qu'elle reste interruptible. Le contenu change instantanément (fréquence d'utilisation).

.tabs { position: relative; display: flex; gap: 2px; border-bottom: 1px solid var(--line); }
.tabs [role=tab] { position: relative; z-index: 1; flex: 0 0 auto; /* largeur fixe ou min-content/max-content */ padding: 8px 16px; border: none; background: none; cursor: pointer; }
.tabs .tab-surface {
  position: absolute; bottom: 0; left: 0; height: 2px; background: var(--accent);
  transition: transform 150ms var(--ease-out);
  /* géré en JS via `style.width` + `style.transform` sur la surface */
}
/* contenu : transition 0ms, display:block/none */
// Gestion de l'onglet : cliquer change data-state, la surface se déplace via transform et largeur calculées sur la cible
const tabSurface = document.querySelector('.tab-surface');
const tabs = document.querySelectorAll('[role=tab]');
function moveSurface(target) {
  const r = target.getBoundingClientRect();
  const parent = target.closest('.tabs').getBoundingClientRect();
  tabSurface.style.width = r.width + 'px';
  tabSurface.style.transform = `translateX(${r.left - parent.left}px)`;
}
tabs.forEach(t => t.addEventListener('click', (e) => moveSurface(e.currentTarget)));

Vérification

Avant de déclarer terminé, vérifier ceci :

  • Toutes les animations utilisent uniquement transform / opacity. Aucune exception visible ? (Ouvrir l'inspecteur, cocher « CSS transitions » dans l'onglet Animations, faire glisser le curseur).
  • La page chargée a la même disposition avec ou sans animation (js non présent → .reveal visible).
  • @media (prefers-reduced-motion: reduce) : déplacer le curseur « Réduire le mouvement » dans les devtools → le mouvement s'arrête. Simuler avec emulate CSS media feature prefers-reduced-motion: reduce.
  • @media (hover: hover) : le survol fonctionne sur un écran avec souris ; un écran tactile ne montre pas de survol persistant après avoir tapé (utiliser chrome emulate touch / responsive mode).
  • Pas de sauts de mise en page (regarder le score Cumulative Layout Shift dans Lighthouse).
  • Les animations se déclenchent au premier survol/pression, pas après un délai (pas de transition-delay négatif, pas de animation-delay sauf pour l'échelonnement).
  • Les transitions sont interruptibles : survoler rapidement différents onglets/cartes → l'élément s'adoucit vers la nouvelle cible, ne finit pas la première animation.
  • Conservation de la tabulation au clavier : tous les éléments interactifs sont atteignables et activables au clavier (Tab, Entrée/Espace). Les animations ne verrouillent pas le focus.
  • La révélation au défilement se produit une fois et n'est pas retardée par l'échelonnement du chargement asynchrone (vérifier avec un réseau lent / Fast 3G).
  • Le rapport liste chaque point d'interaction avec fichier:ligne, le principe et comment le voir (par exemple « survoler la carte 4 dans la grille principale »).

## Rapport

<point d'interaction> | <principe # / loi> | fichier:ligne |

  • Bouton .btn-primary | 1, Fitts | src/components/Button.css:12 | survoler ou cliquer le bouton « Envoyer »
  • Champ .email | 10, Doherty | src/components/Form.css:34 | saisir une adresse invalide, tabuler hors du champ
  • Carte .product-card | 11, 3 | src/components/Card.css:7 | survoler la carte « Montre »

Skills associés