L'avant-garde du terminal : se réapproprier le système de fichiers avec Claude Code - Partie 2 : Le saut agentique : orchestrer une logique multi-fichiers sans débogueur

Passer des prompts à un seul tour à l'exécution de tâches autonomes et à l'auto-correction

Partie 2 sur 4 de la série « L'avant-garde du terminal : se réapproprier le système de fichiers avec Claude Code »

L'écran scintille avec une série de commandes rapides. ls, cat src/auth/service.ts, grep -r "JWT_SECRET" ., npm test. Il n'y a aucun humain au clavier.

Dans un environnement de développement traditionnel, cette séquence représenterait un développeur à la recherche d'un bug — un sondage rythmique et manuel de l'état du système. Mais ici, dans la lueur froide de la CLI Claude Code, cela représente tout autre chose : la boucle OODA d'un agent autonome.

Si la partie 1 de cette série portait sur la transition du navigateur vers le terminal, la partie 2 concerne la transformation de l'IA elle-même. Nous quittons l'ère de la « chatbox » — le destinataire poli et passif de prompts — pour entrer dans celle du « Saut Agentique ». C'est le moment où l'IA cesse de parler de code pour commencer à vivre en son sein, orchestrant la logique à travers des dizaines de fichiers, exécutant ses propres tests et, plus important encore, corrigeant ses propres erreurs avant même que l'humain ne remarque qu'elles ont été commises.

La boucle OODA dans le shell : comment Claude « pense »

Pour comprendre pourquoi Claude Code semble différent d'un LLM basé sur le Web, il faut examiner son cadre de prise de décision interne. Alors qu'un modèle sur navigateur est essentiellement un « autocomplétage » sophistiqué pour les pensées, Claude Code opère sur un cycle familier aux pilotes de chasse et aux théoriciens de la stratégie : la boucle OODA (Observer, S'orienter, Décider, Agir).

1. Observer : Au lieu d'attendre que vous colliez un extrait, Claude Code observe l'ensemble du système de fichiers. Il lit votre package.json, scanne votre arborescence de répertoires et note la présence d'un fichier .env qu'il ne doit pas toucher.
2. S'orienter : Il contextualise votre demande. Si vous dites « répare le bug de connexion », il ne se contente pas de regarder login.ts. Il s'oriente en trouvant le schéma de la base de données, le middleware d'authentification et la logique de validation front-end.
3. Décider : Il formule un plan en plusieurs étapes. « Je vais d'abord créer un cas de test de reproduction, puis modifier la logique de hachage, puis vérifier avec le test. »
4. Agir : Il s'exécute. Il écrit le code, lance la commande shell et lit le résultat.

C'est dans cette boucle que se produit le « Saut Agentique ». Dans une interface Web, si l'IA vous donne un code qui ne fonctionne pas, la boucle est rompue ; c'est à vous d'observer l'erreur et de la signaler. Dans la CLI, c'est l'IA qui examine la stack trace. Elle voit la ReferenceError, soupire (métaphoriquement) et repasse immédiatement à la phase « Observer » pour comprendre quel import elle a manqué.

Le Model Context Protocol (MCP) : l'USB-C de l'intelligence

Si la boucle OODA est le cerveau, le Model Context Protocol (MCP) est le système nerveux. Lancé par Anthropic fin 2024 et arrivé à maturité en 2025, le MCP est devenu le « port USB-C » pour les agents IA.

Auparavant, une IA était un « cerveau dans une cuve ». Pour lui donner des données, vous deviez les transporter manuellement jusqu'à elle dans un seau (le prompt). Le MCP change la donne en créant une interface standardisée permettant aux agents de se brancher directement sur des silos de données locaux et distants.

Aujourd'hui, Claude Code ne se contente pas de lire vos fichiers ; il se connecte à un écosystème de serveurs MCP :

• Le serveur GitHub : Il gère vos PR, recherche des patterns dans les autres dépôts de votre organisation et vérifie les descriptions de tickets.
• Le serveur Postgres : Il inspecte le schéma de votre base de données en direct pour s'assurer que la migration qu'il écrit correspond réellement aux types de colonnes en production.
• Le serveur Google Maps : Il extrait des données géospatiales réelles pour l'application de géolocalisation que vous construisez, garantissant que la logique de routage est ancrée dans la réalité.
• Le serveur Slack : Il peut même « demander à un humain » des éclaircissements en envoyant un message sur un canal de dev et en attendant qu'une réponse apparaisse dans sa fenêtre de contexte.

Ce protocole représente un changement fondamental dans l'utilité de l'IA. En standardisant la manière dont un agent « voit » le monde, nous sommes passés d'intégrations fragiles codées sur mesure à une réalité plug-and-play où un agent peut naviguer dans une infrastructure d'entreprise complexe aussi facilement qu'un humain avec un VPN.

Débogage autonome : la mort du workflow « Coller et Prier »

L'expérience la plus viscérale du Saut Agentique est de regarder Claude Code gérer une erreur de logique. Dans l'ancien workflow — ce que nous pourrions appeler « Coller et Prier » (Paste-and-Pray) — vous colliez une erreur dans un chat, obteniez une version « réparée », la recolliez, et constatiez que cela ne fonctionnait toujours pas.

Dans l'avant-garde du terminal, le workflow ressemble à ceci :

1. Utilisateur : « Il y a un bug dans le flux de paiement où la taxe n'est pas calculée pour la Californie. »
2. Claude : Crée un nouveau fichier de test tests/repro_bug.test.ts.
3. Claude : Lance le test. Il échoue.
4. Claude : Modifie src/logic/tax.ts.
5. Claude : Relance le test. Il échoue avec une erreur différente (une erreur de syntaxe).
6. Claude : Voit l'erreur de syntaxe, la corrige, relance le test. Il réussit.
7. Claude : Supprime le fichier de test temporaire et présente le diff à l'utilisateur.

C'est du code « auto-réparateur ». L'IA agit comme son propre ingénieur QA. Au moment où elle vous présente une solution, celle-ci a déjà survécu à une collision avec la réalité d'un environnement d'exécution. Elle est passée de la « justesse hallucinatoire » à la « fonctionnalité vérifiée ».

La psychologie de la délégation : de la discussion à la direction

Ce changement est autant psychologique que technique. Lorsque nous interagissons avec un chatbot, nous « discutons » — une activité sociale à faibles enjeux. Lorsque nous interagissons avec Claude Code, nous « déléguons ».

Les psychologues et les chercheurs en IA ont noté que déléguer à un agent nécessite un niveau de confiance plus élevé mais offre une charge cognitive nettement inférieure. Vous n'êtes plus responsable du « comment » ; vous êtes responsable du « quoi ». Cela transforme le rôle du développeur de « rédacteur de lignes » à « directeur d'intention ».

Cependant, cette délégation s'accompagne de nouvelles compétences : l'ingénierie de contexte (Context Engineering). Parce que l'agent vit dans votre système de fichiers, votre système de fichiers est sa mémoire. Les développeurs performants utilisent désormais des « fichiers de contexte » comme CLAUDE.md ou GEMINI.md pour stocker les règles spécifiques au projet, les manifestes architecturaux et les commandes courantes. Vous n'enseignez pas à l'IA ; vous définissez les limites de son terrain de jeu.

L'essor du sous-agent : orchestrer une équipe numérique

À la mi-2025, le « Saut » est allé encore plus loin avec l'introduction des Sous-agents et des Agents d'arrière-plan.

Claude Code peut désormais générer des sous-tâches spécialisées. Pendant que l'agent principal refactorise votre API, il peut lancer un « Sous-agent de documentation » pour mettre à jour le README et un « Sous-agent de test » pour exécuter la suite complète dans un processus en arrière-plan.

Ce parallélisme signifie que le terminal n'est plus une conversation à voie unique. C'est un centre de commandement. Vous pouvez voir votre équipe agentique travailler en arrière-plan — un agent récupérant des données via une connexion MCP Postgres, un autre vérifiant le canal Slack pour les retours d'un coéquipier, et un troisième fusionnant le code final.

Conclusion : la fin du « tour unique »

Le « Saut Agentique » marque la fin de l'ère du « tour unique » (single-turn) de l'IA. Nous ne lançons plus une balle par-dessus un mur en espérant qu'elle revienne sous forme de chef-d'œuvre. Nous travaillons avec un contremaître numérique capable de naviguer dans nos systèmes de fichiers, de corriger sa propre trajectoire et de se connecter au vaste réseau de nos données via des protocoles comme le MCP.

Mais à mesure que l'IA devient plus autonome, l'humain devient plus critique. Dans la partie 3, nous explorerons la « Nouvelle Expérience Développeur » — comment le rôle du programmeur est redéfini quand l'IA peut écrire, tester et déboguer mieux qu'un ingénieur junior, et pourquoi le « goût architectural » devient la monnaie la plus précieuse du terminal.

À suivre dans cette série : [Partie 3 : La nouvelle expérience développeur : architecturer l'intention à l'ère de l'autonomie — Comment le rôle de l'humain passe de « codeur » à « orchestrateur » et l'importance croissante du goût architectural sur la maîtrise de la syntaxe.]

Cet article fait partie de la chronique Stacks de l'Institut XPS. Explorez d'autres [applications pratiques de l'ingénierie native de l'IA dans notre chronique Solutions].