Tu donnes une tâche à ton agent. Il travaille, il te répond « c'est terminé ». Et en vrai, il a sauté trois étapes. Ce comportement a un nom — la partial compliance — et il existe une skill gratuite, Unlazy, qui le tue. Elle découpe ton projet en petites tâches, donne à chacune sa checklist et une définition claire de « terminé », et interdit à l'agent d'annoncer la fin tant qu'il ne l'a pas prouvé. Tout se passe dans Claude Code. Voici le mode d'emploi complet, avec les 3 prompts à copier.
1Le vrai problème : la partial compliance
Tu demandes cinq choses. L'agent en fait trois, correctement. Puis il rédige un résumé qui parle des cinq, sur un ton confiant, et te rend la main. Ce n'est pas un mensonge délibéré : c'est un agent qui, faute d'un critère explicite, considère qu'« avoir bien avancé » et « avoir fini » sont la même chose.
Pourquoi ça arrive. Une consigne longue contient plusieurs exigences implicites. L'agent traite les plus saillantes, celles qui ressemblent au cœur de la demande — et laisse tomber les périphériques : le cas limite, la vérification, la mise à jour du fichier voisin, le test qui prouve que ça marche. Rien dans le contexte ne lui dit qu'il a le droit de s'arrêter, donc il s'arrête quand il « sent » que c'est bon.
Ce que ça te coûte. Le coût n'est pas dans les étapes manquées : il est dans les allers-retours pour les découvrir. Tu relis, tu testes, tu repères un trou, tu le signales, l'agent répond « ah oui, bonne remarque, j'avais oublié », il corrige — et tu recommences. Trois fois. C'est là que part le temps que l'IA était censée te faire gagner.
2Installer Unlazy dans Claude Code (en détail)
Unlazy est une skill. Dans Claude Code, une skill est un dossier d'instructions que l'agent charge au démarrage de la session et applique quand le contexte s'y prête. L'installation est un one-shot : une fois posée, elle est là pour tous tes projets.
Avant de commencer — deux prérequis. Il te faut Node.js installé sur ta machine (c'est lui qui fournit la commande npx), et une session Claude Code ouverte dans un terminal. Rien d'autre : pas de compte à créer, pas de clé à configurer, la skill est gratuite.
La méthode. Tu peux taper la commande toi-même, mais le plus simple est de laisser Claude Code la lancer : s'il y a un souci d'environnement (droits, chemin, version de Node), il le voit dans la sortie du terminal et le corrige lui-même. Colle ce prompt tel quel :
Installe la skill Unlazy : exécute `npx skills add Leonxlnx/unlazy`. Si ça bloque, corrige le problème et réessaie. Confirme quand c'est bon et dis-moi comment relancer pour qu'elle soit prise en compte.
Ce qui se passe alors. La commande récupère la skill depuis son dépôt public et l'écrit dans un dossier de skills. Deux emplacements possibles selon la façon dont tu l'installes : au niveau utilisateur (~/.claude/skills/) — la skill est alors disponible dans tous tes projets — ou au niveau projet (.claude/skills/ à la racine du dépôt) — elle ne vaut que pour ce projet. Demande à Claude de te dire où exactement il l'a posée : c'est la première chose à savoir quand tu voudras la retrouver, la mettre à jour ou la supprimer.
Vérifier que c'est réellement installé. Ne te contente pas du « c'est fait » de l'agent — ce serait ironique. Trois contrôles, dans l'ordre :
- le dossier existe et contient un fichier d'instructions (typiquement un SKILL.md) — demande à Claude de te lister le contenu du dossier ;
- la commande d'installation s'est terminée sans erreur — si tu vois un message d'échec réseau ou de permission, ce n'est pas installé, même si le dossier a été créé ;
- après relance, la skill est bien visible dans les skills disponibles de la session.
Relancer la session — l'étape qu'on oublie. Les skills sont chargées au démarrage. Tant que tu restes dans la session où tu viens de l'installer, Claude Code ne la « voit » pas. Ferme la session en cours et rouvre-la, puis vérifie que la skill apparaît. C'est aussi bête que ça, et c'est la raison n°1 des « je l'ai installée mais ça ne change rien ».
3Avant un gros projet : autorise le parallélisme
C'est l'étape la plus importante, et c'est celle que tout le monde saute. Par défaut, Claude Code enchaîne les tâches une par une. Sur un petit correctif, c'est parfait. Sur un projet découpé en douze tâches, tu attends que la 1 finisse pour que la 2 commence — alors que la moitié d'entre elles ne dépendent de rien.
Claude Code sait lancer des sous-agents qui travaillent en parallèle, chacun avec son propre contexte. Mais il ne le fait pas spontanément sur un projet long : il faut l'y autoriser explicitement, et lui demander de repérer les tâches indépendantes avant de se lancer. Colle ce prompt au tout début du projet, avant même de décrire ce que tu veux :
Pour ce projet, tu as le droit de lancer plusieurs agents en parallèle. Découpe d'abord le plan, repère les tâches indépendantes, et lance-les en même temps via des sous-agents séparés au lieu de les faire une par une.
Pourquoi l'ordre compte. Si tu colles ce prompt après avoir lancé la tâche, le plan est déjà figé et l'exécution a commencé en série. En le mettant avant, tu changes la façon dont le plan lui-même est construit : l'agent va structurer le découpage pour le parallélisme, en isolant ce qui peut avancer sans attendre.
Ce que ça change concrètement. Trois tâches indépendantes de dix minutes prennent dix minutes au lieu de trente. Et surtout, chaque sous-agent travaille avec un contexte propre, concentré sur sa tâche — au lieu d'un seul agent qui traîne l'historique complet du projet et se disperse.
4Ce qu'Unlazy fait quand tu lances ton projet
Une fois installée, tu n'as plus rien de spécial à faire : tu donnes ta tâche normalement, comme d'habitude. La skill se déclenche et transforme la manière dont l'agent organise le travail. Trois mécanismes, qui se répondent :
Le découpage en petites tâches avec checklist. Au lieu d'une grosse consigne floue traitée d'un bloc, le projet devient une liste de tâches réduites, chacune accompagnée de sa checklist. L'effet est double : l'agent ne peut plus « oublier » un item, puisqu'il est écrit ; et toi tu vois, en un coup d'œil, ce qui est réellement traité et ce qui reste.
La définition de « terminé ». Pour chaque tâche, la skill écrit ce que veut dire « fini » — de façon concrète et vérifiable, pas « la fonctionnalité marche » mais un critère observable. C'est le cœur du système : le critère est posé avant l'exécution, donc l'agent ne peut plus le redéfinir en cours de route pour se donner raison.
Le fichier « gate ». C'est le verrou. Un fichier liste ce que l'agent doit vérifier avant d'avoir le droit de dire que c'est terminé. Tant que les points ne sont pas passés, il n'a pas l'autorisation de conclure. La conséquence est simple : « c'est fait » n'est plus une impression, c'est une sortie de contrôle.
Résultat : même travail, beaucoup moins d'allers-retours. Tu passes du rôle de relecteur qui traque les trous à celui de valideur qui lit un résultat déjà vérifié.
5Régler la profondeur selon la taille du projet
Le découpage n'est pas gratuit. Sur une petite demande, un découpage trop fin te fabrique dix sous-tâches pour un travail de quinze minutes : tu passes plus de temps à lire l'organisation qu'à lire le résultat. Sur un gros projet, à l'inverse, un découpage trop grossier laisse revenir exactement le problème qu'on cherchait à supprimer — des tâches assez larges pour qu'on puisse en sauter un morceau.
Tu peux donc dire explicitement à Unlazy jusqu'où découper. Une phrase suffit, à adapter au projet :
Découpe ce projet en 3 branches parallèles maximum.
Change simplement le nombre selon ce que tu lances. Un repère pour t'orienter :
| Type de projet | Profondeur à demander | Parallélisme | Ce que tu gagnes |
|---|---|---|---|
| Correctif ciblé, une seule intention | Peu de branches (1–2) | Inutile | Le gate, sans la lourdeur |
| Fonctionnalité complète | ★ 3 branches | Oui | Le meilleur rapport clarté / vitesse |
| Projet multi-briques (front + back + données) | Plus profond, par brique | ★ Indispensable | Chaque brique avance sans attendre |
| Refonte ou migration | Profond, découpage explicite | Oui, par lot | Aucun morceau oublié en route |
L'ordre d'exécution, en résumé
Si tu ne dois retenir qu'une chose, retiens la séquence — c'est elle qui fait la différence, pas les prompts pris isolément :
- Une fois pour toutes : tu installes la skill avec le prompt 1, puis tu relances ta session.
- Au début de chaque gros projet : tu colles le prompt 2 pour autoriser le parallélisme — avant de décrire la tâche.
- Si besoin : tu ajoutes le prompt 3 pour caler la profondeur de découpage sur la taille du chantier.
- Puis tu donnes ta tâche normalement. Unlazy fait le reste : checklists, définition de terminé, gate de vérification.
