Communitygithub.com

Subtle Motion

Fügen Sie jeder Website dezente, elegante Animationen hinzu (einfaches HTML/CSS, React, Next, Vue, Svelte, Astro), die sich geschmeidig anfühlen, ohne aufdringlich zu wirken – flüssig und ruckelfrei mit 60fps auch auf schwachen Geräten.

Was ist Subtle Motion?

Dieses Skill, 'Subtle Motion', bringt die 12 Disney-Animationprinzipien, adaptiert für UI, zusammen mit den bewegungsrelevanten UX-Gesetzen (Fitts, Hick, Miller, Doherty, Postel, Jakob, Nutzungshäufigkeit) auf jede Website. Ziel ist es, die Nutzererfahrung subtil zu verbessern, ohne dass Animationen bewusst wahrgenommen werden. Es unterstützt alle gängigen Frameworks und setzt strikt auf CSS-Transformationen und Opacity, um maximale Performance zu gewährleisten. Der Skill arbeitet nach einem gestaffelten Workflow: Zuerst wird die bestehende Seite analysiert, dann werden bis zu fünf Berührungspunkte (z. B. Buttons, Karten, Formulare) ausgewählt und mit globalen Tokens und spezifischen Mustern wie 'Press (Squash)', 'Card lift' oder 'Scroll reveal' versehen. Wichtig sind harte Regeln wie maximale Animationsdauer von 300ms, Beachtung von `prefers-reduced-motion` und die Nutzungshäufigkeit: Je öfter ein Element genutzt wird, desto dezenter die Animation. Am Ende steht eine Verifikation und ein detaillierter Report über die implementierten Touchpoints.

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

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Was macht Subtle Motion?

Bewegung ist die Würze. Der Nutzer sollte die Seite als „geschmeidig" empfinden, niemals eine „Animation" bemerken. Quellen: Disneys The Illusion of Life, Jon Yablonskis Laws of UX, Raphael Salajas userinterface.wiki, Emil Kowalski (Nutzungshäufigkeit).

Harte Regeln (niemals brechen)

  1. Animiere nur transform und opacity (plus filter/clip-path sparsam). Animiere niemals width, height, top, left, margin, padding, box-shadow Größe oder font-size. Benötigst du einen Schattenwechsel? Überblende die opacity eines Pseudoelements.
  2. Flotte Timing: UI-Bewegung unter 300ms. Drücken 80–120ms, Schwebe 150ms, Eintritt 200–300ms, Austritt ≈ 70% des Eintritts. Nur eine einmalige Heldenanimation darf 500ms betragen.
  3. Kleine Distanzen. Translate 2–16px, scale 0.97–1.03, rotate ≤ 6°. Größeres wirkt wie eine „Animation".
  4. Langsam rein & langsam raus. Niemals linear bei Bewegung. Ease-out zum Eintreten, ease-in zum Verlassen.
  5. Nutzungshäufigkeit: Je öfter es verwendet wird, desto weniger animiert es. Tastaturnavigation, Befehlspaletten, Tabs, die 100×/Tag genutzt werden, Listenauswahl: sofort (0ms) oder ein ≤100ms Einblenden. Animiere erstmalige und seltene Momente, nicht wiederholte.
  6. Doherty-Schwelle: Antworte innerhalb von 100ms, beende innerhalb von 400ms. Feedback (gedrückter Zustand, Wartezustand) beginnt im gleichen Frame wie die Eingabe. Alles, was langsamer als 400ms ist, zeigt einen Fortschritt an.
  7. prefers-reduced-motion: reduce unterbindet Bewegung. Opacity-Überblendungen dürfen bleiben.
  8. Schwebe-Effekte nur unter @media (hover: hover). Andernfalls bleibt Touch-Hover kleben.
  9. CSS zuerst, keine Animationsbibliotheken, es sei denn, das Projekt hat bereits eine. Keine JS-Schleifen, wenn CSS es kann.
  10. Inhalte niemals verzögern oder verstecken. Enthüllungen dürfen keine Inhalte verstecken, wenn JS fehlschlägt, Klicks blockieren oder das LCP-Element beim Laden animieren.
  11. Inszenierung: Eine fokussierte Bewegung nach der anderen. Maximal ~5 Bewegungs-Touchpoints pro Seite; niemals zwei Dinge, die im selben Moment um die Aufmerksamkeit konkurrieren.
  12. will-change nur während der Animation (oder auf ≤3 persistenten Elementen).
  13. Standardmäßig unterbrechbar. Zustände, die während des Ablaufs umschalten können (Schweben, Umschalten, Öffnen/Schließen, Tab-Indikator) verwenden transition, das von jeder Position aus neu zielt. @keyframes nur für einmalige Momente (Schütteln, Klingeln, Senden), die sauber neu starten.
  14. Skaliere die Dauer nach Größe und Auslöser. Kleine Elemente schneller als große (Icon 100ms, Karte 250ms, Blatt 300ms). Benutzerinitiiert = sofort; systeminitiiert (Toast, Hintergrundupdate) darf das langsame Ende nehmen.
  15. Kein Blinken mehr als 3×/s; alles, was länger als 5s schleift, benötigt eine Pausensteuerung (oder schleife nicht).

Die Prinzipien als UI-Regeln

Wähle diejenigen aus, die zum Touchpoint passen; niemals alle auf einmal. Jedes ist mit einem Muster unten verknüpft.

Nr.PrinzipIn der UI bedeutet dasMuster
1Quetschen & DehnenDinge quetschen beim Aufprall, dehnen sich in der Bewegung: GewichtDrücken, Umschalten
2AntizipationKleiner Rückzieher vor einer großen Bewegung (Senden, Absenden, Ausfliegen)Sende-Button
3InszenierungLenke den Blick auf eine Sache: Dimme Geschwister, eine Bewegung nach der anderenKartenfokus
4Pose zu PoseDefiniere Start-/Endzustände; lasse den Browser zwischentweentransition, nicht Frame-für-Frame-JS
5NachschwingenTeile setzen sich, nachdem der Körper gestoppt hat (kleines Überschwingen)Toast, Badge
6Langsam rein & langsam rausBeschleunigen und verlangsamen, niemals konstante GeschwindigkeitToken
7BögenReisende Elemente bewegen sich auf Kurven, nicht auf geraden LinienFliegen-zum-Warenkorb
8Sekundäre AktionKleine Verzierung, die die Hauptaktion unterstütztErfolgsring
9Flotte TimingDauer bestimmt das Gefühl; UI < 300msToken
10Übertriebenes FeedbackGehe über das Reale hinaus, damit der Moment ankommt (Fehler, Erfolg)Fehler-Schütteln
11Solides Zeichnen / 3DGib flachen Dingen Tiefe und VolumenKarten-Neigung
12AnziehungskraftDie Summe aller Details, konsistent auf der gesamten SeiteBestehen prüfen
UX-GesetzBewegungskonsequenzMuster
Fitts' GesetzGrößere, nähere Ziele werden schneller getroffenTreffflächen
Größere TreffflächenKlickbarer Bereich ≥ 44×44px, auch wenn das Visuelle kleiner istTreffflächen
Hicks GesetzMehr Auswahl = langsamere Entscheidungen; animiere nicht viele Optionen auf einmalStaffelungsbegrenzung
Millers GesetzHäppchenweise Inhalte (~7 Elemente); in Gruppen enthüllen, nicht einzelnStaffelungsbegrenzung
Doherty-Schwelle<100ms Feedback, <400ms insgesamt, sonst Fortschritt anzeigenWartezustand
Postels GesetzAkzeptiere chaotische Eingabe, gib saubere Ausgabe zurück; animiere die Bereinigung sanftEingabeformatierung
Jakobs GesetzVerwende konventionelle Bewegungen (Menüs fallen vom Auslöser, Modals blenden ein+skalieren aus der Mitte)Overlay
NutzungshäufigkeitHäufig = weniger AnimationRegel 5

Arbeitsablauf

  1. Lies die Seite zuerst. Framework, CSS-Ansatz (Tailwind, CSS-Module, pur), vorhandene Bewegungen und Token. Verwende sie wieder.
  2. Klassifiziere jedes interaktive Element nach Häufigkeit: selten (Anmeldung, Checkout, Erfolg), gelegentlich (Karten, Abschnitte, Modals), häufig (Navigation, Tabs, Paletten, Listenzeilen). Häufig bekommt ≤100ms oder nichts.
  3. Wähle ≤5 Touchpoints aus, sortiert nach Gefühl-pro-Aufwand:
    1. Buttons/Links: Drücken-Quetschen + Trefffläche (Prinzipien 1, Fitts)
    2. Formular-Feedback: Fehler-Schütteln, Erfolgsring, Wartezustand (10, 8, Doherty)
    3. Karten: Schwebe-Anheben, optionales Neigen (11)
    4. Abschnitte: Scroll-Enthüllung, gestaffelte Einblendung (6, Miller)
    5. Overlays/Toasts: Eintritt/Austritt mit Nachschwingen (5, Jakob)
  4. Füge die Token einmalig global hinzu.
  5. Wende die Muster nur auf die ausgewählten Touchpoints an.
  6. Verifiziere (letzter Abschnitt). Nicht erledigt bis verifiziert.
  7. Berichte: Jeder Touchpoint mit Datei:Zeile, das angewendete Prinzip und wie man es sehen kann.

Token (einmalig global hinzufügen)

:root {
  --ease-out: cubic-bezier(.23, 1, .32, 1);       /* Eintritt, Schwebe */
  --ease-in: cubic-bezier(.55, 0, 1, .45);        /* Austritt */
  --ease-in-out: cubic-bezier(.65, 0, .35, 1);    /* Bewegung auf dem Bildschirm */
  --ease-settle: cubic-bezier(.34, 1.4, .64, 1);  /* Nachschwingen: ~4% Überschwingen */
  /* Federgefühl, unterbrechbar; Browser ohne linear() fallen auf `ease` zurück */
  --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;
  }
}

Tailwind-Projekt? Füge diese in @theme / tailwind.config extend ein, anstatt eine neue CSS-Datei.

Muster

Drücken: Quetschen (1) + Trefffläche (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); }

/* Kleine Icon-Buttons: vergrößere die Trefffläche, nicht das Visuelle */
.icon-btn { position: relative; }
.icon-btn::before { content: ""; position: absolute; inset: 50% auto auto 50%; width: 44px; height: 44px; translate: -50% -50%; }

Umschalten: Quetschen & Dehnen (1)

Der Knopf dehnt sich während der Reise und setzt sich bei der Landung.

.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; }

Senden / Abschicken: Antizipation (2)

Nur bei seltenen „Commit"-Aktionen. 2px zurückziehen, dann los.

@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; }

Kartenfokus: Inszenierung (3)

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

Nur auf dichten Rastern verwenden, bei denen eine Wahl zählt. Überspringe bei Inhalten, die gelesen werden.

Karten-Anheben + optionales Neigen: Solides Zeichnen (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; }
}

Neigen (nur für Präsentationsobjekte wie ein Produkt, eine Preis- oder Kreditkarte; ≤6°, nur Zeiger, rAF-gedrosselt):

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(); // einmal pro Frame lesen, nicht pro Übergang
        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 = ''; });
  }
}

Toast / Badge: Nachschwingen (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); }

Überschwingen nur bei Dingen, die ankommen (Toasts, Badges, Zähler), niemals bei Layout oder Textblöcken.

Fliegen-zum-Warenkorb: Bögen (7)

Teile X und Y auf zwei verschachtelte Elemente mit unterschiedlichen Easings auf; der Pfad krümmt sich.

.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); }

Setze --dx/--dy aus einem getBoundingClientRect()-Lesevorgang, bevor .flying hinzugefügt wird.

Erfolgsring: Sekundäre Aktion (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) } }

Fehler-Schütteln: Übertriebenes Feedback (10)

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

Erneutes Auslösen durch Entfernen und erneutes Hinzufügen des Attributs. Immer mit einer Textmeldung kombinieren (Barrierefreiheit).

Wartezustand: Doherty-Schwelle

Sofortiges Feedback beim Drücken; wenn die Aktion >400ms dauert, zeige einen Spinner/Fortschritt innerhalb des Buttons an (behalte seine Breite fix bei, um Layout-Verschiebungen zu vermeiden). Bevorzuge optimistische UI: Zeige das Ergebnis, rolle bei Fehler zurück.

Chaotische Eingabe → saubere Ausgabe: Postels Gesetz

Formatiere bei blur (Telefonnummern, Kartennummern, Daten), nicht bei jedem Tastendruck. Überblende den Wert mit einer 150ms Opacity-Änderung, keine Bewegung.

Scroll-Enthüllung: Langsam rein/raus (6) + Häppchenbildung (Miller, Hick)

Inhalt standardmäßig sichtbar; nur ausgeblendet, wenn JS bestätigt, dass er enthüllt werden kann.

.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));
  • Staffele mit style="--i: n"; bei 6 Schritten begrenzt (Miller). Lange Listen als eine Gruppe enthüllen.
  • Einmalig enthüllen. Überspringe alles oberhalb der Falte.
  • Frameworks: Gleiches CSS; führe den Observer in einem Mount-Effekt aus, trenne die Verbindung beim Unmount.

Overlays: Jakobs Gesetz

Nur konventionelle Bewegung: Dropdowns wachsen aus ihrem Auslöser (transform-origin auf der Auslöser-Seite), Modals blenden ein + skalieren 0.98→1 aus der Mitte, Blätter gleiten von ihrer Kante. Zuerst nativ: <dialog> / popover mit @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); }
}

Befehlspalette / Menü, das mehrmals täglich über die Tastatur geöffnet wird: Nutzungshäufigkeit sagt, den Übergang zu überspringen.

Tabs: Ordneroberfläche, die gleitet (kein Akzent-Unterstrich)

Das AI-/Template-Versteck ist der dünne Akzent-Unterstrich, nicht die Bewegung. Verwende eine vertraute physische Form (Jakob) und lass diese Form die Bewegung ausführen:

  • Ordner-Tabs (bevorzugt): Die Oberfläche des ausgewählten Tabs geht in das Panel über und gleitet zum angeklickten Tab.
  • Segmentiertes Steuerelement: Für 2–4 Optionen; das gedrückte Segment gleitet auf die gleiche Weise.

Mache Tabs gleich breit, damit die Oberfläche nur translateX benötigt (keine Breite oder scaleX, was Radius und Rahmen verzerrt). Verwende einen ≤150ms Übergang, damit er unterbrechbar bleibt. Inhalte wechseln sofort (Nutzungshäufigkeit).

.tabs { position: relative; display: flex; gap: 2px; border-bottom: 1px solid var(--line); }
.tabs [role=tab] { position: relative; z-index: 1; flex: 0 0 96px; height: 32px; cursor: pointer; background: none; border: 0; font: inherit; }
.tabs [role=tab][aria-selected=true] { /* optionaler Stil, damit der aktive Tab sichtbar ist (z. B. font-weight) */ }
.tabs .surface {
  position: absolute; bottom: 0; left: 0; height: 100%; width: var(--tab-w);
  background: var(--surface2); border-radius: 6px 6px 0 0;
  transition: transform var(--dur-fast) var(--ease-out); /* verschiebt sich nur */
  transform: translateX(var(--surface-x));
}
// Setze --tab-w und --surface-x nach jeder Tab-Auswahl
// rAF-gelesen, nicht pro Klick
const updateSurface = () => {
  const sel = tabs.querySelector('[aria-selected=true]');
  if (!sel) return;
  const r = sel.getBoundingClientRect(), pr = tabs.getBoundingClientRect();
  surface.style.setProperty('--tab-w', r.width + 'px');
  surface.style.setProperty('--surface-x', (r.left - pr.left) + 'px');
};

Verifikation

  1. Prüfe auf harte Regelverstöße: width, height usw. animiert? Dauer >400ms ohne Fortschritt? prefers-reduced-motion deaktiviert Bewegung nicht?
  2. FPS-Check im DevTools-Performance-Panel – suche nach langen Aufgaben oder Layout-Erschütterungen. Animation darf keine Layout-Erschütterung verursachen.
  3. Öffne/Schließe Dinge schnell – schlägt der Zustand um, bevor die Animation endet? (Wenn nicht: transition, nicht @keyframes verwenden).
  4. Deaktiviere JS – ist der Inhalt noch sichtbar und klickbar?
  5. Button-weite Prüfung – wenn ein Button nach dem Klicken Spinner/Text ändert, seine min-width berechnet.
  6. Wisch-Gesten – funktionieren sie noch, während eine Animation läuft? (Berühre pointer-events an keinem animierten Element, außer opacity.
  7. Bildschirmleseprüfung auf prefers-reduced-motion – Sollte keine Bewegung haben (Opacity-Überblendungen sind in Ordnung).
  8. Scroll-Enthüllung auf Mobil – Safari-Höhe/Navigation? Überprüfe die rootMargin.

Berichtsvorlage

## Subtle Motion – Bericht

**Genutzte Token:** `--ease-out`, `--ease-settle`, `--dur-press`, `--dur-base`, `--rise`.

### 1. Button-Press (src/components/Button.tsx:12)
- **Prinzip:** 1 Quetschen & Dehnen, Fitts – Trefffläche
- **Demo:** Klicke einen beliebigen `<Button>`. Er quetscht auf scale(.97) und kehrt zurück.

### 2. Scroll-Enthüllung (src/sections/Features.tsx:8)
- **Prinzip:** 6 Langsam rein/raus, Miller – Häppchenbildung
- **Demo:** Scrolle zum Abschnitt „Features". Karten erscheinen als Gruppe, gestaffelt bis zu 6.

### 3. Overlay-Eintritt (src/components/Modal.tsx:20)
- **Prinzip:** 3 Inszenierung, 5 Nachschwingen, Jakob
- **Demo:** Öffne die Kartenmodal. Sie tritt mit einem Nachschwingen-Ease von unten ein. Der Hintergrund wird weichgezeichnet.

Verwandte Skills