Communitygithub.com

xzedm/clipplic-landing

Diretrizes de Design da Plataforma Android — Material Design 3. Use ao construir apps Android com Jetpack Compose ou layouts XML, implementando Material You, navegação ou acessibilidade.

O que é clipplic-landing?

Esta skill fornece as diretrizes completas de design da plataforma Android, focadas no Material Design 3 e no Material You. Ela serve como um guia de referência para desenvolvedores que estão criando aplicativos Android nativos, seja com Jetpack Compose ou XML. A skill aborda tópicos críticos como cores dinâmicas, papéis de cores semânticas, temas claro e escuro, navegação adaptativa (barra inferior, trilho de navegação, gaveta), layout responsivo com classes de tamanho de janela, tipografia, ícones, superfícies e elevação, animações e acessibilidade. Baseia-se na documentação oficial do Material Design 3 e do Android, garantindo que os aplicativos sigam as melhores práticas da plataforma, com suporte a dispositivos Android 12+ e versões anteriores. É útil para garantir conformidade com o Material Design, implementação consistente de UI e experiência do usuário otimizada.

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

Perguntar na sua IA favorita

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

Documentação

Diretrizes de Design da Plataforma Android — Material Design 3

1. Material You & Tematização [CRÍTICO]

1.1 Cor Dinâmica

Ative a cor dinâmica derivada do papel de parede do usuário. A cor dinâmica é o padrão no Android 12+ e deve ser a estratégia principal de tematização.

// Compose: Tema de cor dinâmica
@Composable
fun AppTheme(
    darkTheme: Boolean = isSystemInDarkTheme(),
    dynamicColor: Boolean = true,
    content: @Composable () -> Unit
) {
    val colorScheme = when {
        dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
            val context = LocalContext.current
            if (darkTheme) dynamicDarkColorScheme(context)
            else dynamicLightColorScheme(context)
        }
        darkTheme -> darkColorScheme()
        else -> lightColorScheme()
    }
    MaterialTheme(
        colorScheme = colorScheme,
        typography = AppTypography,
        content = content
    )
}
<!-- XML: Cor dinâmica em themes.xml -->
<style name="Theme.App" parent="Theme.Material3.DayNight.NoActionBar">
    <item name="dynamicColorThemeOverlay">@style/ThemeOverlay.Material3.DynamicColors.DayNight</item>
</style>

Regras:

  • R1.1: Sempre forneça um esquema de cores estático de fallback para dispositivos anteriores ao Android 12.
  • R1.2: Nunca codifique valores hexadecimais de cores em componentes. Sempre referencie papéis de cores do tema.
  • R1.3: Teste com pelo menos 3 papéis de parede diferentes para verificar a harmonia das cores dinâmicas.

1.2 Papéis de Cores

O Material 3 define um conjunto estruturado de papéis de cores. Use-os semanticamente, não esteticamente.

PapelUsoOn-Papel
primaryAções principais, estados ativos, FABonPrimary
primaryContainerElementos primários menos proeminentesonPrimaryContainer
secondaryUI de suporte, chips de filtroonSecondary
secondaryContainerIndicador ativo da barra de navegaçãoonSecondaryContainer
tertiaryAcento, contraste, complementaronTertiary
tertiaryContainerCampos de entrada, acentos menos proeminentesonTertiaryContainer
surfaceFundos, cartões, folhasonSurface
surfaceVariantElementos decorativos, divisoresonSurfaceVariant
errorEstados de erro, ações destrutivasonError
errorContainerFundos de erroonErrorContainer
outlineBordas, divisores—
outlineVariantBordas sutis—
inverseSurfaceFundo do SnackbarinverseOnSurface
// Correto: papéis de cores semânticas
Text(
    text = "Mensagem de erro",
    color = MaterialTheme.colorScheme.error
)
Surface(color = MaterialTheme.colorScheme.errorContainer) {
    Text(text = "Detalhe do erro", color = MaterialTheme.colorScheme.onErrorContainer)
}

// ERRADO: cores codificadas
Text(text = "Erro", color = Color(0xFFB00020)) // Anti-padrão

Regras:

  • R1.4: Cada elemento de primeiro plano deve usar o papel de cor on correspondente ao seu fundo (ex.: texto onPrimary no fundo primary).
  • R1.5: Use surface e suas variantes para fundos. Nunca use primary ou secondary como grandes áreas de fundo.
  • R1.6: Use tertiary com moderação, apenas para acento e contraste complementar.

1.3 Temas Claro e Escuro

Suporte ambos os temas claro e escuro. Respeite a configuração do sistema por padrão.

// Compose: Detectar tema do sistema
val darkTheme = isSystemInDarkTheme()

Regras:

  • R1.7: Sempre suporte ambos os temas claro e escuro. Nunca lance apenas o claro.
  • R1.8: Superfícies do tema escuro usam mapeamento tonal baseado em elevação, não preto puro (#000000). Use os papéis de cor surface que lidam com isso automaticamente.
  • R1.9: Forneça uma substituição manual de tema nas configurações do app (Sistema / Claro / Escuro).

1.4 Sementes de Cores Personalizadas

Quando a marca exigir cores personalizadas, forneça uma cor semente e gere paletas tonais usando o Material Theme Builder.

// Esquema de cores personalizado com semente da marca
private val BrandLightColorScheme = lightColorScheme(
    primary = Color(0xFF1B6D2F),
    onPrimary = Color(0xFFFFFFFF),
    primaryContainer = Color(0xFFA4F6A8),
    onPrimaryContainer = Color(0xFF002107),
    // ... gere a paleta completa a partir da semente
)

Regras:

  • R1.10: Gere paletas tonais a partir de cores semente usando o Material Theme Builder. Nunca escolha tons individuais manualmente.
  • R1.11: Ao usar cores personalizadas, ainda suporte a cor dinâmica como padrão e use as cores personalizadas como fallback.

2. Navegação [CRÍTICO]

2.1 Barra de Navegação (Inferior)

O padrão de navegação principal para telefones com 3-5 destinos de nível superior.

// Compose: Barra de Navegação
NavigationBar {
    items.forEachIndexed { index, item ->
        NavigationBarItem(
            icon = {
                Icon(
                    imageVector = if (selectedItem == index) item.filledIcon else item.outlinedIcon,
                    contentDescription = item.label
                )
            },
            label = { Text(item.label) },
            selected = selectedItem == index,
            onClick = { selectedItem = index }
        )
    }
}

Regras:

  • R2.1: Use a Barra de Navegação para 3-5 destinos de nível superior em telas compactas. Nunca use para menos de 3 ou mais de 5.
  • R2.2: Sempre mostre rótulos nos itens da barra de navegação. Barras de navegação apenas com ícones não são permitidas.
  • R2.3: Use ícones preenchidos para o estado selecionado e ícones contornados para estados não selecionados.
  • R2.4: O indicador ativo usa a cor secondaryContainer. Não substitua isso.

2.2 Trilho de Navegação

Para telas médias e expandidas (tablets, dobráveis, desktop).

// Compose: Trilho de Navegação para telas maiores
NavigationRail(
    header = {
        FloatingActionButton(
            onClick = { /* ação principal */ },
            containerColor = MaterialTheme.colorScheme.tertiaryContainer
        ) {
            Icon(Icons.Default.Add, contentDescription = "Criar")
        }
    }
) {
    items.forEachIndexed { index, item ->
        NavigationRailItem(
            icon = { Icon(item.icon, contentDescription = item.label) },
            label = { Text(item.label) },
            selected = selectedItem == index,
            onClick = { selectedItem = index }
        )
    }
}

Regras:

  • R2.5: Use o Trilho de Navegação em tamanhos de janela médios (600-839dp) e expandidos (840dp+). Combine-o com a Barra de Navegação no compacto.
  • R2.6: Opcionalmente, inclua um FAB no cabeçalho do trilho para a ação principal.
  • R2.7: Rótulos são opcionais no trilho, mas recomendados para clareza.

2.3 Gaveta de Navegação

Para 5+ destinos ou hierarquias de navegação complexas, tipicamente em telas expandidas.

// Compose: Gaveta de Navegação Permanente para telas grandes
PermanentNavigationDrawer(
    drawerContent = {
        PermanentDrawerSheet {
            Text("Nome do App", modifier = Modifier.padding(16.dp),
                 style = MaterialTheme.typography.titleMedium)
            HorizontalDivider()
            items.forEach { item ->
                NavigationDrawerItem(
                    label = { Text(item.label) },
                    selected = item == selectedItem,
                    onClick = { selectedItem = item },
                    icon = { Icon(item.icon, contentDescription = null) }
                )
            }
        }
    }
) {
    Scaffold { /* conteúdo da página */ }
}

Regras:

  • R2.8: Use a gaveta modal em telas compactas, gaveta permanente em telas expandidas.
  • R2.9: Agrupe itens da gaveta em seções com divisores e cabeçalhos de seção.

2.4 Gestão de Volta Preditiva

Android 13+ suporta volta preditiva com uma animação de pré-visualização.

// Compose: Volta preditiva com BackHandler (androidx.activity.compose)
BackHandler(enabled = true) {
    // Chamado quando a volta é confirmada; navegue de volta no seu controlador de navegação
    navController.popBackStack()
}
// Compose: Animação de progresso da volta preditiva usando o modificador predictiveBackHandler
// (androidx.activity:activity-compose 1.8+)
Modifier.predictiveBackHandler(enabled = true) { progress ->
    // progress é um Flow<BackEventCompat> com x, y, swipeEdge, progress (0.0–1.0)
    progress.collect { backEvent ->
        animationState = backEvent.progress
    }
}
<!-- AndroidManifest.xml: optar pela volta preditiva -->
<application android:enableOnBackInvokedCallback="true">

Regras:

  • R2.10: Opte pela volta preditiva no manifesto. Em apps Compose, use BackHandler (de androidx.activity.compose) para interceptar eventos de volta. Em apps baseados em View, implemente OnBackInvokedCallback (API 33+) ou OnBackPressedCallback (AndroidX) em vez de substituir onBackPressed().
  • R2.11: O gesto de volta do sistema navega para trás na pilha de navegação. O botão Acima (seta da barra de ferramentas) navega para cima na hierarquia do app. Eles podem diferir.
  • R2.12: Nunca intercepte a volta do sistema para mostrar diálogos "tem certeza?", a menos que haja entrada de usuário não salva.
  • R2.13: Não suprima a animação de pré-visualização de volta fornecida pelo sistema. Se você implementar transições de entrada/saída personalizadas, interpole-as usando BackEventCompat.progress (0.0–1.0) e respeite BackEventCompat.swipeEdge (EDGE_LEFT/EDGE_RIGHT) para que a tela de saída seja reduzida e deslocada em direção à borda de início, correspondendo à animação do sistema.
  • R2.14: Prefira reconhecimento em vez de recall. Mantenha os destinos rotulados, o estado selecionado visível e o contexto da pilha de retorno preservado para que os usuários não tenham que reconstruir onde estão após cada etapa de navegação.
// Compose: conduzir uma animação personalizada a partir do progresso da volta preditiva
Modifier.predictiveBackHandler(enabled = true) { progress ->
    progress.collect { backEvent ->
        // backEvent.progress: 0.0 (início do gesto) → 1.0 (confirmado)
        // backEvent.swipeEdge: BackEventCompat.EDGE_LEFT ou EDGE_RIGHT
        exitScale = 1f - (backEvent.progress * 0.1f)
        exitOffsetX = if (backEvent.swipeEdge == BackEventCompat.EDGE_LEFT) -backEvent.progress * 32.dp.toPx() else backEvent.progress * 32.dp.toPx()
    }
}

2.5 Seleção do Componente de Navegação

Tamanho da Tela3-5 Destinos5+ Destinos
Compacto (< 600dp)Barra de NavegaçãoGaveta Modal + Barra de Navegação
Médio (600-839dp)Trilho de NavegaçãoGaveta Modal + Trilho de Navegação
Expandido (840dp+)Trilho de NavegaçãoGaveta Permanente

3. Layout & Responsividade [ALTA]

3.1 Classes de Tamanho de Janela

Use classes de tamanho de janela para layouts adaptativos, não pontos de interrupção de pixel brutos.

// Compose: Classes de tamanho de janela
val windowSizeClass = calculateWindowSizeClass(this)
when (windowSizeClass.widthSizeClass) {
    WindowWidthSizeClass.Compact -> CompactLayout()
    WindowWidthSizeClass.Medium -> MediumLayout()
    WindowWidthSizeClass.Expanded -> ExpandedLayout()
}
ClasseLarguraDispositivo TípicoColunas
Compacto< 600dpTelefone retrato4
Médio600-839dpTablet retrato, dobrável8
Expandido840dp+Tablet paisagem, desktop12

Regras:

  • R3.1: Sempre use WindowSizeClass de material3-window-size-class para decisões de layout responsivo.
  • R3.2: Nunca use pontos de interrupção de pixel fixos. As categorias de dispositivos são fluidas.
  • R3.3: Suporte todas as três classes de tamanho de largura. No mínimo, compacto e expandido.

3.2 Grade Material

Aplique margens e medianiz canônicas da grade Material.

Classe de TamanhoMargensMedianizColunas
Compacto16dp8dp4
Médio24dp16dp8
Expandido24dp24dp12

Regras:

  • R3.4: O conteúdo não deve ocupar toda a largura em telas expandidas. Use uma largura máxima de conteúdo de ~840dp ou layout de lista-detalhe.
  • R3.5: Aplique margens horizontais consistentes correspondendo à especificação da grade.

3.3 Exibição Borda a Borda

Android 15+ exige borda a borda. Todos os apps devem desenhar atrás das barras do sistema.

// Compose: Configuração borda a borda
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        enableEdgeToEdge()
        super.onCreate(savedInstanceState)
        setContent {
            Scaffold(
                modifier = Modifier.fillMaxSize(),
                // Scaffold lida com insets para barras superior/inferior automaticamente
            ) { innerPadding ->
                Content(modifier = Modifier.padding(innerPadding))
            }
        }
    }
}

Regras:

  • R3.6: Chame enableEdgeToEdge() antes de setContent. Desenhe atrás da barra de status e da barra de navegação.
  • R3.7: Use WindowInsets para preencher o conteúdo longe das barras do sistema. Scaffold lida com isso para o conteúdo da barra superior e inferior automaticamente.
  • R3.8: O conteúdo rolável deve rolar atrás das barras do sistema transparentes com preenchimento de insets apropriado no topo e na base da lista.

3.4 Suporte a Dispositivos Dobráveis

// Compose: Detectar postura de dobra
val foldingFeatures = WindowInfoTracker.getOrCreate(context)
    .windowLayoutInfo(context)
    .collectAsState(initial = WindowLayoutInfo(emptyList()))

Regras:

  • R3.9: Detecte a posição da dobradiça/dobra e evite colocar conteúdo crítico através da dobra.
  • R3.10: Use ListDetailPaneScaffold ou SupportingPaneScaffold da biblioteca adaptativa Material3 para layouts cientes de dobra.

4. Tipografia [ALTA]

4.1 Escala de Tipo Material

PapelTamanho PadrãoPeso PadrãoUso
displayLarge57sp400Texto herói, integração
displayMedium45sp400Texto de recurso grande
displaySmall36sp400Exibição proeminente
headlineLarge32sp400Títulos de tela
headlineMedium28sp400Cabeçalhos de seção
headlineSmall24sp400Títulos de cartão
titleLarge22sp400Título da barra de aplicativo superior
titleMedium16sp500Abas, navegação
titleSmall14sp500Subtítulos
bodyLarge16sp400Texto do corpo principal
bodyMedium14sp400Texto do corpo secundário
bodySmall12sp400Legendas
labelLarge14sp500Botões, rótulos proeminentes
labelMedium12sp500Chips, metadados
labelSmall11sp500Rótulos de componentes pequenos

Regras:

  • R4.1: Defina Typography personalizada uma vez no tema do seu app. Personalize com base na face de fonte da sua marca.
// Exemplo de tipografia personalizada
val AppTypography = Typography(
    displayLarge = TextStyle(fontFamily = FontFamily.Default, fontWeight = FontWeight.Normal),
    headlineLarge = TextStyle(fontFamily = FontFamily.Default, fontWeight = FontWeight.Bold),
    bodyLarge = TextStyle(fontFamily = FontFamily.Default, fontWeight = FontWeight.Normal),
    labelLarge = TextStyle(fontFamily = FontFamily.Default, fontWeight = FontWeight.Medium)
)
  • R4.2: Use lineHeight da tipografia (o Material 3 define automaticamente lineHeight como 1.0×, 1.25× ou 1.5× dependendo do papel).
  • R4.3: Não use fontes diferentes para tamanhos diferentes da mesma face de fonte. Escolha uma face e varie o peso.

5. Ícones [ALTA]

5.1 Ícones de Material

Use ícones preenchidos e contornados consistentemente.

UsoEstadoForma do Ícone
Barra de navegação, itens de gavetaSelecionadoPreenchido
Barra de navegação, itens de gavetaNão selecionadoContornado
Ações em AppBarsQualquerContornado
Ações FABQualquerPreenchido

Regras:

  • R5.1: Use ícones de Material Design do pacote material-icons-core ou extensões. Use ícones SVG (vector drawable) para ícones personalizados.
  • R5.2: Ícones decorativos (sem ação) devem ser marcados como contentDescription = null para acessibilidade.
  • R5.3: Sempre forneça contentDescription para ícones interativos.

6. Superfícies & Elevação [MÉDIA]

6.1 Efeitos de Elevação e Sombra

Os componentes do Material 3 usam sombras para indicar elevação. Use Card, ElevatedButton, Surface em vez de sombras manuais.

// Compose: Níveis de elevação do Material 3
Surface(
    tonalElevation = 3.dp, // Elevação para o nível 3
    shadowElevation = 1.dp
) {
    Text("Conteúdo")
}

Regras:

  • R6.1: Use Surface com tonalElevation em vez de elevation diretamente. As cores de superfície mudam com a elevação no modo escuro.
  • R6.2: Ajuste a elevação com base nos níveis de elevação do Material 3: 0 (plano), 1 (card/botão), 2 (gaveta/folha), 3 (caixa de diálogo/Snackbar), 4 (FAB), 5 (barra de aplicativo).

7. Animações [MÉDIA]

7.1 Animações Preditivas de Volta

Veja a Seção 2.4 acima.

7.2 Animação de Tema

// Compose: Animação suave de tema
AnimatedContent(
    targetState = currentTheme,
    transitionSpec = {
        if (targetState == Theme.Dark) {
            fadeIn() with fadeOut()
        } else {
            fadeIn() with fadeOut()
        }
    }
) { theme ->
    WhenTheme(theme)
}

Regras:

  • R7.1: Use animateFloatAsState ou AnimatedVisibility para animar alterações em elementos de UI.
  • R7.2: Animações padrão de componentes são fornecidas pelo Material 3. Não as substitua, a menos que seja necessário para a marca.
  • R7.3: Use FadeThrough para transições entre ícones.

8. Acessibilidade [ALTA]

8.1 Meta de Toque

Todos os alvos de toque devem ter pelo menos 48dp × 48dp.

// Compose: Tamanho mínimo de toque
Modifier.minimumInteractiveComponentSize() // 48dp

Regras:

  • R8.1: Garanta que todos os elementos interativos cumpram a meta de toque de 48dp.
  • R8.2: Use Modifier.minimumInteractiveComponentSize para componentes que não atingem o tamanho mínimo.
  • R8.3: Forneça espaço suficiente entre alvos de toque adjacentes (8dp+).

8.2 Contraste de Cores

**Regras:**
- R8.4: Garanta que as taxas de contraste de cores cumpram os padrões WCAG AA (4.5:1 para texto normal, 3:1 para texto grande).
- R8.5: Teste com o verificador de contraste do Android Studio. Verifique tanto os modos claro quanto escuro.

8.3 Navegação por Leitor de Tela

// Compose: Acessibilidade
Icon(
    painter = painterResource(id = R.drawable.ic_edit),
    contentDescription = "Editar perfil" // texto descritivo para TalkBack
)

Regras:

  • R8.6: Todos os ícones interativos devem ter contentDescription.
  • R8.7: Imagens decorativas devem ter contentDescription = null.
  • R8.8: Use SemanticsModifier (ex.: semantics { role = Role.Button }) para mapear elementos de UI para funções de acessibilidade apropriadas.

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

Apple's approach to interface design and fluid, physical motion, translated for the web. Use when building or reviewing gesture-driven UI, spring animations, drag/swipe/sheet interactions, momentum and interruptible transitions, translucent materials and depth, typography (optical sizing, tracking, leading), reduced-motion, or the design foundations (feedback, spatial consistency, restraint) behind Apple-style interfaces.

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