Communitygithub.com

xzedm/clipplic-landing

Abordagem da Apple para design de interfaces e movimento físico fluido, traduzida para a web. Use ao construir ou revisar interfaces orientadas a gestos, animações spring, interações de arrastar/deslizar/folha, momentum e transições interrompíveis, materiais translúcidos e profundidade, tipografia (tamanho óptico, tracking, entrelinha), movimento reduzido ou os fundamentos de design (feedback, consistência espacial, moderação) por trás das interfaces no estilo Apple.

O que é clipplic-landing?

Este skill detalha os princípios de design de interface da Apple, extraídos de palestras como *Designing Fluid Interfaces* (WWDC 2018) e traduzidos para o desenvolvimento web com CSS, Pointer Events, requestAnimationFrame e bibliotecas spring como Motion/Framer Motion. O foco principal é criar interfaces que parecem uma extensão natural do usuário, respondendo instantaneamente ao toque, herdando velocidade, projetando momentum e sendo interrompíveis a qualquer momento. Abrange tópicos como eliminação de latência, rastreamento 1:1, uso de molas (springs) para animações interrompíveis, transferência de velocidade entre gesto e animação, projeção de momentum, consistência espacial e design de gestos. O objetivo é fornecer aos desenvolvedores web um guia prático para implementar a fluidez e a qualidade das interfaces da Apple em seus projetos, seja em componentes individuais ou em sistemas de design completos. As plataformas suportadas incluem qualquer ambiente web que use CSS, JavaScript e bibliotecas de animação modernas, como Motion ou Framer Motion.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/xzedm/clipplic-landing/tree/HEAD/.agents/skills/apple-design

Perguntar na sua IA favorita

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

Documentação

Apple Design

Como a Apple constroi interfaces que deixam de parecer um computador e começam a parecer uma extensão de você. Este conhecimento vem das palestras de design da WWDC da Apple — principalmente Designing Fluid Interfaces (WWDC 2018) — destilado e traduzido para a plataforma web (CSS, Pointer Events, requestAnimationFrame, bibliotecas spring como Motion/Framer Motion).

O fio condutor: uma interface parece viva quando o movimento começa a partir do valor atual na tela, herda a velocidade do usuário, projeta o momentum para frente e pode ser pega e revertida a qualquer instante. Molas (springs) são a ferramenta que torna tudo isso natural, porque são inerentemente interrompíveis e conscientes de velocidade.

A Ideia Central

"Quando alinhamos a interface à maneira como pensamos e nos movemos, algo mágico acontece — ela deixa de parecer um computador e começa a parecer uma extensão sem costura de nós."

Uma interface é fluida quando se comporta como o mundo físico: as coisas respondem instantaneamente, movem-se continuamente, carregam momentum, resistem nos limites e podem ser redirecionadas durante o movimento. Tudo abaixo é uma maneira de chegar mais perto disso.

A Apple enquadra o design como servindo a quatro necessidades humanas: segurança/previsibilidade, compreensão, realização e alegria. Cada regra aqui serve a uma delas.

1. Resposta — eliminar latência

No momento em que a latência aparece, a sensação de imediatismo "cai de um penhasco." A resposta é a base sobre a qual tudo o mais é construído.

  • Responda no pointer-down, não na liberação. Destaque um botão no instante em que é pressionado. Esperar pelo click/touch-up para mostrar feedback parece morto.
  • Seja vigilante em relação a cada latência. Audite debounces, timers artificiais, esperas de transição e o atraso de tap de ~300ms. Qualquer coisa no caminho de entrada que não seja essencial é uma regressão.
  • O feedback deve ser contínuo durante a interação, não apenas no final. Para um arrasto, slider ou gaveta, atualize a UI 1:1 com o ponteiro o tempo todo — nunca anime apenas quando o gesto for concluído.
/* O feedback vive no pressionamento, e é instantâneo */
.button:active {
  transform: scale(0.97);
  transition: transform 100ms ease-out;
}

2. Manipulação direta — rastreamento 1:1

"Toque e conteúdo devem se mover juntos."

Quando o usuário arrasta algo, ele deve permanecer grudado ao dedo — e respeitar o deslocamento de onde o pegou. Ajustar ao centro do elemento ao agarrar quebra a ilusão imediatamente.

  • Use Pointer Events com setPointerCapture para que o rastreamento continue mesmo quando o ponteiro sai dos limites do elemento.
  • Rastreie um breve histórico de velocidade/posição (últimos eventos pointermove), não apenas o ponto atual — você precisará da velocidade na liberação.
el.addEventListener('pointerdown', (e) => {
  el.setPointerCapture(e.pointerId);
  const grabOffset = e.clientY - el.getBoundingClientRect().top; // respeitar onde agarrou
  // ...rastrear histórico de posição + timestamp para velocidade
});

3. Interrompibilidade — o princípio mais importante

"O pensamento e o gesto acontecem em paralelo."

Cada animação deve ser interrompível e redirecionável a qualquer momento. Um usuário deve ser capaz de pegar um elemento em movimento no meio do voo e revertê-lo sem esperar que a animação termine. Um modal que está fechando e o usuário agarra novamente deve seguir o dedo — não terminar de fechar primeiro, depois reabrir.

  • Nunca bloqueie a entrada durante uma transição.
  • Sempre anime a partir do valor de apresentação (atual), nunca do valor alvo. Na interrupção, leia a transformação ao vivo do elemento na tela e inicie a nova animação a partir daí. Começar pelo valor lógico/alvo causa um salto visível.
  • Evite transições CSS e @keyframes para qualquer coisa orientada a gestos — eles não podem ser suavemente agarrados e revertidos durante o voo. As molas (springs) animam a partir do valor atual por padrão, que é exatamente o que a interrupção precisa.
  • Quando um gesto reverte, misture a velocidade — não a corte abruptamente. Substituir uma animação por outra em uma reversão cria uma descontinuidade de velocidade, uma "parede de tijolos." Bibliotecas spring que carregam a velocidade através de um retarget evitam isso. (Isso é o que as animações aditivas do iOS fazem nativamente; na web, escolha uma biblioteca spring que refaça o alvo a partir da velocidade atual.)
  • Decomponha o movimento 2D em molas X e Y independentes. Uma única mola em uma distância 2D dessincroniza quando X e Y têm velocidades diferentes.

4. Comportamento sobre animação — use molas (springs)

"Pense na animação como uma conversa entre você e o objeto, não algo prescrito pela interface."

Uma animação pré-roteirizada e de duração fixa não pode responder a novas entradas. Uma mola pode — novas entradas apenas mudam o alvo, e o movimento permanece contínuo. Recorra a molas para qualquer coisa que um usuário possa tocar.

A Apple deliberadamente substituiu o trio de física (massa/rigidez/amortecimento) por dois parâmetros amigáveis ao designer. Pense nestes:

  • Razão de amortecimento — controla o overshoot. 1.0 = criticamente amortecido, sem quique, acomodação suave. < 1.0 = overshoot e oscila. Mais baixo = mais elástico.
  • Resposta — quão rapidamente o valor atinge o alvo, em segundos. Mais baixo = mais rápido. Isso não é "duração" — uma mola não tem duração fixa; seu tempo de acomodação emerge dos parâmetros.

Padrões:

  • Inicie a maioria das UI com amortecimento 1.0 (criticamente amortecido) — gracioso e não perturbador.
  • Adicione quique (amortecimento ~0.8) apenas quando o próprio gesto carregou momentum (um flick, um arremesso, uma liberação de arrasto). Overshoot em um menu que apenas apareceu parece errado; overshoot em um cartão que você empurrou parece certo.

Valores concretos que a Apple envia:

InteraçãoAmortecimentoResposta
Mover / reposicionar (ex. PiP)1.00.4
Rotação0.80.4
Gaveta / folha0.80.3

Mapeamento web (Motion / Framer Motion): a API spring bounce + duration mapeia de perto para o amortecimento + resposta da Apple. Um estilo de casa seguro é damping: 1.0 em toda parte por padrão; reserve o quique para interações físicas impulsionadas por momentum.

import { animate } from 'motion';

// Padrão criticamente amortecido (sem overshoot)
animate(el, { y: 0 }, { type: 'spring', bounce: 0, duration: 0.4 });

// Interação de momentum — um pouco de quique, apenas porque um flick o precedeu
animate(el, { y: target }, { type: 'spring', bounce: 0.2, duration: 0.4 });

5. Transferência de velocidade — a costura entre arrasto e animação

Quando um gesto termina, a animação deve continuar na velocidade exata do dedo, para que não haja costura visível entre arrastar e animar. Este é o detalhe que mais separa "fluido" de "apenas razoável."

Passe a velocidade de liberação do ponteiro como a velocidade inicial da mola. Algumas APIs spring querem velocidade relativa — normalize-a pela distância restante até o alvo:

velocidadeRelativa = velocidadeGesto / (valorAlvo − valorAtual)

Exemplo: elemento em y=50, alvo y=150 (100px a percorrer), dedo movendo-se a 50px/s → velocidade inicial da mola = 50 / 100 = 0.5. Framer Motion / Motion aceita velocidade absoluta em px/s diretamente (opção velocity), então você geralmente passa o valor bruto.

6. Projeção de momentum — anime para onde o gesto está indo

"Pegue uma pequena entrada e faça uma grande saída."

Não ajuste ao limite mais próximo a partir do ponto de liberação. Use a velocidade para projetar a posição de descanso — exatamente como a desaceleração de scroll — então ajuste ao alvo mais próximo desse ponto projetado. Isso é o que faz um flick parecer que arremessa o elemento.

Função de projeção exata da Apple (do código de exemplo Designing Fluid Interfaces):

// decelerationRate ≈ 0.998 para sensação de scroll normal; 0.99 para mais rápido
function project(initialVelocity /* px/s */, decelerationRate = 0.998) {
  return (initialVelocity / 1000) * decelerationRate / (1 - decelerationRate);
}

const projectedEndpoint = currentPosition + project(releaseVelocity);
const target = nearestSnapPoint(projectedEndpoint);   // escolher alvo a partir da projeção
animateSpringTo(target, { velocity: releaseVelocity }); // então transferir velocidade (§5)

Nota: o v²/(2·decel) do livro de física não é o que a Apple envia — use a forma de decaimento exponencial acima. Este é o comportamento padrão em boas bottom-sheets e carrosséis (Vaul, Embla).

7. Consistência espacial — caminhos simétricos, origens ancoradas

"Se algo desaparece de um jeito, esperamos que emerga de onde veio."

  • Entre e saia pelo mesmo caminho. Um painel que desliza da direita deve ser descartado para a direita. Entrar pela direita / sair por baixo parece desconectado e confuso.
  • Ancore as interações à sua fonte. Um menu, popover ou folha deve originar-se do elemento que o acionou — defina transform-origin para o gatilho, para que a relação espacial entre o botão e o conteúdo seja óbvia. (Este é o mesmo ponto de consciência de origem que popovers escalando de seu gatilho, não de seu centro.)
  • Espelhe a suavização em transições reversíveis para que o caminho de saída corresponda ao caminho de retorno (use pontos de controle cúbicos inversos de bézier para as duas direções).

8. Dica na direção do gesto

Humanos predizem um estado final a partir de uma trajetória. O movimento intermediário deve telegrafar para onde as coisas estão indo — os módulos da Central de Controle "crescem para cima e para fora em direção ao seu dedo." Faça com que os quadros intermediários apontem para o resultado, não apenas interpolem cegamente até ele.

9. Elasticidade (rubber-banding) — limites suaves

Em um limite, resista progressivamente em vez de parar bruscamente. Uma parada brusca parece "congelada"; resistência contínua parece "responsiva, mas não há mais nada aqui." Aplique amortecimento que aumenta quanto mais além do limite o usuário arrasta.

// Quanto mais além do limite, menos o elemento segue — coisas reais desaceleram antes de parar
function rubberband(overshoot, dimension, constant = 0.55) {
  return (overshoot * dimension * constant) / (dimension + constant * Math.abs(overshoot));
}

10. Detalhes de design de gestos (a lista de verificação de "sensação")

  • Tap: destaque no touch-down (instantâneo), confirme no touch-up. Adicione ~10px de histerese/almofada de acerto em torno do alvo e permita cancelar arrastando para longe e voltando.
  • Arrasto/deslize: exija um pequeno limite de movimento (histerese, ~10px) antes de se comprometer com uma direção, então rastreie 1:1.
  • Detecte todos os gestos plausíveis em paralelo desde o primeiro movimento, então cancele com confiança os perdedores uma vez que a intenção esteja clara. Evite reconhecedores que apenas relatam um estado final (eventos do tipo swipeleft) — eles descartam o rastreamento contínuo de que você precisa para feedback.
  • Minimize atrasos de desambiguação. A detecção de duplo toque inevitavelmente atrasa toques únicos; só pague esse custo onde o duplo toque realmente existe.

11. Suavidade no nível do quadro

Suavidade é sobre o que está nos quadros, não apenas a taxa de quadros.

  • Mantenha a mudança de posição por quadro abaixo do limite de percepção para evitar estroboscopia.
  • Para movimento muito rápido, um sutil desfoque de movimento / esticamento codifica velocidade e é lido melhor do que um traçado nítido e duro.
  • requestAnimationFrame é o relógio sincronizado com a tela da web (a Apple usa CADisplayLink). Anime apenas propriedades amigáveis ao compositor — transform e opacity — e sugira com will-change onde o movimento é iminente.

12. Materiais e profundidade — translucidez transmite hierarquia

A Apple usa materiais translúcidos como uma camada funcional flutuante que traz estrutura sem roubar o foco. Na web, aproxime com backdrop-filter.

  • Construa navs/barras de ferramentas/folhas como camadas translúcidas (backdrop-filter: blur() + um fundo semitransparente) com conteúdo rolando por baixo — não barras opacas que consomem uma faixa fixa.
  • Peso do material codifica hierarquia: materiais mais escuros/pesados separam regiões estruturais (barras laterais); materiais mais claros atraem a atenção para elementos interativos (botões). Nunca empilhe uma superfície translúcida clara sobre outra — a legibilidade colapsa.
  • Superfícies maiores devem parecer mais grossas: desfoque mais forte + uma sombra mais profunda do que chips pequenos. Considere sombra consciente de contexto — mais pesada sobre conteúdo ocupado/texto para separação, mais clara sobre fundos lisos.
  • Escureça para focar, separe para manter o fluxo. Uma tarefa modal emparelha a superfície com um véu de escurecimento e empurra o fundo para trás/para baixo. Um painel paralelo e não bloqueador usa transparência e deslocamento sem um véu para que o fluxo não seja quebrado. Para folhas empilhadas, escureça progressivamente e empurre cada camada pai para trás.
  • Vibração mantém o texto legível sobre fundos variáveis. Sobre superfícies desfocadas/translúcidas, não use texto cinza plano — use contraste mais alto, peso ligeiramente mais pesado e um pequeno aumento no espaçamento entre letras. Coloque a cor em uma camada sólida, não no primeiro plano translúcido.
  • Efeitos de borda de scroll, não divisores rígidos. Em vez de uma borda de 1px embaixo de um cabeçalho fixo, desbote uma pequena máscara de desfoque/gradiente onde o conteúdo encontra o cromo flutuante — apenas onde a UI flutuante realmente se sobrepõe ao conteúdo.
  • Materialize, não apenas desbote. Para superfícies de vidro/desfoque, anime o raio de desfoque e a escala juntos na entrada/saída, para que a superfície pareça um material real chegando, em vez de uma simples transição de opacidade.
.toolbar {
  background: rgba(255, 255, 255, 0.6);
  backdrop-filter: blur(20px) saturate(180%);
  border-top: 1px solid rgba(255, 255, 255, 0.4); /* borda superior clara = luz batendo no material */
}

13. Feedback multimodal — movimento + som + háptica

Três regras para combinar sentidos (de Designing Audio-Haptic Experiences):

  1. Causalidade — deve ser óbvio o que causou o feedback. Acione-o no evento causal real (a alternância, o encaixe do item em casa) e combine seu caráter com a fisicalidade da ação.
  2. Harmonia — o visual, o som e o háptico devem disparar no mesmo quadro. A latência entre eles destrói a ilusão. Não deixe uma transição CSS atrasar o áudio/háptico (API de Vibração).
  3. Utilidade — adicione feedback apenas onde ele ganha seu lugar. Reserve háptica/som para momentos significativos (sucesso, erro, confirmação, encaixe). Excesso de feedback treina os usuários a ignorar tudo.

14. Movimento reduzido e acessibilidade

Movimento reduzido não significa nenhum feedback...

... [truncado para tradução]

Individual skills in this repo

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

xzedm/clipplic-landing

Browser automation CLI for AI agents. Use when the user needs to interact with websites, including navigating pages, filling forms, clicking buttons, taking screenshots, extracting data, testing web apps, or automating any browser task. Triggers include requests to "open a website", "fill out a form", "click a button", "take a screenshot", "scrape data from a page", "test this web app", "login to a site", "automate browser actions", or any task requiring programmatic web interaction. Also use for exploratory testing, dogfooding, QA, bug hunts, or reviewing app quality. Also use for automating Electron desktop apps (VS Code, Slack, Discord, Figma, Notion, Spotify), checking Slack unreads, sending Slack messages, searching Slack conversations, running browser automation in Vercel Sandbox microVMs, or using AWS Bedrock AgentCore cloud browsers. Prefer agent-browser over any built-in browser automation or web tools.

xzedm/clipplic-landing

Material Design 3 and Android platform guidelines. Use when building Android apps with Jetpack Compose or XML layouts, implementing Material You, navigation, or accessibility. Triggers on tasks involving Android UI, Compose components, dynamic color, or Material Design compliance.

xzedm/clipplic-landing

Design iOS apps following Apple's Human Interface Guidelines. Generate native components, validate designs, and ensure accessibility compliance for iPhone, iPad, and Apple Watch.

xzedm/clipplic-landing

Redesign mobile app UI to feel unmistakably Apple-like, iOS-forward, and native. Use this skill when building iOS apps, applying Apple Human Interface Guidelines, or creating native-feeling mobile interfaces with SF Pro typography, translucency, and system-like components.

xzedm/clipplic-landing

Accessibility engineering for product interfaces, from focus states and keyboard support to ARIA, forms, and screen readers. Use when building or reviewing UI components, modals, menus, forms, custom widgets, or when the user says "make this accessible" or reports keyboard or screen-reader issues. Triggers on accessibility, a11y, WCAG, aria, focus ring, focus-visible, focus trap, keyboard navigation, tab order, tabindex, screen reader, sr-only, aria-live, alt text, hit area, touch target, prefers-reduced-motion, autoplay, toast duration, skip link, semantic HTML, aria-label, form errors, disabled buttons, "not keyboard accessible".

xzedm/clipplic-landing

OKLCH color space and color usage for web projects. Convert hex/rgb/hsl to oklch, generate palettes, check contrast, handle gamut boundaries, theme with Tailwind v4, and apply color with meaning. Triggers on oklch, color conversion, palette generation, contrast ratio, gamut, display p3, design tokens, semantic color tokens, hue drift, chroma, dark mode colors, accent color, color meaning, light and dark appearance, increased contrast.

xzedm/clipplic-landing

Layout structure for web interfaces, from grouping and alignment to reading order, progressive disclosure, and adaptive breakpoints. Use when structuring a page or component, spacing or aligning controls, deciding what collapses at small sizes, handling RTL layout direction, or reviewing frontend code for layout. Triggers on layout, spacing, alignment, grouping, negative space, whitespace, visual hierarchy, reading order, progressive disclosure, breakpoints, responsive layout, container queries, safe area, full-bleed, edge-to-edge, layout margins, RTL layout, logical properties.

xzedm/clipplic-landing

Web typography from choosing fonts to spacing, wrapping and accessibility. Use when picking or pairing typefaces, configuring variable fonts or OpenType features, setting up a type scale, checking heading hierarchy, styling text in components, truncating text, styling underlines, selection, placeholders or carets, or reviewing frontend code for typography. Triggers on typography, fonts, font formats, woff2, variable fonts, font-weight, opentype, font-feature-settings, letter-spacing, line-height, type scale, heading hierarchy, heading levels, tabular numbers, text-wrap, truncation, line clamp, underlines, text-decoration, text selection, iOS input zoom, scaled input text, font smoothing, text contrast, measure, line length, text-box, smart punctuation, drop cap.

xzedm/clipplic-landing

Design engineering principles for making interfaces feel polished. Use when building UI components, reviewing frontend code, implementing animations, hover states, shadows, borders, micro-interactions, enter/exit animations, choosing or reviewing icons, or any visual detail work. Triggers on UI polish, design details, "make it feel better", "feels off", stagger animations, border radius, optical alignment, image outlines, box shadows, icons, icon stroke weight, icon states, motion restraint.

xzedm/clipplic-landing

Deploy applications and websites to Vercel. Use when the user requests deployment actions like "deploy my app", "deploy and give me the link", "push this live", or "create a preview deployment".

xzedm/clipplic-landing

Generate developer handoff specs from a design. Use when a design is ready for engineering and needs a spec sheet covering layout, design tokens, component props, interaction states, responsive breakpoints, edge cases, and animation details.

xzedm/clipplic-landing

This skill encodes Emil Kowalski's philosophy on UI polish, component design, animation decisions, and the invisible details that make software feel great.

xzedm/clipplic-landing

Extract design primitives from a public website and generate starter token files for your project.

xzedm/clipplic-landing

Use this skill alongside figma-use when the task involves translating an application page, view, or multi-section layout into Figma. Triggers: 'write to Figma', 'create in Figma from code', 'push page to Figma', 'take this app/page and build it in Figma', 'create a screen', 'build a landing page in Figma', 'update the Figma screen to match code', 'convert this modal/dialog/drawer/panel to Figma'. This is the preferred workflow skill whenever the user wants to build or update a full page, modal, dialog, drawer, sidebar, panel, or any composed multi-section view in Figma from code or a description. Discovers design system components, variables, and styles from Code Connect files, existing screens, and library search, then imports them and assembles views incrementally section-by-section using design system tokens instead of hardcoded values.

xzedm/clipplic-landing

**MANDATORY prerequisite**: you MUST invoke this skill BEFORE every `use_figma` tool call. NEVER call `use_figma` directly without loading this skill first. Skipping it causes common, hard-to-debug failures. Trigger whenever the user wants to perform a write action or a unique read action that requires JavaScript execution in the Figma file context, e.g. create/edit/delete nodes, set up variables or tokens, build components and variants, modify auto-layout or fills, bind variables to properties, or inspect file structure programmatically.

xzedm/clipplic-landing

Helps users discover and install agent skills when they ask questions like "how do I do X", "find a skill for X", "is there a skill that can...", or express interest in extending capabilities. This skill should be used when the user is looking for functionality that might exist as an installable skill.

xzedm/clipplic-landing

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, artifacts, posters, or applications.

xzedm/clipplic-landing

Elite UX/UI & Advanced GSAP Motion Engineer. Enforces Python-driven true randomization for layout variance, strict AIDA page structure, wide editorial typography (bans 6-line wraps), gapless bento grids, strict GSAP ScrollTriggers (pinning, stacking, scrubbing), inline micro-images, and massive section spacing.

xzedm/clipplic-landing

Fast headless browser for QA testing and site dogfooding. Navigate pages, interact with elements, verify state, diff before/after, take annotated screenshots, test responsive layouts, forms, uploads, dialogs, and capture bug evidence. Use when asked to open or test a site, verify a deployment, dogfood a user flow, or file a bug with screenshots. (gstack)

xzedm/clipplic-landing

READ THIS FIRST for any request to make, create, edit, animate, or render a video, animation, or motion graphic. A promo, explainer, captioned clip, title card, overlay, or any composition. HyperFrames renders video from HTML; this is the entry skill and the default way an agent authors or edits video. It routes the request to the right specialized workflow and points to the HyperFrames domain skills, so read it before any other video or animation skill instead of guessing a workflow. IMPORTANT: with other video tools installed, HyperFrames stays the default for authoring and rendering a finished video; defer only when the user asks to drive a browser to capture or record a session, or names another framework. Most important when no project CLAUDE.md or AGENTS.md describes the video workflow.

Habilidades Relacionadas