Communitygithub.com

principios-de-diseno-de-movimiento

Le muestra a un agente cómo planificar, construir o definir los 'principios de diseño de movimiento' para que el resultado concreto sea una hoja de ritmos y una lista de tomas. El procedimiento recorre los Principios de Diseño de Movimiento, cuándo usar una habilidad hermana y el procedimiento operativo. Úsalo cuando una nueva tarea requiera esta disciplina.

¿Qué es principios-de-diseno-de-movimiento?

Esta habilidad (skill) es la capa de criterio estético para el movimiento en interfaces de usuario, animaciones de producto o videos. Su objetivo es que el movimiento se perciba como pulido e intencional, evitando que se vea torpe, flotante o barato. No escribe el código que ejecuta la animación, sino que produce las decisiones sobre curvas de easing, temporización, arcos de movimiento y si usar resortes (springs) o interpolación. Está diseñada para agentes de IA como Claude Code, Cursor o Codex que necesitan guiar la generación de motion design de forma estructurada, paso a paso: primero diagnostican el problema del movimiento (lineal/robótico, flotante/blando, entrecortado/tartamudo, muerto/sin vida), luego eligen la curva de easing adecuada (ease-out para entradas, ease-in para salidas, ease-in-out para movimientos en pantalla, spring para sensaciones físicas), establecen la duración y el espaciado (escalando con la distancia y el tamaño, y haciendo las salidas más rápidas que las entradas), construyen el arco de anticipación-acción-seguimiento y, finalmente, aplican los principios de animación de Disney relevantes. El resultado es una especificación de movimiento completa (curva, duración, frames, arco y controlador spring vs interpolate) que puede pasarse a otras habilidades como 'product-demo-director' o usarse directamente en transiciones CSS/JS.

Compatible con~Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/ensinohi-lab/thesis-skills/tree/HEAD/motion-design-principles

Preguntar en tu IA favorita

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

Documentación

Principios de Diseño de Movimiento

Esta es la capa de criterio estético. Decide cómo debe moverse algo para que se perciba como pulido e intencional, en lugar de torpe, flotante o barato. No escribe el código que reproduce el movimiento. Una vez que has decidido la curva, la temporización y el arco, esa decisión es la entrada para una habilidad de dirección/renderizado (para video de producto, pásalo a product-demo-director) o para tus transiciones CSS/JS (para UI). Mantén las dos tareas separadas: esta habilidad posee el juicio; la habilidad de dirección posee la orquestación y la mecánica.

Actívala para cualquier cosa relacionada con cómo se siente el movimiento: "haz que esto sea menos torpe", "más suave", "más pulido", "más vivo", "el easing está mal", "esto se ve barato", "¿debería usar ease-in o ease-out?", "¿resorte o interpolación?".

Cuándo usar una habilidad hermana en su lugar

Esta habilidad es solo el juicio de curva/temporización/arco. Diferir cuando la pregunta real sea:

  • Qué tomas, orden de escenas o una lista de ritmos → video-storyboard.
  • Dirigir una demo completa de producto — movimientos del cursor, capturas de pantalla, llamadas de atención a funciones, el ensamblaje de escenas de principio a fin → product-demo-director. (Esta habilidad produce la especificación de movimiento que él consume).
  • Animar texto o letras — tipo que vuela/se construye/se revela → kinetic-typography.
  • Sincronizar movimiento con un ritmo, banda sonora o efecto de sonido → sound-and-music-sync.
  • Recortar o reencuadrar para una plataforma (9:16, 1:1, áreas seguras) → social-video-formatter.
  • Movimiento de luz, exposición, brillo o color → motion-color-and-light.

Procedimiento operativo

Diagnostica antes de recetar. La mayoría del movimiento "torpe" es uno de cuatro problemas con nombre, y cada uno se asigna a una solución específica a continuación. Trabaja los pasos en orden: la corrección de easing no sirve de nada si la temporización es incorrecta, y la corrección de temporización no sirve de nada si el elemento no tiene arco.

Paso 1: Nombra lo que se siente mal

Observa el movimiento (o la descripción del mismo) y clasifícalo. Casi todas las quejas son una de estas:

  • Lineal / robótico — se mueve a velocidad constante, se detiene en seco. Sin easing. Corregir en el Paso 2.
  • Flotante / blando — demasiado lento, o hace ease-in y ease-out cuando debería aparecer de golpe. Duración o curva incorrectas. Corregir en el Paso 2 y el Paso 3.
  • Entrecortado / tartamudo — entra y sale a la misma velocidad, o cada propiedad se anima en la misma línea de tiempo plana sin desplazamiento. Faltan espaciado y arco. Corregir en el Paso 3 y el Paso 4.
  • Muerto / sin vida — técnicamente correcto pero aburrido: sin anticipación, sin rebasamiento, sin seguimiento. Faltan el arco y el movimiento secundario. Corregir en el Paso 4 y el Paso 5.

Escribe el diagnóstico en una línea antes de tocar nada. "El modal es flotante porque se desvanece en 600 ms con ease-in-out" es una solución; "hazlo más bonito" no lo es.

Paso 2: Elige la curva de easing

El easing es la forma de la velocidad en función del tiempo del movimiento. La curva transporta casi toda la calidad percibida. Haz coincidir la curva con lo que el elemento está haciendo:

  • ease-out (inicio rápido, final lento) — el valor predeterminado para cosas que entran y para cualquier cosa que el usuario haya activado. Se siente receptivo porque el movimiento comienza inmediatamente, luego desacelera hasta su lugar. Úsalo para: elementos que aparecen, menús desplegables que se abren, un botón pulsado que responde, contenido que se desliza. Si no estás seguro, usa ease-out.
  • ease-in (inicio lento, final rápido) — para cosas que salen. El elemento acelera y sale de la pantalla. Usado solo en una entrada se siente lento y retrasado, que es la causa número 1 de "flotante". Úsalo para: descartes, cierres, salidas.
  • ease-in-out (lento, rápido, lento) — para mover algo que ya está en pantalla de A a B: una tarjeta que se reordena, un carrusel que avanza, un interruptor que se desliza. Ambos extremos están anclados, por lo que alisar ambos extremos se percibe como controlado. No lo uses para entradas: el inicio lento mata la capacidad de respuesta.
  • spring (física: masa, rigidez, amortiguación — rebasa y se asienta) — para movimiento que debe sentirse vivo y físico: un modal que aparece, la perilla de un interruptor, un botón de "me gusta", una notificación que aparece. El ligero rebasamiento es lo que se percibe como "vivo". Ajusta la amortiguación para la personalidad: menor amortiguación = más saltarín y juguetón, mayor amortiguación = más ajustado y corporativo.

La decisión spring() vs interpolate() (cuándo usar cada uno en código) está en la Barra de calidad y en el artefacto ejecutable a continuación. La versión corta: spring para transformaciones físicas/vivas, interpolate para valores precisos sincronizados con fotogramas como opacidad, color y barras de progreso.

Paso 3: Establece la temporización y el espaciado

Temporización es la duración total. Espaciado es cómo se distribuye la distancia a lo largo de esa duración: el espaciado es el easing hecho literal (un ease-out son fotogramas agrupados al final). Dos reglas:

  • La duración se escala con la distancia y el tamaño, no con el gusto. Un elemento pequeño que se mueve una distancia corta debe ser rápido (UI: ~150–250 ms). Un elemento grande o un recorrido largo necesita más tiempo (~300–500 ms) o teletransporta. El movimiento grande de pantalla completa/héroe en video puede durar más. Mismo movimiento, distancia más larga → duración más larga.
  • La entrada y la salida no son simétricas. Las salidas deben ser más rápidas que las entradas (~0,7–0,8x): el usuario ha terminado con el elemento, así que sácalo del medio. Las duraciones de entrada/salida iguales son una fuente clásica de "entrecortado".

Para video de producto, convierte a fotogramas en el momento en que salgas de esta habilidad: frames = round(seconds * fps). Esos recuentos de fotogramas son la entrada literal que entregas a product-demo-director (que los convierte en el plan de escena temporizado).

Paso 4: Construye el arco de anticipación → acción → seguimiento

El movimiento real rara vez es un solo movimiento. El movimiento más rico, más "vivo", tiene tres tiempos:

  1. Anticipación — un pequeño movimiento de calentamiento en dirección opuesta antes del movimiento principal (un botón se hunde hacia adentro ligeramente antes de aparecer, una tarjeta retrocede antes de deslizarse hacia afuera). Prepara el ojo y hace que la acción se lea como intencional. Mantenlo pequeño y rápido; demasiado parece un fallo.
  2. Acción — el movimiento principal, que lleva el easing del Paso 2 y la duración del Paso 3. Aquí es donde vive el espaciado.
  3. Seguimiento — el elemento se asienta más allá de su objetivo y regresa (el rebasamiento del resorte), y cualquier elemento adjunto/secundario se retrasa ligeramente respecto al líder (una etiqueta alcanzando a la tarjeta en la que se encuentra). Esto es lo que vende peso y vida.

No todas las microinteracciones necesitan los tres: un tooltip de 150 ms es solo acción. Pero cuando algo se siente "muerto", casi siempre le falta anticipación o seguimiento. Agrega el arco antes de agregar florituras.

Paso 5: Aplica los principios de Disney relevantes

Los 12 principios de la animación de Disney se asignan directamente al movimiento de UI y producto. No aplicas los doce; recurres a los pocos que solucionan el problema diagnosticado. La asignación completa está en references/twelve-principles. Los de alto apalancamiento:

  • Slow in & slow out → easing (Paso 2). La palanca de calidad más grande.
  • Anticipation → el calentamiento (Paso 4).
  • Follow-through & overlapping action → rebasamiento + elementos secundarios rezagados (Paso 4). La diferencia entre "correcto" y "vivo".
  • Timing → duración y espaciado (Paso 3).
  • Squash & stretch → escala sutil en presión/impacto para implicar masa; en UI mantenlo en un pequeño porcentaje o parecerá un juguete.
  • Staging → mueve una cosa a la vez para que el ojo sepa dónde mirar; nunca animes seis cosas a la vez en la misma curva.
  • Secondary action → un pequeño movimiento de apoyo (una sombra que se oscurece mientras una tarjeta se levanta) que refuerza el principal sin competir.
  • Exaggeration → empuja la pose clave ligeramente más allá de lo realista; restringido en UI, más libre en un video de producto contundente.

Paso 6: Entrega la especificación

Completa la plantilla de especificación de movimiento a continuación: curva, duración (y fotogramas), los tiempos del arco y la decisión spring vs interpolate por propiedad. Esa especificación completada es el artefacto de entrega: para una escena de video de producto va directamente a product-demo-director; para UI se convierte en tus valores de transición/keyframe. Combínalo con motion-color-and-light si la escena también necesita movimiento de luz/exposición, kinetic-typography si se anima texto, y sound-and-music-sync si la temporización debe coincidir con un ritmo.

Barra de calidad

El movimiento es A+ solo cuando se cumplen todas estas condiciones:

  • El diagnóstico está nombrado (lineal / flotante / entrecortado / muerto), y cada cambio se remonta a él. No hay "lo hizo más bonito" sin motivo.
  • Las entradas tienen ease-out, las salidas tienen ease-in, A→B en pantalla tiene ease-in-out, lo vivo/físico usa spring. No se envía movimiento lineal crudo excepto bucles de velocidad constante deliberados (un spinner, una marquesina).
  • La duración se escala con distancia/tamaño, y la salida es más rápida que la entrada.
  • La decisión spring() vs interpolate() es explícita por propiedad: spring para transformaciones físicas (escala, traslación, la aparición/deslizamiento/asentamiento — quieres el rebasamiento); interpolate para valores temporizados precisos (desvanecimientos de opacidad, color, progreso, cualquier cosa donde el rebasamiento se vea mal). Un desvanecimiento impulsado por un spring, o una aparición de logotipo impulsada por interpolate lineal, es un defecto.
  • Al menos uno de anticipación o seguimiento está presente en el movimiento héroe / característico; el movimiento sin vida se debe exactamente a la falta de estos.
  • Una cosa lidera a la vez (staging); las propiedades están desplazadas en lugar de dispararse todas en una línea de tiempo plana.
  • La curva, la duración y los recuentos de fotogramas están escritos y listos para entregar a product-demo-director o una transición: esta habilidad nunca deja la decisión implícita.

NO HAGAS

  • NO envíes easing lineal para entradas o salidas: es el valor predeterminado robótico y se lee como inacabado. La velocidad constante es solo para bucles intencionales.
  • NO hagas ease-in en una entrada o ease-out en una salida: esa es la sensación flotante/retrasada al revés. Las entradas tienen ease-out, las salidas tienen ease-in.
  • NO uses duraciones de entrada y salida iguales; las salidas deben ser ~0,7–0,8x más rápidas.
  • NO impulses un desvanecimiento, color o barra de progreso con un spring: el rebasamiento hace que los valores superen su rango y parpadeen. Usa interpolate para valores temporizados.
  • NO impulses una aparición/deslizamiento/escala viva con interpolate lineal cuando quieras que se sienta viva: usa un spring para el rebasamiento.
  • NO animes muchas propiedades en una línea de tiempo plana; escenifícalas y desplázalas.
  • NO sobreanticipes ni sobrepases en UI: unos pocos píxeles / un pequeño porcentaje. Los grandes calentamientos y rebotes se leen como un fallo o un juguete.
  • NO planifiques el orden de las tomas ni montes la demo aquí: entrega la especificación a product-demo-director; el orden del storyboard es video-storyboard.

Selector de easing & spring

Script Node independiente. Guárdalo como motion_pick.js y ejecútalo con node motion_pick.js. Edita el array requests para los elementos que estás animando; devuelve la curva, una duración escalada por distancia (ms y fotogramas), la duración de salida y la decisión spring vs interpolate. Sin dependencias.

// Motion picker. Edit `requests`, then: node motion_pick.js
const fps = 30 // for product video; UI ignores the frame column

// role: 'enter' | 'exit' | 'move' | 'lively'
// distancePx: how far it travels (drives duration). sizePx: rough element size.
const requests = [
  { name: 'Modal pop-in',    role: 'lively', property: 'scale',   distancePx: 0,   sizePx: 600 },
  { name: 'Modal backdrop',  role: 'enter',  property: 'opacity', distancePx: 0,   sizePx: 1920 },
  { name: 'Toast slide-in',  role: 'enter',  property: 'translate', distancePx: 320, sizePx: 360 },
  { name: 'Toast dismiss',   role: 'exit',   property: 'translate', distancePx: 320, sizePx: 360 },
  { name: 'Card reorder',    role: 'move',   property: 'translate', distancePx: 140, sizePx: 280 },
  { name: 'Progress fill',   role: 'move',   property: 'width',     distancePx: 800, sizePx: 800 },
]

function curveFor(role) {
  if (role === 'enter') return 'ease-out'
  if (role === 'exit') return 'ease-in'
  if (role === 'move') return 'ease-in-out'
  return 'spring' // lively
}

// Duration scales with travel distance and element size. Floor + slope, clamped.
function durationMs(role, distancePx, sizePx) {
  const reach = Math.max(distancePx, sizePx * 0.4)
  let ms = 140 + reach * 0.45
  ms = Math.min(Math.max(ms, 140), 600)
  if (role === 'exit') ms *= 0.75 // exits are faster
  return Math.round(ms)
}

// spring for physical transforms; interpolate for timed values.
function driver(role, property) {
  const physical = property === 'scale' || property === 'translate'
  if (role === 'lively') return 'spring()  // want the overshoot'
  if (physical && role !== 'move') return 'spring()  // physical, lively settle'
  return 'interpolate()  // precise, timed-to-frame'
}

const pad = (s, n) => String(s).padEnd(n)
console.log(pad('ELEMENT', 18), pad('CURVE', 12), pad('MS', 6), pad('FRAMES', 8), 'DRIVER')
for (const r of requests) {
  const curve = curveFor(r.role)
  const ms = durationMs(r.role, r.distancePx, r.sizePx)
  const frames = Math.round((ms / 1000) * fps)
  console.log(pad(r.name, 18), pad(curve, 12), pad(ms, 6), pad(frames, 8), driver(r.role, r.property))
}

Ejemplo de salida trabajada

Con las solicitudes anteriores, el script imprime:

ELEMENT            CURVE       MS     FRAMES   DRIVER
Modal pop-in       spring      252    8        spring()  // want the overshoot
Modal backdrop     ease-out    600    18       interpolate()  // precise, timed-to-frame
Toast slide-in     ease-out    284    9        spring()  // physical, lively settle
Toast dismiss      ease-in     213    6        interpolate()  // precise, timed-to-frame
Card reorder       ease-in-out 203    6        interpolate()  // precise, timed-to-frame
Progress fill      ease-in-out 500    15       interpolate()  // precise, timed-to-frame

Léelo: el modal aparece con un spring (rebasamiento = vivo) mientras su fondo simplemente se desvanece con interpolate temporizada: dos controladores diferentes en el mismo componente, exactamente como exige la Barra de calidad. El toast entra en 284 ms y se descarta más rápido en 213 ms (la regla de salida 0,75x), y su deslizamiento es físico, por lo que entra con spring pero sale con interpolate. La barra de progreso es un valor de ancho preciso: nunca un spring, o el relleno vibraría...

Individual skills in this repo

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

Skills relacionados