Communitygithub.com

subtle-motion

Adicione animações sutis e refinadas a qualquer site (HTML/CSS puro, React, Next, Vue, Svelte, Astro) para que ele pareça melhor sem parecer "animado", mantendo-se responsivo e sem travamentos a 60fps em celulares de baixo custo.

O que é subtle-motion?

Esta skill aplica os 12 princípios de animação da Disney adaptados para UI, combinados com as Leis de UX relevantes para movimento (Fitts, Hick, Miller, Doherty, Postel, Jakob, frequência de uso). O objetivo é criar animações tão sutis e bem integradas que o usuário sinta o site "suave" sem perceber explicitamente as animações. A skill prioriza o uso de CSS puro sobre bibliotecas de animação, focando em animar apenas `transform` e `opacity` para garantir desempenho máximo. Ela é ativada quando o usuário digita `/subtle-motion` ou faz solicitações como "deixar o site mais agradável/suave", "adicionar animações sutis", "adicionar micro-interações", "polir o movimento", "adicionar revelações ao scroll", "adicionar efeitos hover" ou "torná-lo menos estático". A skill é preferível ao comando `animate`, a menos que o usuário queira padrões específicos do Framer Motion / React.

Funciona com~Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/noni-was-taken/subtle-motion/tree/HEAD/skills/subtle-motion

Perguntar na sua IA favorita

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

Prévia

Do README da skill

Documentação

Subtle Motion (Movimento Sutil)

Movimento é tempero. O usuário deve sentir que o site é "suave", nunca notar "uma animação". Fontes: The Illusion of Life (Disney), Laws of UX (Jon Yablonski), userinterface.wiki (Raphael Salaja), Emil Kowalski (frequência de uso).

Regras rígidas (nunca quebrar)

  1. Animar apenas transform e opacity (mais filter/clip-path com moderação). Nunca anime width, height, top, left, margin, padding, box-shadow (tamanho) ou font-size. Precisa mudar uma sombra? Desvaneie a opacity de um pseudo-elemento.
  2. Tempo rápido: movimento da UI abaixo de 300ms. Pressionar: 80–120ms, hover: 150ms, entrada: 200–300ms, saída ≈ 70% da entrada. Apenas um herói único pode chegar a 500ms.
  3. Distâncias pequenas. Translação de 2–16px, escala de 0,97–1,03, rotação ≤ 6°. Maior que isso parece "animado".
  4. Aceleração e desaceleração. Nunca linear em movimento. ease-out para entrada, ease-in para saída.
  5. Frequência de uso: quanto mais usado, menos anima. Navegação por teclado, paletas de comando, abas usadas 100x/dia, seleção de lista: instantâneo (0ms) ou um desvanecimento de ≤100ms. Anime momentos raros e de primeira vez, não os repetidos.
  6. Limiar de Doherty: responda em 100ms, termine em 400ms. O feedback (estado pressionado, estado pendente) começa no mesmo quadro da entrada. Qualquer coisa mais lenta que 400ms mostra progresso.
  7. prefers-reduced-motion: reduce elimina movimento. Desvanecimentos de opacidade podem permanecer.
  8. Efeitos de hover apenas sob @media (hover: hover). Toque obtém hovers pegajosos caso contrário.
  9. CSS primeiro, sem bibliotecas de animação a menos que o projeto já tenha uma. Sem loops JS quando CSS pode fazer.
  10. Nunca atrasar ou ocultar conteúdo. Revelações não devem ocultar conteúdo se JS falhar, bloquear cliques ou animar o elemento LCP no carregamento.
  11. Encenação: um movimento focal por vez. Máx. ~5 pontos de movimento por página; nunca duas coisas competindo pelo olhar no mesmo momento.
  12. will-change apenas durante a animação (ou em ≤3 elementos persistentes).
  13. Interrompível por padrão. Estado que pode mudar durante o movimento (hover, alternar, abrir/fechar, indicador de aba) usa transition, que redireciona de onde estiver. @keyframes apenas para momentos únicos (sacudir, tocar, enviar) que reiniciam de forma limpa.
  14. Dimensionar a duração pelo tamanho e iniciador. Elementos pequenos mais rápidos que grandes (ícone 100ms, cartão 250ms, folha 300ms). Iniciado pelo usuário = imediato; iniciado pelo sistema (toast, atualização em segundo plano) pode levar o extremo lento.
  15. Sem flashes mais de 3×/s; qualquer coisa em loop > 5s precisa de um controle de pausa (ou não faça loop).

Os princípios, como regras de UI

Escolha os que se encaixam no ponto de contato; nunca todos de uma vez. Cada um mapeia um padrão abaixo.

#PrincípioNa UI significaPadrão
1Squash & stretch (compressão e esticamento)As coisas comprimem no impacto, esticam em movimento: pesoPressionar, Alternar
2AntecipaçãoPequeno recuo antes de um grande movimento (enviar, enviar formulário, voar para fora)Botão Enviar
3EncenaçãoDirecionar o olhar para uma coisa: escurecer irmãos, um movimento de cada vezFoco em cartão
4Pose a poseDefinir estados inicial/final; deixar o navegador interpolartransition, não JS quadro a quadro
5Follow through (acompanhamento)Partes se acomodam depois que o corpo para (pequeno excesso)Toast, Distintivo
6Aceleração e desaceleraçãoAcelerar e desacelerar, nunca velocidade constanteTokens
7ArcosElementos em movimento se movem em curvas, não linhas retasVoar para o carrinho
8Ação secundáriaPequeno floreio que apoia a ação principalAnel de sucesso
9Tempo rápidoA duração define a sensação; UI < 300msTokens
10Feedback exageradoUltrapassar o real para que o momento se fixe (erros, sucesso)Sacudir de erro
11Desenho sólido / 3DDar às coisas planas profundidade e volumeInclinar cartão
12ApeloA soma de cada detalhe, consistente em todo o sitePassar na verificação
Lei de UXConsequência para o movimentoPadrão
Lei de FittsAlvos maiores e mais próximos são mais rápidos de atingirÁreas de clique
Áreas de clique maioresÁrea clicável ≥ 44×44px, mesmo que o visual seja menorÁreas de clique
Lei de HickMais escolhas = decisões mais lentas; não anime muitas opções ao mesmo tempoLimite de escalonamento
Lei de MillerAgrupar conteúdo (~7 itens); revelar em grupos, não item por itemLimite de escalonamento
Limiar de DohertyFeedback <100ms, total <400ms, senão mostrar progressoEstado pendente
Lei de PostelAceitar entrada confusa, retornar saída limpa; animar a limpeza suavementeFormatar entrada
Lei de JakobUsar movimento convencional (menus descem do gatilho, modais desvanecem+escalam do centro)Sobreposição
Frequência de usoFrequente = menos animaçãoRegra 5

Fluxo de trabalho

  1. Leia o site primeiro. Framework, abordagem CSS (Tailwind, CSS modules, puro), movimento e tokens existentes. Reutilize-os.
  2. Classifique cada elemento interativo por frequência: raro (cadastro, checkout, sucesso), ocasional (cartões, seções, modais), frequente (nav, abas, paletas, linhas de lista). Frequente recebe ≤100ms ou nada.
  3. Escolha ≤5 pontos de contato, classificados por sensação-custo:
    1. Botões/links: compressão ao pressionar + área de clique (princípios 1, Fitts)
    2. Feedback de formulários: sacudir de erro, anel de sucesso, estado pendente (10, 8, Doherty)
    3. Cartões: elevação no hover, inclinação opcional (11)
    4. Seções: revelação no scroll, escalonamento em grupos (6, Miller)
    5. Sobreposições/toasts: entrada/saída com acompanhamento (5, Jakob)
  4. Adicione os tokens uma vez, globalmente.
  5. Aplique padrões apenas aos pontos de contato escolhidos.
  6. Verifique (última seção). Não está pronto até ser verificado.
  7. Relatório: cada ponto de contato com arquivo:linha, o princípio que aplica e como vê-lo.

Tokens (adicionar uma vez, globalmente)

:root {
  --ease-out: cubic-bezier(.23, 1, .32, 1);       /* entrada, hover */
  --ease-in: cubic-bezier(.55, 0, 1, .45);        /* saída */
  --ease-in-out: cubic-bezier(.65, 0, .35, 1);    /* mover na tela */
  --ease-settle: cubic-bezier(.34, 1.4, .64, 1);  /* acompanhamento: ~4% de excesso */
  /* sensação de mola, interrompível; navegadores sem linear() voltam para `ease` */
  --ease-spring: linear(0, .07 3%, .29 9%, .62 18%, .86 28%, 1.01 40%, 1.03 50%, 1.015 65%, 1);
  --dur-press: 100ms;
  --dur-fast: 150ms;
  --dur-base: 250ms;
  --dur-slow: 300ms;
  --rise: 8px;
}
@media (prefers-reduced-motion: reduce) {
  :root { --rise: 0px; }
  *, *::before, *::after {
    animation-duration: 1ms !important;
    animation-iteration-count: 1 !important;
    transition-duration: 1ms !important;
    scroll-behavior: auto !important;
  }
}

Projeto Tailwind? Coloque estes em @theme / tailwind.config extend em vez de um novo arquivo CSS.

Padrões

Pressionar: compressão (1) + área de clique (Fitts)

.btn {
  position: relative;
  transition: transform var(--dur-fast) var(--ease-out), background-color var(--dur-fast) var(--ease-out);
}
@media (hover: hover) { .btn:hover { transform: translateY(-1px); } }
.btn:active { transform: scale(.97); transition-duration: var(--dur-press); }

/* Botões de ícone pequenos: aumentar a área de clique, não o visual */
.icon-btn { position: relative; }
.icon-btn::before { content: ""; position: absolute; inset: 50% auto auto 50%; width: 44px; height: 44px; translate: -50% -50%; }

Alternar: compressão e esticamento (1)

O botão estica enquanto viaja, acomoda quando chega.

.switch .knob { transition: transform var(--dur-base) var(--ease-settle); }
.switch[aria-checked="true"] .knob { transform: translateX(20px); }
.switch:active .knob { transform: scaleX(1.2); transform-origin: left; }
.switch[aria-checked="true"]:active .knob { transform: translateX(20px) scaleX(1.2); transform-origin: right; }

Enviar / submeter: antecipação (2)

Apenas em ações raras de "confirmação". Puxe 2px para trás, depois vá.

@keyframes send { 0% { transform: none } 30% { transform: translate(-2px, 2px) } 100% { transform: translate(24px, -24px); opacity: 0 } }
.send.is-sending svg { animation: send 280ms var(--ease-in-out) forwards; }

Foco em cartão: encenação (3)

@media (hover: hover) {
  .grid:has(.card:hover) .card:not(:hover) { opacity: .6; }
}
.grid .card { transition: opacity var(--dur-base) var(--ease-out); }

Use apenas em grades densas onde uma escolha importa. Pule em conteúdo que as pessoas leem.

Elevação do cartão + inclinação opcional: desenho sólido (11)

.card { position: relative; transition: transform var(--dur-base) var(--ease-out); }
.card::after {
  content: ""; position: absolute; inset: 0; border-radius: inherit; pointer-events: none;
  box-shadow: 0 12px 32px -12px rgb(0 0 0 / .25);
  opacity: 0; transition: opacity var(--dur-base) var(--ease-out);
}
@media (hover: hover) {
  .card:hover { transform: translateY(-3px); }
  .card:hover::after { opacity: 1; }
}

Inclinação (apenas para itens de vitrine como um produto, preço ou cartão de crédito; ≤6°, apenas pointer, limitado por rAF):

if (matchMedia('(hover: hover) and (prefers-reduced-motion: no-preference)').matches) {
  for (const el of document.querySelectorAll('.tilt')) {
    let raf = 0;
    el.addEventListener('pointermove', (e) => {
      cancelAnimationFrame(raf);
      raf = requestAnimationFrame(() => {
        const r = el.getBoundingClientRect(); // ler uma vez por quadro, não por transição
        const x = (e.clientX - r.left) / r.width - .5, y = (e.clientY - r.top) / r.height - .5;
        el.style.transform = `perspective(800px) rotateX(${-y * 6}deg) rotateY(${x * 6}deg)`;
      });
    });
    el.addEventListener('pointerleave', () => { cancelAnimationFrame(raf); el.style.transform = ''; });
  }
}

Toast / distintivo: acompanhamento (5)

.toast { transition: transform var(--dur-slow) var(--ease-settle), opacity var(--dur-fast) var(--ease-out); }
.toast[data-state="closed"] { transform: translateY(12px); opacity: 0; transition-timing-function: var(--ease-in); }

Excesso apenas em coisas que chegam (toasts, distintivos, contadores), nunca em layout ou blocos de texto.

Voar para o carrinho: arcos (7)

Divida X e Y em dois elementos aninhados com diferentes facilitações; o caminho curva.

.fly-x { transition: transform 300ms linear; }
.fly-y { transition: transform 300ms var(--ease-in); }
.flying .fly-x { transform: translateX(var(--dx)); }
.flying .fly-y { transform: translateY(var(--dy)) scale(.4); }

Defina --dx/--dy a partir de uma leitura getBoundingClientRect() antes de adicionar .flying.

Anel de sucesso: ação secundária (8)

.btn.is-success::after {
  content: ""; position: absolute; inset: -4px; border-radius: inherit; border: 2px solid currentColor;
  animation: ring 400ms var(--ease-out) forwards; pointer-events: none;
}
@keyframes ring { from { opacity: .6; transform: scale(.95) } to { opacity: 0; transform: scale(1.15) } }

Sacudir de erro: feedback exagerado (10)

@keyframes shake { 20%,60% { transform: translateX(-4px) } 40%,80% { transform: translateX(4px) } }
.field[aria-invalid="true"] { animation: shake 280ms var(--ease-in-out); }

Re-ative removendo e readicionando o atributo. Sempre emparelhe com uma mensagem de texto (acessibilidade).

Estado pendente: Limiar de Doherty

Feedback de pressionar imediatamente; se a ação levar >400ms, mostre um spinner/progresso dentro do botão (mantenha sua largura fixa para evitar mudança de layout). Prefira UI otimista: mostre o resultado, reverta em caso de erro.

Entrada confusa → saída limpa: Lei de Postel

Formate no blur (números de telefone, números de cartão, datas), não em cada tecla. Faça a transição do valor com uma mudança de opacidade de 150ms, sem movimento.

Revelação no scroll: aceleração/desaceleração (6) + agrupamento (Miller, Hick)

Conteúdo visível por padrão; apenas oculto uma vez que JS confirme que pode revelá-lo.

.js .reveal {
  opacity: 0; transform: translateY(var(--rise));
  transition: opacity var(--dur-slow) var(--ease-out), transform var(--dur-slow) var(--ease-out);
  transition-delay: calc(min(var(--i, 0), 5) * 50ms);
}
.js .reveal.in { opacity: 1; transform: none; }
document.documentElement.classList.add('js');
const io = new IntersectionObserver((entries) => {
  for (const e of entries) if (e.isIntersecting) { e.target.classList.add('in'); io.unobserve(e.target); }
}, { rootMargin: '0px 0px -10% 0px' });
document.querySelectorAll('.reveal').forEach((el) => io.observe(el));
  • Escalone com style="--i: n"; limitado a 6 etapas (Miller). Listas longas revelam como um grupo.
  • Revele uma vez. Pule qualquer coisa acima da dobra.
  • Frameworks: mesmo CSS; execute o observer em um efeito de montagem, desconecte ao desmontar.

Sobreposições: Lei de Jakob

Apenas movimento convencional: dropdowns crescem a partir do seu gatilho (transform-origin no lado do gatilho), modais desvanecem + escalam 0.98→1 do centro, folhas deslizam da sua borda. Nativo primeiro: <dialog> / popover com @starting-style.

dialog, [popover] {
  opacity: 0; transform: translateY(4px) scale(.98);
  transition: opacity var(--dur-fast) var(--ease-in), transform var(--dur-fast) var(--ease-in),
              overlay var(--dur-fast) allow-discrete, display var(--dur-fast) allow-discrete;
}
dialog[open], [popover]:popover-open {
  opacity: 1; transform: none;
  transition-timing-function: var(--ease-out); transition-duration: var(--dur-base);
}
@starting-style {
  dialog[open], [popover]:popover-open { opacity: 0; transform: translateY(4px) scale(.98); }
}

Paleta de comando / menu aberto por teclado muitas vezes ao dia: a frequência de uso diz para pular a transição.

Abas: superfície de pasta que desliza (não um sublinhado de destaque)

A diferença de IA/modelo é o sublinhado de destaque fino, não o movimento. Use uma forma física familiar (Jakob) e deixe essa forma fazer o movimento:

  • Abas de pasta (preferido): a superfície da aba selecionada se funde ao painel e desliza para a aba clicada.
  • Controle segmentado: para 2–4 opções; o segmento pressionado desliza da mesma forma.

Faça as abas terem largura igual para que a superfície precise apenas de translateX (sem largura ou scaleX, que distorce raio e borda). Use uma transição de ≤150ms para que permaneça interrompível. O conteúdo troca instantaneamente (frequência de uso).

.tabs { position: relative; display: flex; gap: 2px; border-bottom: 1px solid var(--line); }
.tabs [role=tab] { position: relative; z-index: 1; flex: 0 0 96px; padding: 8px 12px; border: 0; background: transparent; cursor: pointer; }
.tabs [role=tab][aria-selected="true"] { color: var(--accent); }
.tab-indicator {
  position: absolute; bottom: -1px; left: 0; height: 2px; background: var(--accent);
  transition: transform var(--dur-fast) var(--ease-out);
  pointer-events: none;
}

Defina a tradução do indicador no JS calculando offsetLeft da aba selecionada.

Verificação (sempre fazer, sem exceção)

Não está feito até que TODOS verifiquem:

  • Hardware ligado no DevTools (desempenho → GPU). Nenhuma área vermelha de pintura em interações.
  • prefers-reduced-motion: reduce ativado: nenhum movimento, apenas transições de opacidade. Pressionar instantâneo.
  • Dispositivo móvel lento (estrangulamento da CPU 6x no DevTools): 60fps em hover, scroll, abertura de modal.
  • Sem mudança de layout: ative o modo de pintura (Paint flashing) no DevTools; interaja. Nenhum retângulo verde além dos toasts.
  • Interrupção: inicie um hover de cartão, durante a transição, mova o mouse para outro lugar → sem estado travado. Para abas, clique na aba 1, depois imediatamente na 3 → a transição redireciona suavemente.
  • Teclado: Tab através de cada elemento focado. As transições funcionam (nenhuma trava @keyframes em itens navegáveis por teclado).
  • Leitor de tela: aria-live="polite" em regiones animadas (contadores, toasts). Sem conteúdo desaparecendo.
  • Nenhum conteúdo oculto: desabilite JS → todo o conteúdo revelado é visível.

Relatório de movimento

Formato:

[arquivo:linha] - [Princípio/Lei] - [O quê / Como ver]

Exemplo:

  • src/components/Button.tsx:42 - Squash & stretch + Fitts - Botão de envio comprime no clique e tem área de clique oculta de 44px. Pressione e segure para ver a compressão.
  • src/components/CardList.tsx:15-20 - Encenação (princípio 3) + Hick - Grade de cartões: passar o mouse escurece os cartões não focados. Passe o mouse sobre uma grade de 4 cartões.
  • src/components/Toast.tsx:30-35 - Acompanhamento (5) + Jakob - Toast desliza para cima com 4% de excesso, depois se acomoda. Acione um envio bem-sucedido.
  • src/styles/tokens.css:1-12 - Toques - Definições de duração, facilitação e elevação. Abra o arquivo.

Quando usar / quando evitar

CenárioAção
"Faça o site parecer melhor"subtle-motion (esta skill)
"Adicione animações legais"subtle-motion ("legais" = usuário médio, sutil)
"Adicione transições de página com Framer Motion / React Spring"animate
"Faça um jogo / página interativa com canvas / WebGL"animate (precisa de controle de loop)
"Acelere a sensação de uma SPA"animate (transições de rota com view transitions)
"Dê uma repaginada visual"subtle-motion + redesign ou theme

Leitura adicional

Habilidades Relacionadas