Communitygithub.com

xzedm/clipplic-landing

Directives Material Design 3 et plateforme Android. À utiliser lors du développement d'applications Android avec Jetpack Compose ou XML, de l'implémentation de Material You, de la navigation ou de l'accessibilité.

Qu'est-ce que clipplic-landing ?

Ce skill (compétence) fournit un guide complet et normatif pour implémenter Material Design 3 (Material You) dans les applications Android. Il couvre de manière exhaustive la thématisation dynamique des couleurs, les rôles de couleurs sémantiques, les thèmes clair et sombre, ainsi que la gestion des couleurs personnalisées. En matière de navigation, le skill détaille la barre de navigation (bottom bar), le rail de navigation, le tiroir de navigation et la gestion du geste de retour prédictif d'Android 13+, avec des règles strictes sur leur sélection en fonction de la taille de l'écran (classes de taille). Il aborde également la mise en page adaptative avec les classes de taille de fenêtre, la grille Material, l'affichage edge-to-edge obligatoire sur Android 15+, et le support des appareils pliables. Enfin, il définit les échelles typographiques Material et les composants essentiels comme les boutons, les cartes, les dialogues, les champs de texte et l'accessibilité (cibles tactiles, contraste, lecteur d'écran). Ce skill est critique pour les développeurs utilisant Jetpack Compose ou les layouts XML, et son objectif est de garantir une conformité totale avec les directives de conception Android et une expérience utilisateur cohérente et moderne.

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

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Directives de conception de la plateforme Android — Material Design 3

1. Material You et Thématisation [CRITIQUE]

1.1 Couleur dynamique

Activez la couleur dynamique dérivée du fond d'écran de l'utilisateur. La couleur dynamique est la stratégie de thématisation par défaut sur Android 12+.

// Compose : Thème couleur dynamique
@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 : Couleur dynamique dans themes.xml -->
<style name="Theme.App" parent="Theme.Material3.DayNight.NoActionBar">
    <item name="dynamicColorThemeOverlay">@style/ThemeOverlay.Material3.DynamicColors.DayNight</item>
</style>

Règles :

  • R1.1 : Fournissez toujours un jeu de couleurs statique de secours pour les appareils antérieurs à Android 12.
  • R1.2 : Ne codez jamais en dur les valeurs hexadécimales des couleurs dans les composants. Référencez toujours les rôles de couleurs du thème.
  • R1.3 : Testez avec au moins 3 fonds d'écran différents pour vérifier l'harmonie des couleurs dynamiques.

1.2 Rôles des couleurs

Material 3 définit un ensemble structuré de rôles de couleurs. Utilisez-les de manière sémantique, pas esthétique.

RôleUtilisationSur le rôle
primaryActions clés, états actifs, FABonPrimary
primaryContainerÉléments primaires moins importantsonPrimaryContainer
secondaryInterface de support, chips de filtreonSecondary
secondaryContainerIndicateur actif de la barre de navigationonSecondaryContainer
tertiaryAccent, contraste, complémentaireonTertiary
tertiaryContainerChamps de saisie, accents moins importantsonTertiaryContainer
surfaceArrière-plans, cartes, feuillesonSurface
surfaceVariantÉléments décoratifs, séparateursonSurfaceVariant
errorÉtats d'erreur, actions destructricesonError
errorContainerArrière-plans d'erreuronErrorContainer
outlineBordures, séparateurs—
outlineVariantBordures subtiles—
inverseSurfaceArrière-plan du SnackbarinverseOnSurface
// Correct : rôles de couleurs sémantiques
Text(
    text = "Message d'erreur",
    color = MaterialTheme.colorScheme.error
)
Surface(color = MaterialTheme.colorScheme.errorContainer) {
    Text(text = "Détail de l'erreur", color = MaterialTheme.colorScheme.onErrorContainer)
}

// ERRONÉ : couleurs codées en dur
Text(text = "Erreur", color = Color(0xFFB00020)) // Anti-patron

Règles :

  • R1.4 : Chaque élément de premier plan doit utiliser le rôle de couleur « on » correspondant à son arrière-plan (par exemple, texte onPrimary sur fond primary).
  • R1.5 : Utilisez surface et ses variantes pour les arrière-plans. N'utilisez jamais primary ou secondary comme grandes zones d'arrière-plan.
  • R1.6 : Utilisez tertiary avec parcimonie, uniquement pour l'accentuation et le contraste complémentaire.

1.3 Thèmes clair et sombre

Prenez en charge les thèmes clair et sombre. Respectez le réglage système par défaut.

// Compose : Détection du thème système
val darkTheme = isSystemInDarkTheme()

Règles :

  • R1.7 : Prenez toujours en charge les thèmes clair et sombre. Ne publiez jamais une application en mode clair uniquement.
  • R1.8 : Les surfaces du thème sombre utilisent un mappage tonal basé sur l'élévation, pas du noir pur (#000000). Utilisez les rôles de couleur surface qui gèrent cela automatiquement.
  • R1.9 : Fournissez une option de remplacement manuel du thème dans les paramètres de l'application (Système / Clair / Sombre).

1.4 Couleurs personnalisées à partir d'une graine

Lorsque l'image de marque nécessite des couleurs personnalisées, fournissez une couleur de graine et générez des palettes tonales à l'aide de Material Theme Builder.

// Jeu de couleurs personnalisé avec une graine de marque
private val BrandLightColorScheme = lightColorScheme(
    primary = Color(0xFF1B6D2F),
    onPrimary = Color(0xFFFFFFFF),
    primaryContainer = Color(0xFFA4F6A8),
    onPrimaryContainer = Color(0xFF002107),
    // ... générer la palette complète à partir de la graine
)

Règles :

  • R1.10 : Générez les palettes tonales à partir de couleurs de graine à l'aide de Material Theme Builder. Ne sélectionnez jamais manuellement des teintes individuelles.
  • R1.11 : Lorsque vous utilisez des couleurs personnalisées, prenez toujours en charge la couleur dynamique par défaut et utilisez les couleurs personnalisées comme solution de secours.

2. Navigation [CRITIQUE]

2.1 Barre de navigation (en bas)

Le modèle de navigation principal pour les téléphones avec 3 à 5 destinations de premier niveau.

// Compose : Barre de navigation
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 }
        )
    }
}

Règles :

  • R2.1 : Utilisez la barre de navigation pour 3 à 5 destinations de premier niveau sur les écrans compacts. Ne l'utilisez jamais pour moins de 3 ou plus de 5 destinations.
  • R2.2 : Affichez toujours les libellés sur les éléments de la barre de navigation. Les barres de navigation avec uniquement des icônes ne sont pas autorisées.
  • R2.3 : Utilisez des icônes pleines pour l'état sélectionné et des icônes avec contour pour les états non sélectionnés.
  • R2.4 : L'indicateur actif utilise la couleur secondaryContainer. Ne modifiez pas cela.

2.2 Rail de navigation

Pour les écrans moyens et larges (tablettes, pliables, bureau).

// Compose : Rail de navigation pour les grands écrans
NavigationRail(
    header = {
        FloatingActionButton(
            onClick = { /* action principale */ },
            containerColor = MaterialTheme.colorScheme.tertiaryContainer
        ) {
            Icon(Icons.Default.Add, contentDescription = "Créer")
        }
    }
) {
    items.forEachIndexed { index, item ->
        NavigationRailItem(
            icon = { Icon(item.icon, contentDescription = item.label) },
            label = { Text(item.label) },
            selected = selectedItem == index,
            onClick = { selectedItem = index }
        )
    }
}

Règles :

  • R2.5 : Utilisez le rail de navigation sur les fenêtres de taille moyenne (600-839dp) et large (840dp+). Associez-le à la barre de navigation sur les fenêtres compactes.
  • R2.6 : Incluez éventuellement un FAB dans l'en-tête du rail pour l'action principale.
  • R2.7 : Les libellés sont facultatifs sur le rail mais recommandés pour plus de clarté.

2.3 Tiroir de navigation

Pour 5 destinations ou plus, ou des hiérarchies de navigation complexes, généralement sur les écrans larges.

// Compose : Tiroir de navigation permanent pour les grands écrans
PermanentNavigationDrawer(
    drawerContent = {
        PermanentDrawerSheet {
            Text("Nom de l'application", 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 { /* contenu de la page */ }
}

Règles :

  • R2.8 : Utilisez le tiroir modal sur les écrans compacts et le tiroir permanent sur les écrans larges.
  • R2.9 : Regroupez les éléments du tiroir en sections avec des séparateurs et des en-têtes de section.

2.4 Geste de retour prédictif

Android 13+ prend en charge le retour prédictif avec un aperçu animé.

// Compose : Retour prédictif avec BackHandler (androidx.activity.compose)
BackHandler(enabled = true) {
    // Appelé lorsque le retour est confirmé ; naviguez vers l'arrière dans votre contrôleur de navigation
    navController.popBackStack()
}
// Compose : Animation de progression du retour prédictif à l'aide du modificateur predictiveBackHandler
// (androidx.activity:activity-compose 1.8+)
Modifier.predictiveBackHandler(enabled = true) { progress ->
    // progress est un Flow<BackEventCompat> avec x, y, swipeEdge, progress (0.0–1.0)
    progress.collect { backEvent ->
        animationState = backEvent.progress
    }
}
<!-- AndroidManifest.xml : opt-in pour le retour prédictif -->
<application android:enableOnBackInvokedCallback="true">

Règles :

  • R2.10 : Optez pour le retour prédictif dans le manifeste. Dans les applications Compose, utilisez BackHandler (de androidx.activity.compose) pour intercepter les événements de retour. Dans les applications View, implémentez OnBackInvokedCallback (API 33+) ou OnBackPressedCallback (AndroidX) au lieu de surcharger onBackPressed().
  • R2.11 : Le geste de retour système navigue vers l'arrière dans la pile de navigation. Le bouton Haut (flèche de la barre d'outils) navigue vers le haut dans la hiérarchie de l'application. Ceux-ci peuvent différer.
  • R2.12 : N'interceptez jamais le retour système pour afficher des boîtes de dialogue « êtes-vous sûr ? » sauf en cas de saisie utilisateur non enregistrée.
  • R2.13 : Ne supprimez pas l'animation d'aperçu de retour fournie par le système. Si vous implémentez des transitions d'entrée/sortie personnalisées, interpolez-les à l'aide de BackEventCompat.progress (0.0–1.0) et respectez BackEventCompat.swipeEdge (EDGE_LEFT/EDGE_RIGHT) afin que l'écran de sortie se réduise et se déplace vers le bord initiateur, correspondant à l'animation système.
  • R2.14 : Préférez la reconnaissance au rappel. Gardez les destinations étiquetées, l'état sélectionné visible et le contexte de la pile de retour préservé afin que les utilisateurs n'aient pas à reconstruire où ils se trouvent après chaque étape de navigation.
// Compose : piloter une animation personnalisée à partir de la progression du retour prédictif
Modifier.predictiveBackHandler(enabled = true) { progress ->
    progress.collect { backEvent ->
        // backEvent.progress : 0.0 (début du geste) → 1.0 (confirmé)
        // 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 Sélection du composant de navigation

Taille d'écran3-5 Destinations5+ Destinations
Compact (< 600dp)Barre de navigationTiroir modal + Barre de navigation
Moyen (600-839dp)Rail de navigationTiroir modal + Rail de navigation
Large (840dp+)Rail de navigationTiroir permanent

3. Mise en page et adaptation [ÉLEVÉ]

3.1 Classes de taille de fenêtre

Utilisez les classes de taille de fenêtre pour les mises en page adaptatives, pas les points d'arrêt en pixels bruts.

// Compose : Classes de taille de fenêtre
val windowSizeClass = calculateWindowSizeClass(this)
when (windowSizeClass.widthSizeClass) {
    WindowWidthSizeClass.Compact -> CompactLayout()
    WindowWidthSizeClass.Medium -> MediumLayout()
    WindowWidthSizeClass.Expanded -> ExpandedLayout()
}
ClasseLargeurAppareil typiqueColonnes
Compact< 600dpTéléphone portrait4
Moyen600-839dpTablette portrait, pliable8
Large840dp+Tablette paysage, bureau12

Règles :

  • R3.1 : Utilisez toujours WindowSizeClass de material3-window-size-class pour les décisions de mise en page adaptative.
  • R3.2 : N'utilisez jamais de points d'arrêt en pixels fixes. Les catégories d'appareils sont fluides.
  • R3.3 : Prenez en charge les trois classes de taille de largeur. Au minimum, compact et large.

3.2 Grille Material

Appliquez les marges et gouttières canoniques de la grille Material.

Classe de tailleMargesGouttièresColonnes
Compact16dp8dp4
Moyen24dp16dp8
Large24dp24dp12

Règles :

  • R3.4 : Le contenu ne doit pas s'étendre sur toute la largeur sur les écrans larges. Utilisez une largeur de contenu maximale d'environ 840 dp ou une disposition liste-détail.
  • R3.5 : Appliquez des marges horizontales cohérentes correspondant aux spécifications de la grille.

3.3 Affichage edge-to-edge

Android 15+ impose l'affichage edge-to-edge. Toutes les applications doivent dessiner derrière les barres système.

// Compose : Configuration edge-to-edge
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        enableEdgeToEdge()
        super.onCreate(savedInstanceState)
        setContent {
            Scaffold(
                modifier = Modifier.fillMaxSize(),
                // Scaffold gère les encoches pour les barres supérieure/inférieure automatiquement
            ) { innerPadding ->
                Content(modifier = Modifier.padding(innerPadding))
            }
        }
    }
}

Règles :

  • R3.6 : Appelez enableEdgeToEdge() avant setContent. Dessinez derrière la barre d'état et la barre de navigation.
  • R3.7 : Utilisez WindowInsets pour éloigner le contenu des barres système. Scaffold gère cela pour le contenu de la barre supérieure et de la barre inférieure automatiquement.
  • R3.8 : Le contenu défilant doit défiler derrière les barres système transparentes avec un remplissage d'encoche approprié en haut et en bas de la liste.

3.4 Prise en charge des appareils pliables

// Compose : Détection de la posture de pliage
val foldingFeatures = WindowInfoTracker.getOrCreate(context)
    .windowLayoutInfo(context)
    .collectAsState(initial = WindowLayoutInfo(emptyList()))

Règles :

  • R3.9 : Détectez la position de la charnière/du pli et évitez de placer du contenu critique à travers le pli.
  • R3.10 : Utilisez ListDetailPaneScaffold ou SupportingPaneScaffold de la bibliothèque adaptative Material3 pour les mises en page adaptées aux pliables.

4. Typographie [ÉLEVÉ]

4.1 Échelle typographique Material

RôleTaille par défautPoids par défautUtilisation
displayLarge57sp400Texte héros, onboarding
displayMedium45sp400Texte de fonctionnalité important
displaySmall36sp400Affichage important
headlineLarge32sp400Titres d'écran
headlineMedium28sp400En-têtes de section
headlineSmall24sp400Titres de cartes
titleLarge22sp400Titre de la barre d'application supérieure
titleMedium16sp500Onglets, navigation
titleSmall14sp500Sous-titres
bodyLarge16sp400Texte du corps principal
bodyMedium14sp400Texte du corps secondaire
bodySmall12sp400Légendes
labelLarge14sp500Boutons, libellés importants
labelMedium12sp500Chips
labelSmall11sp500Badges, petits libellés

Règles :

  • R4.1 : Utilisez toujours les styles de texte Material 3 (MaterialTheme.typography.role). N'appliquez jamais directement les tailles sp/dp.
  • R4.2 : Personnalisez les polices via un fichier de police dans res/font et le système de typographie Compose ou la famille de polices XML.
  • R4.3 : Maintenez un contraste de 3:1 entre le texte et les surfaces colorées non textuelles, mais de 4.5:1 pour le texte et les icônes (conformité WCAG AA).
  • R4.4 : Utilisez lineHeight = fontSize * 1.2 pour les titres et fontSize * 1.5 pour le corps du texte.
  • R4.5 : N'utilisez jamais displayLarge ou displayMedium pour du contenu dynamique. Réservez-les pour les écrans de marque et les écrans d'accueil.
// Compose : Application correcte de la typographie
Text(
    text = "Titre de l'écran",
    style = MaterialTheme.typography.headlineMedium
)

5. Composants [MOYEN]

5.1 Boutons

TypeUsageOù
FilledButtonAction principaleBoîtes de dialogue, formulaires
FilledTonalButtonAction secondaireZones de contenu
OutlinedButtonAlternative modéréeDialogues, listes

[contenu tronqué pour la traduction]

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.

Skills associés