Dans Claude Code, /code-review cherche ce qui est cassé (bugs de correction) et /simplify cherche ce qui est inutilement compliqué (doublons, abstractions mortes, code à réduire). On lance /simplify une fois que ça fonctionne, puis /code-review sur le code final avant de livrer. Depuis la version 2.1.328 (19 novembre 2026), sur la plupart des modèles, /code-review ne remonte plus que les bugs et les violations du CLAUDE.md. Cet article explique la règle, l'ordre et une routine de relecture, dans le cadre de notre parcours pour apprendre Claude.
En bref :
- Depuis la 2.1.328 (19 novembre 2026),
/code-reviewremonte, sur la plupart des modèles, les bugs et les violations du CLAUDE.md, rien d'autre. /simplifylance quatre agents en parallèle (réutilisation, simplification, efficacité, niveau d'abstraction) et applique les corrections.- Ordre conseillé : faire fonctionner,
/simplify, vérifier que le comportement n'a pas changé, puis/code-review. - Un commit avant chaque commande permet de revenir en arrière si une simplification casse quelque chose.
- Aucune des deux ne remplace une relecture humaine sur les parties sensibles (paiement, authentification, données personnelles).
Quelle est la différence entre /code-review et /simplify dans Claude Code ?
/code-review demande au code « est-ce que ça marche, est-ce que c'est sûr ? », /simplify demande « est-ce que c'est plus compliqué que nécessaire ? ». Selon la documentation officielle, la première remonte les bugs et les violations de ton CLAUDE.md, la seconde nettoie la réutilisation, la simplification et l'efficacité.
| Commande | Question posée au code | Résultat attendu |
|---|---|---|
/code-review | Y a-t-il un bug, une régression, une règle du CLAUDE.md violée ? | Un rapport de problèmes (sans --fix, rien n'est modifié) |
/simplify | Y a-t-il du code dupliqué, une abstraction inutile, un helper existant qu'on aurait dû réutiliser ? | Des corrections appliquées au code modifié |
Une nuance de la doc à garder en tête : elle écrit « sur la plupart des modèles » et précise que, selon ton modèle et ton niveau d'effort, la revue peut aussi couvrir des nettoyages. Ne pars donc pas du principe que la séparation est étanche : vérifie dans la sortie de ton propre modèle ce qui est remonté. Pour le cadre général de l'outil, la documentation Claude Code d'Anthropic reste la référence, et notre page sur l'installation et l'usage de Claude Code couvre les premiers pas.
Pourquoi /code-review se limite-t-il désormais aux bugs ?
Parce qu'un rapport qui mélange « ceci plante » et « ceci pourrait être plus joli » noie le premier dans le second. Le changelog de la version 2.1.328 le dit sans détour : pour les nettoyages (réutilisation, simplification, efficacité), il faut lancer /simplify. Les nettoyages ont donc leur propre commande, et /code-review garde la question de la correction.
Ce que tu récupères concrètement avec /code-review : des erreurs de logique, des cas limites non gérés, des régressions, et les écarts avec les règles de ton CLAUDE.md. Cette dernière entrée est facile à oublier : ta commande suit les consignes de ton projet. Elle ne lit pas en revanche REVIEW.md, qui est réservé au service Code Review géré sur GitHub.
Un exemple de sortie, inventé pour illustrer (le format réel varie), sur un petit fichier Next.js de capture de leads (route API qui enregistre un email) :
app/api/lead/route.ts
[bug] l.14 `email.trim()` appelé avant de vérifier que `email` existe :
une requête sans champ email renvoie une 500 au lieu d'une 400.
[bug] l.22 l'erreur de l'insertion est avalée par un catch vide :
le visiteur voit « merci » même si rien n'a été enregistré.
[CLAUDE.md] l.9 la règle « pas de console.log en production » est violée.Remarque ce qui n'apparaît pas : aucun commentaire sur le nom d'une variable, sur le fait que la validation est répétée dans un autre fichier, ni sur le style. Ce n'est plus le rôle de cette commande. Tu peux aussi cibler précisément ce qui est relu : /code-review 1234 pour une pull request, /code-review src/auth pour un dossier, /code-review main...ma-branche pour une branche. Sans cible, la commande relit la branche courante (commits en avance sur l'upstream plus modifications non commitées).
Quand lancer /simplify plutôt que /code-review ?
Lance /simplify quand le code fonctionne déjà mais s'est alourdi : copier-coller entre composants, fonctions utilitaires jamais appelées, couches ajoutées pour des besoins qui n'existent plus. La doc le décrit comme une relecture du code modifié qui applique les corrections, avec quatre agents qui tournent en parallèle : réutilisation des helpers existants, simplification, efficacité, bon niveau d'abstraction.
Trois situations qui justifient de le lancer :
- Après une longue session de génération, quand Claude a empilé les ajouts les uns sur les autres et que le projet contient deux façons de faire la même chose.
- Avant d'ajouter une fonctionnalité sur une base touffue : mieux vaut alléger le terrain avant de construire dessus.
- Quand un fichier dépasse ce qu'on peut relire d'un coup et que tu n'oses plus y toucher.
Un contre-exemple qui compte : ne lance pas /simplify sur du code qui plante. Il ne cherche pas de bugs de correction, c'est explicitement écrit dans la doc. Si ton formulaire renvoie une erreur, corrige d'abord (avec /code-review ou à la main), simplifie ensuite.
Un point d'historique utile si tu as des scripts anciens : avant la version 2.1.147, l'actuelle /code-review s'appelait /simplify et appliquait les corrections par défaut. Si un script s'en servait pour chercher des bugs, la doc recommande de passer à /code-review --fix.
Dans quel ordre enchaîner /simplify et /code-review avant de livrer ?
Dans cet ordre : faire fonctionner, /simplify, vérifier que rien n'a changé, puis /code-review. On réduit le code d'abord pour chercher les bugs sur la version finale, pas sur du code qui va encore être réécrit.
- Faire fonctionner. Le parcours principal tourne en local, tu l'as essayé à la main.
- Commiter, puis
/simplify. Le commit te donne un point de retour. Relis le diff avant d'accepter les changements. - Prouver que le comportement n'a pas changé. Relance tes tests s'il y en a, sinon refais ton parcours de test manuel (soumettre le formulaire, vérifier l'enregistrement, vérifier l'email reçu).
- Commiter, puis
/code-review. Sur le code final, avec le niveau d'effort adapté à l'enjeu.
Pourquoi cet ordre précisément : une simplification peut introduire une régression, et c'est /code-review qui l'attrape s'il passe après. Inverser l'ordre te ferait corriger des bugs dans du code que /simplify va ensuite réécrire, donc relire deux fois. Cet ordre est un choix de méthode, pas une règle de la documentation : certains pratiquent l'inverse (corriger les bugs d'abord avec /code-review --fix, simplifier ensuite, puis tester). Dans les deux cas, garde un commit entre chaque étape.
Sur le niveau d'effort de /code-review : à low, la revue ne remonte que les résultats dont elle est la plus sûre, ce qui limite les faux positifs ; de medium à max, elle élargit la couverture. Sans niveau tapé, elle reprend le dernier niveau utilisé, même d'une session précédente (un avis le signale).
/code-review high
/code-review src/auth high
/code-review --fix mediumComment appliquer ces deux commandes sur un vrai projet, pas à pas ?
Prenons un projet Next.js déployé sur Vercel, avec un formulaire de capture de leads. Au fil des sessions, la validation de l'email a été recopiée dans trois composants : le formulaire de la page d'accueil, celui de la page tarifs et celui du pop-up de sortie. Chaque copie est légèrement différente, et une seule gère les espaces autour de l'adresse.
Étape 1, point de retour :
git add -A && git commit -m "formulaire leads: version qui fonctionne"Étape 2, dans Claude Code, tu lances la simplification sur ce qui vient d'être modifié :
/simplifyCe que tu peux raisonnablement attendre en retour, d'après les quatre axes de la commande : une proposition d'extraire la validation dans une fonction partagée, de supprimer un fichier utilitaire que plus rien n'importe, de remplacer un petit helper maison par un helper déjà présent dans le projet. Chaque proposition arrive comme une correction appliquée : regarde le diff.
git diffRègle de relecture du diff, même sans être développeur : le nombre de fichiers touchés correspond-il à ce que tu attendais ? Une suppression de fichier est-elle justifiée par « plus personne ne l'appelle » ? Si le diff t'échappe, demande à Claude de l'expliquer en langage simple avant de valider. Refuse sans hésiter une modification qui touche un fichier sans rapport avec ta demande.
Étape 3, preuve que rien n'a changé : tu soumets le formulaire depuis les trois pages, avec un email valide, un email avec espaces, un champ vide. Les trois pages doivent maintenant réagir de la même façon (ce qui était justement le défaut).
Étape 4 :
git add -A && git commit -m "formulaire leads: validation factorisée"
/code-review highSi la revue signale par exemple que la fonction partagée ne gère pas un champ absent, tu corriges, tu relances, et tu passes à la livraison. Ce découpage, deux commits et deux commandes, a un intérêt très concret : en cas de problème, tu sais lequel des deux passages l'a causé. Pour déployer ensuite, notre page sur Vercel et Next.js décrit la mise en ligne.
Quelles erreurs éviter avec ces commandes de relecture ?
- Tout accepter sans lire le diff.
/simplifyapplique des corrections ; l'accord que tu donnes engage ton code. Lis, ou fais expliquer, avant de valider. - Lancer
/simplifysans commit préalable. Sans point de retour, annuler une simplification ratée devient un nettoyage manuel. Un commit avant chaque commande règle le problème. - Confondre code court et code simple. Réduire le nombre de lignes n'est pas le but ; un code un peu plus long mais lisible vaut mieux qu'une version compressée que tu ne sais plus relire.
- Attendre de
/code-reviewun avis d'architecture ou de style. Il cherche des bugs et des écarts avec ton CLAUDE.md, pas à juger si ton projet est bien organisé.
Questions fréquentes
Faut-il toujours lancer /simplify avant /code-review ?
Pas toujours, mais c'est l'ordre le plus économe : on réduit le code d'abord, puis on cherche les bugs sur la version finale. Si le code est déjà court et lisible, /code-review seul suffit.
/simplify peut-il casser mon code ?
Oui, comme toute réécriture. Commitez avant de le lancer, relisez le diff proposé et relancez vos tests ou votre parcours de test manuel. En cas de régression, un retour au commit précédent règle le problème en quelques secondes.
Que faire si /code-review ne signale aucun bug ?
Cela veut dire que la relecture automatique n'a rien trouvé, pas que le code est parfait. Testez les cas limites vous-même et faites relire par un humain les parties critiques avant de les mettre en production.
Ces commandes fonctionnent-elles sur un projet que je n'ai pas écrit moi-même ?
Oui, elles s'appliquent à tout dépôt ouvert dans Claude Code. Sur un code hérité, commencez par /code-review pour repérer ce qui est fragile, puis /simplify par petits périmètres plutôt que sur tout le dépôt.
Faut-il être développeur pour utiliser /simplify et /code-review ?
Non, mais il faut savoir lire un diff au minimum pour décider quoi accepter. Si le diff vous échappe, demandez à Claude de l'expliquer en langage simple avant de valider.
Passer à la pratique : intégrer la relecture dans ta routine de livraison
Place ces deux commandes avant chaque commit sur la branche principale et avant chaque déploiement : /simplify quand la fonctionnalité est terminée, /code-review juste avant de pousser. Cela prend peu de temps et évite d'envoyer en production un code que personne n'a relu.
Une limite à garder en tête : une relecture automatique ne suffit plus quand l'erreur coûte cher. Sur la logique métier, le paiement, l'authentification ou les données personnelles de tes clients, fais relire par une personne, ou par un développeur si tu n'en es pas un. Les notes de version du dépôt Claude Code te permettent de suivre les évolutions de ces commandes, qui bougent vite ; la /code-review et la /simplify d'aujourd'hui ne seront pas forcément celles du trimestre prochain. Les annonces d'Anthropic donnent le contexte produit.
Pour construire un produit complet avec cette discipline, de la maquette au déploiement, avec la relecture intégrée à chaque étape, tu peux suivre la formation de cinq semaines pour livrer ton propre produit avec Claude. Pour aller plus loin sur les projets applicatifs, nos contenus sur la création d'applications avec Claude Code et ceux sur la configuration de Claude au quotidien prolongent cet article.
