Communitygithub.com

Motion Craft

Diseña animaciones aceleradas por GPU con Web Animations API (WAAPI), Animaciones Guiadas por Scroll (ScrollTimeline/ViewTimeline), la técnica FLIP, sistemas de easing y accesibilidad (prefers-reduced-motion). Úsalo cuando el usuario pida crear animaciones, transiciones, efectos de scroll, transiciones de página o movimiento interactivo para interfaces web. NO usar para animaciones basadas en canvas (Three.js, PixiJS), edición de video o diseño de movimiento no web (móvil nativo).

¿Qué es Motion Craft?

Motion Craft es una habilidad para Claude Code que permite diseñar animaciones web de alto rendimiento, centradas en la comunicacion visual por encima de la mera decoración. Proporciona un marco de decisión estructurado para responder preguntas clave antes de animar: cuándo animar (evitando animaciones en acciones frecuentes), cuál es el propósito, qué easing usar (con una biblioteca de curvas personalizadas fuertes) y la duración adecuada (con reglas estrictas como UI bajo 300ms). Soporta múltiples plataformas: CSS Transitions (preferidas para UI por su interrumpibilidad), CSS Animations (keyframes), Web Animations API (WAAPI) para animaciones dinámicas fuera del hilo principal, Scroll-Driven Animations (ViewTimeline y ScrollTimeline), la técnica FLIP para animaciones de layout, y física de muelles (springs). Incluye reglas de oro de rendimiento como animar solo `transform` y `opacity` para mantener 60fps, y un formato requerido de revisión con tabla Before | After | Why. También enfatiza la accesibilidad con `prefers-reduced-motion`. Está inspirada en Emil Kowalski (Linear, Sonner, Vaul), Paul Lewis (Google Chrome) y el CSS Animation Working Group.

Compatible con~Claude Code~Codex CLI✓Cursor✓OpenCode
npx skills add https://github.com/EliasOulkadi/shokunin/tree/HEAD/.pack/skills/motion-craft

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

¿Qué hace Motion Craft?

Animaciones que comunican, no decoran. Cada fotograma debe ganarse su lugar.

Inspirado por Emil Kowalski (Linear, Sonner, Vaul), Paul Lewis (Google Chrome) y el CSS Animation Working Group.

Flujo de trabajo

El Marco de Decisión de Animación

Antes de escribir cualquier código de animación, responde estas cuatro preguntas en orden.

1. ¿Debería esto animarse?

FrecuenciaDecisiónRazón
100+ veces/día (atajos de teclado, paleta de comandos, alternar búsqueda)Sin animación. Nunca.La animación hace que las acciones frecuentes se sientan retardadas. Raycast no tiene animación de apertura/cierre. Óptimo.
Decenas de veces/día (efectos hover, navegación de listas)Eliminar o reducir drásticamenteLos usuarios notan la latencia de la animación en interacciones repetidas
Ocasional (modales, cajones, toasts)Animación estándarEl lugar adecuado para el movimiento
Raro / primera vez (onboarding, confirmación, celebración)Añadir deleiteEstos momentos merecen animaciones más largas y ricas

Nunca animar acciones iniciadas por teclado. Estas se repiten cientos de veces al día.

2. ¿Cuál es el propósito?

Cada animación debe tener una respuesta clara a "¿por qué se anima esto?"

PropósitoEjemplo¿Válido?
Consistencia espacialEl toast entra y sale desde la misma dirección✅
Indicación de estadoEl botón se transforma para mostrar "enviado"✅
RetroalimentaciónEl botón se escala hacia abajo al presionar, confirmando que la interfaz escuchó al usuario✅
Prevenir cambios bruscosElementos que aparecen gradualmente en lugar de aparecer abruptamente✅
ExplicaciónAnimación de marketing que muestra cómo funciona una función✅
"Se ve genial" Y el usuario lo ve a menudoMovimiento gratuito❌

3. ¿Qué easing debería usar?

EscenarioEasingCSS
Elemento entrandoease-out (comienza rápido, se siente receptivo)cubic-bezier(0, 0, 0.2, 1)
Elemento saliendoease-in (comienza lento, capta la atención brevemente y luego acelera)cubic-bezier(0.4, 0, 1, 1)
Movimiento / transformación en pantallaease-in-outcubic-bezier(0.4, 0, 0.2, 1)
Hover / cambio de coloreasecubic-bezier(0.25, 0.1, 0.25, 1)
Movimiento constante (marquesina, barra de progreso)linearcubic-bezier(0, 0, 1, 1)
Interacciones de UI (botones, tooltips, menús desplegables)ease-out fuertecubic-bezier(0.23, 1, 0.32, 1)

Crítico: nunca usar ease-in para animaciones de entrada de UI. Un menú desplegable con ease-in a 300ms se siente más lento que ease-out al mismo 300ms porque ease-in retrasa el movimiento inicial, justo el momento que el usuario está observando más de cerca.

4. ¿Qué tan rápido debería ser?

ElementoDuraciónEasing
Retroalimentación de presión de botón (escala)100-160mscubic-bezier(0.23, 1, 0.32, 1)
Entrada / salida de tooltip125-200mscubic-bezier(0.23, 1, 0.32, 1)
Menú desplegable / select / popover150-250mscubic-bezier(0.23, 1, 0.32, 1)
Transformación hover (escala, elevación)200mscubic-bezier(0.23, 1, 0.32, 1)
Entrada de modal / diálogo200-300mscubic-bezier(0, 0, 0.2, 1)
Salida de modal / diálogo150-200mscubic-bezier(0.4, 0, 1, 1)
Entrada de cajón / hoja200-400mscubic-bezier(0.32, 0.72, 0, 1) (similar a iOS)
Entrada de toast300-400mscubic-bezier(0.23, 1, 0.32, 1)
Salida de toast200-300mscubic-bezier(0.4, 0, 1, 1)
Transición de página300-400mscubic-bezier(0.4, 0, 0.2, 1)
Revelación por scroll (desvanecimiento + deslizamiento hacia arriba)400-800mscubic-bezier(0.16, 1, 0.3, 1)
Destello de carga1000-1500ms (infinito)linear
Mantener presionado para eliminar (presionar)2000mslinear (deliberado)
Mantener presionado para eliminar (soltar)200mscubic-bezier(0.23, 1, 0.32, 1) (rápido)
Marketing / explicativo800-3000msvariable, depende de la narrativa

Regla: Las animaciones de UI deben estar por debajo de 300ms. Un menú desplegable de 180ms se siente notablemente más receptivo que uno de 400ms.

Curvas de easing personalizadas

Los valores CSS integrados ease / ease-in / ease-out son demasiado débiles. Usa estas variantes personalizadas más fuertes:

:root {
  --ease-out-strong: cubic-bezier(0.23, 1, 0.32, 1);     /* Interacciones de UI, la firma de Emil */
  --ease-in-out-strong: cubic-bezier(0.77, 0, 0.175, 1);  /* Movimiento en pantalla */
  --ease-drawer: cubic-bezier(0.32, 0.72, 0, 1);          /* Cajón similar a iOS */
  --ease-out-expo: cubic-bezier(0.16, 1, 0.3, 1);         /* Revelaciones lentas, dramático */
  --ease-out-quint: cubic-bezier(0.22, 1, 0.36, 1);       /* Alternativa fuerte de ease-out */
  --ease-spring: cubic-bezier(0.34, 1.56, 0.64, 1);       /* Ligero rebasamiento, con moderación */
}

Fuentes: easing.dev, easings.co


La Regla de Oro de los 60fps

16.67ms por fotograma. Verificar con la pestaña Rendimiento de Chrome DevTools. Animar solo transform y opacity.

Propiedad¿Composición por GPU?Dispara
transform (translate, scale, rotate)✅ SíSolo composición
opacity✅ SíSolo composición
filter🤷 A vecesPintura + Composición
clip-path🤷 A vecesPintura + Composición
width, height, top, left, margin, padding, border-width❌ NoDiseño + Pintura + Composición
box-shadow❌ NoPintura + Composición
color, background-color❌ NoSolo pintura

Formato de Revisión (Obligatorio)

Al revisar código de animación de UI, DEBES usar una tabla markdown con las columnas Antes | Después | Por qué. NO uses una lista con "Antes:" y "Después:" en líneas separadas.

Formato correcto:

AntesDespuésPor qué
transition: all 300mstransition: transform 200ms ease-outEspecifica propiedades exactas; evita all que provoca recálculo de diseño
transform: scale(0)transform: scale(0.95); opacity: 0Nada en el mundo real aparece de la nada
ease-in en menú desplegablecubic-bezier(0.23, 1, 0.32, 1)ease-in comienza lento, se siente lento. ease-out fuerte da retroalimentación instantánea
Sin estado :active en botóntransform: scale(0.97) en :activeLos botones deben sentirse receptivos al presionar
transform-origin: center en popovertransform-origin: var(--radix-popover-content-transform-origin)Los popovers deben escalar desde su disparador. Los modales permanecen centrados.
transition: 300ms sin prefers-reduced-motion@media (prefers-reduced-motion: reduce) { transition-duration: 0.01ms }WCAG 2.1 requiere soporte de movimiento reducido
animate={{ x: 100 }} en Framer Motionanimate={{ transform: "translateX(100px)" }}x/y de Framer Motion NO están acelerados por hardware. Usa cadena transform para GPU.

Formato incorrecto (nunca hacer esto):

Antes: transition: all 300ms
Después: transition: transform 200ms ease-out

Transiciones CSS (preferidas para UI)

Las transiciones CSS son interrumpibles: pueden redirigirse a mitad de la animación. Los keyframes se reinician desde cero. Para cualquier interacción que pueda activarse rápidamente (toasts, alternadores, menús desplegables), las transiciones producen resultados más suaves.

.button {
  transition: transform 160ms ease-out;
}
.button:active {
  transform: scale(0.97);
}

.tooltip {
  transition: transform 125ms ease-out, opacity 125ms ease-out;
  transform-origin: var(--transform-origin);
}

Temporización asimétrica de entrada / salida

La entrada puede ser más lenta (el usuario está decidiendo), la salida debe ser rápida (el sistema responde):

.overlay {
  transition: clip-path 200ms ease-out;  /* soltar: rápido */
}
.button:active .overlay {
  transition: clip-path 2s linear;       /* presionar: lento y deliberado */
}

Tooltips: omitir retraso en hovers subsiguientes

.tooltip {
  transition: transform 125ms ease-out, opacity 125ms ease-out;
  transform-origin: var(--transform-origin);
}
.tooltip[data-instant] {
  transition-duration: 0ms;
}

Estados de entrada con @starting-style (solo Chrome a partir de 2026, aún no Baseline)

.toast {
  opacity: 1;
  transform: translateY(0);
  transition: opacity 400ms ease-out, transform 400ms ease-out;

  @starting-style {
    opacity: 0;
    transform: translateY(100%);
  }
}

Nota: @starting-style y las animaciones guiadas por scroll (animation-timeline: view(), animation-timeline: scroll()) son solo Chrome a partir de 2026. Usa fallbacks con JavaScript (IntersectionObserver) para compatibilidad entre navegadores.

Patrón de mantener presionado para eliminar

.overlay {
  clip-path: inset(0 100% 0 0);
  transition: clip-path 200ms ease-out;   /* soltar: rápido */
}
.button:active .overlay {
  clip-path: inset(0 0 0 0);
  transition: clip-path 2s linear;        /* presionar: lento y deliberado */
}

BOTONES - Retroalimentación Táctil

Cada elemento presionable necesita una respuesta física.

.button {
  transition: transform 160ms cubic-bezier(0.23, 1, 0.32, 1);
}
.button:active {
  transform: scale(0.97);
}

La escala debe ser sutil (0.95-0.98). Aplicar a todos los elementos presionables: botones, tarjetas, elementos de lista, pestañas.


POPOVERS - Conscientes del Origen

Los popovers escalan desde su disparador, no desde el centro. Los modales permanecen centrados.

/* Radix UI */
.popover {
  transform-origin: var(--radix-popover-content-transform-origin);
}
/* Base UI */
.popover {
  transform-origin: var(--transform-origin);
}
/* Modales (siempre centrados) */
.modal {
  transform-origin: center;
}

No importa si el usuario lo nota individualmente. En conjunto, los detalles no vistos se acumulan.


Animaciones Escalonadas (Stagger)

Cuando múltiples elementos entran juntos, escalona su aparición.

.item {
  opacity: 0;
  transform: translateY(8px);
  animation: fadeIn 300ms ease-out forwards;
}
.item:nth-child(1) { animation-delay: 0ms; }
.item:nth-child(2) { animation-delay: 50ms; }
.item:nth-child(3) { animation-delay: 100ms; }
.item:nth-child(4) { animation-delay: 150ms; }

@keyframes fadeIn {
  to {
    opacity: 1;
    transform: translateY(0);
  }
}

Mantén los retrasos de escalonamiento cortos (30-80ms entre elementos). Nunca bloquees la interacción mientras se reproduce el escalonamiento.


Animaciones CSS (keyframes)

Usar para animaciones predeterminadas y no dinámicas. Los keyframes se reinician desde cero al interrumpirse, evítalos para UI.

@keyframes enter-right {
  from { opacity: 0; transform: translateX(16px); }
  to   { opacity: 1; transform: translateX(0); }
}
.enter {
  animation: enter-right 300ms ease-out forwards;
}

Animaciones con Muelles (Springs)

Los muelles se sienten más naturales que las animaciones basadas en duración porque simulan física real. Mantienen la velocidad al ser interrumpidos.

Cuándo usar muelles

  • Interacciones de arrastre con impulso
  • Elementos que se sienten "vivos" (estilo Apple Dynamic Island)
  • Gestos que pueden interrumpirse a mitad de la animación
  • Interacciones decorativas de seguimiento del ratón

Enfoque Apple (recomendado, más fácil de razonar)

{ type: "spring", duration: 0.5, bounce: 0.2 }

Física tradicional (más control)

{ type: "spring", stiffness: 100, damping: 10, mass: 1 }

Mantén el rebote sutil (0.1-0.3). Evita el rebote en la mayoría de la UI. Úsalo solo para arrastrar para descartar e interacciones lúdicas.

Interacciones de ratón basadas en muelles

import { useSpring } from 'framer-motion'

const springX = useSpring(mouseX * 0.1, { stiffness: 100, damping: 10 })

Sin muelle: se siente artificial, instantáneo. Con muelle: se siente natural, tiene impulso.


WEB ANIMATIONS API (WAAPI)

Animaciones CSS programáticas. Aceleradas por hardware, interrumpibles, sin necesidad de librería.

const element = document.querySelector('.card')

const animation = element.animate([
  { transform: 'scale(1)', opacity: 1 },
  { transform: 'scale(0.95)', opacity: 0.7 },
], {
  duration: 200,
  easing: 'cubic-bezier(0.23, 1, 0.32, 1)',
  fill: 'both',
})

animation.pause()
animation.play()
animation.reverse()
animation.finish()
animation.finished.then(() => console.log('done'))

WAAPI supera a Framer Motion bajo carga pesada: se ejecuta fuera del hilo principal. Úsalo para animaciones dinámicas e interrumpibles donde los keyframes CSS se quedan cortos.


ANIMACIONES GUIADAS POR SCROLL

Nota de soporte del navegador: Las animaciones guiadas por scroll (animation-timeline: view() y scroll()) son solo Chrome/Edge a partir de 2026, aún no Baseline. Proporciona fallbacks con JavaScript mediante IntersectionObserver para Firefox/Safari.

ViewTimeline (elemento entra/sale del viewport)

@keyframes fade-up {
  from { opacity: 0; transform: translateY(20px); }
  to   { opacity: 1; transform: translateY(0); }
}
.reveal {
  animation: fade-up 600ms linear both;
  animation-timeline: view();
  animation-range: entry 0% entry 100%;
}

ScrollTimeline (posición de scroll de la página)

@keyframes shrink {
  from { height: 80px; }
  to   { height: 50px; }
}
.site-header {
  animation: shrink 300ms linear both;
  animation-timeline: scroll();
  animation-range: 0 200px;
}

Paralaje vinculado al scroll (JavaScript vainilla)

const layers = document.querySelectorAll('[data-parallax]')
window.addEventListener('scroll', () => {
  const scrollY = window.scrollY
  layers.forEach(layer => {
    const speed = parseFloat(layer.dataset.parallax) || 0.3
    layer.style.transform = `translateY(${scrollY * speed}px)`
  })
})

Técnica FLIP

Para animaciones de diseño: animar elementos que cambian de posición/tamaño.

function animateLayout(element, callback) {
  const first = element.getBoundingClientRect()
  callback()
  const last = element.getBoundingClientRect()

  const dx = first.left - last.left
  const dy = first.top - last.top
  const dw = first.width / last.width
  const dh = first.height / last.height

  element.animate([
    { transform: `translate(${dx}px, ${dy}px) scale(${dw}, ${dh})` },
    { transform: 'translate(0, 0) scale(1, 1)' },
  ], {
    duration: 300,
    easing: 'cubic-bezier(0.4, 0, 0.2, 1)',
  })
}

CLIP-PATH para Animación

Una de las herramientas de animación más potentes en CSS. Acelerada por hardware.

.overlay {
  clip-path: inset(0 100% 0 0);
  transition: clip-path 200ms ease-out;
}
.visible {
  clip-path: inset(0 0 0 0);
}

Usar para: mantener presionado para eliminar, revelaciones de imagen al hacer scroll, controles deslizantes de comparación, transiciones de color sin interrupciones en pestañas.


RENDIMIENTO PERCIBIDO

La velocidad en la animación afecta directamente cómo se percibe el rendimiento de la aplicación. Las animaciones suaves y receptivas (sub 200ms para UI) hacen que la aplicación se sienta instantánea, incluso si el trabajo subyacente tarda más. Prioriza la retroalimentación visual inmediata sobre la finalización real de la tarea.


ACCESIBILIDAD

Siempre respeta las preferencias de movimiento reducido del usuario.

@media (prefers-reduced-motion: reduce) {
  *,
  *::before,
  *::after {
    animation-duration: 0.01ms !important;
    animation-iteration-count: 1 !important;
    transition-duration: 0.01ms !important;
    scroll-behavior: auto !important;
  }
}

También proporciona una opción en la interfaz para desactivar las animaciones independientemente de la preferencia del sistema.


RECURSOS

Individual skills in this repo

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

Skills relacionados