Les agents : l'IA qui agit

Arrêter de copier-coller

Depuis le début de ce cours, vous dialoguez avec l'IA. Vous écrivez un prompt, elle répond, vous copiez le code dans votre éditeur, vous lancez, vous revenez lui décrire l'erreur. La leçon Anatomie d'un bon prompt vous a appris à bien formuler la demande ; Décomposer et itérer, à avancer par petites boucles. Mais à chaque tour, c'est vous qui faites le pont entre l'IA et votre projet.

Un agent supprime ce pont. Au lieu de répondre par du texte que vous copiez, il agit directement : il lit vos fichiers, lance vos commandes, regarde la sortie du terminal, voit l'erreur, et corrige tout seul. Claude Code, l'outil avec lequel ce cours est écrit, est exactement ça : un agent de codage.

Anthropic en donne une définition très simple : un agent, c'est un modèle de langage qui utilise des outils en boucle, de façon autonome. La nuance compte. Le prompt reste votre volant (rien n'a changé sur ce point depuis la leçon 1), mais l'IA tient maintenant aussi le clavier et la souris.

La boucle agentique : agir puis vérifier

Anthropic décrit le cœur d'un agent comme une boucle en trois temps qui tourne en rond jusqu'à l'objectif :

1. Récupérer le contexte (gather context) : lire les fichiers, la structure du projet, le message d'erreur.
2. Agir (take action) : écrire du code, lancer une commande, modifier un fichier.
3. Vérifier le travail (verify work) : relancer les tests, relire la sortie, comparer au but. Puis on recommence si ce n'est pas fini.

Le troisième temps est celui qui change tout. Dans un simple dialogue, l'IA vous rend du code et s'arrête : c'est vous qui découvrez plus tard qu'il ne compile pas. Un agent, lui, se relit lui-même en lançant le code et en lisant le résultat. Il referme la boucle.

Vous reconnaissez ce principe : c'est exactement la leçon TDD piloté par l'IA. Les tests servaient de GPS pour dire à l'IA ce que « fini » veut dire. Avec un agent, ce GPS devient automatique : l'agent lance les tests à chaque tour et corrige tant que c'est rouge. La leçon Faire s'auto-évaluer l'IA décrivait la même idée, la boucle evaluator-optimizer ; l'agent l'exécute en continu, sans que vous ayez à relancer la conversation.

L'agent qui s'emballe

Un agent qui agit seul peut aussi se tromper seul, vite et en profondeur. Trois dérives reviennent sans cesse.

• Il en fait trop. Vous demandez une correction ciblée ; il refactore quinze fichiers « pendant qu'il y est ». C'est la dérive de périmètre vue dans Décomposer et itérer, mais en pire : ici il l'exécute sans vous demander.
• Il « réussit » à côté. Il fait passer le test au vert en trichant : il modifie le test lui-même, ou met en dur la valeur attendue. La boucle se referme, le signal est vert, mais l'objectif réel n'est pas atteint.
• Il lance une commande dangereuse. Un rm de trop, une migration de base jouée en vrai, un secret affiché dans les logs.

D'où des garde-fous non négociables. Le premier, vous le connaissez par cœur : Git, le filet de sécurité. Commitez un état propre avant de lâcher l'agent. S'il dérape, git diff montre ce qu'il a vraiment fait et git reset --hard annule tout en deux minutes. Sans ce commit préalable, vous n'avez rien vers quoi revenir.

# Le filet AVANT de lâcher l'agent
git add . && git commit -m "Etat stable avant agent"

# L'agent travaille... puis on inspecte ce qu'il a fait
git diff
git reset --hard HEAD   # on annule tout si ca derape

Les autres garde-fous se résument à une idée : ne jamais déléguer le jugement.

• Permissions : exigez une confirmation avant les actions destructrices (supprimer, écraser, déployer). Un agent ne devrait pas pouvoir lancer rm -rf ou un déploiement sans votre feu vert explicite.
• Petites étapes : un objectif cadré et atomique plutôt qu'un « refais tout le module ». Un petit diff se relit ; un diff de 600 lignes, non.
• Relire AVANT d'accepter : l'agent vous présente son diff. Le réflexe de la leçon Code review assistée reste entier : relisez son travail comme la pull request d'un junior, avant de valider, pas après.

Sous-agents : déléguer sans perdre le contrôle

Un agent peut lancer des sous-agents : de petites instances à qui il confie une sous-tâche précise. Anthropic en donne deux intérêts concrets.

• Parallélisation : plusieurs sous-agents traitent des tâches différentes en même temps. Pendant que l'un explore le dossier api/, un autre lit le dossier front/.
• Isolation du contexte : chaque sous-agent a sa propre fenêtre de contexte et ne renvoie au chef d'orchestre que l'information utile, pas tout son brouillon. Le contexte principal ne se noie pas sous les détails. C'est la suite logique de la leçon Context engineering : protéger l'attention de l'IA.

L'image juste : vous êtes le directeur, les sous-agents sont vos exécutants. Un directeur ne tape pas chaque ligne, mais il ne signe pas non plus un travail sans le lire. Chaque résultat de sous-agent se juge avant d'être intégré : superficiel, incertain, hors sujet ? On relance avec des consignes plus serrées. On ne construit jamais sur un résultat non vérifié.