Communitygithub.com

Motion Advanced

Fortgeschrittene Bewegungsmuster für React / Next.js – Drag & Drop, Gesten, Textanimationen, SVG-Pfadzeichnen, benutzerdefinierte Hooks, imperative Sequenzen (useAnimate), Ladezustände und der vollständige API-Entscheidungsbaum. Erfordert motion-foundations.

Was ist Motion Advanced?

Dieses Skill bietet ein umfassendes Toolkit für komplexe, interaktive und physikbasierte Animationen in React/Next.js-Anwendungen, die über einfache Muster hinausgehen. Es deckt eine breite Palette fortgeschrittener Szenarien ab, darunter Drag-Interaktionen wie Drag-to-Dismiss und sortierbare Listen, Gesten-Swipe- und Long-Press-Erkennung, Textanimationen Wort für Wort oder als Live-Zähler, SVG-Pfadzeichnung und Icon-Morphing sowie imperatives Sequencing mit `useAnimate`. Der Schwerpunkt liegt auf Physik-basierten Bewegungen mit `useSpring`, die natürlicher wirken, sowie auf der effizienten Nutzung von `motion.Value`+`useTransform` zur Vermeidung von Re-Rendern. Der Skill enthält klare Regeln, wie z. B. das Testen auf Touch-Geräten, das Pausieren unendlicher Animationen im Hintergrund, die Kombination von Offset und Geschwindigkeit für Schwellenwerte und die korrekte Bereinigung von Event-Listenern. Ein Entscheidungsbaum hilft bei der Auswahl der richtigen API für verschiedene Szenarien. Das Skill enthält vollständige Codebeispiele für Draggable Cards, Drag-to-Dismiss-Sheets, Reorderable Lists, Swipe Detection, einen Long Press Hook, Wort-für-Wort-Enthüllung, einen Number Counter, SVG Path Draw-on, einen Stroke Progress Ring, einen useScrollReveal Hook, einen Cursor Follower, Shimmer Skeleton, Button Loading State und Pulse Dot mit Sichtbarkeits-Pause.

Funktioniert mit~Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/Cody-W-Tucker/skills/tree/HEAD/skills/motion-advanced

In Ihrer bevorzugten KI fragen

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

Dokumentation

Was macht Motion Advanced?

Komplexe, interaktive und physikbasierte Animationsmuster. Erfordert, dass zuerst motion-foundations eingerichtet wird. Verwende diese, wenn motion-patterns nicht ausreicht.

Wann zu aktivieren

  • Erstellen von Drag-to-Dismiss-Blättern, Wischgesten oder neu anordenbaren Listen
  • Animieren von Text Wort für Wort, Zeichen für Zeichen oder als Live-Zähler
  • Zeichnen von SVG-Pfaden, Morphing von Symbolen oder Animieren von kreisförmigen Fortschritten
  • Schreiben eines benutzerdefinierten Animations-Hooks (useScrollReveal, magnetischer Button, Cursor-Follower)
  • Sequenzieren von mehrstufigen Animationen imperativ mit useAnimate
  • Erstellen von Spinnern, Schimmer-Skeletten, Puls-Indikatoren oder Ladezuständen für Buttons

Ausgaben

Dieses Skill produziert:

  • Drag-Interaktionen: ziehbare Karten, Drag-to-Dismiss-Blätter, Reorder.Group-Listen
  • Gesten-Hooks: Swipe-Erkennung, langes Drücken, Pin-Outline
  • Textanimationskomponenten: Wort-Enthüllung, Zeichen-Schreibmaschine, Zahlenzähler
  • SVG-Animation: Pfad zeichnen, Symbol morphing, Strich-Fortschrittsring
  • Benutzerdefinierte Hooks: useScrollReveal, useHoverScale, useNavigationDirection, useInViewOnce
  • Imperative Sequenzen über useAnimate mit unterbrechungssicherem async/await
  • Ladekomponenten: Spinner, Schimmer, Puls-Punkt, Fortschrittsbalken, Button-Ladezustand

Prinzipien

  • Physikbasierte Bewegung (useSpring, springs.*) fühlt sich für direkte Manipulation immer natürlicher an als dauerbasierte.
  • useMotionValue + useTransform berechnet abgeleitete Werte, ohne erneutes Rendern auszulösen.
  • useAnimate-Sequenzen sind imperativ und unterbrechungssicher – ein Aufruf von animate() während des Laufs bricht die vorherige Animation automatisch ab.
  • Bewegungswerte (useMotionValue, useSpring) sind SSR-sicher und verursachen keine Hydrierungsfehler.

Regeln

  1. Drag-Interaktionen müssen auf Touch-Geräten getestet werden, nicht nur mit der Maus. Die drag-Eigenschaft funktioniert auf beiden, aber das Gefühl und die Schwellenwerte unterscheiden sich.
  2. Unendliche Animationen müssen pausieren, wenn document.visibilityState === "hidden". Hintergrund-Tabs dürfen keine GPU/CPU verbrauchen.
  3. Der Wisch-Schwellenwert muss explizit sein. Niemals die Absicht allein aus der Geschwindigkeit ableiten; kombiniere offset + velocity-Prüfungen.
  4. Der useAnimate-Bereichs-Ref muss an ein gemountetes DOM-Element angehängt werden. Ein Aufruf von animate() vor dem Mounten wirft einen stillen Fehler.
  5. Bewegungswerte dürfen beim Rendern nicht neu erstellt werden. useMotionValue(0) innerhalb eines Komponentenrumpfs ist korrekt; new MotionValue(0) in einem Render ist nicht korrekt.
  6. Alle Token-Werte werden aus motion-foundations importiert. Keine Inline-Zahlen.
  7. Benutzerdefinierte Hooks müssen die Bereinigung handhaben. Jedes window.addEventListener benötigt ein passendes removeEventListener im useEffect-Rückgabewert.
  8. SVG-Morphing erfordert gleiche Pfadbefehlanzahlen. Pfade mit unterschiedlichen Befehlstrukturen springen statt zu interpolieren.

Entscheidungshilfe

Auswahl der richtigen erweiterten API

SzenarioAPI
Ziehen mit Physik beim Loslassendrag + dragTransition: springs.release
Geordnete Drag-to-Reorder-ListeReorder.Group + Reorder.Item
Verwerfen bei Zieh-Offsetdrag="y" + onDragEnd-Offset-Prüfung
Wischen links/rechtsdrag="x" + onDragEnd-Offset-Prüfung
Langes DrückenuseLongPress Hook
Über Zeit geglätteter WertuseSpring
Von einem anderen abgeleiteter WertuseTransform
Mehrstufige SequenzuseAnimate mit async/await
Einmalige imperative Animationanimate() aus motion
Text tritt Wort für Wort einStaffeln auf inline-block-Spans
SVG zeichnet einpathLength 0 → 1
SVG-Morphingd-Attribut-Tween (gleiche Befehle)
Kreisförmiger FortschrittstrokeDashoffset-Tween

Wann useSpring vs. eine Spring-Transition verwendet wird

useSpringtransition: springs.*
Verwende fürCursor-Follower, zeigergesteuerte WerteDiskrete Zustandsänderungen
AktualisierungenKontinuierlich, bei jedem FrameAusgelöst durch Zustandsänderung
UnterbrechungSanft – Physik nimmt die Geschwindigkeit aufStartet vom aktuellen Wert neu

Kernkonzepte

useMotionValue + useTransform

Reaktive Berechnung ohne erneutes Rendern:

const x = useMotionValue(0)
const opacity = useTransform(x, [-200, 0, 200], [0, 1, 0])
// opacity wird bei jeder Änderung von x aktualisiert – kein setState, kein Re-Render

useAnimate

Gibt [scope, animate] zurück. Der Bereichs-Ref muss an ein DOM-Element angehängt werden. animate()-Aufrufe sind unterbrechungssicher – ein Aufruf während des Laufs bricht den vorherigen Lauf ab.

const [scope, animate] = useAnimate()

async function play() {
  await animate(".step-1", { opacity: 1 }, { duration: 0.3 })
  await animate(".step-2", { x: 0 },       { duration: 0.4 })
        animate(".step-3", { scale: 1 },    { duration: 0.25 })  // feuern und vergessen
}

return <div ref={scope}>...</div>

Codebeispiele

Ziehbare Karte

"use client"
import { motion } from "motion/react"
import { springs, motionTokens } from "@/lib/motion-tokens"

<motion.div
  drag
  dragConstraints={{ left: -100, right: 100, top: -100, bottom: 100 }}
  dragElastic={0.1}
  whileDrag={{
    scale: motionTokens.scale.pop,
    boxShadow: "0 16px 40px rgba(0,0,0,0.2)",
  }}
  dragTransition={springs.release}
/>

Drag-to-Dismiss-Blatt

"use client"
import { motion, useMotionValue, useTransform } from "motion/react"

export function BottomSheet({ onClose }: { onClose: () => void }) {
  const y = useMotionValue(0)
  const opacity = useTransform(y, [0, 200], [1, 0])

  return (
    <motion.div
      drag="y"
      dragConstraints={{ top: 0 }}
      style={{ y, opacity }}
      onDragEnd={(_, info) => {
        // Regel 3: kombiniere Offset + Geschwindigkeit
        if (info.offset.y > 120 || info.velocity.y > 500) onClose()
      }}
    />
  )
}

Neu anordenbare Liste

"use client"
import { Reorder } from "motion/react"

export function SortableList() {
  const [items, setItems] = useState(initialItems)
  return (
    <Reorder.Group axis="y" values={items} onReorder={setItems}>
      {items.map((item) => (
        <Reorder.Item key={item.id} value={item}>
          {item.label}
        </Reorder.Item>
      ))}
    </Reorder.Group>
  )
}

Swipe-Erkennung

"use client"
import { motion } from "motion/react"

const OFFSET_THRESHOLD  = 50
const VELOCITY_THRESHOLD = 300

<motion.div
  drag="x"
  dragConstraints={{ left: 0, right: 0 }}
  onDragEnd={(_, info) => {
    const swipedRight = info.offset.x > OFFSET_THRESHOLD  || info.velocity.x > VELOCITY_THRESHOLD
    const swipedLeft  = info.offset.x < -OFFSET_THRESHOLD || info.velocity.x < -VELOCITY_THRESHOLD
    if (swipedRight) onSwipeRight()
    if (swipedLeft)  onSwipeLeft()
  }}
/>

Long-Press-Hook

import { useRef } from "react"

export function useLongPress(callback: () => void, ms = 600) {
  const timerRef = useRef<ReturnType<typeof setTimeout>>()
  return {
    onPointerDown:  () => { timerRef.current = setTimeout(callback, ms) },
    onPointerUp:    () => clearTimeout(timerRef.current),
    onPointerLeave: () => clearTimeout(timerRef.current),
  }
}

Wort-für-Wort-Enthüllung

"use client"
import { motion } from "motion/react"
import { springs } from "@/lib/motion-tokens"

export function AnimatedText({ text }: { text: string }) {
  return (
    <motion.p
      variants={{ visible: { transition: { staggerChildren: 0.05 } } }}
      initial="hidden"
      animate="visible"
    >
      {text.split(" ").map((word, i) => (
        <motion.span
          key={i}
          className="inline-block mr-1"
          variants={{
            hidden:  { opacity: 0, y: 12 },
            visible: { opacity: 1, y: 0, transition: springs.gentle },
          }}
        >
          {word}
        </motion.span>
      ))}
    </motion.p>
  )
}

Zahlenzähler

"use client"
import { useRef, useEffect } from "react"
import { animate } from "motion"
import { motionTokens } from "@/lib/motion-tokens"

export function Counter({ to }: { to: number }) {
  const nodeRef = useRef<HTMLSpanElement>(null)

  useEffect(() => {
    const controls = animate(0, to, {
      duration: motionTokens.duration.crawl,
      ease: motionTokens.easing.smooth,
      onUpdate: (v) => {
        if (nodeRef.current) nodeRef.current.textContent = Math.round(v).toString()
      },
    })
    return controls.stop   // Regel 7: Bereinigung
  }, [to])

  return <span ref={nodeRef} />
}

SVG-Pfad zeichnen

"use client"
import { motion } from "motion/react"
import { motionTokens } from "@/lib/motion-tokens"

<motion.path
  d="M 0 100 Q 50 0 100 100"
  initial={{ pathLength: 0, opacity: 0 }}
  animate={{ pathLength: 1, opacity: 1 }}
  transition={{ duration: motionTokens.duration.slow, ease: motionTokens.easing.smooth }}
/>

Strich-Fortschrittsring

"use client"
import { motion } from "motion/react"
import { motionTokens } from "@/lib/motion-tokens"

const CIRCUMFERENCE = 2 * Math.PI * 40   // r=40

export function ProgressRing({ progress }: { progress: number }) {
  return (
    <svg width="100" height="100" viewBox="0 0 100 100">
      <circle cx="50" cy="50" r="40" fill="none" stroke="#e5e7eb" strokeWidth="8" />
      <motion.circle
        cx="50" cy="50" r="40"
        fill="none" stroke="#6366f1" strokeWidth="8"
        strokeLinecap="round"
        strokeDasharray={CIRCUMFERENCE}
        animate={{ strokeDashoffset: CIRCUMFERENCE - (progress / 100) * CIRCUMFERENCE }}
        transition={{ duration: motionTokens.duration.normal, ease: motionTokens.easing.smooth }}
        style={{ rotate: -90, transformOrigin: "center" }}
      />
    </svg>
  )
}

useScrollReveal-Hook

"use client"
import { useRef } from "react"
import { useScroll, useTransform } from "motion/react"
import { motionTokens } from "@/lib/motion-tokens"

export function useScrollReveal() {
  const ref = useRef(null)
  const { scrollYProgress } = useScroll({ target: ref, offset: ["start end", "end start"] })
  const opacity = useTransform(scrollYProgress, [0, 0.3], [0, 1])
  const y       = useTransform(scrollYProgress, [0, 0.3], [motionTokens.distance.lg, 0])
  return { ref, style: { opacity, y } }
}

// Verwendung
const { ref, style } = useScrollReveal()
<motion.section ref={ref} style={style} />

Cursor-Follower

"use client"
import { useEffect } from "react"
import { motion, useMotionValue, useSpring } from "motion/react"
import { springs } from "@/lib/motion-tokens"

export function CursorFollower() {
  const x = useMotionValue(-100)
  const y = useMotionValue(-100)
  const sx = useSpring(x, springs.gentle)
  const sy = useSpring(y, springs.gentle)

  useEffect(() => {
    const move = (e: MouseEvent) => { x.set(e.clientX); y.set(e.clientY) }
    window.addEventListener("mousemove", move)
    return () => window.removeEventListener("mousemove", move)   // Regel 7
  }, [])

  return (
    <motion.div
      className="fixed top-0 left-0 w-6 h-6 rounded-full bg-indigo-500
                 pointer-events-none -translate-x-1/2 -translate-y-1/2 z-50"
      style={{ x: sx, y: sy }}
    />
  )
}

Schimmer-Skelett

"use client"
import { useEffect } from "react"
import { motion, useAnimation } from "motion/react"
import { motionTokens } from "@/lib/motion-tokens"

export function ShimmerSkeleton({ className = "" }: { className?: string }) {
  const controls = useAnimation()

  useEffect(() => {
    const play = () =>
      controls.start({
        x: ["-100%", "100%"],
        transition: {
          repeat: Infinity,
          duration: motionTokens.duration.crawl,
          ease: motionTokens.easing.linear,
        },
      })

    const handleVisibility = () => {
      if (document.visibilityState === "hidden") controls.stop()
      else void play()
    }

    void play()
    document.addEventListener("visibilitychange", handleVisibility)
    return () => {
      controls.stop()
      document.removeEventListener("visibilitychange", handleVisibility)
    }
  }, [controls])

  return (
    <div className={`relative overflow-hidden bg-gray-200 rounded ${className}`}>
      <motion.div
        className="absolute inset-0 bg-gradient-to-r from-transparent via-white/60 to-transparent"
        initial={{ x: "-100%" }}
        animate={controls}
      />
    </div>
  )
}

Button-Ladezustand

"use client"
import { motion, AnimatePresence } from "motion/react"
import { motionTokens, springs } from "@/lib/motion-tokens"

export function LoadingButton({
  loading,
  label,
  onClick,
}: {
  loading: boolean
  label: string
  onClick: () => void
}) {
  return (
    <motion.button
      onClick={onClick}
      animate={{ opacity: loading ? 0.7 : 1 }}
      whileTap={loading ? {} : { scale: motionTokens.scale.press }}
      transition={springs.snappy}
      disabled={loading}
    >
      <AnimatePresence mode="wait">
        {loading ? (
          <motion.span
            key="loading"
            initial={{ opacity: 0 }} animate={{ opacity: 1 }} exit={{ opacity: 0 }}
            transition={{ duration: motionTokens.duration.fast }}
          >
            …
          </motion.span>
        ) : (
          <motion.span
            key="label"
            initial={{ opacity: 0 }} animate={{ opacity: 1 }} exit={{ opacity: 0 }}
            transition={{ duration: motionTokens.duration.fast }}
          >
            {label}
          </motion.span>
        )}
      </AnimatePresence>
    </motion.button>
  )
}

Unendliche Animation mit Sichtbarkeits-Pause

"use client"
import { useEffect } from "react"
import { motion, useAnimation } from "motion/react"
import { motionTokens } from "@/lib/motion-tokens"

export function PulseDot() {
  const controls = useAnimation()

  useEffect(() => {
    const pulse = () =>
      controls.start({
        scale: [1, 1.4, 1],
        opacity: [1, 0.6, 1],
        transition: { repeat: Infinity, duration: motionTokens.duration.crawl },
      })

    // Regel 2: pausieren, wenn Tab ausgeblendet ist
    const handleVisibility = () => {
      if (document.visibilityState === "hidden") controls.stop()
      else void pulse()
    }

    void pulse()
    document.addEventListener("visibilitychange", handleVisibility)
    return () => {
      controls.stop()
      document.removeEventListener("visibilitychange", handleVisibility)
    }
  }, [controls])

  return (
    <motion.div
      className="w-3 h-3 rounded-full bg-indigo-500"
      animate={controls}
    />
  )
}

Individual skills in this repo

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

Cody-W-Tucker/skills

Landing page quality assessment for paid advertising campaigns. Evaluates message match, page speed, mobile experience, trust signals, form optimization, and conversion rate potential. Use when user says landing page, post-click experience, landing page audit, conversion rate, or landing page optimization.

Cody-W-Tucker/skills

TikTok Ads deep analysis covering creative quality, tracking, bidding, campaign structure, and TikTok Shop. Evaluates 28 checks with emphasis on creative-first strategy, safe zone compliance, and Smart+ campaigns. Use when user says TikTok Ads, TikTok marketing, TikTok Shop, Spark Ads, Smart+, or TikTok campaign.

Cody-W-Tucker/skills

YouTube Ads specific analysis covering campaign types, creative quality, audience targeting, and measurement. Evaluates video ad performance across skippable, non-skippable, bumper, Shorts, Demand Gen, and Connected TV formats. Covers VAC→Demand Gen migration, Shorts creative requirements, and CTV shoppable ads. Use when user says YouTube Ads, video ads, pre-roll, bumper ads, YouTube campaign, Shorts ads, or CTV ads.

Cody-W-Tucker/skills

Craft the story that makes investors say \"I want in.\" Master the narrative structure that Reid Hoffman, Sequoia, and top founders use to raise capital. Use when: **Preparing to fundraise** to develop your story before the deck; **Investor meetings** to structure conversations that convert; **Pitch practice** to refine your narrative arc; **Cold outreach** to write compelling investor emails; **Pivoting** to reframe your story after a change

Cody-W-Tucker/skills

Identify the best GTM motions and tools across 7 motion types: Inbound, Outbound, Paid Digital, Community, Partners, ABM, and PLG. Use when selecting marketing channels, choosing between inbound and outbound strategy, or planning cross-channel campaigns.

Cody-W-Tucker/skills

Produce a print-grade single-page kami (紙 / 纸) document — warm parchment canvas, ink-blue accent, serif at one weight, no italic, no cool grays. The output reads like a professional white paper or studio one-pager, not an app UI. Multilingual by design (EN · zh-CN · ja). One self-contained HTML file, zero dependencies.

Cody-W-Tucker/skills

Optimize landing pages for maximum conversions using proven frameworks from Unbounce and Oli Gardner—apply the \"one goal, one message, one action\" principle with data-driven design, copy, and CTA best practices. Use when: **Create a new landing page** for a campaign; **Optimize an existing landing page** that isn't converting; **Review landing page design** before launch; **Improve form conversion rates** on lead gen pages; **A/B test landing page elements** systematically

Cody-W-Tucker/skills

Motion tokens, spring presets, performance rules, device adaptation, accessibility enforcement, and SSR safety for React / Next.js using motion/react. Foundation layer — all other motion skills depend on this.

Cody-W-Tucker/skills

A single-frame motion-design composition with looping CSS animations — rotating type ring, animated globe, ticking timer, parallax labels. Renders as a hero video poster you can hand straight to HyperFrames or any keyframe-based exporter. Use when the brief asks for "motion design", "animated hero", "loop", "video poster", "title card", or pairs Open Claude Design with HyperFrames for a kinetic export.

Cody-W-Tucker/skills

Production-ready animation patterns for React / Next.js — button, modal, toast, stagger, page transitions, exit animations, scroll, and layout — built on motion-foundations tokens and springs.

Cody-W-Tucker/skills

Production-ready UI motion system for React/Next.js. Use when implementing animations, transitions, or motion patterns.

Cody-W-Tucker/skills

Produce a single-file slide deck in the Atelier Zero visual language (warm-paper background, italic-serif emphasis spans, coral terminating dots, surreal collage plates) — Open Design's brand deck recipe. The deck uses **horizontal magazine-style swipe pagination** (←/→, wheel, swipe), a per-slide chrome strip with brand mark and slide counter, an ESC overview grid, a coral progress bar, and inherits the canonical stylesheet + 16-slot image library from the sister `open-design-landing` skill.

Cody-W-Tucker/skills

Produce a world-class single-page editorial landing site in the Atelier Zero visual language (Monocle / Apartamento / Études editorial collage) — the same aesthetic Open Design uses for its own marketing surface. The agent fills a typed `inputs.json` from a brand brief, optionally generates 16 collage assets via gpt-image-2, then runs a pure-function composer that emits a self-contained HTML file; a separate path can mirror the Astro marketing site in `apps/landing-page/`. Drop-in scroll-reveal motion and a Headroom-style sticky nav are wired automatically.

Cody-W-Tucker/skills

Best practices for Remotion - Video creation in React. 29 domain-specific rules covering 3D, animations, audio, captions, charts, transitions, and more.

Cody-W-Tucker/skills

Single-page SaaS landing with hero, features, social proof, pricing, and CTA. Respects the active DESIGN.md color/typography/layout tokens. Trigger keywords: "saas landing", "marketing page", "product landing".

Cody-W-Tucker/skills

Single-page SaaS landing with hero, features, social proof, pricing, and CTA. Respects the active DESIGN.md color/typography/layout tokens. Trigger keywords: "saas landing", "marketing page", "product landing".

Cody-W-Tucker/skills

Master April Dunford's 8-step sales narrative from \"Sales Pitch\" (2023). Transform your positioning into a compelling story that wins enterprise deals. Use when: Structuring B2B sales presentations and demos; Creating pitch decks for complex products; Training sales teams on narrative-driven selling; Converting positioning strategy into sales conversations; Winning against entrenched competitors

Cody-W-Tucker/skills

Swiss-style user-research narrative template in warm-paper editorial aesthetics. Use when users ask for a premium research deck or story-first live artifact with minimalist typography, high-clarity layout, subtle motion, donut breakdowns, and keyboard/click navigation across slides in a single HTML file.

Cody-W-Tucker/skills

See, Understand, Act on video and audio. See- ingest from local files, URLs, RTSP/live feeds, or live record desktop; return realtime context and playable stream links. Understand- extract frames, build visual/semantic/temporal indexes, and search moments with timestamps and auto-clips. Act- transcode and normalize (codec, fps, resolution, aspect ratio), perform timeline edits (subtitles, text/image overlays, branding, audio overlays, dubbing, translation), generate media assets (image, audio, video), and create real time alerts for events from live streams or desktop capture.

Cody-W-Tucker/skills

Download YouTube videos with customizable quality and format options. Use this skill when the user asks to download, save, or grab YouTube videos. Supports various quality settings (best, 1080p, 720p, 480p, 360p), multiple formats (mp4, webm, mkv), and audio-only downloads as MP3.

Verwandte Skills