Communitygithub.com

Motion Craft

Projete animações aceleradas por GPU com Web Animations API (WAAPI), animações orientadas por rolagem (ScrollTimeline/ViewTimeline), técnica FLIP, sistemas de easing e acessibilidade (prefers-reduced-motion).

O que é Motion Craft?

Esta skill é um guia completo para a criação de animações web de alto desempenho e com propósito, voltada para desenvolvedores que utilizam plataformas como Claude Code, Cursor ou Codex. Ela estabelece uma estrutura de decisão que prioriza a experiência do usuário: antes de animar, é preciso determinar se a animação é realmente necessária, qual seu propósito, qual easing e duração usar, sempre respeitando a regra de 60fps ao animar apenas transform e opacity. A skill oferece receitas detalhadas para CSS Transitions (preferidas para interações de UI por serem interrompíveis), CSS Animations com keyframes, Spring Animations realistas, Web Animations API (WAAPI) para animações programáticas e aceleradas por hardware, Scroll-Driven Animations (ViewTimeline/ScrollTimeline) com fallbacks em JS, técnica FLIP para animações de layout, e clip-path para efeitos poderosos como hold-to-delete e revelações. Inclui tabelas de referência rápida para durações e easings, e um formato obrigatório de revisão de código com tabela Antes/Depois/Porquê. A skill também enfatiza a acessibilidade com suporte a prefers-reduced-motion e a importância de animações assimétricas (entrada mais lenta, saída rápida).

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

Perguntar na sua IA favorita

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

Documentação

O que Motion Craft faz?

Animações que comunicam, não decoram. Cada quadro deve merecer seu lugar.

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

Workflow

A Estrutura de Decisão de Animação

Antes de escrever qualquer código de animação, responda a estas quatro perguntas em ordem.

1. Isso deve animar?

FrequênciaDecisãoMotivo
100+ vezes/dia (atalhos de teclado, paleta de comandos, alternância de pesquisa)Sem animação. Nunca.A animação faz ações frequentes parecerem lentas. O Raycast não tem animação de abrir/fechar. Ideal.
Dezenas de vezes/dia (efeitos de hover, navegação em listas)Remover ou reduzir drasticamenteOs usuários percebem a latência da animação em interações repetidas
Ocasional (modais, gavetas, toasts)Animação padrãoO lugar certo para movimento
Raro / primeira vez (integração, confirmação, celebração)Adicionar encantoEsses momentos merecem animações mais longas e ricas

Nunca anime ações iniciadas por teclado. Elas se repetem centenas de vezes ao dia.

2. Qual é o propósito?

Cada animação deve ter uma resposta clara para "por que isso anima?"

PropósitoExemploVálido?
Consistência espacialToast entra e sai da mesma direção✓
Indicação de estadoBotão se transforma para mostrar "enviado"✓
FeedbackBotão diminui ao pressionar, confirmando que a interface ouviu o usuário✓
Evitar mudanças abruptasElementos aparecendo gradualmente em vez de abruptamente✓
ExplicaçãoAnimação de marketing mostrando como um recurso funciona✓
"Parece legal" E o usuário vê com frequênciaMovimento gratuito✗

3. Qual easing usar?

CenárioEasingCSS
Elemento entrandoease-out (começa rápido, parece responsivo)cubic-bezier(0, 0, 0.2, 1)
Elemento saindoease-in (começa devagar, chama a atenção brevemente e acelera)cubic-bezier(0.4, 0, 1, 1)
Movimento / transformação na telaease-in-outcubic-bezier(0.4, 0, 0.2, 1)
Hover / mudança de coreasecubic-bezier(0.25, 0.1, 0.25, 1)
Movimento constante (marquee, barra de progresso)linearcubic-bezier(0, 0, 1, 1)
Interações de UI (botões, tooltips, dropdowns)ease-out fortecubic-bezier(0.23, 1, 0.32, 1)

Crítico: nunca use ease-in para animações de entrada de UI. Um dropdown com ease-in em 300ms parece mais lento do que ease-out nos mesmos 300ms porque o ease-in atrasa o movimento inicial - exatamente o momento que o usuário está observando mais atentamente.

4. Qual deve ser a duração?

ElementoDuraçãoEasing
Feedback de pressionamento de botão (escala)100-160mscubic-bezier(0.23, 1, 0.32, 1)
Entrada / saída de tooltip125-200mscubic-bezier(0.23, 1, 0.32, 1)
Dropdown / select / popover150-250mscubic-bezier(0.23, 1, 0.32, 1)
Transformação de hover (escala, elevação)200mscubic-bezier(0.23, 1, 0.32, 1)
Entrada de modal / diálogo200-300mscubic-bezier(0, 0, 0.2, 1)
Saída de modal / diálogo150-200mscubic-bezier(0.4, 0, 1, 1)
Entrada de gaveta / painel200-400mscubic-bezier(0.32, 0.72, 0, 1) (tipo iOS)
Entrada de toast300-400mscubic-bezier(0.23, 1, 0.32, 1)
Saída de toast200-300mscubic-bezier(0.4, 0, 1, 1)
Transição de página300-400mscubic-bezier(0.4, 0, 0.2, 1)
Revelação por rolagem (fade + slide up)400-800mscubic-bezier(0.16, 1, 0.3, 1)
Brilho de carregamento1000-1500ms (infinito)linear
Segurar para excluir (pressionar)2000mslinear (proposital)
Segurar para excluir (soltar)200mscubic-bezier(0.23, 1, 0.32, 1) (rápido)
Marketing / explicativo800-3000msvariável, depende da narrativa

Regra: Animações de UI devem ficar abaixo de 300ms. Um dropdown de 180ms parece visivelmente mais responsivo do que um de 400ms.

Curvas de easing personalizadas

Os ease / ease-in / ease-out internos do CSS são muito fracos. Use estas variantes personalizadas mais fortes:

:root {
  --ease-out-strong: cubic-bezier(0.23, 1, 0.32, 1);     /* Interações de UI, a marca registrada do Emil */
  --ease-in-out-strong: cubic-bezier(0.77, 0, 0.175, 1);  /* Movimento na tela */
  --ease-drawer: cubic-bezier(0.32, 0.72, 0, 1);          /* Gaveta estilo iOS */
  --ease-out-expo: cubic-bezier(0.16, 1, 0.3, 1);         /* Revelações lentas, dramáticas */
  --ease-out-quint: cubic-bezier(0.22, 1, 0.36, 1);       /* Ease-out forte alternativo */
  --ease-spring: cubic-bezier(0.34, 1.56, 0.64, 1);       /* Leve ultrapassagem, com moderação */
}

Fontes: easing.dev, easings.co


A Regra de Ouro dos 60fps

16.67ms por quadro. Verifique com a aba Desempenho do Chrome DevTools. Anime apenas transform e opacity.

PropriedadeComposto por GPU?Aciona
transform (translate, scale, rotate)✓ SimApenas composição
opacity✓ SimApenas composição
filter✗ Às vezesPintura + Composição
clip-path✗ Às vezesPintura + Composição
width, height, top, left, margin, padding, border-width✗ NãoLayout + Pintura + Composição
box-shadow✗ NãoPintura + Composição
color, background-color✗ NãoApenas pintura

Formato de Revisão (Obrigatório)

Ao revisar código de animação de UI, você DEVE usar uma tabela markdown com as colunas Antes | Depois | Porquê. NÃO use uma lista com "Antes:" e "Depois:" em linhas separadas.

Formato correto:

AntesDepoisPorquê
transition: all 300mstransition: transform 200ms ease-outEspecifique propriedades exatas; evite all que aciona recálculo de layout
transform: scale(0)transform: scale(0.95); opacity: 0Nada no mundo real surge do nada
ease-in no dropdowncubic-bezier(0.23, 1, 0.32, 1)ease-in começa devagar - parece lento. Ease-out forte dá feedback instantâneo
Sem estado :active no botãotransform: scale(0.97) no :activeBotões devem parecer responsivos ao pressionar
transform-origin: center no popovertransform-origin: var(--radix-popover-content-transform-origin)Popovers devem escalar a partir do gatilho. Modais permanecem centralizados.
transition: 300ms sem prefers-reduced-motion@media (prefers-reduced-motion: reduce) { transition-duration: 0.01ms }WCAG 2.1 exige suporte a movimento reduzido
animate={{ x: 100 }} no Framer Motionanimate={{ transform: "translateX(100px)" }}x/y do Framer Motion NÃO são acelerados por hardware. Use string transform para GPU.

Formato errado (nunca faça isso):

Antes: transition: all 300ms
Depois: transition: transform 200ms ease-out

Transições CSS (preferidas para UI)

As transições CSS são interruptíveis - elas podem ser redirecionadas no meio da animação. Keyframes reiniciam do zero. Para qualquer interação que possa ser acionada rapidamente (toasts, alternâncias, dropdowns), as transições produzem resultados mais 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);
}

Tempo assimétrico de entrada / saída

A entrada pode ser mais lenta (o usuário está decidindo), a saída deve ser rápida (o sistema respondendo):

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

Tooltips: pular atraso em hovers subsequentes

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

Estados de entrada com @starting-style (apenas Chrome a partir de 2026, ainda não 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 e animações orientadas por rolagem (animation-timeline: view(), animation-timeline: scroll()) são apenas Chrome a partir de 2026. Use fallbacks em JavaScript para suporte entre navegadores.

Padrão segurar para excluir

.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;        /* pressionar: lento e deliberado */
}

BOTÕES - Feedback Tátil

Cada elemento pressionável precisa de uma resposta física.

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

A escala deve ser sutil (0.95-0.98). Aplicada a todos os elementos pressionáveis - botões, cards, itens de lista, abas.


POPOVERS - Conscientes da Origem

Popovers escalam a partir do gatilho, não do centro. Modais permanecem centralizados.

/* Radix UI */
.popover {
  transform-origin: var(--radix-popover-content-transform-origin);
}
/* Base UI */
.popover {
  transform-origin: var(--transform-origin);
}
/* Modais (sempre centralizados) */
.modal {
  transform-origin: center;
}

Se o usuário percebe individualmente não importa. No agregado, detalhes não vistos se acumulam.


Animações Escalonadas

Quando vários elementos entram juntos, escalone sua aparição.

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

Mantenha os atrasos de escalonamento curtos (30-80ms entre itens). Nunca bloqueie a interação enquanto o escalonamento está em execução.


Animações CSS (keyframes)

Use para animações predeterminadas e não dinâmicas. Keyframes reiniciam do zero na interrupção - evite 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;
}

Animações Spring

Springs parecem mais naturais do que animações baseadas em duração porque simulam física real. Elas mantêm a velocidade quando interrompidas.

Quando usar springs

  • Interações de arrastar com impulso
  • Elementos que parecem "vivos" (estilo Apple Dynamic Island)
  • Gestos que podem ser interrompidos no meio da animação
  • Interações decorativas de rastreamento do mouse

Abordagem Apple (recomendada - mais fácil de raciocinar)

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

Física tradicional (mais controle)

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

Mantenha o bounce sutil (0.1-0.3). Evite bounce na maioria das UIs. Use para arrastar para dispensar e interações lúdicas apenas.

Interações com mouse baseadas em spring

import { useSpring } from 'framer-motion'

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

Sem spring: parece artificial, instantâneo. Com spring: parece natural, tem impulso.


WEB ANIMATIONS API (WAAPI)

Animações CSS programáticas. Aceleradas por hardware, interruptíveis, sem necessidade de biblioteca.

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 o Framer Motion sob carga pesada - ela é executada fora da thread principal. Use para animações dinâmicas e interruptíveis onde os keyframes CSS são insuficientes.


ANIMAÇÕES ORIENTADAS POR ROLAGEM

Nota de suporte do navegador: Animações orientadas por rolagem (animation-timeline: view() e scroll()) são apenas Chrome/Edge a partir de 2026, ainda não Baseline. Forneça fallbacks em JS via IntersectionObserver para Firefox/Safari.

ViewTimeline (elemento entra/sai da 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 (posição de rolagem da página)

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

Paralaxe vinculado à rolagem (vanilla JS)

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 animações de layout - animando elementos que mudam de posição/tamanho.

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 Animação

Uma das ferramentas de animação mais poderosas em 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);
}

Use para: segurar para excluir, revelações de imagem ao rolar, controles deslizantes de comparação, transições de cor contínuas em abas.


PERCEPÇÃO DE DESEMPENHO

A velocidade na animação afeta diretamente como

Individual skills in this repo

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

Habilidades Relacionadas