Communitygithub.com

xzedm/clipplic-landing

Professeur interactif de style LeetCode pour la préparation aux entretiens techniques. Génère des environnements de codage avec des défis produits réels, enseigne les motifs et techniques, prend en charge Python/TypeScript/Kotlin/Swift et propose un entraînement à difficulté progressive pour les structures de données et les algorithmes.

Qu'est-ce que clipplic-landing ?

Ce skill transforme la préparation aux entretiens techniques en une expérience interactive et pratique, à la manière d'un LeetCode amélioré. Il génère des environnements de codage complets dans le navigateur, avec des défis inspirés de scénarios réels d'entreprises comme Instagram, Uber, Netflix ou Amazon. Le skill met l'accent sur l'apprentissage par motifs (20 motifs essentiels), avec une difficulté progressive allant de facile à expert. Il prend en charge plusieurs langages (Python, TypeScript, Kotlin, Swift) et fournit un retour instantané avec des explications détaillées. L'interface utilisateur inclut un éditeur de code, des tests intégrés, des indices et des solutions optimales, ce qui en fait un outil idéal pour les développeurs souhaitant maîtriser les algorithmes et structures de données dans un contexte réaliste.

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

Demander à votre IA préférée

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

Documentation

LeetCode Teacher

Un professeur interactif de préparation aux entretiens techniques qui génère des environnements de codage attrayants avec des défis produits réels, un entraînement à la reconnaissance de motifs et une prise en charge multi-langage.

Ce que fait ce skill

Transforme la préparation aux entretiens techniques en expériences interactives et pratiques :

  • Environnements de codage interactifs - Environnements de codage dans le navigateur avec retour instantané
  • Prise en charge multi-langage - Python, TypeScript, Kotlin, Swift
  • Défis produits réels - Scénarios pratiques d'entreprises réelles
  • Reconnaissance de motifs - Apprenez les 20 motifs de codage essentiels
  • Difficulté progressive - Facile → Moyen → Difficile → Expert
  • Retour instantané - Exécutez les tests en temps réel avec des explications détaillées
  • Enseignement de techniques - Maîtrisez les approches de résolution de problèmes

Pourquoi ce skill est important

Pratique LeetCode traditionnelle :

  • Problèmes abstraits et déconnectés
  • Aucun guide de reconnaissance de motifs
  • Approche par essais et erreurs
  • Intimidant pour les débutants
  • Options de langage limitées

Avec ce skill :

  • Scénarios produits réels
  • Apprentissage basé sur les motifs
  • Résolution de problèmes guidée
  • Courbe de difficulté progressive
  • Pratique multi-langage
  • Interface interactive et amusante

Principes fondamentaux

1. Apprentissage axé sur les motifs

  • Reconnaître les motifs de problèmes
  • Appliquer des modèles éprouvés
  • Développer l'intuition par la pratique
  • Maîtriser un motif à la fois

2. Contexte produit réel

  • Classement du fil Instagram
  • Correspondance des trajets Uber
  • Recommandation Netflix
  • Recherche de messages Slack
  • Gestion des stocks Amazon

3. Difficulté progressive

  • Commencez par les fondamentaux
  • Augmentez la complexité progressivement
  • Débloquez des motifs avancés
  • Suivez la progression des compétences

4. Maîtrise multi-langage

  • Pratiquez dans votre langage cible
  • Comparez les implémentations
  • Apprenez les astuces spécifiques au langage
  • Passez l'entretien dans n'importe quel langage

5. Apprentissage interactif

  • Écrivez du code dans le navigateur
  • Exécutez les tests instantanément
  • Obtenez des indices lorsque vous êtes bloqué
  • Voyez les solutions optimales
  • Suivez vos progrès

Motifs de problèmes couverts

Motifs de tableaux et chaînes

1. Deux pointeurs

Motif : Utiliser deux pointeurs pour parcourir un tableau
À utiliser quand : Vous devez trouver des paires, triplets ou sous-tableaux
Exemple : "Trouver les utilisateurs Instagram qui s'aiment mutuellement"
Complexité : O(n) temps, O(1) espace

2. Fenêtre glissante

Motif : Maintenir une fenêtre qui glisse dans le tableau
À utiliser quand : Vous devez trouver un sous-tableau avec une certaine propriété
Exemple : "Trouver les sujets tendance dans les N derniers tweets"
Complexité : O(n) temps, O(k) espace

3. Pointeurs rapide et lent

Motif : Deux pointeurs se déplaçant à des vitesses différentes
À utiliser quand : Détecter des cycles, trouver l'élément du milieu
Exemple : "Détecter une dépendance circulaire dans le gestionnaire de paquets"
Complexité : O(n) temps, O(1) espace

Motifs d'arbres et de graphes

4. BFS d'arbre

Motif : Parcours niveau par niveau à l'aide d'une file
À utiliser quand : Vous avez besoin d'un traitement niveau par niveau
Exemple : "Afficher les amis par degré de connexion"
Complexité : O(n) temps, O(w) espace (w = largeur maximale)

5. DFS d'arbre

Motif : Parcours préordre, inordre ou postordre
À utiliser quand : Vous devez explorer tous les chemins
Exemple : "Trouver tous les chemins dans le système de fichiers"
Complexité : O(n) temps, O(h) espace (h = hauteur)

6. BFS de graphe

Motif : Explorer les voisins niveau par niveau
À utiliser quand : Chemin le plus court, exploration par niveaux
Exemple : "Trouver le chemin de connexion le plus court sur LinkedIn"
Complexité : O(V + E) temps, O(V) espace

7. DFS de graphe

Motif : Explorer aussi loin que possible avant de revenir en arrière
À utiliser quand : Recherche de chemin, détection de cycle
Exemple : "Détecter des références circulaires dans un graphe social"
Complexité : O(V + E) temps, O(V) espace

8. Tri topologique

Motif : Ordonner les nœuds par dépendances
À utiliser quand : Ordonnancement de tâches, systèmes de construction
Exemple : "Ordonner les cours en fonction des prérequis"
Complexité : O(V + E) temps, O(V) espace

Motifs de programmation dynamique

9. Sac à dos 0/1

Motif : Inclure ou exclure chaque élément
À utiliser quand : Optimisation avec contraintes
Exemple : "Sélectionner les meilleures annonces dans le budget"
Complexité : O(n * capacité) temps et espace

10. Sac à dos illimité

Motif : Peut utiliser un élément un nombre illimité de fois
À utiliser quand : Monnaie, combinaisons
Exemple : "Transactions minimales pour atteindre le solde"
Complexité : O(n * cible) temps et espace

11. Nombres de Fibonacci

Motif : L'état actuel dépend des états précédents
À utiliser quand : Monter des escaliers, problèmes de pavage
Exemple : "Façons de naviguer à travers les écrans d'une application"
Complexité : O(n) temps, O(1) espace optimisé

12. Plus longue sous-séquence commune

Motif : Comparer deux séquences
À utiliser quand : Outils de diff, distance d'édition
Exemple : "Trouver des extraits de code similaires"
Complexité : O(m * n) temps et espace

Autres motifs essentiels

13. Recherche binaire modifiée

Motif : Recherche binaire sur un tableau trié ou pivoté
À utiliser quand : Recherche en O(log n)
Exemple : "Trouver la version où le bug a été introduit"
Complexité : O(log n) temps, O(1) espace

14. Éléments Top K

Motif : Utiliser un tas pour suivre les K plus grands/plus petits
À utiliser quand : Trouver les éléments les plus importants
Exemple : "Obtenir les K hashtags tendance"
Complexité : O(n log k) temps, O(k) espace

15. Fusion K-way

Motif : Fusionner K tableaux/listes triés
À utiliser quand : Combiner des données triées
Exemple : "Fusionner les flux d'activité de K utilisateurs"
Complexité : O(n log k) temps, O(k) espace

16. Retour sur trace (Backtracking)

Motif : Essayer toutes les possibilités avec élagage
À utiliser quand : Générer des permutations, combinaisons
Exemple : "Générer toutes les combinaisons valides de parenthèses"
Complexité : Variable, souvent exponentielle

17. Union-Find

Motif : Suivre les composants connectés
À utiliser quand : Connectivité réseau, regroupement
Exemple : "Trouver des groupes d'amis connectés"
Complexité : O(α(n)) amorti par opération

18. Intervalles

Motif : Fusionner, insérer ou trouver des intervalles qui se chevauchent
À utiliser quand : Planification de calendrier, plages horaires
Exemple : "Trouver des créneaux de réunion libres"
Complexité : O(n log n) temps, O(n) espace

19. Pile monotone

Motif : Maintenir une pile croissante/décroissante
À utiliser quand : Élément suivant plus grand/plus petit
Exemple : "Calcul de la période de cours d'une action"
Complexité : O(n) temps, O(n) espace

20. Trie (Arbre préfixe)

Motif : Arbre de préfixes pour les opérations sur les chaînes
À utiliser quand : Saisie automatique, correspondance de préfixes
Exemple : "Implémenter la saisie automatique de recherche"
Complexité : O(m) temps par opération (m = longueur du mot)

Exemples de défis produits réels

Niveau Facile

Instagram : Compteur de likes

Scénario réel : Compter combien de fois les publications de l'utilisateur ont été aimées aujourd'hui
Motif : Table de hachage
Structure de données : Dictionnaire/HashMap
Langages : Python, TypeScript, Kotlin, Swift

Slack : Messages non lus

Scénario réel : Trouver le premier message non lu dans un canal
Motif : Recherche linéaire avec indicateur
Structure de données : Tableau
Enseigne : Terminaison anticipée

Uber : Calculer la course

Scénario réel : Calculer le coût du trajet en fonction de la distance et du temps
Motif : Calcul simple
Structure de données : Nombres
Enseigne : Opérations mathématiques, arrondi

Niveau Moyen

Netflix : Top N recommandations

Scénario réel : Trouver les N meilleurs films par note
Motif : Éléments Top K (Tas)
Structure de données : File de priorité
Enseigne : Opérations de tas, tri partiel

Amazon : Gestion des stocks

Scénario réel : Trouver les produits dont le stock est faible
Motif : Filtrage avec seuil
Structure de données : Tableau + HashMap
Enseigne : Filtrage multi-critères

Twitter : Hashtags tendance

Scénario réel : Trouver les hashtags les plus utilisés dans une fenêtre de temps
Motif : Fenêtre glissante + compteur de fréquences
Structure de données : File + HashMap
Enseigne : Gestion de fenêtre temporelle

LinkedIn : Degrés de connexion

Scénario réel : Trouver le chemin de connexion entre deux utilisateurs
Motif : BFS
Structure de données : Graphe (liste d'adjacence)
Enseigne : Chemin le plus court, suivi de niveau

Niveau Difficile

Google Calendar : Trouver des créneaux de réunion

Scénario réel : Trouver des créneaux horaires libres pour tous les participants
Motif : Fusion d'intervalles
Structure de données : Tableau d'intervalles
Enseigne : Tri, fusion d'intervalles qui se chevauchent

Spotify : Mélange de playlist

Scénario réel : Mélange aléatoire véritable évitant la répétition d'artistes
Motif : Fisher-Yates modifié
Structure de données : Tableau
Enseigne : Randomisation avec contraintes

GitHub : Résolution de conflits de fusion

Scénario réel : Trouver la plus longue sous-séquence commune dans les fichiers
Motif : Programmation dynamique (LCS)
Structure de données : Tableau 2D
Enseigne : Définition d'état DP, optimisation

Airbnb : Classement des recherches

Scénario réel : Classer les annonces par plusieurs critères pondérés
Motif : Tri personnalisé + Tas
Structure de données : File de priorité avec comparateur
Enseigne : Comparaisons complexes, départage

Exemple d'environnement interactif

Environnement Python

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>🚀 LeetCode Teacher - Two Sum (Instagram Likes)</title>
  <style>
    * { margin: 0; padding: 0; box-sizing: border-box; }
    body {
      font-family: 'SF Mono', 'Monaco', 'Courier New', monospace;
      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
      min-height: 100vh;
      padding: 20px;
      color: white;
    }
    .container {
      max-width: 1400px;
      margin: 0 auto;
      display: grid;
      grid-template-columns: 1fr 1fr;
      gap: 20px;
    }
    .panel {
      background: rgba(255, 255, 255, 0.1);
      backdrop-filter: blur(10px);
      border-radius: 15px;
      padding: 30px;
      box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3);
    }
    h1 {
      font-size: 2.5em;
      margin-bottom: 10px;
      text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.3);
    }
    .difficulty {
      display: inline-block;
      padding: 5px 15px;
      border-radius: 20px;
      font-size: 0.9em;
      font-weight: bold;
      margin-bottom: 20px;
    }
    .easy { background: #4CAF50; }
    .medium { background: #FF9800; }
    .hard { background: #F44336; }
    .problem {
      background: rgba(255, 255, 255, 0.1);
      padding: 20px;
      border-radius: 10px;
      margin: 20px 0;
      line-height: 1.6;
    }
    .code-editor {
      width: 100%;
      min-height: 400px;
      background: #1e1e1e;
      color: #d4d4d4;
      font-family: 'SF Mono', monospace;
      font-size: 14px;
      padding: 20px;
      border-radius: 10px;
      border: none;
      resize: vertical;
    }
    .controls {
      display: flex;
      gap: 10px;
      margin: 20px 0;
    }
    .btn {
      padding: 12px 30px;
      border: none;
      border-radius: 10px;
      font-size: 1em;
      font-weight: bold;
      cursor: pointer;
      transition: transform 0.2s;
    }
    .btn-run {
      background: linear-gradient(135deg, #4CAF50, #45a049);
      color: white;
    }
    .btn-hint {
      background: linear-gradient(135deg, #FF9800, #F57C00);
      color: white;
    }
    .btn-solution {
      background: linear-gradient(135deg, #2196F3, #1976D2);
      color: white;
    }
    .btn:hover { transform: translateY(-2px); }
    .output {
      background: #1e1e1e;
      color: #4CAF50;
      padding: 20px;
      border-radius: 10px;
      min-height: 100px;
      font-family: monospace;
      white-space: pre-wrap;
      margin-top: 20px;
    }
    .test-case {
      background: rgba(255, 255, 255, 0.05);
      padding: 15px;
      border-radius: 8px;
      margin: 10px 0;
      border-left: 4px solid #4CAF50;
    }
    .test-failed {
      border-left-color: #F44336;
    }
    .stats {
      display: flex;
      justify-content: space-around;
      margin: 20px 0;
      padding: 20px;
      background: rgba(255, 255, 255, 0.1);
      border-radius: 10px;
    }
    .stat {
      text-align: center;
    }
    .stat-value {
      font-size: 2em;
      font-weight: bold;
      color: #FFD700;
    }
    .pattern-badge {
      display: inline-block;
      background: rgba(255, 215, 0, 0.2);
      color: #FFD700;
      padding: 5px 15px;
      border-radius: 15px;
      margin: 5px;
      font-size: 0.9em;
    }
  </style>
</head>
<body>
  <div class="container">
    <!-- Left Panel: Problem -->
    <div class="panel">
      <h1>🎯 Two Sum</h1>
      <span class="difficulty easy">Easy</span>
      <span class="pattern-badge">Pattern: Hash Map</span>
      <span class="pattern-badge">Array</span>

      <div class="problem">
        <h3>📱 Real Product Scenario: Instagram Likes</h3>
        <p>You're building Instagram's "Mutual Likes" feature. Given an array of user IDs who liked your post and a target sum, find two users whose IDs add up to the target.</p>

        <h4 style="margin-top: 20px;">Problem:</h4>
        <p>Given an array of integers <code>nums</code> and an integer <code>target</code>, return indices of two numbers that add up to <code>target</code>.</p>

        <h4 style="margin-top: 20px;">Example:</h4>
        <code style="display: block; padding: 10px; background: rgba(0,0,0,0.3); border-radius: 5px;">
Input: nums = [2, 7, 11, 15], target = 9<br>
Output: [0, 1]<br>
Explanation: nums[0] + nums[1] = 2 + 7 = 9
        </code>

        <h4 style="margin-top: 20px;">Constraints:</h4>
        <ul style="margin-left: 20px;">
          <li>2 ≤ nums.length ≤ 10⁴</li>
          <li>Only one valid answer exists</li>
          <li>Can't use the same element twice</li>
        </ul>
      </div>

      <div class="stats">
        <div class="stat">
          <div class="stat-value" id="testsRun">0</div>
          <div>Tests Run</div>
        </div>
        <div class="stat">
          <div class="stat-value" id="testsPassed">0</div>
          <div>Passed</div>
        </div>
        <div class="stat">
          <div class="stat-value" id="attempts">0</div>
          <div>Attempts</div>
        </div>
      </div>

      <div id="hints" style="margin-top: 20px;"></div>
    </div>

    <!-- Right Panel: Code Editor -->
    <div class="panel">
      <h2>💻 Your Solution (Python)</h2>
      <textarea class="code-editor" id="codeEditor">def two_sum(nums, target):
    """
    Find two numbers that add up to target.

    Args:
        nums: List of integers
        target: Target sum

    Returns:
        List of two indices

    Time: O(n²) - Brute force
    Space: O(1)



…

[tronqué pour la traduction]

Note : L'environnement interactif complet (HTML, CSS, JavaScript) n'est pas reproduit ici par souci de concision. Le skill génère un environnement de codage complet et fonctionnel dans le navigateur.

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

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)

Skills associés