Astuces avancées Claude Code

Reprendre et continuer une session

Chaque session Claude Code enregistre un transcript de conversation (l'historique complet des échanges) en local. Quand vous fermez le terminal ou perdez la connexion, ce contexte n'est pas perdu. Deux options vous permettent de le retrouver.

--continue reouvre automatiquement la session la plus récente. Vous n'avez pas besoin de retenir un identifiant. Lancez claude --continue depuis le même dossier de projet et Claude Code recharge la dernière conversation pour que vous puissiez reprendre exactement là où vous vous étiez arrêté.

--resume vous donne le choix. Cette option liste vos sessions récentes avec leurs horodatages et de courts résumés, afin que vous puissiez sélectionner la bonne quand vous avez jonglé entre plusieurs tâches. Passez un identifiant de session directement pour ignorer la liste : claude --resume <session-id>.

• Utilisez --continue pour le cas simple : une seule tâche active, juste interrompue.
• Utilisez --resume quand vous devez revenir à une session plus ancienne ou spécifique.
• Le contexte rechargé de cette façon est comptabilisé dans votre fenêtre de contexte active (la limite de tokens par conversation), donc les très longues sessions anciennes peuvent être raccourcies.
• Les deux options fonctionnent dans le CLI interactif, l'extension VS Code et le plugin JetBrains.

Rewind : revenir en arrière en toute sécurité

Claude Code crée un point de contrôle (une capture de votre conversation et de l'état de vos fichiers) chaque fois que vous envoyez un message. Si une modification tourne mal, vous pouvez revenir à n'importe quel point de contrôle antérieur sans perdre l'historique de votre projet.

La commande /rewind ouvre le sélecteur de points de contrôle. Vous faites défiler les tours passés, choisissez celui vers lequel vous souhaitez revenir, et Claude Code restaure à la fois le contexte de la conversation et les fichiers sur le disque à cet instant précis. L'opération est non destructive : les tours supprimés disparaissent de la session active, mais votre historique git (si vous en avez un) reste intact.

Raisons courantes d'utiliser rewind :

• Claude a introduit un bug que vous ne pouvez pas facilement annuler avec une seule modification.
• Vous avez approuvé une grande refactorisation et avez changé d'avis.
• Vous souhaitez essayer deux approches différentes depuis le même point de départ (expérimentation sans risque).
• La conversation a dérivé hors sujet et un contexte antérieur donnait de meilleurs résultats.

L'expérimentation sans risque est le véritable atout ici : revenez à un point de contrôle propre, essayez l'approche A, notez le résultat, revenez à nouveau, essayez l'approche B, puis conservez la meilleure. Aucun fichier de sauvegarde manuel nécessaire.

Coller des images et des captures d'écran

Claude Code accepte les images directement dans le champ de saisie du chat. Vous pouvez glisser-déposer un fichier sur la fenêtre du terminal, coller depuis votre presse-papiers avec Ctrl+V (ou Cmd+V sur Mac), ou indiquer un chemin de fichier. L'image est encodée et envoyée avec votre invite textuelle dans la même requête.

Cette fonctionnalité est disponible sur les trois surfaces : le CLI (terminal), l'extension IDE (VS Code, JetBrains) et l'interface web de claude.ai utilisée avec les projets Claude Code. Sur le CLI, faire glisser un fichier dans la fenêtre du terminal insère son chemin, et Claude Code le résout et le charge automatiquement.

Cas d'usage courants pour les images dans une session de code :

• Captures de bugs : collez une erreur de console navigateur ou un état d'interface défectueux et demandez à Claude Code de le diagnostiquer.
• Références de design : déposez un export Figma ou une maquette et demandez le HTML/CSS correspondant.
• Dialogues d'erreur : capturez une boîte de dialogue de plantage ou un panneau de logs difficile à copier en texte.
• Diagrammes d'architecture : partagez une photo de tableau blanc et demandez à Claude Code de générer la structure décrite.

La capacité de vision (comprendre le contenu des images) est disponible sur claude-opus-4-8 et claude-sonnet-4-6. Haiku (claude-haiku-4-5) prend également en charge les images, mais avec une profondeur de raisonnement moindre. Pour une analyse d'interface complexe ou des diagrammes détaillés, préférez Sonnet ou Opus.

Référencez des fichiers rapidement

Claude Code vous offre trois méthodes rapides pour intégrer un fichier dans votre prompt sans avoir à taper un chemin complet. Les maîtriser réduit la friction lorsque vous référenciez du code, des configurations ou des docs en cours de conversation.

Le glisser-déposer fonctionne dans tout terminal qui le prend en charge : faites glisser un fichier depuis votre explorateur de fichiers sur le prompt de Claude Code et le chemin absolu est collé instantanément. Pas de frappe, pas d'erreur.

La mention @ (tapez @ suivi d'un nom de fichier ou d'un chemin partiel) ouvre un sélecteur de fichier intégré. Claude Code recherche dans votre projet et vous laisse choisir le fichier. Le chemin résolu est inséré dans le prompt et le contenu du fichier est joint comme contexte pour Claude.

Trois façons de référencer des fichiers rapidement :

• Glisser-déposer : faites glisser un fichier depuis votre explorateur de fichiers système sur le prompt du terminal.
• Mention @ : tapez @nomdefichier et choisissez dans la liste d'autocomplétion.
• Complétion par Tab : tapez un chemin partiel et appuyez sur Tab pour le compléter, comme dans une commande shell normale. Fonctionne avec /read, /edit et les références de fichiers simples dans votre message.

Exécuter une commande en ligne avec !

Dans le shell interactif de Claude Code (le REPL que vous obtenez en tapant claude sans argument), vous pouvez préfixer n'importe quelle commande shell avec ! pour l'exécuter et injecter sa sortie directement dans le contexte de votre conversation. Le contexte désigne ici la mémoire de travail que Claude lit avant de répondre.

C'est important car Claude ne peut pas voir votre système de fichiers ni l'historique de votre terminal par lui-même. Le préfixe ! est le moyen le plus rapide de transmettre à Claude des données réelles et actuelles, sans copier-coller.

Utilisations courantes du préfixe ! :

• !git log --oneline -10 affiche les dix derniers commits pour que Claude puisse raisonner sur l'historique.
• !cat package.json permet à Claude de lire un fichier de configuration sans que vous ayez à l'ouvrir séparément.
• !npm test 2>&1 injecte la sortie des tests (y compris les erreurs) dans le contexte afin que Claude puisse diagnostiquer les échecs immédiatement.
• !ls src/ fournit à Claude un listing du répertoire qu'il peut utiliser pour suggérer des modifications de fichiers.

La sortie apparaît dans le tour de conversation, visible par vous et par Claude. Si la commande produit de nombreuses lignes, Claude les voit toutes, mais des sorties très longues peuvent consommer une part significative de votre fenêtre de contexte (le budget total de tokens pour une session).

Enregistrer une mémoire avec #

Claude Code peut retenir des faits, des préférences et des règles d'une session à l'autre. Le moyen le plus rapide d'écrire une mémoire est de commencer votre message par #. Ce seul caractère indique à Claude Code d'enregistrer ce qui suit, plutôt que de le traiter comme une instruction ordinaire.

Lorsque vous tapez quelque chose comme # always use TypeScript strict mode, Claude Code décide où le stocker : soit dans CLAUDE.md (un fichier texte brut situé dans votre dossier de projet ou votre dossier personnel, qui sert de feuille d'instructions persistante), soit dans son espace de mémoire interne. Vous n'avez pas à choisir manuellement ; Claude Code sélectionne le bon emplacement selon que le fait est spécifique au projet ou général.

Éléments courants à noter avec # :

• Règles de style de code (conventions de nommage, paramètres de formateur)
• Contexte spécifique au projet (stack, organisation des dossiers, particularités de l'environnement)
• Préférences personnelles (langue, ton, sans tiret cadratin, sans emoji)
• Commandes ou scripts récurrents dont vous oubliez toujours les options

Vous pouvez consulter ce qui a été enregistré en ouvrant CLAUDE.md dans votre éditeur ou en demandant à Claude Code : what do you remember about this project?. Les mémoires écrites dans CLAUDE.md sont en texte brut et entièrement modifiables, vous pouvez donc nettoyer, réorganiser ou supprimer des entrées à tout moment.

Interrompre et rediriger

Lorsque Claude Code est en cours d'exécution, appuyer sur Esc envoie une interruption douce. Claude termine l'étape atomique en cours, puis s'arrête et attend votre prochaine instruction. Vous ne perdez ni le contexte de session, ni les modifications de fichiers déjà écrites, ni l'historique de la conversation.

C'est différent de Ctrl+C, qui tue le processus entièrement et vous oblige à redémarrer. Esc est l'outil chirurgical : utilisez-le quand Claude prend la mauvaise direction mais que vous voulez le piloter, pas recommencer de zéro.

Après l'interruption, vous pouvez :

• Taper une correction et appuyer sur Entrée pour rediriger Claude vers la bonne approche.
• Demander à Claude d'annuler le dernier ensemble de modifications de fichiers avec /undo avant de donner de nouvelles instructions.
• Coller du contexte supplémentaire (un message d'erreur, un chemin de fichier, une contrainte oubliée) pour que Claude puisse continuer avec de meilleures informations.
• Taper /clear si la conversation a trop dérivé et que vous voulez repartir sur une ardoise vierge tout en restant dans la même session.

La règle pratique : interrompez tôt. Si vous voyez Claude prendre une mauvaise décision architecturale dès le premier appel d'outil, appuyez immédiatement sur Esc. Le laisser continuer cinq étapes de plus avant d'interrompre signifie plus de travail d'annulation.

Mots-clés de raisonnement

Claude Code vous permet de régler l'intensité du raisonnement du modèle avant qu'il réponde. Trois mots-clés en anglais courant contrôlent ce comportement : think, think hard et ultrathink. Il suffit d'en insérer un dans votre invite et Claude Code active un passage de raisonnement interne étendu (parfois appelé "budget de réflexion") avant de rédiger sa réponse.

L'équilibre est simple : plus de réflexion signifie de meilleures réponses sur les problèmes difficiles, mais aussi plus de tokens consommés et un temps d'attente plus long. Les tokens sont les morceaux que le modèle lit et écrit ; chaque étape de raisonnement supplémentaire consomme des tokens, ce qui coûte du temps et, si vous êtes sur un abonnement payant, de l'argent.

Quand utiliser chaque niveau :

• think : raisonnement supplémentaire léger, adapté aux questions modérément complexes où la réponse par défaut semble superficielle.
• think hard : passage plus profond, utile pour les décisions d'architecture, les bugs complexes ou les plans à plusieurs étapes.
• ultrathink : budget maximum, réservé aux problèmes les plus difficiles (refactorisations complexes, problèmes de sécurité subtils). Notablement plus lent.

Ces mots-clés fonctionnent dans tous les contextes de Claude Code : l'invite du terminal, le chat intégré dans votre éditeur et l'interface web. Vous pouvez les combiner avec d'autres instructions dans une seule phrase.

Créez vos propres commandes slash

Claude Code vous permet de définir des commandes slash personnalisées sous forme de simples fichiers Markdown stockés dans un dossier .claude/commands/ à la racine de votre projet. Lorsque vous tapez /votre-commande dans l'invite Claude Code, il lit ce fichier et l'exécute comme une instruction.

Le nom du fichier devient le nom de la commande. Un fichier appelé .claude/commands/review.md crée la commande /review. Le contenu du fichier est l'invite que Claude reçoit, vous le rédigez donc exactement comme vous rédigeriez n'importe quelle invite soignée.

Les arguments vous permettent de passer des valeurs dynamiques dans une commande. À l'intérieur du fichier Markdown, utilisez l'espace réservée $ARGUMENTS (tout en majuscules). Tout ce que vous tapez après le nom de la commande dans l'invite est substitué à cet espace réservée au moment de l'exécution.

• Placez les commandes de niveau projet dans .claude/commands/ (suivies par git, partagées avec votre équipe).
• Placez les commandes personnelles qui s'appliquent à tous les projets dans ~/.claude/commands/ (votre répertoire personnel).
• Les arguments forment une seule chaîne : /review src/auth.ts passe src/auth.ts en tant que $ARGUMENTS.
• Les commandes peuvent être aussi longues et structurées que nécessaire : listes de vérification, instructions étape par étape, règles de format de sortie.

Gérer les extensions

Claude Code expose trois gestionnaires intégrés qui vous permettent d'inspecter et de contrôler ses points d'extension sans modifier manuellement les fichiers de configuration. Tapez /agents pour lister tous les sous-agents disponibles dans le projet actuel, /mcp pour voir quels serveurs MCP (serveurs Model Context Protocol, outils externes que Claude Code peut appeler) sont connectés et leur état, et /hooks pour afficher les commandes shell qui se déclenchent automatiquement avant ou après des événements clés comme un commit ou un arrêt.

Chaque gestionnaire est un panneau en direct, pas un simple affichage de fichier statique. Depuis /mcp, vous pouvez voir si un serveur est en cours d'exécution, le redémarrer ou le déconnecter immédiatement. Depuis /hooks, vous pouvez examiner chaque hook enregistré (le nom de l'événement, la commande et si elle s'exécute au premier plan ou en arrière-plan) afin de savoir exactement quelle automatisation est attachée à votre session.

La vue /agents est particulièrement utile lorsque vous travaillez dans un projet qui définit des sous-agents personnalisés (des agents limités à ce dépôt via .claude/agents/). Elle affiche les agents au niveau du projet et les agents globaux, ce qui vous permet de repérer les conflits de noms ou les entrées obsolètes avant qu'ils ne provoquent un comportement inattendu.

• /agents : liste tous les sous-agents (globaux et limités au projet).
• /mcp : inspecte, redemmarre ou déconnecte les serveurs MCP en direct.
• /hooks : audite chaque hook d'événement relié à la session en cours.
• Les trois gestionnaires reflètent l'état fusionné de ~/.claude/settings.json global et de .claude/settings.json du projet.

Mode headless et pipelines

Par défaut, Claude Code ouvre une session interactive dans laquelle vous tapez vos requêtes et lisez les réponses. Le mode headless supprime entièrement cette étape : vous passez votre invite directement en ligne de commande avec le flag -p (abréviation de --print), Claude répond une seule fois sur stdout (la sortie standard, c'est-à-dire le flux de texte du terminal), puis le processus se termine. Aucun menu, aucune attente de saisie.

Cela fait de Claude Code un véritable outil de style Unix que vous pouvez intégrer dans des pipelines shell (chaînes de commandes où la sortie d'un programme alimente le suivant) et des scripts d'automatisation. Le résultat s'affiche en texte brut, donc tout programme capable de lire du texte peut l'exploiter : un fichier de log, une autre commande, une étape CI (une étape dans un système d'intégration continue qui exécute des vérifications automatiques sur votre code).

Utilisations courantes du mode headless :

• Résumer un fichier : cat report.txt | claude -p "Summarise this in three bullet points"
• Générer un message de commit à partir d'un diff : git diff | claude -p "Write a concise commit message"
• Traiter en lot de nombreux fichiers dans un script de boucle
• Rediriger la sortie de Claude vers un autre outil : claude -p "List 5 test cases for a login form" | tee test-ideas.txt

Ajoutez --model pour choisir un modèle spécifique, et --output-format json (ou stream-json) lorsqu'un script en aval a besoin de données structurées plutôt que de texte courant. Gardez les invites courtes et précises : le mode headless ne permet pas d'aller-retour pour clarifier une ambiguïté.

Sessions parallèles avec les worktrees

Un Git worktree est un deuxième (ou troisième, ou quatrième) checkout du même dépôt, chacun vivant dans son propre dossier et suivant sa propre branche. Vous pouvez exécuter une session Claude Code séparée dans chaque worktree simultanément, afin que différentes tâches avancent en parallèle sans qu'une session en bloque une autre.

Pour créer un worktree, lancez git worktree add <path> <branch> depuis votre dépôt principal. Le chemin est un nouveau dossier ; la branche peut être nouvelle ou existante. Ouvrez ce dossier dans un nouveau terminal et lancez claude. Claude Code lit le répertoire de travail automatiquement, de sorte que chaque session ne voit que sa propre branche.

Conventions pratiques pour gérer trois à cinq sessions parallèles sans s'y perdre :

• Nommez le dossier d'après la tâche, pas la branche : ../myapp-feat-auth plutôt que ../wt1. Vous vous en féliciterez quand vous jonglerez avec cinq terminaux.
• Utilisez un alias shell pour passer rapidement d'un worktree à l'autre : alias wt-auth="cd ~/myapp-feat-auth && claude".
• Une branche par worktree : ne checkoutez jamais la même branche dans deux worktrees en même temps (Git l'interdit par conception).
• Faites le ménage une fois terminé : git worktree remove <path> puis supprimez le dossier, pour garder git worktree list lisible.

Le flag CLI Claude Code --resume vous permet de vous rattacher à une conversation précédente par identifiant de session. Combinez-le avec les worktrees : un worktree maintient une session de refactoring longue durée, un autre fait tourner une session de correction de bug rapide que vous reprenez à la demande.

Sélection du modèle et mode rapide

Claude Code fonctionne avec l'un des trois modèles (le moteur IA sous-jacent) : Opus (claude-opus-4-8), Sonnet (claude-sonnet-4-6) ou Haiku (claude-haiku-4-5). Chacun offre un compromis entre capacité, vitesse et coût.

Changez de modèle à tout moment grâce à la commande /model. Tapez-la seule pour afficher le sélecteur, ou passez directement un identifiant de modèle :

• /model claude-opus-4-8 pour le raisonnement le plus puissant (architecture, bugs difficiles, contexte long).
• /model claude-sonnet-4-6 pour l'équilibre idéal au quotidien : bonne qualité avec une latence réduite.
• /model claude-haiku-4-5 pour les tâches rapides et économiques : renommage de fichiers, résumés courts, modifications simples.

La commande /fast est un interrupteur de session. Elle indique à Claude Code de privilégier la vitesse plutôt que la profondeur pour le reste de la conversation, utile lorsque vous itérez rapidement et souhaitez des réponses vives plutôt qu'un raisonnement étendu. Tapez /fast à nouveau pour désactiver ce mode.

Mise à jour, juillet 2026 : la gamme a bougé. Claude Sonnet 5 (claude-sonnet-5) est sorti le 30 juin 2026 et est désormais le modèle par défaut de Claude Code, et Fable 5 (claude-fable-5), le nouveau palier au-dessus d'Opus, est disponible sur les offres payantes. Le fast mode a mûri en bascule /fast sur Opus 4.8 : la leçon dédiée plus loin dans ce module couvre son prix et ses pièges.

/fast mode : payer pour la vitesse

Le mode rapide est un aperçu de recherche dans Claude Code qui échange de l'argent contre de la vitesse. Tapez /fast dans une session et, si vous étiez sur un autre modèle, Claude Code vous bascule vers Opus et affiche une icône éclair dans l'interface. À partir de ce moment, le même modèle Opus tourne jusqu'à 2,5 fois plus vite en tokens de sortie par seconde. Il est important de comprendre ce que ce n'est pas : le mode rapide n'est pas un modèle différent, plus léger. Il fait tourner exactement les mêmes poids Opus. Ce qui change, c'est un indicateur de configuration API qui demande à l'infrastructure d'Anthropic de prioriser vos requêtes pour une latence plus faible, et vous payez une prime pour cette priorité.

La prime correspond exactement au double du tarif standard. En juillet 2026, le tarif standard d'Opus 4.8 est de 5 $ par million de tokens en entrée (MTok, l'unité utilisée pour la tarification des tokens) et 25 $ par MTok en sortie. Le mode rapide sur Opus 4.8 facture 10 $ par MTok en entrée et 50 $ par MTok en sortie. Ainsi, une tâche qui coûterait 1 $ en tokens à vitesse standard coûte 2 $ à vitesse rapide. Vous ne payez pas pour une réponse plus intelligente, vous payez pour que la même réponse arrive plus vite.

Le mode rapide impose une version minimale de Claude Code : v2.1.36 ou ultérieure. Depuis la v2.1.154, Opus 4.8 est le modèle par défaut utilisé dès que le mode rapide est activé, ce qui explique pourquoi le changement de modèle se fait automatiquement quand vous tapez /fast. La prise en charge du mode rapide n'est pas permanente pour tous les niveaux de modèle. Le mode rapide pour Opus 4.7 a été déprécié le 25 juin 2026, et Anthropic prévoit de le supprimer entièrement le 24 juillet 2026 ; après cette date, demander le mode rapide sur Opus 4.7 renverra une erreur au lieu de se dégrader silencieusement. Le mode rapide d'Opus 4.6 a déjà été retiré plus tôt, le 29 juin 2026, et il se comporte différemment : au lieu de renvoyer une erreur, les requêtes en mode rapide sur Opus 4.6 reviennent silencieusement à la vitesse et à la facturation standard. Vous pouvez détecter ce repli silencieux en vérifiant le champ usage.speed dans les réponses API ; si vous attendiez le mode rapide et que le champ n'indique pas fast, vous avez été facturé au tarif standard alors que vous pensiez avoir opté pour la prime.

L'erreur la plus coûteuse à éviter avec le mode rapide est de l'activer en plein milieu d'une longue conversation. Quand vous basculez /fast en cours de session, Claude Code n'applique pas simplement le tarif rapide et coûteux aux nouveaux messages à venir. Il refacture tout le contexte existant au tarif d'entrée du mode rapide sans mise en cache. Normalement, la mise en cache des prompts permet de refacturer le contexte répété à un tarif fortement réduit lors des tours suivants. Changer de vitesse invalide ce cache, donc une session avec 100 000 tokens de contexte accumulé qui bascule en mode rapide paie le plein tarif d'entrée du mode rapide sur les 100 000 tokens à nouveau, pas seulement sur la réponse suivante. La règle pratique : décidez si vous voulez le mode rapide avant de commencer une session, ou ne l'utilisez pas du tout dans cette session. L'activer en cours de route peut transformer une conversation longue et bon marché en une conversation coûteuse en une seule étape.

Le mode rapide dispose de son propre pool de limites de débit, distinct des limites de débit standard d'Opus. Si vous épuisez la limite du mode rapide, les requêtes reviennent automatiquement à la vitesse standard plutôt que d'échouer purement et simplement, donc une rafale d'utilisation en mode rapide ne cassera pas votre session, elle deviendra simplement plus lente et moins chère une fois la limite atteinte. Pour les administrateurs qui gèrent une équipe, deux réglages settings.json existent : définir "fastMode": true l'active, fastModePerSessionOptIn peut forcer chaque utilisateur à opter pour le mode rapide par session plutôt que de l'avoir activé par défaut, et définir la variable d'environnement CLAUDE_CODE_DISABLE_FAST_MODE=1 désactive entièrement le mode rapide au niveau de la machine ou de l'équipe. Sur un plan d'abonnement Claude (et non une facturation API à l'usage), l'utilisation du mode rapide puise exclusivement dans votre pool de crédits d'usage et ne touche jamais aux limites de messages incluses dans votre plan, c'est donc une ligne budgétaire séparée à surveiller.

Le mode rapide n'est pas disponible partout. Il ne fonctionne pas dans l'extension VS Code, et il n'est pas disponible lorsque vous exécutez Claude via Amazon Bedrock, Google Cloud Vertex AI ou Microsoft Foundry ; c'est une fonctionnalité propre à Claude Code et à l'API directe uniquement. Utilisez-le pour du travail interactif sensible à la latence, comme des sessions de pair-programming où vous regardez le flux de sortie et attendez la réponse de Claude avant votre prochaine action. Évitez-le pour les longs traitements par lots, les refactorisations de nuit, ou toute charge de travail où le coût total compte plus que gagner quelques secondes par réponse, car doubler le prix par token s'accumule rapidement sur un travail à volume élevé.

• /fast est un basculement de configuration de requête sur les mêmes poids Opus, pas un modèle séparé moins cher ou moins performant.
• Le mode rapide coûte le double : 10 $/50 $ par MTok sur Opus 4.8 contre 5 $/25 $ en standard, pour une sortie jusqu'à 2,5 fois plus rapide.
• L'activer en cours de conversation refacture tout le contexte existant au tarif coûteux ; décidez en début de session, pas en cours de route.
• Vérifiez usage.speed dans les réponses API pour détecter un repli silencieux vers la vitesse et la facturation standard, en particulier sur les modèles dont le mode rapide a été retiré comme Opus 4.6.

La revue de code a trois profondeurs

Claude Code embarque une famille intégrée de commandes de revue sous /code-review (en date de juillet 2026). Dans sa forme la plus simple, /code-review examine votre diff actuel (l'ensemble des lignes que vous avez modifiées mais pas encore validées ni fusionnées) et rapporte deux types de constats : des bugs de correction et des opportunités de nettoyage. Vous n'avez pas besoin de décrire ce que vous avez changé. La commande lit le diff elle-même et raisonne dessus.

Chaque exécution se déroule à un niveau d'effort, un curseur qui arbitre entre profondeur de revue et bruit. Aux niveaux low ou medium, la revue renvoie moins de constats, mais chacun est à haute confiance : des choses dont Claude est plutôt sûr qu'il s'agit de vrais problèmes. Au niveau high et au-delà, la revue élargit sa couverture, ce qui signifie qu'elle examine davantage de code environnant et davantage de modes de défaillance possibles, et elle peut faire remonter des constats dont elle est moins certaine. Ce compromis est intentionnel : le faible effort est pensé pour une vérification de bon sens rapide pendant que vous itérez encore, le fort effort est pensé pour le moment juste avant d'ouvrir réellement une pull request (une PR, la demande de fusionner votre branche dans la base de code principale).

Deux options changent ce qu'il advient des constats une fois qu'ils existent. --comment publie chaque constat comme commentaire en ligne sur la pull request, rattaché à la ligne exacte qu'il concerne, de sorte qu'un relecteur humain voit les notes de Claude aux côtés de sa propre lecture du diff. --fix saute l'étape de discussion et applique les constats directement à votre arborescence de travail (les fichiers sur disque dans votre checkout local). Utilisées ensemble ou séparément, ces options vous laissent choisir entre une revue qui informe un humain et une revue qui édite du code en votre nom.

Pour tout ce qui présente des enjeux plus élevés, il y a /code-review ultra. Cela lance une revue multi-agents qui s'exécute dans le cloud plutôt qu'en local : plusieurs instances d'agent examinent la branche indépendamment, et leurs constats sont ensuite vérifiés de façon contradictoire, ce qui signifie qu'un agent essaie activement de réfuter ou de trouver des failles dans ce qu'un autre agent a affirmé avant que cela ne vous soit rapporté. Cela permet d'attraper les faux positifs qu'une passe unique a tendance à produire. Notez l'historique du nom : ce mode s'appelait auparavant ultrareview en tant que commande autonome ; cet alias est désormais déprécié (encore reconnu en date de juillet 2026, mais destiné à disparaître, donc adaptez vos habitudes et vos scripts vers /code-review ultra). Vous pouvez aussi cibler une pull request spécifique plutôt que votre branche actuelle : /code-review ultra 482 passe en revue la PR numéro 482 directement.

La revue ultra n'est pas gratuite au-delà d'un certain point. En date de juillet 2026, les abonnés aux offres Pro et Max bénéficient de trois exécutions ultra gratuites, après quoi chaque exécution coûte environ 5 à 20 dollars en crédits d'usage selon la taille du diff passé en revue. Pour les équipes qui veulent cela dans l'intégration continue (CI, le pipeline automatisé qui s'exécute à chaque push), il existe une sous-commande distincte claude ultrareview pensée pour être appelée depuis des scripts CI plutôt qu'interactivement.

Une exigence stricte traverse tout cela : il vous faut un dépôt git (un dossier suivi par le système de contrôle de version git). La forme sans argument de /code-review ultra regroupe votre branche locale et l'envoie pour revue, et elle ne nécessite pas de remote GitHub (une copie du dépôt hébergée sur GitHub) pour fonctionner ; seule la forme avec numéro de PR a besoin que la PR existe réellement sur GitHub.

Une échelle raisonnable : lancez le simple /code-review à l'effort par défaut pendant que vous écrivez encore le code, comme vérification bon marché. Montez à l'effort high juste avant d'ouvrir une PR, quand vous voulez une couverture plus large même au prix de quelques constats incertains. Passez à ultra sur les changements qui sont volumineux, touchent une infrastructure partagée, ou vous inquiètent : l'étape de vérification contradictoire rentabilise son coût quand une deuxième, ou troisième, passe indépendante attrape quelque chose qu'une seule passe n'attraperait pas. Quelle que soit la profondeur, souvenez-vous qu'un constat de revue est une hypothèse, pas un verdict : reproduisez le bug avant de refactoriser autour.