Claude Code : ce n'est pas un chatbot

Tu décris ton problème dans une fenêtre de discussion. Tu récupères vingt lignes, tu les colles dans ton fichier, tu rattrapes l’indentation, tu relances. Ça marche plutôt bien, et c’est précisément pour ça que la question revient : on te répète qu’il existe une autre façon de travailler avec l’IA, et tu ne vois pas ce qu’elle aurait de si différent.

Ce qui se passe vraiment

La différence tient dans une seule question : qui touche aux fichiers ?

	Assistant	Agent
Qui écrit dans ton projet	toi	lui
Voit ton code réel	non	oui
Peut lancer tes tests	non	oui
Sait si sa réponse marche	jamais	après avoir essayé

Dans ce que tu fais aujourd’hui, l’IA répond du texte. Elle propose, tu appliques. Et surtout : elle travaille en aveugle. Elle ne voit pas ton fichier réel, ne peut pas lancer tes tests, ne saura jamais si sa proposition passe chez toi. C’est toi qui fais l’aller-retour, à la main, une bouchée à la fois.

L’autre façon de travailler porte un nom : l’agentic coding (un mode de travail où l’IA lit les fichiers, lance les commandes et modifie le code elle-même, pendant que tu regardes ou que tu la réorientes). Elle ne te décrit pas la correction : elle ouvre le fichier, l’écrit, relance les tests, lit l’erreur, recommence. C’est ça, la contrepartie — pas d’aller plus vite, mais de boucler : agir, constater, corriger, sans que tu serves de courroie de transmission entre l’IA et ton projet.

Où ça tourne. On travaillera dans le terminal tout au long de ce parcours. C’est un choix, pas une définition : l’outil existe aussi comme extension d’éditeur, application de bureau et version navigateur, avec la même mécanique — ce qui change, c’est l’endroit où le code s’exécute. Et il ne remplace pas ton éditeur : il tourne à côté, sur le même dossier, que tu gardes ouvert.

Claude Code n’est pas le modèle. C’est la deuxième chose à retenir, et celle qui vaut le détour. Claude Code est le harnais ; Claude est le modèle à l’intérieur. Le harnais est ce qui :

fournit les outils — lire, écrire, chercher, exécuter ;
décide de ce qui a besoin de ton autorisation ;
gère ce que le modèle a le droit de voir ;
enchaîne les actions les unes après les autres.

Chacune de ces briques a sa leçon plus loin. Retiens seulement qu’aucune n’est dans le modèle.

L’image à garder, parce qu’elle va servir tout au long du parcours : l’atelier et l’artisan. Tu ouvres l’atelier, tu en fixes les règles de sécurité, et tu reçois le travail fini. L’artisan travaille dedans. L’atelier n’est pas un décor : c’est lui qui décide quel outil l’artisan peut prendre sans demander, et à quel moment il doit lever la tête pour obtenir un accord.

Ce que cette distinction t’apporte : ce que tu apprends ici porte sur l’atelier. Les notions (autorisations, contexte, mémoire, moments de déclenchement) restent les mêmes quand tu changes d’artisan.

Leurs réglages, eux, bougent, et il faut le savoir tout de suite : certains outils ne sont pas fournis à tous les modèles, certains modes d’autorisation ne sont pas disponibles partout, et l’atelier lui-même est remanié plusieurs fois par mois.

Apprends les notions, vérifie les réglages le jour où tu t’en sers.

Ce qu’on fait

Il n’y a rien à installer dans cette leçon — l’installation est la suivante. Ce qui se met en place ici, c’est un réflexe et une conséquence.

Le réflexe. Devant n’importe quelle démonstration d’IA pour le code, pose la question de tri : qui applique le changement ? Si la réponse est « moi, en collant », tu regardes un assistant. Si la réponse est « elle, dans mes fichiers », tu regardes un agent. Les deux sont utiles, et la fin de cette leçon dit quand l’assistant reste le meilleur choix.

La conséquence, et c’est le point de toute la suite. Le copier-coller ne te faisait pas relire — soyons honnêtes, personne ne relit deux cents lignes collées. Ce qu’il t’imposait, c’était un plafond de débit. Vingt lignes par aller-retour, une bouchée à la fois. Ce n’était pas un contrôle, mais ça t’empêchait mécaniquement de prendre trop d’avance sur ta propre attention.

L’agent supprime le plafond. Il ne fournit pas le contrôle. C’est le seul écart qui compte, et c’est celui que tout le reste du parcours sert à combler — la leçon 10, « comment tu sais que ça marche, si tu ne lis pas le code », attaque la question de front.

En pratique — Dès ta première session, vérifie dans quel mode d’autorisation tu démarres. Selon ta version et ton offre, l’outil te demande validation avant chaque modification, ou travaille en autonomie avec des contrôles en arrière-plan. Ce n’est pas un détail, et ça a changé récemment : regarde plutôt que supposer. C’est le sujet de la leçon 8, « les permissions : jusqu’où on le laisse faire ».

Ce que ça ne fait pas

Agir n’est pas avoir raison. Un assistant qui se trompe produit un texte que tu ne colleras peut-être jamais. Un agent qui se trompe a déjà écrit. Il existe bien un filet — une photo de tes fichiers est prise avant chaque message que tu envoies. Mais il est plus troué qu’il n’y paraît : ce qui part vers une base de données ou un déploiement ne se rembobine pas, et même sur ton disque plusieurs cas y échappent. C’est le sujet de la leçon 7, « reprendre, revenir en arrière, ne rien perdre ». Retiens pour l’instant que ce filet ne remplace pas un enregistrement de ton travail.

Ce n’est pas une IA qui « connaît » ton projet. Elle ne voit que ce qui est entré dans son contexte. Ce qui n’y est pas n’existe pas pour elle — et c’est l’explication de la plupart des moments où elle fait n’importe quoi. C’est le sujet de la leçon 3, « comment ça marche vraiment ».

Ce n’est pas gratuit, et pas seulement en argent. Trois coûts apparaissent au moment précis où la machine se met à lire et à exécuter toute seule :

elle lit ce qu’elle juge utile — donc elle voit des choses que tu n’aurais pas collées toi-même. Si tu travailles sous clause de confidentialité, c’est un changement de nature ;
elle exécute ce qu’elle lit — un fichier hostile, une page web, une issue peuvent contenir des instructions qui s’adressent à elle. Ça porte un nom, et il vaut mieux le connaître parce que c’est celui sous lequel tu trouveras tout ce qui s’écrit dessus : la prompt injection (l’instruction glissée dans un contenu qu’il lit, et qui s’adresse à lui plutôt qu’à toi). Cette catégorie de risque n’existe pas en copier-coller. C’est la seule du parcours dont on puisse dire ça. La leçon 8 donne la barrière ;
elle consomme beaucoup plus : lire quarante fichiers pour une tâche n’a pas le même prix qu’un aller-retour de vingt lignes.

Conséquence directe : si ta tâche tient en vingt lignes collées, l’assistant reste le bon outil. Ce parcours ne dit pas le contraire.

Ce n’est pas une promesse de vitesse. Ce qui change n’est pas le temps que met le code à apparaître, c’est l’endroit où il apparaît : directement dans ton projet, sans passer par tes mains. Un modèle plus récent se trompera moins souvent — ce qui rend l’erreur plus rare, donc moins surveillée, donc plus chère le jour où elle arrive. C’est une raison d’avoir des filets, jamais une raison de s’en passer.

Ce n’est pas un outil qu’on configure entièrement avant de s’en servir. Tu vas croiser des listes d’extensions, de fichiers de configuration, de réglages recommandés. On n’en installe aucun tant que le besoin ne s’est pas manifesté. Chaque ajout a son moment déclencheur, et ces moments font l’objet de la leçon 5, « les huit moments où on ajoute quelque chose ».

Où c’est écrit

Cette leçon ne demande rien à installer, mais tout ce qu’elle affirme se vérifie — et c’est le réflexe qu’elle veut poser. Les liens pointent vers les pages anglaises, pour les raisons que donnera la leçon 4 ; la version française existe, /fr/ à la place de /en/.

Vue d’ensemble — ce qu’est Claude Code et ce qu’il sait faire, dans les mots de ceux qui l’écrivent ;
Comment ça marche — la boucle, les outils, et la séparation entre le harnais et le modèle ;
Modes d’autorisation — dans quel mode une session démarre, ce qui en décide, et pourquoi ça a changé récemment ;
Points de restauration — ce que le filet couvre, et la section que la documentation intitule elle-même « ce n’est pas un remplacement du contrôle de version ».

Le point de bascule

Tu as compris quand tu ne comptes plus les lignes que tu colles, mais celles que tu laisses entrer sans savoir comment tu vérifieras qu’elles sont bonnes.

Vérifier que c’est passé

On te montre un outil qui propose un correctif que tu appliques toi-même. Assistant ou agent ?

Assistant. La question de tri porte sur une seule chose : qui écrit dans les fichiers. Si c’est toi, peu importe la qualité du correctif ou le nom du produit — tu restes la courroie de transmission, et l’outil ne saura jamais si sa proposition marche chez toi.

Ton collègue dit : « je passe à l'agent, je vais coder deux fois plus vite ». Que lui réponds-tu ?

Qu’il se trompe de gain. Ce qui change n’est pas la vitesse d’apparition du code, c’est l’endroit où il apparaît — directement dans le projet. La vraie contrepartie est ailleurs : l’agent peut essayer, lancer les tests, lire l’erreur et recommencer, ce qu’un assistant ne peut pas faire. S’il vise la vitesse, il produira surtout plus de code que ce qu’il vérifie.

Un nouveau modèle sort, meilleur que le précédent. Qu'est-ce que ça change à ce que tu viens d'apprendre ?

Presque rien, et c’est le but. Les notions — autorisations, contexte, mémoire, moments de déclenchement — appartiennent au harnais, pas au modèle. Ce qui bouge, ce sont les réglages : les outils fournis, les modes disponibles par défaut. Et attention au raisonnement inverse, celui qui coûte cher : un modèle qui se trompe moins souvent rend l’erreur plus rare, donc moins surveillée, donc plus chère le jour où elle arrive.