Communitygithub.com

blixvip/skills

O vocabulário de movimento que separa animação premium de 'AI slop' — efeitos de texto pop-blur-fade, escalonamentos sequenciais, câmeras sempre em movimento suave, entradas de objetos e as tabelas de temporização e easing por trás deles. Inclui código pronto para Remotion (interpolate/spring) e HyperFrames (GSAP). Use ao animar quadros desenhados, quando o movimento parece 'rígido', 'saltitante', 'instável', 'rápido demais', 'uniforme demais' ou ao escrever qualquer código de temporização/easing para vídeo.

O que é skills?

Esta skill fornece um vocabulário de animação profissional para criadores de vídeo que usam Remotion e HyperFrames (GSAP), focado em eliminar movimentos que parecem gerados por IA e substituí-los por animações que transmitem qualidade artesanal. Ela define quatro leis fundamentais de animação: nada linear, nada simultâneo, câmera nunca parada e durações variadas; fornece tabelas de temporização detalhadas com durações, escalonamentos e funções de easing para cada tipo de elemento (palavras, ícones, painéis, objetos hero, traços); explica técnicas como pop-blur-fade de texto palavra por palavra, entradas escalonadas de cartões e movimentos de câmera push-in/drift constantes. Inclui implementações prontas em código TypeScript para Remotion e HTML+GSAP para HyperFrames, com mapas de easing, componentes de câmera e estruturas de linha do tempo determinísticas. A skill é essencial para desenvolvedores que querem criar vídeos animados com aparência profissional, evitando travamentos comuns como easing linear, entradas simultâneas, loops infinitos, aleatoriedade e violações de regras de clipping.

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

Perguntar na sua IA favorita

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

Documentação

motion-animate

O design decide se um quadro é bom. O movimento decide se ele parece caro. A mesma composição animada com easing linear e entradas simultâneas parece gerada; animada com o vocabulário abaixo, parece autoral.

Receitas dos motores: Apêndice A, Apêndice B.

As quatro leis

  1. Nada é linear. Cada propriedade se move com uma suavização. Movimento linear não existe no mundo físico e o olho percebe isso instantaneamente.
  2. Nada entra ao mesmo tempo. Os elementos chegam em uma ordem deliberada com 60–120ms entre eles. Entrada simultânea é o maior sinal de movimento genérico.
  3. A câmera nunca fica parada. Um push contínuo lento ou deriva sutil em cada composição. Quadros estáticos parecem slides.
  4. Nada é metronômico. Varie durações e espaçamentos entre cortes. Batidas uniformes de 1s parecem automatizadas, não importa o quão boa seja cada batida.

Tabela de temporização

Valores para 30fps; escale para 60fps. Tempos em ms.

ElementoDuraçãoEscalonamentoEasing
Palavra em uma linha de texto400–55060–90out-expo / power3.out
Linha de texto (como unidade)500–650120–180out-cubic / power2.out
Ícone / elemento de UI pequeno350–45080–120out-back (overshoot ≤1.06)
Painel / cartão550–700140–200out-quint / power4.out
Objeto hero (scale-in)700–900—out-expo
Objeto hero (slide-in)650–850—out-quint
Linha / traço de desenho600–1000—in-out-cubic
Push de câmera (por cena)duração total da cena—out-sine, ou linear-ish se muito lento
Saída (qualquer elemento)250–35040–60in-cubic

Saídas são sempre mais rápidas que entradas, aproximadamente metade. Uma animação de saída simétrica parece lenta.

Os movimentos principais

Texto — pop-blur-fade, palavra por palavra

O movimento característico. Todas as propriedades animam juntas, por palavra, escalonadas.

y:       +18px → 0
blur:    12px  → 0
opacity: 0     → 1
ease:    out-expo,  duration 480ms,  stagger 70ms

Opcionalmente adicione scale: 0.96 → 1. Não adicione rotação. Não faça bounce.

Para uma linha longa, escalone por palavra, não por caractere — escalonamento por caractere parece um truque de máquina de escrever e demora muito. Reserve o escalonamento por caractere para uma única palavra curta de destaque.

Palavra de destaque

Executa o mesmo movimento, mas atrasado 120–200ms em relação aos vizinhos e com uma propriedade extra — uma mudança de cor, um aumento de escala para 1.04 ou uma barra de destaque que aparece por trás. Ela deve chegar por último e chegar de forma diferente.

Ícones e UI

Pop-fade: scale 0.7 → 1, opacity 0 → 1, out-back com overshoot limitado a 1.06. Qualquer coisa acima de 1.1 parece um bounce barato.

Regra sequencial: o elemento âncora entra primeiro, depois seus dependentes. Um cartão entra, depois seu ícone, depois seu rótulo. Nunca o inverso, nunca juntos.

Painéis / cartões / vidro

y: +40 → 0, opacity 0 → 1, out-quint, 600ms, escalonados 160ms em uma pilha. Adicione um destaque de luz que percorre o painel 150ms depois que ele pousa — o painel chega, então pega a luz.

Objeto hero

Duas opções, escolha pelo arquétipo:

  • Scale-in: scale 1.25 → 1.00 com rotate 3° → 0°, out-expo, 800ms. Parece que se acomoda no lugar.
  • Slide-in: de fora do quadro com uma inclinação de 2° que se resolve para 0°, out-quint, 750ms. Parece entregue.

A sombra projetada e a textura recortada devem ser parentadas ao hero para que se movam com ele. Sombras não parentadas deslizando independentemente é uma falha grave.

Traço / desenho de linha

Animar comprimento do caminho 0 → 100%, in-out-cubic, 600–1000ms. Suavize na entrada e na saída — um desenho que começa em velocidade máxima parece mecânico. Use para conectar um rótulo a um assunto, sublinhar uma palavra de destaque ou traçar um gráfico.

Câmera

Em cada composição, uma das opções:

  • Push in: scale 1.00 → 1.08 durante toda a batida, out-sine.
  • Push out: scale 1.12 → 1.00, mais rápido no início, estabilizando.
  • Drift: translação em x ou y de 2–4% durante a batida.

Contrato anti-tremor:

  • Anime um elemento wrapper, nunca o elemento que gerencia layout ou clipping.
  • Use apenas transform — nunca top/left/width/height.
  • Escale a camada em movimento cerca de 6% além do quadro para que as bordas nunca apareçam.
  • Defina will-change: transform e force a composição por GPU.
  • Mantenha o deslocamento total pequeno. Grandes movimentos de câmera amplificam cada erro de arredondamento.

Transições entre batidas

  • Corte seco mascarado por um efeito sonoro — o padrão. Crossfades entre quadros desenhados embaralham ambos.
  • Scale-through — um elemento escala para preencher o quadro e a próxima cena é revelada dentro dele.
  • Wipe por uma forma — um círculo ou painel escala além da borda do quadro, carregando a próxima cena.

Não faça crossfade de duas composições desenhadas. Não use um preset de transição genérico.

Proibido

  • Easing linear em algo visível.
  • Overshoot de bounce >1.1 (exceção: um estilo intencionalmente lúdico de SaaS/produto, e então consistentemente).
  • Todos os elementos entrando no mesmo quadro.
  • Durações de batidas uniformes em toda a edição.
  • repeat: -1 ou qualquer loop infinito — as renderizações são amostradas por quadro e devem ser determinísticas.
  • Math.random(), Date.now() ou requisições de rede dentro de uma composição. A mesma entrada deve produzir o mesmo quadro todas as vezes.
  • Movimento aplicado a um wrapper que o framework já controla (veja a regra de clipping no Apêndice B).

Autoavaliação

Percorra a renderização a 0.25× da velocidade. Pergunte:

  • Alguma coisa começa e para abruptamente? → falta easing.
  • Tudo chega junto? → falta escalonamento.
  • O quadro algum fica totalmente parado? → falta câmera.
  • Batidas consecutivas parecem uma batida de tambor? → durações muito uniformes.
  • As bordas de uma camada em movimento aparecem? → não foi superescalada.

Apêndice A — Receitas para Remotion

Baseado em quadros, determinístico por construção. Toda temporização deriva de useCurrentFrame().

Utilitário: tempo em ms, não quadros

Trabalhar em quadros fixa seu fps. Converta.

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

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

Mapa de easing

Os nomes na tabela de temporização, em termos do 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  (saídas)
Easing.bezier(0.16, 1, 0.3, 1)            // o workhorse — expo-ish out

Para overshoot, prefira um spring em vez de Easing.back — é mais fácil manter sutil.

import {spring} from 'remotion';
const s = spring({frame, fps, config: {damping: 200, stiffness: 120, mass: 0.6}});
// damping 200 = sem overshoot visível. Reduza para ~14 para um pequeno ajuste.

Texto — pop-blur-fade, palavra por palavra

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

A palavra de destaque é o mesmo componente com delay definido 120–200ms depois, mais sua própria cor e um scale(1.04).

Câmera — push sempre ativo

Envolva a cena inteira. Superescala para que as bordas nunca apareçam.

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

Coloque a câmera acima da camada de fundo e abaixo de qualquer elemento que deva ficar fixo na borda do quadro.

Pilha de cartões escalonada

const cards = ['Um', 'Dois', 'Três'];
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>
  );
})}

Saída — metade da entrada

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

Estrutura

Use <Sequence from={...} durationInFrames={...}> por batida, guiada diretamente pela tabela de motion-plan. Um Sequence por linha. As durações das batidas vêm do plano, não 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() — se precisar de dispersão, derive-a do índice do elemento.
  • Nunca Date.now() ou new Date().
  • Nunca faça fetch dentro de um componente. Pré-carregue com staticFile() / delayRender().
  • <Video>/<Audio> deve ser <OffthreadVideo> quando possível para correção da renderização.

Pegadinhas

  • filter: blur() em muitos elementos simultâneos é caro — limite o número de nós desfocados simultâneos ou pré-desfoque no asset.
  • Carregamento de fontes: use @remotion/google-fonts ou delayRender em torno de um FontFace.load() local, ou os primeiros quadros renderizarão em uma fonte alternativa.
  • interpolate lança um erro se o intervalo de entrada não for monotonicamente crescente — proteja intervalos computados.
  • Sempre passe extrapolateLeft/extrapolateRight: 'clamp' a menos que você especificamente queira que o valor ultrapasse o intervalo.

Apêndice B — Receitas para HyperFrames / GSAP

HyperFrames compõe HTML + GSAP e renderiza por amostragem de quadros de um navegador headless. Determinismo é obrigatório.

Execute npx hyperframes docs para a API atual. Este arquivo é o padrão de movimento sobre ela — veja a skill hyperframes para o pipeline (init → preview → lint → render).

A regra de clipping (quebra renderizações se violada)

Cada elemento temporizado precisa de data-start, data-duration, data-track-index e class="clip". O framework controla a visibilidade e a transformação em .clip.

Nunca anime o próprio elemento .clip com GSAP. Anime um wrapper filho.

<div class="clip" data-start="4.2" data-duration="5.2" data-track-index="2">
  <div class="cam">           <!-- movimentos da câmera aqui -->
    <div class="inner">       <!-- movimento do elemento aqui -->
      <h1 class="headline">…</h1>
    </div>
  </div>
</div>

Registro da timeline

const tl = gsap.timeline({paused: true});
window.__timelines['main'] = tl;   // id deve corresponder a data-composition-id

Pausada, sempre. O renderizador a posiciona (seek).

Mapa de easing

Nome da tabelaGSAP
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 (saídas)power2.in

Texto — pop-blur-fade, palavra por palavra

Divida em spans de palavra no momento da autoria (não dependa de um divisor em tempo de execução — ele pode competir com o primeiro quadro amostrado).

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

// palavra de destaque chega por último e de forma diferente
tl.from('.headline .accent', {
  scale: 0.96,
  color: 'var(--surface)',
  duration: 0.5,
  ease: 'expo.out',
}, 0.18);

Câmera

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

Superescala a camada em movimento cerca de 6% além do quadro para que as bordas nunca apareçam durante um push-out ou drift.

Pilha de cartões escalonada

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

// destaque de luz chega 150ms após o painel
tl.fromTo('.card .sweep', {xPercent: -140}, {
  xPercent: 140, duration: 0.7, ease: 'power2.inOut', stagger: 0.16,
}, 1.35);

Desenho de traço

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

Regras rígidas

  1. Apenas determinístico — sem Math.random(), sem Date.now(), sem fetch, sem repeat: -1.
  2. 9:16 = 1080×1920. Defina #root { container-type: size; } e dimensione tudo em cqw/cqh (1cqw = 10.8px), nunca vw/vh.
  3. Clips adjacentes no mesmo track não devem se tocar. A matemática de ponto flutuante faz 3.2 + 0.35 = 3.5500000000000003, o que sobrepõe um clip começando em 3.55 e causa overlapping_clips_same_track. Deixe uma lacuna ou use durações como 0.34.
  4. Áudio: vídeos são muted; use uma faixa <audio> mestre pré-misturada (VO + SFX misturados com ffmpeg adelay + amix) em um data-track-index alto dedicado. Múltiplas faixas de áudio podem dessincronizar entre as passadas de renderização.

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.

Habilidades Relacionadas