Communitygithub.com

xzedm/clipplic-landing

Cycle itératif travailleur-relecteur qui génère un sous-agent critique pour noter le travail de 1 à 10 et fournir des retours exploitables, puis révise jusqu'à atteindre un seuil de qualité. À utiliser lors de l'implémentation de fonctionnalités, la rédaction de spécifications, la relecture de code existant ou toute tâche où la qualité prime sur la rapidité. Phrases déclencheurs : « use review-loop », « polish this », « iterate on this », « /review-loop », « review with feedback loop ».

Qu'est-ce que clipplic-landing ?

Cette compétence implémente un cycle travailleur-relecteur au sein d'une session unique, idéal pour Claude Code, Cursor, Codex et autres agents prenant en charge le spawning de sous-agents. Le principe est simple : l'agent principal effectue le travail, puis génère un sous-agent « relecteur » qui évalue le résultat sur une échelle de 1 à 10 avec des retours concrets. En fonction de cette note et d'un seuil de qualité paramétrable (8/10 par défaut), l'agent révise et itère jusqu'à ce que le seuil soit atteint ou qu'un nombre maximum d'itérations (4 par défaut) soit dépassé. La compétence propose des modes « faire et relire » (cycle complet) et « relire un existant » (relecture seule). Elle intègre des règles strictes – le relecteur ne doit jamais être plus faible que le travailleur, et le relecteur doit être un sous-agent frais sans ancrage au raisonnement préalable – ainsi que des directives pour adapter les critères de relecture selon le type de tâche (code, spécification, refactoring, écriture, correction de bug, IaC, migration de base de données, etc.). Un format de rapport d'exemple et des recommandations de coût/vitesse sont fournis. La licence est MIT.

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

Demander à votre IA préférée

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

Documentation

Boucle de relecture (Review Loop)

Cycle itératif travailleur-relecteur au sein d’une session unique. Vous effectuez le travail, vous générez un sous-agent relecteur pour le critiquer, vous révisez en fonction des retours, et vous répétez jusqu’à atteindre le seuil de qualité.

Principe fondamental : Les premières versions ne sont jamais définitives. La critique itérative produit de meilleurs résultats qu’un seul passage.

Note sur les plateformes : Cette compétence fonctionne mieux avec des agents qui prennent en charge le spawning de sous-agents. Sur les plateformes sans cette fonctionnalité, simulez l’étape de relecture en ouvrant un nouveau contexte de discussion, en collant uniquement le livrable (sans le raisonnement antérieur) et en demandant une note de 1 à 10 avec des retours spécifiques.

Prise en main rapide

  1. Dites : « implémente X, utilise review-loop » ou « exécute review-loop sur le fichier que je viens d’écrire »
  2. L’agent effectue le travail (ou lit le travail existant)
  3. Un sous-agent critique distinct le note de 1 à 10 avec des retours spécifiques
  4. L’agent révise et répète jusqu’à ce que la note soit >= 8 (seuil de qualité par défaut)
  5. Un récapitulatif de la boucle est fourni avec le résultat final

Quand l’utiliser

  • L’utilisateur dit « utilise review-loop », « polish this », « iterate on this », « /review-loop »
  • Implémentations complexes où la qualité prime sur la rapidité
  • Documents de conception, spécifications ou écrits techniques
  • Code devant être robuste (sécurité, pipelines de données, logique financière)
  • Lorsque l’utilisateur souhaite une critique contradictoire intégrée au processus

Quand ne PAS l’utiliser

  • Corrections simples, modifications rapides, changements d’une ligne
  • Tâches où les tests sont le seuil de qualité (utilisez TDD + CI à la place)
  • Lorsque l’utilisateur veut simplement que ce soit fait rapidement
  • Travail exploratoire / d’investigation où l’objectif est d’apprendre, pas de livrer
  • Tâches sans critères d’acceptation clairs – définissez-les d’abord, puis utilisez review-loop

Valeurs par défaut

RéglageValeur par défaut
Boucles min2
Boucles max4
Seuil de qualité8/10
Modèle travailleur(votre modèle actuel)
Modèle relecteur(votre modèle actuel ou alternative rapide/équilibré)

Sélection du modèle

La tâche du relecteur évalue la logique et les contraintes. La tâche du travailleur écrit et modifie le code. Choisissez les capacités du sous-agent en conséquence.

RÈGLE CRITIQUE : Le relecteur doit toujours ÊTRE AU MOINS AUSSI PUISSANT que le travailleur. Si le relecteur est plus faible que le travailleur, il ne peut pas critiquer correctement une logique complexe ni détecter des régressions subtiles.

Complexité de la tâcheCapacité du travailleurCapacité du relecteurJustification
Simple / mécanique (CRUD, formatage, code générique)Rapide / LégerÉquilibréLe travailleur léger est rapide, le relecteur équilibré détecte facilement les problèmes
Standard (fonctionnalités, refactorisations, documentation)ÉquilibréÉquilibréBon compromis coût, rapidité et qualité
Complexe (multi-fichiers, intégration, conception)ÉquilibréAvancé / RaisonnementLe relecteur avancé détecte les problèmes d’architecture subtils, le travailleur équilibré peut les implémenter
Très complexe (sécurité, quant, systèmes distribués)Avancé / RaisonnementAvancé / RaisonnementLes deux ont besoin du contexte complet et de la puissance de raisonnement. Le relecteur DOIT égaler la puissance du travailleur.

La règle d’or : Le travailleur doit être assez intelligent pour AGIR sur les retours du relecteur. Si le relecteur dit « corrigez la condition de concurrence avec un sémaphore basé sur un canal » et que le travailleur ne peut pas raisonner sur la concurrence, la boucle ne convergera pas.

Signal d’escalade : Si la note ne s’améliore pas après 2 boucles consécutives avec les mêmes retours, le modèle du travailleur est trop faible. Escaladez :

  • Option A : Demandez à l’utilisateur de passer à un modèle plus performant
  • Option B : Abaissez temporairement le seuil de qualité et notez l’écart pour l’utilisateur
  • Option C : Divisez la tâche en sous-tâches plus petites et exécutez review-loop sur chacune

Comportement par défaut : Puisque vous (l’agent principal) ÊTES le travailleur, générez un sous-agent relecteur qui correspond ou dépasse votre capacité actuelle en fonction de la tâche :

  • Tâches courantes → Relecteur Standard/Équilibré
  • Tâches spécialisées/difficiles → Relecteur Avancé/Raisonnement
  • Vérifications rapides → Relecteur Rapide/Léger (uniquement si vous agissez également en tant que travailleur léger)

Surcharges utilisateur

Les utilisateurs peuvent surcharger n’importe quelle valeur par défaut directement dans leur demande. Analysez-les naturellement :

« implémente X avec review-loop, seuil de qualité 9, utilise un modèle avancé pour la relecture, max 5 boucles »
« polish this, 2 boucles minimum, seuil à 8 »
« exécute review-loop avec relecteur rapide, max 2 boucles »
« utilise review-loop, relecteur raisonnement, seuil de qualité 9, min 3 max 6 »

Règles d’analyse :

  • « seuil de qualité N » ou « gate N » → quality_gate = N
  • « relecteur [modèle] » ou « relecture avec [modèle] » → substitution du modèle de relecteur
  • « max N boucles » → max_loops = N
  • « min N boucles » → min_loops = N
  • Si l’utilisateur ne précise pas, utilisez les valeurs par défaut
  • Si l’utilisateur dit « approfondi » ou « strict » → interprétez comme quality_gate 8, min_loops 2
  • Si l’utilisateur dit « rapide » ou « vite » → interprétez comme max_loops 2, quality_gate 6

Le processus

flowchart TD
    A[Effectuer le travail] --> B[Lancer le sous-agent relecteur]
    B --> C{Boucles min atteintes ?}
    C -- non, toujours continuer --> E[Réviser en fonction des retours]
    C -- oui --> D{Note >= seuil de qualité ?}
    D -- oui --> F[Passage de polissage final]
    D -- non --> G{Boucles max atteintes ?}
    G -- oui, arrêter quand même --> F
    G -- non --> E
    E --> B
    F --> H([Terminé])

Pas à pas

Étape 1 : Effectuer le travail

Réalisez la tâche comme vous le feriez normalement. Écrivez le code, créez la spécification, implémentez la fonctionnalité. Ne vous retenez pas — produisez votre meilleure première version.

Étape 2 : Lancer le sous-agent relecteur

Utilisez l’outil Agent pour envoyer un relecteur. Le relecteur doit :

  • Être un sous-agent séparé (contexte frais, sans ancrage à votre raisonnement)
  • Ne recevoir que le livrable (fichiers, diffs) — pas votre processus de réflexion
  • Noter de 1 à 10 avec des retours spécifiques et exploitables
  • Utiliser par défaut un modèle équilibré/standard (ou un modèle de raisonnement avancé pour les tâches complexes/spécialisées)

Modèle de prompt du relecteur :

Vous êtes un relecteur critique. Notez le travail suivant de 1 à 10 et fournissez des retours spécifiques et exploitables.

## Ce qui a été fait
{brève description de la tâche}

## Critères de relecture
{critères spécifiques à la tâche — ce qui compte pour CETTE tâche}

Exemples de critères bien rédigés :
  Pour un point de terminaison d’API REST :
    - Codes de statut HTTP corrects utilisés
    - Validation des entrées présente sur tous les paramètres
    - Authentification appliquée ; pas d’accès non authentifié
    - Pas de modèle de requête N+1

  Pour un document de conception :
    - L’énoncé du problème est sans ambiguïté
    - Alternatives envisagées avec compromis
    - Pas d’approximations sur la complexité de l’implémentation
    - Les métriques de succès sont mesurables

  Pour un pipeline de données :
    - Idempotent — sûr à réexécuter
    - Les changements de schéma sont gérés élégamment
    - Modes de défaillance documentés
    - Traitement des données personnelles abordé

## Instructions
1. Lisez attentivement le travail
2. Notez de 1 à 10 où :
   - 1-3 : Fondamentalement cassé ou ne répond pas aux exigences majeures
   - 4-6 : Fonctionne mais présente des problèmes significatifs
   - 7-8 : Bon, seulement des problèmes mineurs
   - 9-10 : Excellent, prêt à être livré
3. Listez les problèmes spécifiques avec les références fichier:ligne si applicable
4. Pour chaque problème, expliquez POURQUOI il compte et QUOI corriger
5. Ne soyez PAS poli — soyez honnête et direct
6. Indiquez clairement votre note comme « Note : N/10 »

## Fichiers à relire
{collez le contenu du fichier ou listez les chemins de fichiers avec les extraits pertinents}

Étape 3 : Analyser les retours

Extrayez de la réponse du relecteur :

  • Note (le nombre)
  • Problèmes (classés comme Critique / Important / Mineur)
  • Corrections spécifiques (quoi modifier)

Signalez à l’utilisateur :

Boucle {N}/{max} : Note {X}/10
- {résumé des principaux points de retour}

Étape 4 : Vérifier les conditions d’arrêt

Dans cet ordre :

  1. Si boucles effectuées < min_loops → continuer (toujours)
  2. Si note >= seuil de qualité → arrêter, passer au polissage final
  3. Si boucles effectuées >= max_loops → arrêter, passer au polissage final
  4. Sinon → réviser et boucler

Étape 5 : Réviser

Traitez les retours du relecteur. Corrigez les problèmes Critiques et Importants. Les problèmes Mineurs sont facultatifs. Revenez ensuite à l’Étape 2.

Important : Chaque révision doit être ciblée. Ne réécrivez pas tout — corrigez ce que le relecteur a signalé. Maintenez une liste mentale de TOUS les retours antérieurs pour éviter les régressions.

Étape 6 : Polissage final

Une fois la boucle terminée (seuil de qualité atteint ou boucles max atteintes) :

  • Corrigez les éventuels problèmes mineurs restants s’ils sont triviaux
  • Vérifiez que le résultat final est cohérent (sans artefacts des cycles de révision)
  • Signalez la note finale et le nombre de boucles à l’utilisateur

Adapter les critères du relecteur par type de tâche

Type de tâcheSur quoi le relecteur doit se concentrer
CodeExactitude, cas limites, gestion des erreurs, lisibilité, aucun problème de sécurité
Spécification/ConceptionComplétude, faisabilité, pas d’approximations, implémentabilité
RefactorisationAucun changement de comportement, aucune régression, plus propre qu’avant
RédactionClarté, structure, adapté au public, pas de fioritures
Correction de bugCause racine traitée, test de régression existant, aucun effet secondaire
Infrastructure / IaCIdempotence, moindre privilège, pas de secrets codés en dur, sécurité de destruction
Migration de base de donnéesRéversibilité, stratégie d’index, risque de perte de données, performance à l’échelle
Conception d’APIRétrocompatibilité, authentification, versioning, contrat d’erreur
Suite de testsCouverture des cas limites, aucune interdépendance entre tests, assertions significatives

Deux modes de fonctionnement

Mode A : « Faire et relire » (cycle complet)

L’utilisateur donne une tâche + dit d’utiliser review-loop. Vous effectuez le travail ET exécutez la boucle de relecture.

Utilisateur : « Implémente la couche de cache. Utilise review-loop, seuil de qualité 8. »

Vous :
1. Implémentez la couche de cache
2. Lancez le relecteur → Note 6, retours : éviction manquante, pas de TTL
3. Révisez : ajoutez éviction + TTL
4. Lancez le relecteur → Note 8, retours : mineur sur le nom
5. Polissage final, terminé

Mode B : « Relire un existant » (relecture seule)

L’utilisateur a déjà effectué le travail ou vous l’avez déjà effectué. Exécutez simplement la boucle de relecture sur ce qui existe.

Utilisateur : « Exécute review-loop sur le module d’authentification que je viens d’écrire »

Vous :
1. Lisez le module d’authentification
2. Lancez le relecteur → Note 5, retours : injection SQL, pas de limitation de débit
3. Corrigez : paramétrez les requêtes, ajoutez un limiteur de débit
4. Lancez le relecteur → Note 8, approuvé
5. Terminé

Signaux d’alerte

Ne jamais :

  • S’auto-relire au lieu de lancer un sous-agent (biais d’ancrage)
  • Sauter un cycle de révision parce que « les retours sont erronés » sans justification
  • Gonfler sa propre note (« Je pense que c’est en fait un 9 »)
  • Continuer au-delà de max_loops sans le consentement de l’utilisateur
  • Lancer le relecteur avec tout votre raisonnement/historique (il doit relire le TRAVAIL, pas votre intention)

Si le relecteur a tort :

  • Opposez-vous avec des preuves (montrez le code/les tests qui infirment le retour)
  • Ignorez ce point spécifique dans la révision
  • Notez-le dans votre rapport à l’utilisateur
  • N’abaissez PAS la barre de qualité pour compenser

Exemple de format de rapport

--- Boucle de relecture : {nom de la tâche} ---

Boucle 1/4 : Note 6/10
  Relecteur : Validation d’entrée manquante, pas de gestion d’erreur pour le délai d’attente réseau,
              fonction trop longue (80 lignes).
  Action : Correction des trois problèmes.

Boucle 2/4 : Note 8/10
  Relecteur : Propre. Mineur : le nom de variable `d` pourrait être plus descriptif.
  Action : Seuil de qualité atteint (8 >= 8). Polissage final.

Résultat : 8/10 en 2 boucles. Terminé.

Limitations connues

  • Le sous-agent relecteur n’a pas de mémoire des boucles précédentes — incluez explicitement le contexte des retours antérieurs dans chaque prompt du relecteur pour éviter de répéter les problèmes déjà résolus
  • L’inflation de la note est possible si les critères du prompt du relecteur sont trop vagues — consacrez du temps à la rédaction de critères spécifiques et mesurables
  • Cette compétence ne remplace pas une relecture humaine pour le code critique en matière de sécurité ou de conformité ; traitez le résultat comme une première passe solide
  • La convergence de la boucle n’est pas garantie si la tâche est sous-spécifiée — définissez des critères d’acceptation clairs avant de commencer

Coût et rapidité

  • Chaque boucle = 1 appel du sous-agent relecteur
  • Prévoyez environ 1 à 2 fois le temps d’un seul passage d’implémentation pour un cycle complet de 3 boucles
  • C’est peu coûteux par rapport à la livraison de code bogué, de spécifications vagues ou au déclenchement d’un cycle de relecture tardif
  • Utilisez votre modèle par défaut/standard pour la plupart des relectures ; ne passez à des modèles de raisonnement avancés que pour des domaines spécialisés (audits de sécurité, systèmes distribués, finance quantitative)

Licence

MIT — libre d’utilisation, d’adaptation et de redistribution avec tout outil ou plateforme d’IA. Citation appréciée. Contributions bienvenues.

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