Communitygithub.com

blixvip/skills

El vocabulario de movimiento que separa la animación premium de la 'slop' de IA: texto con pop-blur-fade, escalonamientos secuenciales, cámaras con movimiento suave siempre activo, entradas de objetos y las tablas de temporización y easing detrás de ellas. Incluye código listo para Remotion (interpolate/spring) y HyperFrames (GSAP). Úsalo al animar cuadros diseñados, cuando el movimiento se sienta 'rígido', 'elástico', 'nervioso', 'demasiado rápido', 'demasiado uniforme', o al escribir cualquier código de temporización y easing para video.

¿Qué es skills?

Este skill proporciona un estándar de movimiento profesional para animación de video generada por IA, enfocado en lograr resultados que parezcan creados por un diseñador en lugar de generados automáticamente. Define cuatro leyes fundamentales: nada es lineal, nada entra a la vez, la cámara nunca está quieta, y nada debe ser metronómico. Incluye una tabla de temporización detallada con duraciones, escalonamientos y easings específicos para diferentes elementos como palabras, iconos, paneles, objetos principales y la cámara. También contiene implementaciones prácticas tanto para Remotion (basado en cuadros, usando `interpolate` y `spring` de Remotion) como para HyperFrames (con GSAP y el cumplimiento obligatorio de la regla de clip). El skill es útil para desarrolladores que trabajan con herramientas como Claude Code, Cursor o Codex, y buscan evitar errores comunes de animación como el easing lineal, la entrada simultánea de elementos, la falta de movimiento de cámara, o duraciones uniformes que hacen que el resultado parezca automatizado. Incluye auto-verificaciones y reglas estrictas de determinismo para garantizar renders correctos.

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

Preguntar en tu IA favorita

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

Documentación

motion-animate

El diseño decide si un cuadro es bueno. El movimiento decide si se ve caro. La misma composición animada con easing lineal y entradas simultáneas se lee como generada; animada con el vocabulario a continuación se lee como creada.

Recetas de motores: Apéndice A, Apéndice B.

Las cuatro leyes

  1. Nada es lineal. Cada propiedad se mueve con un ease. El movimiento lineal no existe en el mundo físico y el ojo lo sabe al instante.
  2. Nada entra a la vez. Los elementos llegan en un orden deliberado con 60–120ms entre ellos. La entrada simultánea es el mayor indicio de movimiento generado.
  3. La cámara nunca está completamente quieta. Un push o drift lento y continuo debajo de cada composición. Los cuadros estáticos se leen como diapositivas.
  4. Nada es metronómico. Varía las duraciones y el espaciado entre cortes. Los pulsos uniformes de 1s se sienten automatizados sin importar lo bueno que sea cada pulso.

Tabla de temporización

Valores a 30fps; escala para 60fps. Tiempos en ms.

ElementoDuraciónEscalonamientoEase
Palabra en una línea de texto400–55060–90out-expo / power3.out
Línea de texto (como unidad)500–650120–180out-cubic / power2.out
Icono / elemento UI pequeño350–45080–120out-back (overshoot ≤1.06)
Panel / tarjeta550–700140–200out-quint / power4.out
Objeto principal (scale-in)700–900—out-expo
Objeto principal (slide-in)650–850—out-quint
Trazo de línea600–1000—in-out-cubic
Push de cámara (por escena)duración completa de la escena—out-sine, o lineal si es muy lento
Salida (cualquier elemento)250–35040–60in-cubic

Las salidas son siempre más rápidas que las entradas, aproximadamente la mitad. Una animación de salida simétrica se siente lenta.

Los movimientos principales

Texto — pop-blur-fade, palabra por palabra

El movimiento característico. Cada propiedad anima junto, por palabra, escalonado.

y:       +18px → 0
blur:    12px  → 0
opacity: 0     → 1
ease:    out-expo,  duración 480ms,  escalonamiento 70ms

Opcionalmente añade scale: 0.96 → 1. No añadas rotación. No rebotes.

Para una línea larga, escala por palabra, no por carácter — el escalonamiento por carácter se lee como un truco de máquina de escribir y lleva demasiado tiempo. Reserva el escalonamiento por carácter para una sola palabra corta de acento.

Palabra de acento

Ejecuta el mismo movimiento pero retrasado 120–200ms después de sus vecinos y con una propiedad adicional: un cambio de color, un aumento de escala a 1.04, o una barra de resaltado que se revela detrás de ella. Debe aterrizar al último y aterrizar de manera diferente.

Iconos y UI

Pop-fade: scale 0.7 → 1, opacity 0 → 1, out-back con overshoot limitado a 1.06. Cualquier valor por encima de 1.1 se lee como un rebote barato.

Regla secuencial: el elemento ancla entra primero, luego sus dependientes. Una tarjeta entra, luego su icono, luego su etiqueta. Nunca al revés, nunca juntos.

Paneles / tarjetas / glass

y: +40 → 0, opacity 0 → 1, out-quint, 600ms, escalonado 160ms a través de una pila. Añade un destello de luz que cruce el panel 150ms después de que aterrice — el panel llega, luego atrapa la luz.

Objeto principal

Dos opciones, elige según el arquetipo:

  • Scale-in: scale 1.25 → 1.00 con rotate 3° → 0°, out-expo, 800ms. Se siente como si se asentara en su lugar.
  • Slide-in: desde fuera del cuadro con una inclinación de 2° que se resuelve a 0°, out-quint, 750ms. Se siente entregado.

La sombra proyectada y la textura recortada deben estar parented al héroe para que se muevan con él. Las sombras no parentadas deslizándose independientemente son un fallo grave.

Trazo de línea / dibujo

Anima la longitud del camino 0 → 100%, in-out-cubic, 600–1000ms. Ease de entrada y salida — un dibujo que comienza a máxima velocidad se ve mecánico. Úsalo para conectar una etiqueta a un sujeto, subrayar una palabra de acento, o trazar un gráfico.

Cámara

Debajo de cada composición, una de:

  • Push in: scale 1.00 → 1.08 durante todo el beat, out-sine.
  • Push out: scale 1.12 → 1.00, más rápido al inicio, asentándose.
  • Drift: traslación x o y de 2–4% durante el beat.

Contrato anti-nerviosismo:

  • Anima un elemento wrapper, nunca el elemento que posee el layout o el recorte.
  • Usa solo transform — nunca top/left/width/height.
  • Escala la capa en movimiento ~6% más allá del cuadro para que los bordes nunca se revelen.
  • Establece will-change: transform y fuerza la composición GPU.
  • Mantén el recorrido total pequeño. Los movimientos grandes de cámara amplifican cada error de redondeo.

Transiciones entre beats

  • Corte duro enmascarado por un impacto SFX — el predeterminado. Los crossfades entre cuadros diseñados ensucian ambos.
  • Scale-through — un elemento escala para llenar el cuadro y la siguiente escena se revela dentro de él.
  • Wipe por una forma — un círculo o panel escala más allá del borde del cuadro, llevando la siguiente escena.

No hagas crossfade entre dos composiciones diseñadas. No uses un preset de transición prefabricado.

Prohibido

  • Easing lineal en algo visible.
  • Overshoot de bounce >1.1 (excepción: un estilo intencionalmente juguetón de SaaS/producto, y entonces consistentemente).
  • Todos los elementos entrando en el mismo cuadro.
  • Duraciones de beat uniformes a través de una edición.
  • repeat: -1 o cualquier bucle infinito — los renders se muestrean por cuadros y deben ser deterministas.
  • Math.random(), Date.now(), o fetch de red dentro de una composición. La misma entrada debe producir el mismo cuadro cada vez.
  • Movimiento aplicado a un wrapper que el framework ya controla (ver Apéndice B §regla de clip).

Auto-verificación

Reproduce el render a 0.25× de velocidad. Pregunta:

  • ¿Algo comienza y se detiene abruptamente? → falta ease.
  • ¿Todo aterriza junto? → falta escalonamiento.
  • ¿El cuadro se queda completamente quieto? → falta cámara.
  • ¿Los beats consecutivos se sienten como un golpe de tambor? → duraciones demasiado uniformes.
  • ¿Los bordes de una capa en movimiento se revelan? → no se ha escalado de más.

Apéndice A — Recetas de Remotion

Basado en cuadros, determinista por construcción. Toda la temporización se deriva de useCurrentFrame().

Helper: tiempo en ms, no cuadros

Autorizar en cuadros hardcodea tu fps. Convierte.

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

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

Mapa de easing

Los nombres en la tabla de temporización, en términos de Remotion:

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  (salidas)
Easing.bezier(0.16, 1, 0.3, 1)            // el caballo de batalla — expo-ish out

Para overshoot, prefiere un spring sobre Easing.back — es más fácil mantenerlo sutil.

import {spring} from 'remotion';
const s = spring({frame, fps, config: {damping: 200, stiffness: 120, mass: 0.6}});
// damping 200 = sin overshoot visible. Baja a ~14 para un pequeño asentamiento.

Texto — pop-blur-fade, palabra por palabra

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

La palabra de acento es el mismo componente con delay configurado 120–200ms después más su propio color y un scale(1.04).

Cámara — push siempre activo

Envuelve toda la escena. Escala de más para que los bordes nunca se revelen.

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

Coloca la cámara encima de la capa de suelo y debajo de cualquier elemento que deba permanecer fijo al borde del cuadro.

Pila de tarjetas escalonadas

const cards = ['One', 'Two', 'Three'];
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>
  );
})}

Salida — la mitad de la entrada

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

Estructura

Usa <Sequence from={...} durationInFrames={...}> por beat, impulsado directamente por la tabla motion-plan. Un Sequence por fila. Las duraciones de los beats provienen del plan, no de números redondos.

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

Determinismo

  • Nunca Math.random() — si necesitas dispersión, semilla a partir del índice del elemento.
  • Nunca Date.now() o new Date().
  • Nunca fetch dentro de un componente. Precarga con staticFile() / delayRender().
  • <Video>/<Audio> deben ser <OffthreadVideo> cuando sea posible para la corrección del render.

Gotchas

  • filter: blur() en muchos elementos simultáneos es caro — limita los nodos borrosos concurrentes, o pre-difumina en el asset.
  • Carga de fuentes: usa @remotion/google-fonts o delayRender alrededor de un FontFace.load() local, o los primeros cuadros se renderizarán con una fuente de respaldo.
  • interpolate lanza un error si el rango de entrada no es monótonamente creciente — protege los rangos calculados.
  • Siempre pasa extrapolateLeft/extrapolateRight: 'clamp' a menos que específicamente quieras que el valor se ejecute más allá del rango.

Apéndice B — Recetas de HyperFrames / GSAP

HyperFrames compone HTML + GSAP y renderiza muestreando cuadros de un navegador headless. El determinismo es obligatorio.

Ejecuta npx hyperframes docs para la API actual. Este archivo es el estándar de movimiento sobre él — consulta el skill hyperframes para el pipeline (init → preview → lint → render).

La regla de clip (rompe los renders si se viola)

Cada elemento temporizado necesita data-start, data-duration, data-track-index y class="clip". El framework posee la visibilidad y transform en .clip.

Nunca apliques GSAP al elemento .clip. Anima un wrapper hijo.

<div class="clip" data-start="4.2" data-duration="5.2" data-track-index="2">
  <div class="cam">           <!-- los movimientos de cámara van aquí -->
    <div class="inner">       <!-- el movimiento del elemento va aquí -->
      <h1 class="headline">…</h1>
    </div>
  </div>
</div>

Registro de timeline

const tl = gsap.timeline({paused: true});
window.__timelines['main'] = tl;   // el id debe coincidir con data-composition-id

Pausado, siempre. El renderizador lo busca.

Mapa de easing

Nombre de tablaGSAP
out-expoexpo.out
out-cubicpower2.out
out-quintpower4.out
out-back (limitado)back.out(1.2)
in-out-cubicpower2.inOut
out-sinesine.out
in-cubic (salidas)power2.in

Texto — pop-blur-fade, palabra por palabra

Divide en spans de palabra en tiempo de autoría (no confíes en un divisor en tiempo de ejecución — podría competir con el primer cuadro muestreado).

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

// la palabra de acento aterriza al último y de manera diferente
tl.from('.headline .accent', {
  scale: 0.96,
  color: 'var(--surface)',
  duration: 0.5,
  ease: 'expo.out',
}, 0.18);

Cámara

Anima .cam, nunca .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); }

Escala la capa en movimiento ~6% más allá del cuadro para que los bordes nunca se revelen durante un push-out o drift.

Pila de tarjetas escalonadas

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

// el destello de luz aterriza 150ms después del panel
tl.fromTo('.card .sweep', {xPercent: -140}, {
  xPercent: 140, duration: 0.7, ease: 'power2.inOut', stagger: 0.16,
}, 1.35);

Dibujo de trazo

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

Reglas estrictas

  1. Solo determinista — nada de Math.random(), nada de Date.now(), nada de fetch, nada de repeat: -1.
  2. 9:16 = 1080×1920. Establece #root { container-type: size; } y dimensiona todo en cqw/cqh (1cqw = 10.8px), nunca vw/vh.
  3. Los clips adyacentes del mismo track no deben tocarse. Las matemáticas de punto flotante hacen que 3.2 + 0.35 = 3.5500000000000003, lo que se superpone con un clip que comienza en 3.55 y genera overlapping_clips_same_track. Deja un espacio, o usa duraciones como 0.34.
  4. Audio: los videos están muted; usa una sola pista de <audio> maestra premezclada (VO + SFX mezclados con ffmpeg adelay + amix) en un data-track-index alto dedicado. Múltiples pistas de audio causan deriva.

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.

Skills relacionados