Communitygithub.com

Motion Avançado

Padrões de animação avançados para React / Next.js — arrastar e soltar, gestos, animações de texto, desenho de caminhos SVG, hooks personalizados, sequências imperativas (useAnimate), carregadores e a árvore de decisão completa da API. Requer motion-foundations.

O que é Motion Avançado?

Motion Avançado é um skill abrangente para desenvolvedores React/Next.js que precisam implementar animações complexas e interativas baseadas em física, indo além dos padrões básicos oferecidos pelo `motion-patterns`. Ele fornece uma coleção de patterns, hooks, princípios e regras para construir desde gestos de arrastar e soltar (com suporte a touch), componentes de texto animados (palavra por palavra, letra por letra, contador numérico), animações SVG (desenho de caminhos, morphing de ícones, anel de progresso), hooks personalizados como `useScrollReveal` e `useNavigationDirection`, até sequências imperativas com `useAnimate` e diversos componentes de carregamento (spinner, shimmer, pulse dots). O skill é suportado por qualquer ferramenta de agente de IA que utilize skills, como Claude Code, Cursor ou Codex, e seu funcionamento se baseia em uma documentação detalhada (SKILL.md) que inclui árvores de decisão para escolher a API correta, princípios fundamentais (como o uso de `useSpring` para sensação natural, `useMotionValue` para evitar re-renderizações e `useAnimate` para sequências seguras), além de regras críticas como testar interações de arrastar em dispositivos touch, pausar animações infinitas em abas de fundo e garantir a limpeza de event listeners. Tudo é construído sobre os tokens de design fornecidos pelo `motion-foundations`, garantindo consistência visual.

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

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

O que Motion Avançado faz?

Padrões de animação complexos, interativos e baseados em física. Requer que motion-foundations seja configurado primeiro. Use estes quando motion-patterns não for suficiente.

Quando Ativar

  • Construindo folhas de arrastar para dispensar, gestos de deslizar ou listas reordenáveis
  • Animando texto palavra por palavra, caractere por caractere, ou como um contador ao vivo
  • Desenhando caminhos SVG, transformando ícones ou animando progresso circular
  • Escrevendo um hook de animação personalizado (useScrollReveal, botão magnético, seguidor de cursor)
  • Sequenciando animações de várias etapas imperativamente com useAnimate
  • Construindo spinners, esqueletos shimmer, indicadores de pulso ou estados de carregamento de botão

Saídas

Este skill produz:

  • Interações de arrastar: cartões arrastáveis, folhas de arrastar para dispensar, listas Reorder.Group
  • Hooks de gestos: detecção de deslizar, pressão longa, esboço de pinça
  • Componentes de animação de texto: revelação de palavras, máquina de escrever de caracteres, contador numérico
  • Animação SVG: desenho de caminho, morphing de ícone, anel de progresso de traço
  • Hooks personalizados: useScrollReveal, useHoverScale, useNavigationDirection, useInViewOnce
  • Sequências imperativas via useAnimate com async/await seguro contra interrupções
  • Componentes de carregamento: spinner, shimmer, ponto de pulso, barra de progresso, estado de carregamento de botão

Princípios

  • Movimento baseado em física (useSpring, springs.*) sempre parece mais natural do que baseado em duração para manipulação direta.
  • useMotionValue + useTransform calcula valores derivados sem acionar re-renderizações.
  • Sequências useAnimate são imperativas e seguras contra interrupções — chamar animate() durante a execução cancela automaticamente a animação anterior.
  • Valores de movimento (useMotionValue, useSpring) são seguros para SSR e não causam erros de hidratação.

Regras

  1. Interações de arrastar devem ser testadas em dispositivos touch, não apenas com mouse. A prop drag funciona em ambos, mas a sensação e o limite diferem.
  2. Animações infinitas devem pausar quando document.visibilityState === "hidden". Abas em segundo plano não devem consumir GPU/CPU.
  3. O limite de deslize deve ser explícito. Nunca inferir intenção apenas pela velocidade; combine verificações de offset + velocity.
  4. A ref de escopo useAnimate deve ser anexada a um elemento DOM montado. Chamar animate() antes da montagem falha silenciosamente.
  5. Valores de movimento não devem ser recriados na renderização. useMotionValue(0) dentro do corpo de um componente está correto; new MotionValue(0) em uma renderização não está.
  6. Todos os valores de token são importados de motion-foundations. Sem números inline.
  7. Hooks personalizados devem lidar com a limpeza. Cada window.addEventListener precisa de um removeEventListener correspondente no retorno do useEffect.
  8. Morphing SVG requer contagens iguais de comandos de caminho. Caminhos com diferentes estruturas de comando "pulam" em vez de interpolar.

Orientação de Decisão

Escolhendo a API avançada correta

CenárioAPI
Arrastar com física ao soltardrag + dragTransition: springs.release
Lista ordenada de arrastar para reordenarReorder.Group + Reorder.Item
Dispensar ao arrastar com deslocamentodrag="y" + verificação de deslocamento onDragEnd
Deslizar para esquerda/direitadrag="x" + verificação de deslocamento onDragEnd
Pressão longaHook useLongPress
Valor suavizado ao longo do tempouseSpring
Valor derivado de outrouseTransform
Sequência de várias etapasuseAnimate com async/await
Animação imperativa de uso únicoanimate() de motion
Texto entrando palavra por palavraEscalonamento em spans inline-block
Desenho de SVGpathLength 0 → 1
Morphing de SVGTransição do atributo d (comandos iguais)
Progresso circularTransição de strokeDashoffset

Quando usar useSpring vs uma transição spring

useSpringtransition: springs.*
Use paraSeguidor de cursor, valores rastreados por ponteiroMudanças de estado discretas
AtualizaçõesContínuas, a cada quadroAcionadas por mudança de estado
InterrupçãoSuave — a física continua a partir da velocidadeReinicia a partir do valor atual

Conceitos Principais

useMotionValue + useTransform

Computação reativa sem re-renderizações:

const x = useMotionValue(0)
const opacity = useTransform(x, [-200, 0, 200], [0, 1, 0])
// opacity é atualizado a cada quadro conforme x muda — sem setState, sem re-renderização

useAnimate

Retorna [scope, animate]. A ref de escopo deve ser anexada a um elemento DOM. Chamadas animate() são seguras contra interrupções — chamar durante a execução cancela a execução anterior.

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 })  // dispara e esquece
}

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

Exemplos de Código

Cartão arrastável

"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}
/>

Folha de arrastar para dispensar

"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) => {
        // Regra 3: combinar offset + velocity
        if (info.offset.y > 120 || info.velocity.y > 500) onClose()
      }}
    />
  )
}

Lista reordenável

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

Detecção de deslize

"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()
  }}
/>

Hook de pressão longa

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

Revelação palavra por palavra

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

Contador numérico

"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   // Regra 7: limpeza
  }, [to])

  return <span ref={nodeRef} />
}

Desenho de caminho SVG

"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 }}
/>

Anel de progresso de traço

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

Hook useScrollReveal

"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 } }
}

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

Seguidor de cursor

"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)   // Regra 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 }}
    />
  )
}

Esqueleto shimmer

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

Estado de carregamento de botão

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

Animação infinita com pausa de visibilidade

"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 },
      })

    // Regra 2: pausar quando a aba estiver oculta
    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
      initial={{ scale: 1, opacity: 1 }}
      animate={controls}
    />
  )
}

Plataformas

Este skill é compatível com:

  • Claude Code — agentes de linha de comando
  • Cursor — IDE com inteligência artificial
  • Codex CLI — ferramentas de terminal
  • Qualquer ferramenta de agente de IA que suporte skills

Uso

Para usar este skill, primeiro certifique-se de que motion-foundations está configurado no seu projeto. Em seguida, instale este skill no seu agente de IA.

Instalação via Claude Code:

claude skill add Cody-W-Tucker/skills/motion-advanced

Instalação via Cursor:

Abra as configurações do Cursor e adicione o ID do skill: Cody-W-Tucker/skills/motion-advanced

Verificação:

Depois de instalado, o agente de IA aplicará automaticamente essas regras e patterns ao gerar código de animação.

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.

Habilidades Relacionadas