Communitygithub.com

motion-animate

Das Bewegungsvokabular, das Premium-Animation von KI-Schrott trennt – Text-Pop-Blur-Fade, sequenzielle Staffelung, ständig bewegte Kameras mit Easing, Objekt-Eintritte und die dazugehörigen Timing-/Easing-Tabellen. Enthält fertigen Code für Remotion (interpolate/spring) und HyperFrames (GSAP).

Was ist motion-animate?

**motion-animate** ist ein detaillierter Bewegungsstandard für die Erstellung hochwertiger, kinoreifer Animationen in KI-gestützten Entwickler-Tools wie Claude Code, Cursor und Codex. Es definiert eine Reihe von Kernregeln und Bewegungsmustern, die Animationen von generisch wirkendem „KI-Müll“ unterscheiden. Das Skill bietet konkrete Anweisungen und Codebeispiele für Remotion (über `interpolate` und `spring`) sowie für HyperFrames (mit GSAP). Die Anleitung umfasst vier Grundgesetze, eine detaillierte Timing-Tabelle für verschiedene Elemente (Text, Symbole, Karten, Heldenobjekte, Linien) und spezifische „Moves“ wie Text-Pop-Blur-Fade, Akzentwörter, Symbole, Karten, Heldenobjekte, Strichzeichnungen und Kamerabewegungen. Es enthält außerdem eine „Verboten“-Liste mit häufigen Fehlern und einen Selbstcheck zur Qualitätssicherung. Die Appendizes A und B liefern direkt einsatzbereiten Code für Remotion (Frame-basiert, deterministisch) und HyperFrames/GSAP (mit HTML-Struktur, Timeline-Registrierung und strikten Regeln zur Deterministik und zum Clipping). Das Skill ist besonders nützlich, wenn Animationen „steif“, „hüpfrig“, „ruckelig“, „zu schnell“ oder „zu gleichförmig“ wirken oder wenn Timing- und Easing-Code für Videos geschrieben wird.

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

In Ihrer bevorzugten KI fragen

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

Dokumentation

Was macht motion-animate?

Das Design entscheidet, ob ein Bild gut ist. Die Bewegung entscheidet, ob es teuer aussieht. Die gleiche Komposition, animiert mit linearem Easing und gleichzeitigen Eintritten, wirkt generiert; animiert mit dem untenstehenden Vokabular wirkt sie autorengeführt.

Engine-Rezepte: Anhang A, Anhang B.

Die vier Gesetze

  1. Nichts ist linear. Jede Eigenschaft bewegt sich mit einem Easing. Lineare Bewegung existiert in der physischen Welt nicht, und das Auge erkennt es sofort.
  2. Nichts tritt gleichzeitig ein. Elemente kommen in einer bewussten Reihenfolge mit 60–120 ms Abstand an. Gleichzeitiger Eintritt ist das lauteste Bewegungs-Merkmal.
  3. Die Kamera ist niemals völlig still. Ein langsamer, kontinuierlicher Push oder Drift unter jeder Komposition. Statische Bilder wirken wie Folien.
  4. Nichts ist metronomisch. Variiere Dauern und Schnittabstände. Gleichmäßige 1-Sekunden-Schläge wirken automatisiert, egal wie gut jeder einzelne Schlag ist.

Timing-Tabelle

Werte bei 30 fps; für 60 fps skalieren. Zeiten in ms.

ElementDauerStaffelungEasing
Wort in einer Textzeile400–55060–90out-expo / power3.out
Textzeile (als Einheit)500–650120–180out-cubic / power2.out
Symbol / kleines UI-Element350–45080–120out-back (Überschwingen ≤1.06)
Panel / Karte550–700140–200out-quint / power4.out
Heldenobjekt Scale-In700–900—out-expo
Heldenobjekt Slide-In650–850—out-quint
Linie / Strichzeichnung600–1000—in-out-cubic
Kamera-Push (pro Szene)gesamte Szenenlänge—out-sine oder linear-ähnlich, wenn sehr langsam
Exit (jedes Element)250–35040–60in-cubic

Exits sind immer schneller als Eintritte, etwa halb so lang. Eine symmetrische Aus-Animation wirkt träge.

Die Kern-Bewegungen

Text — Pop-Blur-Fade, Wort für Wort

Der Signature-Move. Jede Eigenschaft animiert gleichzeitig, pro Wort, gestaffelt.

y:       +18px → 0
blur:    12px  → 0
opacity: 0     → 1
ease:    out-expo,  Dauer 480ms,  Staffelung 70ms

Optional scale: 0.96 → 1 hinzufügen. Keine Rotation hinzufügen. Nicht hüpfen lassen.

Bei einer langen Zeile nach Wörtern staffeln, nicht nach Zeichen – eine Zeichen-Staffelung wirkt wie ein Schreibmaschinen-Gimmick und dauert zu lange. Hebe dir die Zeichen-Staffelung für ein einzelnes kurzes Akzentwort auf.

Akzentwort

Führt die gleiche Bewegung aus, aber um 120–200 ms verzögert gegenüber seinen Nachbarn und erhält eine zusätzliche Eigenschaft – eine Farbverschiebung, einen Scale-Boost auf 1.04 oder einen Highlight-Balken, der dahinter hineinwischt. Es sollte als letztes ankommen und anders ankommen.

Symbole und UI

Pop-Fade: scale 0.7 → 1, opacity 0 → 1, out-back mit auf 1.06 begrenztem Überschwingen. Alles über 1.1 wirkt wie ein billiger Hüpfer.

Sequenzielle Regel: Das Ankerelement tritt zuerst ein, dann seine Abhängigen. Eine Karte tritt ein, dann ihr Symbol, dann ihr Label. Niemals umgekehrt, niemals zusammen.

Panels / Karten / Glas

y: +40 → 0, opacity 0 → 1, out-quint, 600ms, um 160ms über einen Stapel gestaffelt. Füge einen Lichtstreifen-Highlight hinzu, der 150ms nachdem das Panel gelandet ist, darüber läuft – das Panel kommt an, dann fängt es das Licht ein.

Heldenobjekt

Zwei Optionen, wähle nach Archetyp:

  • Scale-In: scale 1.25 → 1.00 mit rotate 3° → 0°, out-expo, 800ms. Fühlt sich an, als würde es sich an seinem Platz niederlassen.
  • Slide-In: von außerhalb des Bildrahmens mit einer 2°-Neigung, die sich auf 0° auflöst, out-quint, 750ms. Fühlt sich geliefert an.

Der Schlagschatten und die beschnittene Textur müssen an das Heldenobjekt „geparent“ sein, damit sie sich mit ihm bewegen. Unabhängig gleitende Schatten sind ein schwerwiegender Fehler.

Strich / Linienzeichnung

Animieren der Pfadlänge von 0 auf 100%, in-out-cubic, 600–1000ms. Ease beim Ein- und Ausgang – eine Zeichnung, die mit voller Geschwindigkeit beginnt, wirkt mechanisch. Verwende, um ein Label mit einem Subjekt zu verbinden, ein Akzentwort zu unterstreichen oder ein Diagramm nachzuzeichnen.

Kamera

Unter jeder Komposition eine der folgenden:

  • Push in: scale 1.00 → 1.08 über den gesamten Beat, out-sine.
  • Push out: scale 1.12 → 1.00, schneller am Anfang, zur Ruhe kommend.
  • Drift: x- oder y-Translation von 2–4% über den Beat.

Anti-Ruckel-Vertrag:

  • Animiere ein Wrapper-Element, niemals das Element, das das Layout oder Clipping besitzt.
  • Verwende nur transform – niemals top/left/width/height.
  • Skaliere die bewegte Ebene ~6% über den Bildrand hinaus, sodass Kanten niemals sichtbar werden.
  • Setze will-change: transform und erzwinge GPU-Compositing.
  • Halte die Gesamtbewegung gering. Große Kamerafahrten verstärken jeden Rundungsfehler.

Übergänge zwischen Beats

  • Harter Schnitt, maskiert durch einen SFX-Hit – die Standardeinstellung. Überblendungen zwischen designten Bildern trüben beide.
  • Scale-through – ein Element skaliert hoch, um das Bild auszufüllen, und die nächste Szene wird darin enthüllt.
  • Wipe durch eine Form – ein Kreis oder Panel skaliert über den Bildrand hinaus und trägt die nächste Szene mit sich.

Überblende keine zwei designten Kompositionen. Verwende keine vorgefertigten Übergangs-Presets.

Verboten

  • Lineares Easing bei allem Sichtbaren.
  • Hüpfer-Überschwingen >1.1 (Ausnahme: ein bewusst verspielter SaaS/Produkt-Stil, und dann konsistent).
  • Alle Elemente treten im gleichen Bild ein.
  • Gleichmäßige Beat-Längen innerhalb eines Schnitts.
  • repeat: -1 oder jede Endlosschleife – Renderings sind Einzelbild-abgetastet und müssen deterministisch sein.
  • Math.random(), Date.now() oder Netzwerkabrufe innerhalb einer Komposition. Gleiche Eingabe muss jedes Mal das gleiche Bild erzeugen.
  • Bewegung, die auf einen Wrapper angewendet wird, den das Framework bereits kontrolliert (siehe Anhang B §Clip-Regel).

Selbstcheck

Scrubbe das Rendering bei 0,25-facher Geschwindigkeit. Frage:

  • Beginnt oder endet etwas abrupt? → fehlendes Easing.
  • Kommt alles zusammen an? → fehlende Staffelung.
  • Steht das Bild jemals absolut still? → fehlende Kamera.
  • Fühlen sich aufeinanderfolgende Beats wie ein Trommelschlag an? → Dauern zu gleichmäßig.
  • Werden Kanten einer bewegten Ebene jemals sichtbar? → nicht über-skaliert.

Anhang A – Remotion Rezepte

Bildbasiert, deterministisch durch Konstruktion. Alle Timing leitet sich von useCurrentFrame() ab.

Hilfsfunktion: Zeit in ms, nicht in Bildern

Das Authoring in Bildern hardcodiert deine fps. Konvertiere.

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

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

Easing-Zuordnung

Die Namen aus der Timing-Tabelle, in Remotion-Ausdrücken:

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  (Ausgänge)
Easing.bezier(0.16, 1, 0.3, 1)            // das Arbeitstier – expo-ähnlicher Ausgang

Bei Überschwingen bevorzuge einen spring gegenüber Easing.back – es ist einfacher, subtil zu bleiben.

import {spring} from 'remotion';
const s = spring({frame, fps, config: {damping: 200, stiffness: 120, mass: 0.6}});
// damping 200 = kein sichtbares Überschwingen. Auf ~14 reduzieren für ein kleines Setzen.

Text — Pop-Blur-Fade, Wort für Wort

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

Das Akzentwort ist die gleiche Komponente mit delay, das 120–200ms später gesetzt ist, plus eigener Farbe und einem scale(1.04).

Kamera — immer anliegender Push

Umschließe die ganze Szene. Überskaliere, sodass Kanten nie sichtbar werden.

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

Setze die Kamera über die Grundelement-Ebene und unter jedes Element, das am Bildrand fixiert bleiben muss.

Gestaffelter Kartenstapel

const cards = ['Eins', 'Zwei', 'Drei'];
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>
  );
})}

Exit — die Hälfte des Eintritts

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

Struktur

Verwende <Sequence from={...} durationInFrames={...}> pro Beat, direkt gesteuert von der motion-plan-Tabelle. Ein Sequence pro Zeile. Beat-Dauern stammen aus dem Plan, nicht aus runden Zahlen.

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

Deterministrik

  • Niemals Math.random() – wenn du Streuung brauchst, seede sie aus dem Elementindex.
  • Niemals Date.now() oder new Date().
  • Niemals innerhalb einer Komponente fetchen. Vorladen mit staticFile() / delayRender().
  • <Video>/<Audio> sollte wo möglich <OffthreadVideo> sein, für die Rendering-Korrektheit.

Fallstricke

  • filter: blur() bei vielen gleichzeitigen Elementen ist teuer – begrenze die Anzahl gleichzeitiger unscharfer Knoten oder verwende eine Vor-Unschärfe im Asset.
  • Schriftarten laden: Verwende @remotion/google-fonts oder delayRender um ein lokales FontFace.load() herum, oder die ersten Bilder rendern mit einer Fallback-Schriftart.
  • interpolate wirft einen Fehler, wenn der Eingabebereich nicht monoton steigend ist – schütze berechnete Bereiche.
  • Gib immer extrapolateLeft/extrapolateRight: 'clamp' an, es sei denn, du möchtest gezielt, dass der Wert über den Bereich hinausläuft.

Anhang B – HyperFrames / GSAP Rezepte

HyperFrames komponiert HTML + GSAP und rendert durch Einzelbild-Sampling eines Headless-Browsers. Deterministrik ist zwingend erforderlich.

Führe npx hyperframes docs für die aktuelle API aus. Diese Datei ist der Bewegungsstandard darauf aufbauend – siehe das hyperframes-Skill für die Pipeline (init → preview → lint → render).

Die Clip-Regel (bricht Renderings, wenn verletzt)

Jedes getimte Element benötigt data-start, data-duration, data-track-index und class="clip". Das Framework besitzt die Sichtbarkeit und Transformation bei .clip.

Animiere NIEMALS das .clip-Element selbst. Animiere einen Child-Wrapper.

<div class="clip" data-start="4.2" data-duration="5.2" data-track-index="2">
  <div class="cam">           <!-- Kamerabewegungen hier -->
    <div class="inner">       <!-- Elementbewegungen hier -->
      <h1 class="headline">…</h1>
    </div>
  </div>
</div>

Timeline-Registrierung

const tl = gsap.timeline({paused: true});
window.__timelines['main'] = tl;   // id muss mit data-composition-id übereinstimmen

Angehalten, immer. Der Renderer sucht es.

Easing-Zuordnung

TabellennameGSAP
out-expoexpo.out
out-cubicpower2.out
out-quintpower4.out
out-back (begrenzt)back.out(1.2)
in-out-cubicpower2.inOut
out-sinesine.out
in-cubic (Ausgänge)power2.in

Text — Pop-Blur-Fade, Wort für Wort

Teile den Text zur Authoring-Zeit in Wort-Spans auf (verlasse dich nicht auf einen Laufzeit-Splitter – dieser kann mit dem ersten gesampelten Bild in Konkurrenz treten).

<h1 class="headline">
  <span class="w">Was</span> <span class="w">nach</span>
  <span class="w accent">Disziplin</span> <span class="w">aussieht</span>
</h1>
tl.from('.headline .w', {
  y: 18,
  opacity: 0,
  filter: 'blur(12px)',
  duration: 0.48,
  ease: 'expo.out',
  stagger: 0.07,
}, 0);

// Akzentwort kommt zuletzt und anders
tl.from('.headline .accent', {
  scale: 0.96,
  color: 'var(--surface)',
  duration: 0.5,
  ease: 'expo.out',
}, 0.18);

Kamera

Animiere .cam, niemals .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); }

Überskaliere die bewegte Ebene ~6% über den Bildrand hinaus, sodass Kanten während eines Push-Outs oder Drifts nie sichtbar werden.

Gestaffelter Kartenstapel

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

// Lichtstreifen kommt 150ms nach dem Panel
tl.fromTo('.card .sweep', {xPercent: -140}, {
  xPercent: 140, duration: 0.7, ease: 'power2.inOut', stagger: 0.16,
}, 1.35);

Strichzeichnung

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

Harte Regeln

  1. Nur deterministisch – kein Math.random(), kein Date.now(), kein Fetch, kein repeat: -1.
  2. 9:16 = 1080×1920. Setze #root { container-type: size; } und dimensioniere alles in cqw/cqh (1cqw = 10.8px), niemals vw/vh.
  3. Benachbarte Clips auf dem gleichen Track dürfen sich nicht berühren. Gleitkomma-Arithmetik macht aus 3.2 + 0.35 = 3.5500000000000003, was einen Clip überlappt, der bei 3.55 beginnt, und löst overlapping_clips_same_track aus. Lasse eine Lücke oder verwende Dauern wie 0.34.
  4. Audio: Videos sind muted; verwende eine einzige vorgemischte Master-<audio>-Spur (VO + SFX, gemischt mit ffmpeg adelay + amix) auf einem hohen dedizierten data-track-index. Mehrere <a …> (Text abgeschnitten).

Dieser Standard definiert, wie Bewegung aussieht. Wende ihn auf jeden Beat deiner Komposition an – bevor du den Render-Knopf drückst.

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.

Verwandte Skills