Ce qu’est Claude Code et comment tourne la boucle.
Chapitre 1 · Partie I
Le terminal a appris à parler
Bienvenue. Ceci est un manuel de praticien pour Claude Code tel qu’il existe en octobre 2026 : cent chapitres courts, chacun destiné à vous apprendre une chose utilisable avant que l’eau ne bouille. Il s’adresse aux développeurs, et aux non-développeurs techniques qui s’assoient de plus en plus souvent à côté d’eux en se demandant s’ils ont le droit de toucher au dépôt. Vous l’avez. Avec précaution.
Commençons par la description simple. Claude Code est l’outil de programmation agentique d’Anthropic. Il lit une base de code, modifie des fichiers, exécute des commandes et vérifie son propre travail, et vous pilotez le tout par la conversation. Cette dernière partie évoque un chatbot. La première, non. Un chatbot vous dit ce que vous pourriez taper. Claude Code le tape, l’exécute, lit l’erreur et recommence.
La différence compte plus qu’il n’y paraît. L’autocomplétion termine votre phrase ; un agent termine votre tâche. Mettons que vous tapiez, dans un répertoire de projet, claude, puis : les tests de dates échouent tous les lundis, trouve pourquoi. Il ne devine pas d’après la forme de votre question. Il cherche les tests avec Grep, ouvre les fichiers avec Read, lance la suite avec Bash, remarque qu’une fonction utilitaire suppose que la semaine commence le dimanche, corrige cette fonction et relance la suite pour voir si elle passe désormais. Vous avez regardé ; vous avez peut-être approuvé une étape ou deux ; vous n’avez pas écrit le correctif. Il vous a pourtant fallu décider si ce correctif était le bon. Gardez cette idée en tête. C’est la colonne vertébrale de ce livre.
Le terminal est l’endroit où tout a commencé, et celui où beaucoup le rencontrent encore, mais l’agent n’y vit plus seul. Le même agent se trouve dans une application de bureau aux diffs visuels, dans le navigateur à claude.ai/code où il tourne dans un conteneur cloud, dans VS Code et JetBrains, sur votre téléphone, dans Slack et dans GitHub. Les parties suivantes franchissent chacune de ces portes. Pour l’instant, il suffit de savoir qu’elles ouvrent toutes sur la même pièce : un modèle, un jeu d’outils, et une boucle qui tourne jusqu’à ce que le travail soit fait ou qu’elle ait besoin de vous.
Un agent n’est pas un clavier plus malin. C’est un collègue qui ne se fatigue jamais et qui, parfois, comprend de travers.
Qu’est-ce que cela exige de vous ? Moins de frappe et plus de jugement. Vous passerez votre temps à dire ce que vous voulez avec une certaine précision, à regarder le travail défiler et à relire ce qui revient. Ce sont de vieilles compétences, celles qu’ont toujours eues les bons éditeurs et les bons managers, appliquées à un nouveau genre de collaborateur. Certains lecteurs y trouvent un soulagement. D’autres trouvent cela vaguement troublant, comme découvrir que le lave-vaisselle a des opinions. Les deux réactions sont raisonnables. Aucune n’est une raison de rester hors de la cuisine. Ouvrez un terminal dans un projet que vous connaissez bien, tapez claude et posez une question dont vous connaissez déjà la réponse. Puis regardez s’il la trouve comme vous l’auriez trouvée. C’est l’étalonnage le moins cher que vous vous offrirez jamais. Le terminal a appris à parler. À vous d’apprendre quand l’écouter.
Fig. 1 · Le terminal a appris à parler. Un agent termine la tâche.
Chapitre 2 · Partie I
Brève histoire d’une année rapide
L’histoire est courte, faute de temps pour en avoir une longue. Claude Code est apparu en préversion de recherche en février 2025 : un outil en ligne de commande pour ceux qui acceptaient de lâcher un modèle dans leur terminal. Il est passé en disponibilité générale en mai 2025, en même temps que les modèles Claude 4. En octobre 2026, c’est moins un outil qu’une famille de portes ouvrant sur le même agent : la CLI, une application de bureau, le web, des extensions d’IDE, le mobile, Slack, une extension Chrome, GitHub Actions, et un Remote Control qui permet à votre téléphone de piloter une session tournant sur votre propre machine.
Cela fait beaucoup de changements pour un bout de calendrier aussi court, et cela produit une angoisse bien particulière. Vous apprenez une façon de travailler le lundi et vous lisez le jeudi que quelqu’un en a une meilleure. Une commande sur laquelle vous comptiez se voit dotée d’une petite sœur. Le modèle que vous aviez choisi a un cousin plus récent. Si vous êtes de ceux qui aiment avoir fini d’apprendre une chose avant de s’en servir, ce rythme est légèrement cruel.
La réponse stoïcienne consiste à séparer ce qui bouge de ce qui ne bouge pas. Ce qui bouge, c’est la surface : les commandes, les menus, la porte que vous empruntez, le nom des derniers modèles. Ce qui ne bouge pas, c’est la forme en dessous. Un agent rassemble du contexte, agit, vérifie le résultat et recommence. Vous lui dites à quoi ressemble « terminé » et vous vérifiez qu’il y est arrivé. Les permissions décident de ce qu’il peut faire sans demander. Les fichiers de mémoire lui disent ce qu’il devrait déjà savoir. Ces idées étaient vraies pendant la préversion et elles le sont encore. Apprenez-les correctement, et le reste n’est que du vocabulaire.
Quelques habitudes pratiques transforment aussi ce rythme, de menace, en simple météo. Si vous installez avec l’installateur natif, Claude Code se met à jour tout seul, si bien que vous n’avez jamais beaucoup de retard. Quand quelque chose de nouveau apparaît, tapez /help dans une session plutôt que d’écumer les fils où d’autres étalent leur enthousiasme. Quand quelque chose se comporte bizarrement après une mise à jour, /doctor examine votre configuration et vous dit ce qu’il trouve. Et quand vous lisez un billet de blog sûr de lui à propos d’une fonctionnalité, vérifiez s’il est antérieur à la dernière modification de ladite fonctionnalité. Beaucoup le sont.
Les outils rapides récompensent les principes lents.
Une année rapide donne envie de tout adopter. Résistez. Chaque nouvelle surface est utile à quelqu’un, mais elles ne vous sont pas toutes utiles ce mois-ci. Choisissez la porte que vous franchirez réellement chaque jour, apprenez ses habitudes, et n’ajoutez la suivante que lorsque vous ressentez un manque précis. Un développeur qui maîtrise la CLI sera plus productif qu’un autre qui a installé toutes les extensions et ne fait confiance à aucune.
Le rythme continuera. Ce n’est pas une prévision, juste une observation sur les vingt derniers mois. Vous ne pouvez pas le ralentir et vous n’avez pas besoin de tout suivre. Vous avez besoin de suivre la partie qui touche votre travail, et de savoir où le reste est écrit le jour où il vous servira. La nouveauté ne coûte rien. C’est l’aisance qui rapporte des intérêts.
Fig. 2 · Brève histoire d’une année rapide. Ce qui change, ce qui reste.
Chapitre 3 · Partie I
Rassembler, agir, vérifier
Chaque session de Claude Code, grandiose ou insignifiante, fait tourner la même boucle. Elle rassemble du contexte, agit, vérifie le résultat, et recommence jusqu’à ce que la tâche soit finie ou qu’elle ait besoin de vous. Dès que vous voyez la boucle, vous pouvez la diriger. Tant que vous ne la voyez pas, l’agent ressemble à un prestidigitateur, et on corrige mal un prestidigitateur.
Rassembler est la partie silencieuse. Demandez-lui d’ajouter une limitation de débit à une API et il ne se mettra pas à écrire. Il utilisera Glob pour trouver les fichiers de routes, Grep pour trouver où les requêtes sont traitées, et Read pour ouvrir le middleware que vous avez déjà. Il jettera peut-être un œil au manifeste de paquets pour voir quelles bibliothèques sont installées. C’est l’agent qui fait ce que fait une recrue sensée le premier matin : regarder autour de soi avant de toucher à quoi que ce soit. Si la collecte est maigre, le travail sera assuré et faux. Vous pouvez l’aider en désignant les choses directement, avec une mention @path comme @src/middleware/auth.ts, pour qu’il commence dans la bonne pièce.
Agir est la partie pour laquelle on vient. Claude modifie un fichier avec Edit, en crée un avec Write, ou lance une commande avec Bash. Selon votre mode de permission, certaines de ces actions s’arrêteront pour vous demander d’abord. Dans le mode par défaut, affiché comme Manual (manuel), il demande avant les modifications, les commandes et l’accès réseau. Cette pause n’a rien de bureaucratique. C’est votre occasion de voir l’action avant qu’elle ne se produise, c’est-à-dire le moment où objecter coûte le moins.
Vérifier est la partie qui distingue un agent d’une autocomplétion cultivée. Après une modification, Claude lance les tests, démarre le build, appelle l’endpoint ou relit le fichier pour voir si le changement a atterri comme prévu. Si quelque chose échoue, il lit l’échec et refait un tour. La qualité de cette étape dépend surtout d’une question : la vérification est-elle seulement possible ? Un projet doté d’une suite de tests offre un miroir à l’agent. Un projet sans tests ne lui offre que sa propre opinion, à peu près aussi fiable que la vôtre à deux heures du matin.
Dites-lui donc comment vérifier. Ajoute une limitation de débit à la route de connexion, puis lance npm test et montre-moi la sortie vaut mieux que ajoute une limitation de débit, parce que la consigne nomme la ligne d’arrivée. Vous serez surpris de voir combien de fois la différence entre une bonne session et une session confuse tient à une seule phrase sur la vérification.
La boucle n’est jamais plus honnête que sa dernière étape.
Vous avez le droit d’entrer dans la boucle à tout moment. Appuyez sur Échap et Claude s’arrête ; vous pouvez le réorienter sans perdre la session. Vous pouvez aussi taper pendant qu’il travaille : votre message attend dans une file jusqu’à ce qu’il relève la tête. S’il est parti quelque part où vous ne vouliez pas aller, appuyez deux fois sur Échap, ou utilisez /rewind, pour ramener le code et la conversation à un point de sauvegarde antérieur. Rien de tout cela n’est impoli. C’est ainsi que la collaboration est censée fonctionner. Observez trois ou quatre sessions en gardant la boucle à l’esprit et vous commencerez à voir où les vôtres déraillent. C’est généralement à la première étape ou à la dernière. Le milieu, curieusement, se débrouille tout seul.
Fig. 3 · Rassembler, agir, vérifier. Chaque session tourne en boucle.
Chapitre 4 · Partie I
Installer sans cérémonie
L’installation est la partie la moins intéressante de Claude Code et devrait vous prendre le moins de temps. Il existe une poignée de méthodes, toutes courtes, et la bonne est celle à laquelle vous n’aurez plus jamais à penser.
La voie recommandée est l’installateur natif. Sur macOS, Linux ou WSL, ouvrez un terminal et lancez curl -fsSL https://claude.ai/install.sh | bash. Sous Windows, la documentation officielle propose une ligne PowerShell équivalente. La vertu de l’installation native n’est pas la vitesse mais l’entretien : elle se met à jour toute seule en arrière-plan. Vu la vitesse à laquelle l’outil évolue, cela vaut plus qu’il n’y paraît. Une installation périmée est la raison la plus courante pour laquelle un chapitre comme celui-ci semble ne pas correspondre à votre écran.
Si vous préférez un gestionnaire de paquets, deux chemins sont bien balisés. Sur Mac, brew install --cask claude-code fonctionne comme on s’y attend. Sous Windows, WinGet fait le même travail. Ce sont d’excellents choix pour ceux qui gèrent tout avec un seul outil et s’en trouvent bien. Ayez simplement les idées claires sur qui est responsable des mises à jour, car un cask que vous ne mettez jamais à niveau vieillira en silence pendant que la documentation avance sans lui.
Choisissez l’installation que vous oublierez, puis oubliez-la.
Une fois l’outil installé, placez-vous dans un répertoire de projet et tapez claude. Le premier lancement vous demande de vous connecter. Il vous faut soit un abonnement Claude, comme Pro, Max, Team ou Enterprise, soit une facturation API via une clé Anthropic ou un fournisseur cloud. Prenez celle qui correspond à la façon dont vous, ou votre organisation, payez déjà ; la partie suivante de ce livre consacre un chapitre à la différence. Ceci fait, l’invite vous attend et le vrai travail peut commencer.
Passons à ce dont personne ne parle avant que ça tourne mal. Parfois, l’outil boude. La commande est introuvable, ou bien il démarre mais n’arrive pas à s’authentifier, ou il se comporte comme si un réglage que vous avez fait n’existait pas. Avant de fouiller Internet, lancez /doctor dans une session. Il diagnostique votre installation et votre configuration et vous dit ce qu’il trouve, généralement quelque chose de banal : deux copies installées par deux voies différentes, un chemin qui n’inclut pas le binaire, un fichier de réglages avec une virgule en trop. /status est son compagnon plus doux, utile à consulter quand vous soupçonnez que la session n’est pas configurée comme vous le croyez.
Un minimum d’hygiène paie ici. N’installez que par une seule voie ; si vous en changez, retirez l’ancienne. Gardez le chemin de votre shell en ordre. Si vous travaillez sur plusieurs machines, utilisez partout la même méthode, pour qu’un problème sur l’une ait la même solution sur les autres. Et si vous préparez le terrain pour une équipe, inscrivez l’étape d’installation dans les notes d’accueil du projet, en une ligne, pour que la personne suivante n’invente pas une sixième méthode. Rien de tout cela n’est glorieux. C’est un peu le but. La meilleure installation est celle dont vous n’avez jamais à vous souvenir.
Fig. 4 · Installer sans cérémonie. Installez une fois, oubliez.
Chapitre 5 · Partie I
Vos cinq premières minutes
Choisissez un dépôt que vous connaissez raisonnablement bien. Pas le plus important de l’entreprise, ni un jouet bricolé hier soir ; quelque chose entre les deux, où vous reconnaîtriez une mauvaise réponse. Ouvrez-y un terminal et tapez claude. Vous voilà dans une session, et le curseur attend que vous disiez quelque chose de sensé.
Commencez par lui demander d’expliquer la base de code. Quelque chose comme : Explique-moi comment ce projet est organisé, comme si j’arrivais lundi. Par où entre une requête, et où les données sont-elles stockées ? Regardez ce qu’il fait avant de répondre. Il va lister des fichiers, chercher, en ouvrir quelques-uns. La réponse qui revient teste utilement deux choses à la fois : si l’agent lit bien, et si votre projet est lisible. S’il se trompe sur la structure, c’est peut-être l’agent ; c’est peut-être aussi que votre structure est réellement déroutante, ce qui est bon à savoir.
Ensuite, faites un tout petit changement. Pas une fonctionnalité ; une amélioration modeste et vérifiable. Corrigez un message d’erreur trompeur, ajoutez une description --help manquante, rectifiez l’étape d’installation du README que tout le monde saute sans rien dire. Soyez précis : Dans @README.md, la section d’installation dit de lancer make setup mais le Makefile n’a pas de cible de ce nom. Corrige les instructions pour qu’elles correspondent au Makefile. Les demandes précises produisent de petits diffs, et les petits diffs sont ceux qu’on peut vraiment relire.
Quand il voudra modifier, il demandera. Dans le mode de permission par défaut, affiché comme Manual, chaque modification et chaque commande attend votre accord. Pour une première session, c’est exactement ce que vous voulez. Lisez chaque changement proposé au moment où il apparaît. Si la formulation ne va pas, dites-le en langage clair et laissez-le réviser. Vous n’êtes pas tatillon. Vous étalonnez.
Le premier diff que vous approuvez vous apprend plus que les dix premiers que vous survolez.
Puis relisez le changement dans son ensemble. Dans le terminal, demandez-lui d’afficher le diff, ou lancez git diff vous-même. Si vous préférez quelque chose de plus visuel, l’application de bureau et l’extension VS Code affichent toutes deux les changements en ligne. Cherchez les modifications que vous avez demandées, puis celles que vous n’avez pas demandées. Un agent serviable range parfois une ligne voisine au passage. Ce peut être très bien. Ce ne devrait jamais être une surprise. Enfin, commitez. Vous pouvez demander à Claude de le faire, et il rédigera un message correct, ou le faire vous-même pour garder la cérémonie entre vos mains. Dans les deux cas, le changement est désormais dans git, ce qui compte, car git est votre véritable filet de sécurité. Claude Code garde ses propres points de sauvegarde des modifications, mais c’est une commodité, pas un historique.
Cinq minutes, une explication, un petit changement, une relecture honnête, un commit. Voilà toute la forme du travail, en miniature. Les tâches plus grandes ont pour l’essentiel la même forme, avec plus de patience au milieu. Si la session s’est bien passée, tentez un changement un peu plus gros demain. Si elle s’est mal passée, regardez où : en général, la demande était plus vague qu’elle n’en avait l’air au moment de la taper. Commencez petit. L’agent ne s’en offusquera pas, et vos collègues non plus.
Fig. 5 · Vos cinq premières minutes. Cinq minutes, une vraie revue.
Chapitre 6 · Partie I
Les outils sont ses mains
Un modèle seul ne sait produire que du texte. Ce qui en fait un agent, c’est un ensemble d’outils : des capacités nommées et étroites qui lui permettent de toucher le monde. Les outils de Claude Code portent des noms simples, et il vaut la peine de les apprendre, car ces noms sont aussi les poignées par lesquelles vous accordez ou refusez une permission.
Les outils de lecture viennent en premier. Read ouvre un fichier. Glob trouve des fichiers par motif, et peut donc répondre à où sont tous les fichiers de test ? sans rien ouvrir. Grep cherche dans le contenu des fichiers ; c’est ainsi que Claude trouve tous les appelants d’une fonction avant d’en changer la signature. Ces trois-là servent à rassembler le contexte, et ils sont pour l’essentiel inoffensifs : regarder n’est pas toucher. Les outils d’écriture sont Edit, qui modifie une partie d’un fichier existant, et Write, qui crée un fichier ou en remplace un entièrement. La distinction est pratique. Un Edit est une intervention chirurgicale que vous pouvez relire ligne par ligne. Un Write est une page entièrement neuve, et mérite un regard un peu plus sévère.
Vient ensuite Bash, qui exécute des commandes shell. Bash est l’outil le plus puissant de la boîte, donc celui auquel il faut réfléchir. C’est par lui que Claude lance vos tests, démarre votre build, installe une dépendance ou consulte git status. C’est aussi, en principe, par lui qu’il pourrait supprimer un répertoire. L’essentiel de la mécanique de permissions que vous rencontrerez plus loin existe à cause de Bash.
Deux outils sortent de votre machine. WebFetch récupère une page précise, comme la documentation à jour d’une bibliothèque dont l’API a changé le mois dernier. WebSearch cherche quand Claude ne connaît pas la page. Enfin, Agent lance un sous-agent : un travailleur distinct, doté de son propre contexte, qui part faire une recherche ou une tâche et ne rapporte que son compte rendu. Vous rencontrerez les sous-agents en bonne et due forme dans une partie ultérieure. Pour l’instant, sachez qu’ils évitent à la conversation principale de se remplir de chaque fichier qu’une recherche a effleuré.
Une règle de permission n’est jamais plus précise que le nom d’outil qu’elle contient.
Voici pourquoi les noms comptent. Les règles de permission d’un fichier de réglages s’écrivent en fonction d’eux. "allow": ["Bash(npm test)"] laisse Claude lancer votre commande de test sans demander. "allow": ["WebFetch(domain:github.com)"] le laisse lire librement les pages GitHub. "deny": ["Bash(rm -rf *)"] interdit purement et simplement un certain genre de catastrophe, et un deny l’emporte sur un allow dans tous les modes. Vous pouvez voir et modifier ces règles avec /permissions. Les outils fournis par des serveurs MCP suivent eux aussi un motif, sous la forme mcp__<server>__<tool>, et peuvent donc être autorisés ou refusés de la même manière.
Quand une demande de permission apparaît, elle nomme l’outil et montre ce qu’il veut faire. Lisez cette ligne. En une semaine, vous remarquerez que vous approuvez sans cesse les mêmes choses, généralement des lancements de tests et des lectures, et ce sont de bons candidats pour une règle allow. Les demandes que vous voyez rarement sont celles qui méritent de rester des demandes. Apprenez à connaître ses mains, et vous saurez lesquelles attacher et lesquelles laisser libres.
Fig. 6 · Les outils sont ses mains. Les noms d'outils sont des poignées.
Chapitre 7 · Partie I
Choisir un esprit
Claude Code fonctionne avec les modèles Claude, et c’est vous qui choisissez lequel. Fin 2026, la famille comprend Opus 5.5, Sonnet 5.5, Haiku 4.5 et Fable 5.1. La documentation décrit à quoi sert chacun, et elle change à mesure que la famille s’agrandit ; traitez donc tout résumé, y compris le mien, comme un point de départ et non comme une loi. Changer est simple. Tapez /model dans une session et choisissez dans la liste. Le choix vaut pour cette session, et vous pouvez en changer en cours de route si le travail change de nature. Vous pouvez aussi définir un modèle par défaut dans votre fichier de réglages, sous la clé model, pour que chaque nouvelle session démarre là où vous la voulez d’habitude.
Le second cadran est l’effort. /effort règle la profondeur à laquelle le modèle raisonne avant d’agir, avec des niveaux comme low, medium, high, xhigh et max. Plus d’effort, c’est plus de réflexion : des plans plus soignés, davantage d’attention aux cas limites, et plus de tokens et de temps pour y parvenir. Moins d’effort, c’est l’allure vive. Aucun n’est meilleur dans l’absolu. Une variable renommée ne demande pas une pensée profonde, et un bug de concurrence dans un flux de paiement ne mérite pas une pensée expéditive.
La bonne habitude consiste à choisir selon la tâche, pas selon la vanité. Il existe une forte tentation de toujours prendre le plus gros modèle à l’effort maximal, au nom de l’idée qu’on ne lésine pas sur l’intelligence. L’idée est noble et marche mal. Un modèle poids lourd à l’effort maximal, prié de corriger une coquille, corrigera la coquille après une pause assez longue pour vous faire craindre qu’il soit mort. Pendant ce temps, votre quota fond pour rien. Accordez l’esprit au travail : un généraliste capable pour le quotidien, plus de profondeur quand le problème est réellement difficile ou ambigu, quelque chose de plus léger et plus rapide pour les corvées mécaniques.
Le bon modèle est le moins cher de ceux qui font bien le travail.
Reste la question du contexte. Les modèles compatibles offrent une fenêtre allant jusqu’à un million de tokens, de quoi contenir une base de code conséquente plus une longue conversation. Il est tentant d’y voir la permission de ne plus jamais penser au contexte. N’en faites rien. Une grande fenêtre signifie moins d’interruptions, pas une attention infinie. Un modèle à qui l’on donne tout doit encore trouver ce qui compte, et une session encombrée de trois approches abandonnées se pilote plus mal qu’une session neuve. Utilisez /context pour voir ce qui remplit la fenêtre, et /clear quand vous changez de sujet.
Une bonne façon de travailler ressemble à ceci. Commencez la journée sur votre modèle habituel avec un effort modéré. Quand une tâche résiste, quand l’agent fait deux fois le tour de la boucle sans progresser, augmentez l’effort avant de toucher à quoi que ce soit d’autre, car c’est souvent la profondeur qui manquait. Quand arrive une série de changements de routine, baissez-le de nouveau. Traitez ces cadrans comme les vitesses d’un vélo : on les change pour la côte, pas pour l’image qu’on a de soi.
Personne ne vous décernera de médaille pour avoir utilisé le plus gros modèle sur une correction de README. Choisissez l’esprit dont la tâche a besoin, et gardez la réflexion lourde pour les problèmes qui l’ont méritée.
Fig. 7 · Choisir un esprit. Le cerveau selon la tâche.
Chapitre 8 · Partie I
Le prix du privilège
Claude Code coûte de l’argent, et mieux vaut comprendre comment avant que la facture ou la limite ne se présente d’elle-même. Je ne citerai pas de prix ici. Ils changent, et un livre qui en cite tourne plus vite que le lait. Ce qui change peu, c’est la structure.
Il y a deux façons de payer. La première est un abonnement Claude : Pro, Max, Team ou Enterprise. Vous vous connectez avec votre compte Claude et votre usage de Claude Code puise dans ce forfait. La seconde est la facturation API, soit avec une clé API Anthropic, soit via un fournisseur cloud que votre organisation utilise déjà. Là, vous payez ce que vous consommez. Les abonnements conviennent aux individus et aux équipes qui veulent de la prévisibilité. La facturation API convient aux organisations qui font déjà passer leurs dépenses par un compte cloud, et au travail automatisé qui doit être mesuré avec précision. Beaucoup d’équipes utilisent les deux : des abonnements pour les personnes, la facturation API pour les pipelines.
Dans les deux cas, il existe des limites d’utilisation. Un abonnement n’est pas un buffet à volonté ; les forfaits ont des quotas, et les grosses journées peuvent les atteindre. La facturation API a ses propres contraintes. Les chiffres exacts ont leur place dans la documentation, qui sera à jour quand ce chapitre ne le sera plus. Ce qui compte, c’est qu’une limite existe, et que vous pouvez voir à quelle distance vous en êtes.
Deux commandes aident. /cost montre ce que la session en cours a dépensé. /usage montre ce que vous avez consommé. Jetez-y un œil à la fin d’une longue session pendant une semaine et vous développerez un instinct pour les types de travail qui coûtent cher. Ce sont rarement ceux qu’on croit. Une session qui a relu douze fois le même énorme fichier de log dépensera plus qu’une session qui a écrit une fonctionnalité entière.
Dépensez de l’attention avant de dépenser des tokens. L’attention coûte moins cher, et elle rapporte.
Cette phrase est le cœur pratique du chapitre. L’essentiel du gaspillage ne vient ni d’un gros modèle ni d’un effort élevé. Il vient des demandes vagues. Améliore le tableau de bord invite l’agent à tout lire, à essayer plusieurs choses et à vous demander ce que vous vouliez dire. Fais en sorte que l’indicateur de chargement du tableau de bord n’apparaisse qu’après 300 millisecondes, dans @src/components/Dashboard.tsx coûte une fraction de cela, et produit quelque chose que vous relirez en une minute. Trente secondes de votre réflexion remplacent de longues minutes de son exploration.
Quelques autres habitudes aident. Utilisez /clear quand vous changez de sujet, pour que la tâche suivante ne traîne pas derrière elle le contexte de la précédente. Laissez /compact résumer une longue session plutôt que de transporter chaque échange. Choisissez l’effort délibérément, comme le suggérait le chapitre précédent. Et si vous vous surprenez à répéter la même explication à chaque session, mettez-la une fois pour toutes dans un fichier CLAUDE.md, sujet qu’une partie ultérieure traite en détail. Rien de tout cela n’est de l’avarice. C’est la même discipline qui fait un bon cahier des charges pour un prestataire : un périmètre clair, une ligne d’arrivée connue, et personne de payé pour errer dans le bâtiment à la recherche du problème. L’agent ne voit aucun inconvénient à errer. Votre budget, si. L’argent dépensé en clarté est le seul qu’on ne regrette jamais.
Fig. 8 · Le prix du privilège. L'attention avant les tokens.
Chapitre 9 · Partie I
Ce qu’il fait mal
Tout manuel honnête a un chapitre sur l’échec, et le voici. Claude Code est très bon dans un grand nombre de domaines. Il est aussi mauvais dans quelques-uns, et l’ennui, c’est qu’il y est souvent mauvais avec la même voix calme et fluide que lorsqu’il a raison. Connaître la forme de ses échecs, c’est commencer à bien s’en servir.
Le premier est l’erreur assurée. L’agent vous dira parfois qu’une fonction fait ce qu’elle ne fait pas, ou annoncera que les tests passent alors qu’il a lancé les mauvais, ou expliquera un bug par une histoire cohérente et fausse. Ce n’est pas du mensonge. C’est la nature d’un système qui produit du texte plausible, et plausible est une propriété différente de vrai. La parade n’est pas de tout soupçonner ; ce serait épuisant. La parade, ce sont les preuves. Demandez-lui de vous montrer la sortie des tests, pas de vous la décrire.
Le deuxième, ce sont les hypothèses périmées. Le modèle a appris sur des données arrêtées à une date donnée, et les bibliothèques bougent. Il peut tendre la main vers une API renommée au printemps dernier, ou vers une option de configuration supprimée depuis. Quand quelque chose échoue d’une manière qui sent la dérive de version, orientez-le vers la documentation à jour avec WebFetch, ou dites-lui quelle version vous utilisez. Il s’adapte vite dès qu’il sait. Il ne peut pas savoir ce qu’on ne lui a pas montré.
Le troisième, ce sont les tâches vagues. Nettoie ce module n’a pas de ligne d’arrivée, alors l’agent en inventera une, qui ne sera peut-être pas la vôtre. Il pourrait renommer la moitié des variables, extraire trois fonctions utilitaires et réécrire par souci d’élégance une boucle qui marchait. Chaque changement se défend ; l’ensemble est un diff que personne ne veut relire. Les tâches vagues sont moins l’échec de l’agent qu’un échec partagé, mais c’est la production de l’agent que vous finirez par nettoyer.
L’aisance n’est pas l’exactitude. Traitez une réponse trop lisse comme un brouillon.
Le quatrième, c’est le goût. Claude peut vous dire qu’une conception est incohérente, et il peut suivre une charte de style avec un vrai soin. Ce qu’il ne peut pas faire de façon fiable, c’est savoir laquelle de trois approches raisonnables votre équipe aimera encore dans un an, ou que vos utilisateurs détestent un certain type de fenêtre modale, ou que l’abstraction élégante est la mauvaise parce que le produit s’apprête à changer de cap. Le goût est un contexte accumulé sur les gens et les conséquences. Vous en avez plus que n’importe quel modèle, et vous devriez continuer à l’exercer.
L’antidote aux quatre est le même : la vérification. Assurez-vous qu’il existe un moyen de contrôler le travail, et servez-vous-en. Des tests, un build qui tourne, une vraie requête contre l’endpoint, une lecture attentive du diff. Le mode plan aide aussi. Appuyez sur Maj+Tab jusqu’à ce qu’il s’affiche, et Claude lira et proposera sans rien modifier, si bien que vous pourrez corriger une hypothèse fausse avant qu’elle ne devienne quarante lignes modifiées. Et quand la réponse vous semble trop nette, demandez-lui de plaider contre lui-même. Il est étonnamment doué pour trouver la faille de sa propre histoire quand on l’invite à la chercher. L’agent n’est pas peu fiable. Il est fiable à la manière d’un inconnu compétent : utile dès la première heure, et digne de confiance à proportion de ce que vous avez vérifié.
Fig. 9 · Ce qu’il fait mal. Fluide n'est pas juste.
Chapitre 10 · Partie I
Déléguer, pas autocompléter
Tout, dans cette partie, se ramène à un changement dans la façon dont vous voyez votre propre rôle. Avec l’autocomplétion, vous restez l’auteur ; l’outil suggère le mot suivant et vous l’acceptez ou le rejetez. Avec Claude Code, vous êtes autre chose. Vous êtes la personne qui décide de ce qui doit être fait, qui le confie, et qui juge ce qui revient. Vous êtes devenu l’éditeur.
Ce n’est pas une rétrogradation. Les éditeurs ont toujours été ceux qui savent à quoi sert le texte. Ils n’écrivent pas chaque phrase, mais ils décident lesquelles survivent. En termes logiciels, vous définissez la tâche, les contraintes et, surtout, à quoi ressemble « terminé ». Puis vous lisez le diff comme un éditeur lit un manuscrit : pour savoir s’il fait ce qui était demandé, s’il fait quoi que ce soit qui ne l’était pas, et s’il embarrassera quelqu’un dans six mois.
Définir « terminé » est la compétence la plus rentable. Une bonne définition nomme une vérification qu’on peut réellement lancer. L’import gère les fichiers avec une marque d’ordre des octets ; ajoute un test avec un tel fichier ; la suite passe est une tâche avec une ligne d’arrivée. Rends les imports plus robustes est une humeur. Quand vous donnez une ligne d’arrivée à l’agent, il peut vérifier son propre travail dans la boucle, et votre relecture devient une confirmation plutôt qu’une enquête.
Déléguer, c’est l’art de dire exactement ce qu’on veut, puis de vérifier qu’on l’a obtenu.
Il y a des choses que vous devez garder. Les décisions difficiles à défaire, comme supprimer des données, publier une version ou modifier une interface dont dépendent d’autres équipes, restent les vôtres. Les jugements de goût restent les vôtres. De même que la lecture finale de tout ce qui part sous votre nom. Le système de permissions, qu’une partie ultérieure détaille, existe pour rendre ces frontières explicites : l’agent peut lancer les tests sans demander, mais doit demander avant de pousser.
Il y a aussi des choses que vous devez lâcher, et beaucoup trouvent cela plus difficile. Vous n’avez pas besoin de taper le code passe-partout, de traquer chaque appelant d’une fonction ou de vous rappeler l’option de cette commande-là. Vous n’avez pas besoin de surveiller chaque étape une fois que vous faites confiance à la boucle pour un type de tâche donné. Tourner autour d’un délégataire est un travers bien connu des équipes humaines, et c’est le même travers ici : il vous coûte de l’attention et ne vous apprend rien.
La posture de travail pour la suite de ce livre est donc simple à énoncer et longue à pratiquer. Dites ce que vous voulez avec précision. Dites comment ce sera vérifié. Laissez l’agent travailler. Relisez ce qu’il vous rend comme le ferait un éditeur, honnêtement, et avec votre nom dessus. Avec le temps, vous élargirez ce que vous déléguez, non parce que l’agent aura changé, mais parce que vous aurez appris où il est fiable. Le rez-de-chaussée est posé. Vous savez ce qu’est l’outil, comment tourne sa boucle, comment s’appellent ses mains, quel esprit choisir, ce qu’il coûte et où il trébuche. Tout ce qui se construit au-dessus n’est que détail et levier. Vous avez cessé d’être celui qui tape. Vous restez, toujours, celui qui dit que c’est fini.
Fig. 10 · Déléguer, pas autocompléter. D'auteur à éditeur.
Extrait gratuit · Partie I
Continuer la lecture
Vous avez lu les 10 premiers chapitres sur 100 de Claude Code : le guide ultime 2026. Le livre complet contient chaque chapitre et chaque planche, en PDF et EPUB, en anglais, français, polonais et espagnol.