Communitygithub.com

Testes de UI

Use ao escrever testes de UI, gravar interações, testes com condições de corrida, dependências de tempo, comportamento inconsistente de aprovação/reprovação ou testes de UI do XCTest instáveis - cobre Gravação de Automação de UI (WWDC 2025), espera baseada em condições, condicionamento de rede, testes multifatoriais, depuração de crashes e padrões de teste com foco em acessibilidade.

O que é Testes de UI?

Este skill oferece uma abordagem sistemática para resolver a instabilidade em testes de interface do usuário (UI), especialmente no ecossistema Apple com XCTest e XCUITest. O princípio central é substituir `sleep()` arbitrário por esperas baseadas em condições reais, como `waitForExistence` e `XCTestExpectation`, eliminando condições de corrida e dependências de tempo que causam falhas inconsistentes em diferentes dispositivos ou ambientes de CI. O skill também cobre as novas funcionalidades do WWDC 2025, como a Gravação e Reprodução de Automação de UI, permitindo gravar interações do usuário, reproduzi-las em vários dispositivos e idiomas, e revisar gravações em vídeo para depurar falhas. Ele inclui padrões práticos para esperar por elementos, manipular animações e requisições de rede, e usar identificadores de acessibilidade para criar testes robustos independentes de localização. Além disso, oferece um checklist para garantir a qualidade dos testes, conselhos sobre depuração e um guia passo a passo para preparar o aplicativo e gravar interações de forma eficaz.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ComeOnOliver/skillshub/tree/HEAD/skills/CharlesWiltgen/Axiom/axiom-ui-testing

Perguntar na sua IA favorita

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

Documentação

O que Testes de UI faz?

Visão Geral

Aguarde por condições, não por timeouts arbitrários. Princípio central Testes instáveis surgem de adivinhar quanto tempo as operações levam. A espera baseada em condições elimina condições de corrida.

NOVO na WWDC 2025: A Gravação de Automação de UI permite gravar interações, reproduzir em vários dispositivos/idiomas e revisar gravações em vídeo das execuções de teste.

Exemplos de Prompts

Estas são perguntas reais que desenvolvedores fazem e que este skill foi projetado para responder:

1. "Meus testes de UI passam localmente no meu Mac, mas falham no CI. Como torná-los mais confiáveis?"

→ O skill mostra padrões de espera baseados em condições que funcionam em vários dispositivos/velocidades, eliminando diferenças de tempo no CI

2. "Meus testes usam sleep(2) e sleep(5), mas ainda são instáveis. Como substituir timeouts arbitrários por condições reais?"

→ O skill demonstra waitForExistence, XCTestExpectation e padrões de polling para carregamento de dados, requisições de rede e animações

3. "Acabei de gravar um teste usando a Gravação de Automação de UI do Xcode 26. Como revisar o vídeo e depurar falhas?"

→ O skill aborda fluxos de trabalho de Depuração por Vídeo para analisar gravações e encontrar a etapa exata onde os testes falham

4. "Meu teste está falhando no iPad, mas passando no iPhone. Como escrever testes que funcionem em todos os tamanhos de dispositivo?"

→ O skill explica estratégias de teste multifatorial e predicados independentes de dispositivo para testes robustos entre dispositivos

5. "Quero escrever testes que não sejam instáveis. Quais são os padrões críticos que preciso conhecer?"

→ Oskill fornece modelos de espera baseados em condições, padrões de acessibilidade em primeiro lugar e a árvore de decisão para uma arquitetura de teste confiável


Bandeiras Vermelhas — Problemas de Confiabilidade do Teste

Se você vir QUALQUER um destes, suspeite de problemas de tempo:

  • Testes passam localmente, falham no CI (diferenças de tempo)
  • Testes às vezes passam, às vezes falham (condições de corrida)
  • Testes usam sleep() ou Thread.sleep() (atrasos arbitrários)
  • Testes falham com "elemento de UI não encontrado" e depois passam na repetição
  • Execuções de teste longas (esperando pelos piores cenários)

Árvore de Decisão Rápida

Teste falhando?
├─ Elemento não encontrado?
│  └─ Use waitForExistence(timeout:) não sleep()
├─ Passa localmente, falha no CI?
│  └─ Substitua sleep() por polling de condição
├─ Animação causando problemas?
│  └─ Aguarde a conclusão da animação, não a desabilite
└─ Tempo de requisição de rede?
   └─ Use XCTestExpectation ou waitForExistence

Padrão Central: Espera Baseada em Condições

❌ ERRADO (Timeout Arbitrário):

func testButtonAppears() {
    app.buttons["Login"].tap()
    sleep(2)  // ❌ Adivinhando que leva 2 segundos
    XCTAssertTrue(app.buttons["Dashboard"].exists)
}

✅ CORRETO (Aguardar Condição):

func testButtonAppears() {
    app.buttons["Login"].tap()
    let dashboard = app.buttons["Dashboard"]
    XCTAssertTrue(dashboard.waitForExistence(timeout: 5))
}

Padrões Comuns de Teste de UI

Padrão 1: Aguardando Elementos

// Aguarda o elemento aparecer
func waitForElement(_ element: XCUIElement, timeout: TimeInterval = 5) -> Bool {
    return element.waitForExistence(timeout: timeout)
}

// Uso
XCTAssertTrue(waitForElement(app.buttons["Submit"]))

Padrão 2: Aguardando o Elemento Desaparecer

func waitForElementToDisappear(_ element: XCUIElement, timeout: TimeInterval = 5) -> Bool {
    let predicate = NSPredicate(format: "exists == false")
    let expectation = XCTNSPredicateExpectation(predicate: predicate, object: element)
    let result = XCTWaiter().wait(for: [expectation], timeout: timeout)
    return result == .completed
}

// Uso
XCTAssertTrue(waitForElementToDisappear(app.activityIndicators["Loading"]))

Padrão 3: Aguardando um Estado Específico

func waitForButton(_ button: XCUIElement, toBeEnabled enabled: Bool, timeout: TimeInterval = 5) -> Bool {
    let predicate = NSPredicate(format: "isEnabled == %@", NSNumber(value: enabled))
    let expectation = XCTNSPredicateExpectation(predicate: predicate, object: button)
    let result = XCTWaiter().wait(for: [expectation], timeout: timeout)
    return result == .completed
}

// Uso
let submitButton = app.buttons["Submit"]
XCTAssertTrue(waitForButton(submitButton, toBeEnabled: true))
submitButton.tap()

Padrão 4: Identificadores de Acessibilidade

Definir no aplicativo:

Button("Submit") {
    // ação
}
.accessibilityIdentifier("submitButton")

Usar nos testes:

func testSubmitButton() {
    let submitButton = app.buttons["submitButton"]  // Usa identificador, não rótulo
    XCTAssertTrue(submitButton.waitForExistence(timeout: 5))
    submitButton.tap()
}

Por quê: Identificadores de acessibilidade não mudam com localização, permanecem estáveis em atualizações de UI.

Padrão 5: Atrasos de Requisição de Rede

func testDataLoads() {
    app.buttons["Refresh"].tap()

    // Aguarda o indicador de carregamento desaparecer
    let loadingIndicator = app.activityIndicators["Loading"]
    XCTAssertTrue(waitForElementToDisappear(loadingIndicator, timeout: 10))

    // Agora verifica se os dados foram carregados
    XCTAssertTrue(app.cells.count > 0)
}

Padrão 6: Manipulação de Animação

func testAnimatedTransition() {
    app.buttons["Next"].tap()

    // Aguarda a visualização de destino aparecer
    let destinationView = app.otherElements["DestinationView"]
    XCTAssertTrue(destinationView.waitForExistence(timeout: 2))

    // Opcional: Aguarda um pouco mais para a animação se estabilizar
    // Apenas se absolutamente necessário
    RunLoop.current.run(until: Date(timeIntervalSinceNow: 0.3))
}

Checklist de Teste

Antes de Escrever Testes

  • Use identificadores de acessibilidade para todos os elementos interativos
  • Evite rótulos codificados (use identificadores)
  • Planeje atrasos de rede e animações
  • Escolha timeouts apropriados (2s para UI, 10s para rede)

Ao Escrever Testes

  • Use waitForExistence() não sleep()
  • Use predicados para condições complexas
  • Teste caminhos de sucesso e falha
  • Torne os testes independentes (podem executar em qualquer ordem)

Depois de Escrever Testes

  • Execute os testes 10 vezes localmente (detectar instabilidade)
  • Execute os testes no dispositivo compatível mais lento
  • Execute os testes no ambiente de CI
  • Verifique a duração do teste (se >30s por teste, otimize)

Dicas de Teste de UI do Xcode

Argumentos de Inicialização para Teste

func testExample() {
    let app = XCUIApplication()
    app.launchArguments = ["UI-Testing"]
    app.launch()
}

No código do aplicativo:

if ProcessInfo.processInfo.arguments.contains("UI-Testing") {
    // Usar dados mock, pular onboarding, etc.
}

Execução de Teste Mais Rápida

override func setUpWithError() throws {
    continueAfterFailure = false  // Parar no primeiro erro
}

Depurando Testes com Falha

func testExample() {
    // Tirar screenshot na falha
    addUIInterruptionMonitor(withDescription: "Alert") { alert in
        alert.buttons["OK"].tap()
        return true
    }

    // Imprimir hierarquia de elementos
    print(app.debugDescription)
}

Erros Comuns

❌ Usando sleep() para Tudo

sleep(5)  // ❌ Perde tempo se a operação for concluída em 1s

❌ Não Manipulando Animações

app.buttons["Next"].tap()
XCTAssertTrue(app.buttons["Back"].exists)  // ❌ Pode falhar durante a animação

❌ Rótulos de Texto Codificados

app.buttons["Submit"].tap()  // ❌ Quebra com localização

❌ Testes Dependentes Uns dos Outros

// ❌ O Teste 2 assume que o Teste 1 foi executado primeiro
func test1_Login() { /* ... */ }
func test2_ViewDashboard() { /* assume que está logado */ }

❌ Sem Estratégia de Timeout

element.waitForExistence(timeout: 100)  // ❌ Muito longo
element.waitForExistence(timeout: 0.1)  // ❌ Muito curto

Use timeouts apropriados:

  • Animações de UI: 2-3 segundos
  • Requisições de rede: 10 segundos
  • Operações complexas: 30 segundos no máximo

Impacto no Mundo Real

Antes (usando sleep()):

  • Suite de teste: 15 minutos (esperando pelo pior caso)
  • Testes instáveis: 20% de taxa de falha
  • Falhas de CI: 50% exigem repetição

Depois (espera baseada em condições):

  • Suite de teste: 5 minutos (espera apenas quando necessário)
  • Testes instáveis: <2% de taxa de falha
  • Falhas de CI: <5% exigem repetição

Insight chave Os testes terminam MAIS RÁPIDO E são mais confiáveis quando aguardam condições reais em vez de adivinhar tempos.


Gravação de Automação de UI

Visão Geral

NOVO no Xcode 26: Grave, reproduza e revise testes de automação de UI com gravações em vídeo.

Três Fases:

  1. Gravar — Capture interações (toques, deslizes, pressionamentos de botão de hardware) como código Swift
  2. Reproduzir — Execute em vários dispositivos, idiomas, regiões, orientações
  3. Revisar — Assista às gravações em vídeo, analise falhas, visualize sobreposições de elementos de UI

Plataformas Suportadas: iOS, iPadOS, macOS, watchOS, tvOS, axiom-visionOS (Projetado para iPad)

Como a Automação de UI Funciona

Princípios Chave:

  • A automação de UI interage com seu aplicativo como uma pessoa faria usando gestos e eventos de hardware
  • Executa completamente independente do seu aplicativo (modelos/dados do aplicativo não acessíveis diretamente)
  • Usa a estrutura de acessibilidade como tecnologia subjacente
  • Diz ao SO quais gestos executar, depois aguarda a conclusão sincronicamente, um por vez

Ações incluem:

  • Iniciar seu aplicativo
  • Interagir com botões e navegação
  • Definir estado do sistema (Modo Escuro, axiom-localization, etc.)
  • Definir localização simulada

Acessibilidade é a Base

Entendimento Crítico: A acessibilidade fornece informações diretamente à automação de UI.

O que a acessibilidade vê:

  • Tipos de elemento (botão, texto, imagem, etc.)
  • Rótulos (texto visível)
  • Valores (estado atual para caixas de seleção, etc.)
  • Quadros (posições do elemento)
  • Identificadores (identificadores de acessibilidade — NÃO localizados)

Melhor Prática: Ótima experiência de acessibilidade = ótima experiência de automação de UI.

Preparando Seu Aplicativo para Gravação

Passo 1: Adicione Identificadores de Acessibilidade

SwiftUI:

Button("Submit") {
    // ação
}
.accessibilityIdentifier("submitButton")

// Torne os identificadores específicos para a instância
List(landmarks) { landmark in
    LandmarkRow(landmark)
        .accessibilityIdentifier("landmark-\(landmark.id)")
}

UIKit:

let button = UIButton()
button.accessibilityIdentifier = "submitButton"

// Use índice para células de tabela
cell.accessibilityIdentifier = "cell-\(indexPath.row)"

Identificadores bons são:

  • ✅ Únicos em todo o aplicativo
  • ✅ Descritivos do conteúdo do elemento
  • ✅ Estáticos (não reagem a mudanças de conteúdo)
  • ✅ Não localizados (iguais em todos os idiomas)

Por que os identificadores importam:

  • Títulos/descrições podem mudar, os identificadores permanecem estáveis
  • Funcionam em strings localizadas
  • Identificam exclusivamente elementos com conteúdo dinâmico

Dica Profissional: Use o assistente de codificação do Xcode para adicionar identificadores:

Prompt: "Adicione identificadores de acessibilidade às partes relevantes desta visualização"

Passo 2: Revise a Acessibilidade com o Inspetor de Acessibilidade

Inicie o Inspetor de Acessibilidade:

  • Menu do Xcode → Open Developer Tool → Accessibility Inspector
  • Ou: Inicie pelo Spotlight

Recursos:

  1. Element Inspector — Lista valores de acessibilidade para qualquer visualização
  2. Property details — Clique no nome da propriedade para documentação
  3. Platform support — Funciona em todas as plataformas Apple

O que verificar:

  • Os elementos têm rótulos
  • Os elementos interativos têm tipos (botão, não apenas texto)
  • Valores definidos para elementos com estado (caixas de seleção, alternadores)
  • Identificadores definidos para elementos com conteúdo dinâmico/localizado

Referência de Código de Exemplo: Delivering an exceptional accessibility experience

Passo 3: Adicione um Alvo de Teste de UI

  1. Abra as configurações do projeto no Xcode
  2. Clique em "+" abaixo da lista de alvos
  3. Selecione UI Testing Bundle
  4. Clique em Finish

Resultado: Nova pasta de teste de UI com testes de modelo adicionados ao projeto.

Gravando Interações

Iniciando uma Gravação (Xcode 26)

  1. Abra o arquivo de origem do teste de UI
  2. Um popover aparece explicando como iniciar a gravação (apenas na primeira vez)
  3. Clique no botão "Start Recording" na margem do editor
  4. O Xcode compila e inicia o aplicativo no Simulador/dispositivo

Durante a Gravação:

  • Interaja com o aplicativo normalmente (toques, deslizes, entrada de texto, etc.)
  • O código representando as interações aparece no editor de origem em tempo real
  • A gravação é atualizada conforme você digita (por exemplo, entradas em campos de texto)

Parando a Gravação:

  • Clique no botão "Stop Run" no Xcode

Exemplo de Sessão de Gravação

func testCreateAustralianCollection() {
    let app = XCUIApplication()
    app.launch()

    // Tocar na aba "Collections" (gravado automaticamente)
    app.tabBars.buttons["Collections"].tap()

    // Tocar em "+" para adicionar nova coleção
    app.navigationBars.buttons["Add"].tap()

    // Tocar no botão "Edit"
    app.buttons["Edit"].tap()

    // Digitar o nome da coleção
    app.textFields.firstMatch.tap()
    app.textFields.firstMatch.typeText("Max's Australian Adventure")

    // Tocar em "Edit Landmarks"
    app.buttons["Edit Landmarks"].tap()

    // Adicionar landmarks
    app.tables.cells.containing(.staticText, identifier:"Great Barrier Reef").buttons["Add"].tap()
    app.tables.cells.containing(.staticText, identifier:"Uluru").buttons["Add"].tap()

    // Tocar na marca de seleção para salvar
    app.navigationBars.buttons["Done"].tap()
}

Revisando o Código Gravado

Após a gravação, revise e ajuste as consultas:

Múltiplas Opções: Cada linha tem um menu suspenso mostrando maneiras alternativas de endereçar o elemento.

Recomendações de Seleção:

  1. Para strings localizadas (texto, rótulos de botão): Escolha o identificador de acessibilidade se disponível
  2. Para visualizações aninhadas profundamente: Escolha a consulta mais curta (permanece resiliente à medida que o aplicativo muda)
  3. Para conteúdo dinâmico (carimbos de data/hora, temperatura): Use consulta genérica ou identificador

Exemplo:

// Opções gravadas para o campo de texto:
app.textFields["Collection Name"]              // ❌ Quebra se o rótulo for localizado
app.textFields["collectionNameField"]          // ✅ Usa identificador
app.textFields.element(boundBy: 0)             // ✅ Baseado em posição
app.textFields.firstMatch                      // ✅ Genérico, mais curto

Reproduzindo Testes em Vários Dispositivos e Idiomas

Benefícios da Reprodução Automatizada

Ganho Principal: Um teste gravado pode ser executado em muitos dispositivos e configurações.

O que muda entre execuções:

  • Dispositivo (iPhone, iPad, Apple Watch, etc.)
  • Idioma do sistema
  • Região
  • Orientação (retrato, paisagem)
  • Modo de exibição (Axiom se aplicável)

O que permanece igual:

  • As interações gravadas
  • As verificações nos testes
  • Os identificadores de acessibilidade

Como Funciona a Reprodução

O esquema de teste no Xcode define destinos de execução:

Destinos únicos vs. múltiplos:

Único Destino:

  1. Abra o esquema para seu alvo de teste
  2. Selecione um destino específico (ex: "My iPhone")
  3. Execute o teste

Múltiplos Destinos:

  1. Abra o esquema para seu alvo de teste
  2. Selecione "Múltiplos Destinos"
  3. Escolha os destinos (dispositivos/simuladores)
  4. O Xcode executa o teste em cada destino sequencialmente

Configuração:

  • Product → Scheme → Edit Scheme
  • Navegue para Test → Info
  • Adicione destinos na seção "Destinos"

Revisando Gravações de Teste com Vídeo

Acessando Gravações

  1. Execute testes de UI com vídeo
  2. Abra o Report Navigator (última aba no Navigator do Xcode)
  3. Selecione uma execução de teste — os vídeos são listados na seção Recording

Componentes da Gravação:

  • Tela do dispositivo em escala — tela cheia redimensionável com toques sobrepostos
  • Trilha do tempo — linha do tempo com marcadores para cada interação e ação de teste
  • Sobreposições de UI (opcional) — quadros e rótulos para elementos de acessibilidade à medida que aparecem
  • Ações — etapas gravadas lado a lado com a linha do tempo

Navegando nas Gravações

Navegação Básica:

  • Barra de espaço: Alternar reprodução/pausa
  • Setas para a esquerda/direita: Avançar/retroceder um quadro
  • Clique e arraste: Navegar na trilha do tempo

Filtragem:

  • Botão Issue Only: Mostrar apenas ações que resultaram em problemas
  • Botão Show/Hide Overlays: Alternar sobreposições de acessibilidade

Análise de Falhas

Foco principal: A vista de vídeo move-se automaticamente para o ponto de falha na linha do tempo.

Ações de depuração:

  1. Verifique o layout do elemento no momento da falha
  2. Verifique se sobreposições mostram elementos de acessibilidade corretos
  3. Navegue manualmente pelas ações antes da falha
  4. Compare com execuções bem-sucedidas para encontrar a diferença

Práticas Recomendadas

Para Gravação

  1. Prepare identificadores de acessibilidade primeiro — identifique elementos que serão endereçados
  2. Revise código gravado — otimize consultas, adicione verificações
  3. Adicione verificações explícitas — após gravar ações, adicione verificações para estados esperados
  4. Execute em múltiplos idiomas — garanta que funcione globalmente
  5. Não grave excessivamente — grave seções focadas, não fluxos inteiros de uma vez

Para Reprodução

  1. Use identificador, não string localizada — chaves para testes entre idiomas
  2. Teste em configurações representativas — inclua dispositivo mais lento, diferentes orientações
  3. Revise gravações de falha — o vídeo mostra exatamente o que aconteceu
  4. Monitore a duração do teste — gravações de vídeo adicionam tempo de execução

Boa Higiene de Acessibilidade

  • A boa acessibilidade é boa para testes de UI
  • Use Accessibility Inspector para verificar elementos
  • Identificadores devem ser estáveis, descritivos e não localizados
  • Elementos interativos devem ter tipos de acessibilidade

Próximos Passos

  1. Adicione identificadores de acessibilidade ao seu aplicativo
  2. Adicione testes de UI com espera baseada em condições
  3. Substitua sleep() existentes por waitForExistence
  4. Execute testes em vários dispositivos e idiomas
  5. Revise gravações para diagnosticar falhas
  6. Itere — refine identificadores e consultas para robustez

Lembre-se do princípio central: Aguarde condições, não timeouts arbitrários. Isso torna os testes mais rápidos E mais confiáveis.

Individual skills in this repo

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

ComeOnOliver/skillshub

Create stunning, animation-rich HTML presentations from scratch or by converting PowerPoint files. Use when the user wants to build a presentation, convert a PPT/PPTX to web, or create slides for a talk/pitch. Helps non-designers discover their aesthetic through visual exploration rather than abstract choices.

ComeOnOliver/skillshub

Next.js 16+ 和 Turbopack — 增量打包、文件系统缓存、开发速度,以及何时使用 Turbopack 与 webpack。

ComeOnOliver/skillshub

SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices.

ComeOnOliver/skillshub

See, Understand, Act on video and audio. See- ingest from local files, URLs, RTSP/live feeds, or live record desktop; return realtime context and playable stream links. Understand- extract frames, build visual/semantic/temporal indexes, and search moments with timestamps and auto-clips. Act- transcode and normalize (codec, fps, resolution, aspect ratio), perform timeline edits (subtitles, text/image overlays, branding, audio overlays, dubbing, translation), generate media assets (image, audio, video), and create real time alerts for events from live streams or desktop capture.

ComeOnOliver/skillshub

AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content.

ComeOnOliver/skillshub

Next.js 15 애플리케이션을 위한 프론트엔드 개발 가이드라인. React 19, TypeScript, Shadcn/ui, Tailwind CSS를 사용한 모던 패턴. Server Components, Client Components, App Router, 파일 구조, Shadcn/ui 컴포넌트, 성능 최적화, TypeScript 모범 사례 포함. 컴포넌트, 페이지, 기능 생성, 데이터 페칭, 스타일링, 라우팅, 프론트엔드 코드 작업 시 사용.

ComeOnOliver/skillshub

Provides Tamagui patterns for config v4, compiler optimization, styled context, and cross-platform styling. Must use when working with Tamagui projects (tamagui.config.ts, @tamagui imports).

ComeOnOliver/skillshub

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

ComeOnOliver/skillshub

Create high-converting, visually distinctive landing pages. Use when building marketing pages, product launches, SaaS homepages, or any single-page conversion-focused website. Guides section-by-section composition with anti-AI-slop principles.

ComeOnOliver/skillshub

Auto-loaded context for Portfolio Buddy 2 development. Use for ANY task involving: React 19 development, TypeScript, portfolio analysis features, metrics calculations, trading strategy comparison, or working with the Portfolio Buddy 2 codebase. Contains tech stack, known issues, and architectural constraints.

ComeOnOliver/skillshub

Next.js development tooling via MCP. Inspect routes, components, build info, and debug Next.js apps. Use when working on Next.js applications, debugging routing, or inspecting app structure. NOT for general React or non-Next.js projects.

ComeOnOliver/skillshub

Implement UI using Shadcn MCP (atoms/theme) and 21st.dev MCP (complex sections). Use when adding buttons, layouts, or generating landing pages.

ComeOnOliver/skillshub

A conceptual skill for building an API client in Next.js that handles JWT tokens

ComeOnOliver/skillshub

Best practices and patterns for Next.js App Router, Server Actions, and Routing in this project.

ComeOnOliver/skillshub

The Design System, Theme, and UX rules for the Physical AI Hub.

ComeOnOliver/skillshub

Comprehensive frontend development skill for building modern, performant web applications using ReactJS, NextJS, TypeScript, Tailwind CSS. Includes component scaffolding, performance optimization, bundle analysis, and UI best practices. Use when developing frontend features, optimizing performance, implementing UI/UX designs, managing state, or reviewing frontend code.

ComeOnOliver/skillshub

This document captures learnings from fixing keyboard navigation issues when floating components (Select, DropdownMenu, Popover) have CSS open/close animations.

ComeOnOliver/skillshub

Build Next.js 16 applications with correct patterns and distinctive design. Use when creating pages, layouts, dynamic routes, upgrading from Next.js 15, or implementing proxy.ts. Covers breaking changes (async params/searchParams, Turbopack, cacheComponents) and frontend aesthetics. NOT when building non-React or backend-only applications.

ComeOnOliver/skillshub

Comprehensive Framer Motion animation library for React. Covers motion components, variants, gestures, page transitions, and scroll animations. Use when adding animations to React/Next.js applications.

ComeOnOliver/skillshub

Build interfaces that resonate, not just render. This skill enforces bold, intentional

Habilidades Relacionadas