Toutes les ressources

Skills · 8 min

Le skill qui bloque ton agent IA quand il fait semblant d'avoir fini

Ton agent Claude Code annonce "c'est terminé" et quand tu ouvres le résultat, la moitié du boulot n'est pas là.

Ce qu’il y a dedans

  • Le problème que tu vis chaque semaine
  • C'est quoi exactement unlazy
  • Setup en 60 secondes
  • 5 cas d'usage concrets pour un builder IA

Ton agent Claude Code annonce "c'est terminé" et quand tu ouvres le résultat, la moitié du boulot n'est pas là. Ce phénomène a un nom dans la recherche IA récente (partial compliance) et il existe un skill open source qui règle le problème en une commande. Ce lead magnet te donne l'install exacte, 5 cas d'usage business et les limites à connaître avant de le mettre partout.


Le problème que tu vis chaque semaine

Tu confies à ton agent une tâche en plusieurs étapes. Migration d'une base de données, refonte d'un tunnel de vente, préparation d'un lancement. Douze points à faire, dans l'ordre. Tu lances. Cinq minutes plus tard, l'agent te répond "tâche terminée".

Sauf que tu regardes le résultat. Trois étapes ont été sautées. Deux ont été bâclées. Une a été inventée (le code compile, mais fait autre chose que ce que tu avais demandé). Tu passes 45 minutes à corriger, tu re-prompt, tu re-vérifies. Au final, ça t'aurait coûté moins cher de le faire toi-même.

Le pire, c'est que l'agent ne t'a pas menti par mauvaise volonté. Il a répondu "terminé" comme un stagiaire qui rend un rapport sans avoir relu, parce que rien dans le protocole d'échange ne l'oblige à prouver quoi que ce soit. Tant que la seule sortie possible est un texte de confirmation, il y a un incentive à conclure trop vite.

Ce comportement n'est pas dû à ton prompt mal écrit. C'est un pattern documenté dans un paper de décembre 2025 (Quantifying Laziness, Decoding Suboptimality, and Context Degradation in Large Language Models, arXiv 2512.20662). Les chercheurs ont testé plusieurs LLM sur des instructions multi-parties précises. Résultat : les modèles omettent régulièrement des sections, tronquent leur réponse prématurément, et déclarent "done" sans avoir tout fait. Le nom donné à ce comportement dans la littérature : partial compliance.

Le paper teste principalement GPT-4 et DeepSeek. Les model cards Anthropic documentent des comportements adjacents (self-report peu fiable, sycophantie), mais le terme "partial compliance" vient bien de cette recherche AI générique, pas d'un doc officiel Anthropic. À date le phénomène est reproductible sur tous les LLM frontier, Claude inclus.

La solution structurelle : ne plus laisser l'agent s'auto-évaluer. Le forcer à cocher chaque case avec une preuve reproductible. C'est ce que fait unlazy.


C'est quoi exactement unlazy

Open source (MIT), publié par Leon X (LNX) sur GitHub : github.com/Leonxlnx/unlazy. Distribué via le directory skills.sh, comme la plupart des skills Claude Code sérieux.

Les 3 mécaniques qui changent vraiment ton usage :

  1. Le fichier gates.md, l'ardoise de contrôles à cocher.

Pour chaque tâche que tu confies à ton agent, unlazy génère un fichier gates.md : la liste des critères d'acceptation. Chaque case contient une commande exécutable, un output attendu, et une ligne d'évidence (le vrai résultat obtenu). Une case cochée sans preuve attachée est traitée comme non tenue. C'est plus strict qu'une case vide.

  1. La méthode Depth Tree.

La tâche est découpée en sous-tâches en profondeur. N niveaux. Chaque feuille de l'arbre reçoit le budget temps de la tâche entière. En pratique, l'effort d'exécution se multiplie avec la profondeur. Un fix "simple" en surface devient une vraie inspection en profondeur avant que l'agent te rende son verdict.

  1. Zéro auto-déclaration de succès.

L'agent ne peut plus dire "c'est bon, j'ai fini". Il doit exécuter le check, coller son résultat brut dans le gates.md, et te livrer le fichier avec toutes les preuves. La confiance déclarée est remplacée par de la preuve reproductible. Si un check plante, l'agent le note, s'arrête, te demande une décision.

Sous le capot, c'est un skill Claude Code standard : un dossier avec un SKILL.md, des sous-fichiers de règles, et zéro dépendance runtime (rien à installer d'autre que Node). Tu peux ouvrir le repo pour lire exactement ce qu'il injecte dans le contexte de Claude.


Setup en 60 secondes

Prérequis

  • Claude Code ou Codex CLI installé et fonctionnel
  • Node 16 ou plus récent (déjà installé si tu utilises Claude Code)
  • Aucune clé API supplémentaire, aucun compte tiers

Étape 1 : Installer le skill

Dans ton terminal, à la racine de ton projet ou en global :

code
npx skills add Leonxlnx/unlazy

La commande télécharge le skill dans ~/.claude/skills/unlazy/ et l'enregistre auprès de Claude Code. Tu peux vérifier avec ls ~/.claude/skills/ que le dossier unlazy est bien là.

Étape 2 : Redémarrer ta session Claude Code

Ferme la session en cours, relance claude ou ta commande habituelle. Claude Code recharge les skills disponibles au démarrage.

Étape 3 : Premier test sur une tâche réelle

Lance une tâche à plusieurs étapes que tu confies souvent à ton agent. Par exemple : "installe TailwindCSS sur mon Next.js, migre les 3 pages existantes vers le nouveau design system, et lance les tests". L'agent va d'abord créer un gates.md avec les checks (compile ok, tests verts, visuel non cassé sur les 3 pages) avant même de toucher au code. Puis il exécute, coche, attache les preuves.

Regarde le fichier gates.md à la fin. Si une case est verte, tu sais que le check a vraiment tourné. Si une case est rouge, tu sais exactement où ça a bloqué. Plus de "terminé" flou.

Petit conseil : garde le gates.md dans le repo, versionné avec git. Sur les tâches récurrentes (déploiement, tests avant merge), tu vas le faire évoluer au fil du temps et te constituer ton propre standard maison.


5 cas d'usage concrets pour un builder IA

1. Migration de base de données sans surprise

Le cas classique de tâche à multi-étapes où sauter une case coûte cher. Tu demandes à ton agent de faire passer ton schéma d'une version à une autre. unlazy génère un gates.md avec cinq contrôles : sauvegarde effectuée, nouveau schéma créé, données migrées sans perte (comptage avant/après), tests unitaires verts, intégrité des relations vérifiée. L'agent ne te dit "prêt à basculer en prod" que quand les cinq cases sont cochées avec preuves.

2. Refonte d'un site avant lancement

Tu envoies l'agent auditer et fixer ton nouveau site. Le gates.md devient ton pre-launch checklist : accessibilité (score Lighthouse au-dessus d'un seuil), performance (temps de chargement mobile), broken links (aucun), formulaires qui envoient bien un mail test. Tant qu'un signal est rouge, l'agent ne te livre pas le "go".

3. Lancement d'une campagne Meta Ads

Le brief creative + les audiences ICP + le pixel de tracking + la landing page. Quatre briques, quatre gates. unlazy transforme "l'agent qui te dit c'est prêt à publier" en "l'agent qui te montre les quatre validations avec captures d'écran ou logs". Sur une pub à 500€ par jour, la vérification vaut plus que les 20 minutes de génération supplémentaires.

4. Génération d'un lead magnet Notion

Tu confies à ton agent la rédaction d'une page longue. Le gates.md peut vérifier : la structure suit le template maison, le CTA de signature est présent verbatim, chaque affirmation chiffrée a une source, l'humanizer a été passé, la mise en page Notion tient. L'agent ne t'envoie le lien Notion que si tout est vert. Ça remplace 15 minutes de relecture manuelle par un fichier de preuves que tu peux archiver.

5. Onboarding d'un nouveau client

Le sujet où oublier une étape se paie en réputation. Le gates.md devient l'ossature de ton onboarding : dataroom montée avec les 5 sections standards, accès partagés aux bons drives, ICP confirmé par écrit, KPIs cadencés dans le tableau de bord, premier call planifié. L'agent devient ton chef de projet. (Voir lead magnet TODO pour la dataroom exacte à monter.)


Mes 3 conseils

  1. Écris toi-même le premier gates.md pour chaque type de tâche récurrente. L'agent apprend ton standard. Après deux ou trois passes, il génère des gates.md fidèles à ta manière de travailler. Prends 20 minutes le premier jour pour poser 3-4 templates (migration, déploiement, review de code, onboarding client). Le retour sur investissement arrive dès la deuxième semaine.
  2. Combine avec le pattern lessons.md pour que Claude retienne tes corrections. unlazy fige les checks à passer. lessons.md fige les patterns d'erreur que tu as déjà rencontrés. Les deux ensemble transforment ton Claude Code en collègue qui progresse. (Voir lead magnet LECON.)
  3. Utilise-le sur les tâches à haute conséquence uniquement. Pour un fix de typo ou un renommage, le gates est overkill et ralentit. Pour une migration, un déploiement, une refonte, un onboarding client, tu récupères 30 à 60 minutes de vérification manuelle et surtout tu élimines l'erreur silencieuse.

Les limites à garder en tête

  1. Les gates sont rigides. Si tu changes le contexte de la tâche en cours de route (nouveau critère, priorité qui bascule), il faut arrêter et régénérer le gates.md. Pas de flexibilité freestyle, c'est le prix du rigueur.
  2. La méthode Depth Tree multiplie le temps de génération. Une tâche découpée en 3 niveaux profonds prend facilement 3 fois plus longtemps qu'une exécution directe. Sur un petit fix ce n'est pas rentable. Sur une vraie tâche multi-étapes, tu récupères ce temps en évitant le second passage.
  3. Le skill est optimisé pour du code. Les gates avec commande + output marchent bien pour du dev, du build, du test, des scripts. Sur des tâches purement rédactionnelles ou stratégiques, les critères deviennent flous et le gain diminue.
  4. Le paper source teste GPT-4 et DeepSeek, pas Claude en priorité. Le comportement exact sur Sonnet et Opus est proche mais pas identique. En pratique Opus 4.7 joue le jeu quasi systématiquement. Sonnet peut zapper certains checks à la première tentative, un reprompt explicite règle la question. (Voir lead magnet FIX pour la règle des 2 corrections.)

Le mot de la fin

Un agent qui prétend avoir fini est le premier bug d'un système IA en production. Pas parce que le modèle est mauvais, parce que le protocole d'échange lui laisse la possibilité de mentir sans conséquence. unlazy change ce protocole. Chaque tâche a son ardoise, chaque case a sa preuve, aucune sortie sans validation exécutée.

Installe la commande ce soir. Lance une vraie tâche multi-étapes demain matin, ouvre le gates.md pendant que l'agent bosse. Tu vas voir la différence dans les 10 minutes.

S’inscrire à la newsletter

Pas le temps de tout monter toi-même ?

Je structure ta boîte : systèmes, process et un OS qui fait tourner l’opérationnel sans que tout repasse par toi. On commence par un diagnostic de 45 minutes : on regarde comment ta boîte tourne, ce qui te coûte le plus, et tu repars avec un récap écrit.

ou écris-moi :@capitain.aimaxence@corelabs.studio