Aller au contenu
Encyclopédie informatique Édition 2026

Programmer avec l'IA : assistants et agents de code

Partie 2 sur 3

Niveau de lecture :

4Comment travaille un agent de code

demande ticket ou consigne précise exploration lire le code, les instructions modification écrire le code et les tests vérification compiler, tester, analyser proposition branche et demande de fusion échec : corriger et recommencer intégration continue tests et analyses automatiques revue humaine relire, comprendre, demander des changements fusion dans la branche principale L’agent fait le travail ; une personne reste responsable de ce qui est fusionné.
Figure 2. L’agent boucle jusqu’à ce que les tests passent ; la relecture humaine et les contrôles automatiques décident de l’intégration.

4.1Ce que l’outil voit

La qualité de l’aide dépend avant tout du contexte fourni au modèle : le fichier en cours, les fichiers voisins, les définitions des fonctions utilisées, la documentation, les messages d’erreur. Un projet réel compte des milliers de fichiers, bien plus que ce qu’un modèle peut lire à la fois. Les outils cherchent donc les extraits pertinents, par recherche textuelle dans le dépôt, par analyse de la structure du code, ou par recherche sémantique (voir le RAG). Les agents, eux, explorent comme un développeur : ils listent les dossiers, cherchent un nom de fonction, ouvrent les fichiers qui les intéressent. Plus un projet est bien organisé, bien nommé et bien documenté, mieux l’IA s’y retrouve, exactement comme un nouvel arrivant dans l’équipe.

4.2Les fichiers d’instructions

Pour éviter de répéter les mêmes consignes, on place à la racine du projet un fichier d’instructions que l’agent lit au début de chaque tâche. Un format commun, AGENTS.md, est reconnu par de nombreux outils, et certains ont leur propre nom de fichier. On y décrit le projet, les commandes pour compiler et tester, les conventions, ce qu’il ne faut pas toucher :

# Instructions pour les agents

## Le projet
Application de gestion des inscriptions d'une association (Python 3.12, Django).

## Commandes
- Installer : pip install -r requirements.txt
- Tester : pytest            (tous les tests doivent passer)
- Vérifier le style : ruff check .

## Règles
- Écrire un test pour chaque correction de bogue.
- Ne jamais modifier les fichiers de migration déjà publiés.
- Ne pas ajouter de dépendance sans le signaler dans la demande de fusion.
- Les données de test sont fictives : ne jamais utiliser de vraies adresses.

Ce fichier se versionne avec le code, se relit et s’améliore au fil des erreurs constatées : chaque fois qu’un agent se trompe de la même façon, on ajoute une règle (exercice 4).

4.3Outils, droits et garde-fous

Pour travailler, un agent de code a besoin d’outils : lire et écrire des fichiers, exécuter des commandes dans le terminal, consulter la documentation sur le Web, utiliser Git, parfois accéder à des services par le protocole MCP (voir les agents d’IA). Exécuter des commandes, c’est potentiellement tout faire : effacer des fichiers, installer des programmes, envoyer des données. Les outils proposent donc des niveaux de permission : demander l’accord avant chaque commande, autoriser seulement certaines commandes, comme les tests, ou tout autoriser dans un bac à sable, un environnement isolé, conteneur ou machine virtuelle, sans accès aux données réelles ni aux secrets (voir les conteneurs). La règle de prudence : plus l’agent est autonome, plus son environnement doit être cloisonné (coin cyber).

4.4Mesurer les agents

Comment savoir si un agent de code est compétent ? Le banc d’essai le plus cité, SWE-bench, publié en 2023 par des chercheurs de Princeton, rassemble des problèmes réels signalés sur des projets libres écrits en Python, avec les tests qui vérifient leur correction. L’agent reçoit le projet et la description du problème ; il réussit si les tests passent après ses modifications. Une version vérifiée par des humains, SWE-bench Verified, écarte les problèmes mal posés. Les meilleurs systèmes, qui résolvaient quelques pour cent de ces problèmes en 2023, en résolvent la grande majorité trois ans plus tard. D’autres bancs d’essai mesurent la capacité à mener des tâches longues, à utiliser un terminal ou à travailler dans d’autres langages.

Ces chiffres doivent être lus avec prudence. Un banc d’essai public finit par se retrouver, au moins en partie, dans les données d’entraînement des modèles ; les tâches sont plus nettes et mieux délimitées que dans la vraie vie ; et réussir les tests ne garantit ni la lisibilité, ni la sécurité, ni la maintenabilité du code produit. Rien ne remplace l’essai sur ses propres projets.

4.5Où tournent ces outils

Les outils se présentent sous plusieurs formes, souvent combinées : une extension de l’éditeur de code habituel ; un éditeur entièrement conçu autour de l’IA ; un outil en ligne de commande, qui travaille dans le terminal et s’intègre aux scripts ; un agent dans le nuage, à qui l’on confie une tâche depuis la plateforme d’hébergement du code ou une messagerie d’équipe, et qui revient avec une demande de fusion. Dans la plupart des cas, le modèle tourne sur les serveurs de l’éditeur : le code lu par l’outil y est envoyé. Les entreprises qui ne peuvent pas l’accepter utilisent des offres hébergées dans une région ou un nuage de confiance, ou des modèles ouverts installés sur leurs propres machines, en général moins performants mais sous leur contrôle (voir l’IA sur sa propre machine). Le coût prend la forme d’un abonnement mensuel ou d’une facturation à l’usage, au nombre de jetons, les unités de texte traitées par le modèle ; un agent qui travaille des heures sur un gros projet peut en consommer beaucoup.

Pour s’exercer

Exercice 2 : une faille classique

Un agent a écrit cette fonction de recherche de clients. Quel est le problème ? Comment le corriger ?

def chercher_client(curseur, nom):
    requete = "SELECT * FROM clients WHERE nom = '" + nom + "'"
    curseur.execute(requete)
    return curseur.fetchall()
Voir la réponse

La requête est fabriquée en collant le texte saisi par l’utilisateur : un nom contenant une apostrophe suivie de commandes SQL, le langage des bases de données, modifierait le sens de la requête. C’est une injection SQL, l’une des failles les plus anciennes et les plus graves (voir l’injection SQL). La correction consiste à utiliser une requête paramétrée, où la valeur est transmise séparément du texte de la requête :

def chercher_client(curseur, nom):
    curseur.execute("SELECT * FROM clients WHERE nom = ?", (nom,))
    return curseur.fetchall()

Les modèles produisent encore ce genre de code quand des exemples vulnérables abondent dans leurs données d’entraînement. Une analyse automatique de sécurité dans l’intégration continue repère la plupart de ces erreurs.

Exercice 3 : le paquet inconnu

L’assistant conseille : « installez le paquet requetes-faciles-pro avec pip install requetes-faciles-pro ». Vous ne le connaissez pas. Que vérifier avant de l’installer ?

Voir la réponse

Sur le dépôt officiel des paquets Python, PyPI : le paquet existe-t-il ? Depuis quand ? Qui le publie ? Combien de téléchargements, de versions ? Renvoie-t-il vers un dépôt de code source actif, avec une documentation et des contributeurs ? Un paquet très récent, sans historique, au nom proche d’un paquet célèbre, ou dont le nom a été suggéré par une IA sans autre source, est suspect : il peut avoir été créé pour piéger les développeurs (coin cyber, figure 3). Il faut aussi se demander si une bibliothèque reconnue, ou la bibliothèque standard du langage, ne fait pas déjà l’affaire.

Exercice 4 : enrichir les instructions

Dans un projet, l’agent ajoute régulièrement des bibliothèques sans prévenir, écrit des messages d’enregistrement Git en anglais alors que l’équipe écrit en français, et oublie de lancer le vérificateur de style. Que faire ?

Voir la réponse

Compléter le fichier d’instructions du projet, par exemple : « Ne jamais ajouter de dépendance sans l’accord explicite de l’utilisateur. » ; « Rédiger les messages d’enregistrement en français, au présent, sous la forme : “Corrige …”, “Ajoute …”. » ; « Avant de terminer, lancer ruff check . et corriger toutes les erreurs signalées. ». Et ajouter des contrôles automatiques là où c’est possible : un vérificateur de style et une liste de dépendances autorisées dans l’intégration continue, qui bloquent la fusion quoi que fasse l’agent. Les consignes guident ; les contrôles garantissent.

Exercice 5 : déléguer ou non ?

Pour chaque tâche, indiquez si on peut la confier largement à un agent, avec relecture, ou s’il faut la garder sous contrôle étroit : (a) écrire des tests pour une fonction existante ; (b) renommer une fonction dans tout le projet ; (c) concevoir le système de connexion et de gestion des mots de passe ; (d) migrer vers la nouvelle version d’une bibliothèque de dates ; (e) corriger un problème qui n’apparaît qu’en production, de façon aléatoire.

Voir la réponse

(a), (b) et (d) se délèguent bien : tâches bien définies, vérifiables par la compilation et les tests ; on relit quand même, en particulier les tests, qui doivent vraiment vérifier quelque chose. (c) touche à la sécurité : l’agent peut aider, mais la conception doit être menée et relue par une personne compétente, en s’appuyant sur des solutions éprouvées plutôt que sur du code inventé (voir le développement sécurisé). (e) est difficile à vérifier : l’agent peut aider à analyser les journaux et à formuler des hypothèses, mais sans accès à la production, et chaque hypothèse doit être confirmée avant correction.

Exercice 6 : le goulot de la relecture

Une équipe de quatre développeurs fait travailler des agents en parallèle : ils produisent 16 demandes de fusion par jour. Chacune demande en moyenne 25 minutes de relecture attentive. Combien de temps de relecture par jour et par développeur ? Qu’en conclure ?

Voir la réponse

16 × 25 = 400 minutes, soit 6 h 40 par jour pour l’équipe, et 100 minutes, soit 1 h 40, par développeur. C’est faisable, mais cela devient une part majeure de leur travail. Si les agents produisent davantage, ou des modifications plus grosses, la relecture devient le goulot d’étranglement, et la tentation est grande de relire en diagonale. D’où l’intérêt de demandes de fusion petites et ciblées, de tests solides, de contrôles automatiques et d’outils d’aide à la relecture, et de ne lancer que les tâches que l’on aura le temps de vérifier.

5Bien travailler avec l’IA

5.1Préparer

  • Décrire précisément le résultat attendu, les contraintes, les cas particuliers : une demande vague donne un résultat vague.
  • Découper une grosse tâche en étapes que l’on peut vérifier une à une.
  • Demander un plan avant le code pour les tâches complexes, et le corriger : il est bien plus simple de réorienter un plan que de défaire mille lignes.
  • Fournir des exemples : un fichier existant à imiter, un test qui décrit le comportement voulu.

5.2Vérifier

  • Les tests d’abord : des tests automatisés sont le meilleur moyen de vérifier le travail d’un agent, et de lui permettre de se vérifier lui-même. On peut écrire les tests soi-même, puis lui demander le code qui les fait passer.
  • Relire chaque modification comme celle d’un collègue : est-ce correct, lisible, cohérent avec le reste du projet ? Les cas limites sont-ils traités ?
  • Comprendre ce que l’on intègre : si l’on est incapable d’expliquer un passage, on demande une explication ou on le réécrit.
  • Vérifier les dépendances ajoutées : existent-elles, sont-elles fiables et maintenues (coin cyber) ?

5.3Garder la main

La gestion de versions est le filet de sécurité de la programmation assistée : travailler sur une branche dédiée, enregistrer souvent des versions intermédiaires, pouvoir tout annuler d’une commande (voir Git). Les contrôles automatiques de l’intégration continue, qui compilent, testent et analysent chaque modification proposée, s’appliquent au code de l’IA comme à celui des humains (voir DevOps et intégration continue). Enfin, une personne reste responsable de ce qui est fusionné : « c’est l’IA qui l’a écrit » n’est pas une excuse recevable dans une équipe, ni devant un client.

5.4Que déléguer ?

L’IA est particulièrement efficace pour les tâches bien définies et faciles à vérifier : écrire des tests, compléter de la documentation, migrer du code vers une nouvelle version d’une bibliothèque, transformer des données d’un format à un autre, écrire des scripts ponctuels, explorer un projet inconnu, prototyper une interface. Elle demande plus de vigilance pour les choix d’architecture, la sécurité, la cryptographie, les performances fines, et tout ce qui touche à des données sensibles ou à des actions irréversibles, où une erreur subtile coûte cher et où la vérification exige une vraie expertise (exercice 5).

5.5L’IA relectrice

L’IA ne sert pas qu’à écrire : elle peut aussi relire. Des outils commentent automatiquement chaque demande de fusion, qu’elle vienne d’un humain ou d’un agent : bogues probables, cas limites oubliés, incohérences avec le reste du projet, failles de sécurité, tests manquants. Ils repèrent souvent des problèmes réels, mais produisent aussi des remarques inutiles ou fausses ; leurs commentaires sont des pistes à examiner, pas des verdicts. Bien employés, ils allègent la relecture humaine sans la remplacer : la personne qui relit se concentre sur ce que la machine juge mal, la pertinence du changement, ses conséquences pour les utilisateurs, la cohérence avec les choix de l’équipe. On peut aussi demander à un assistant d’expliquer une demande de fusion volumineuse, de rédiger la description d’une modification ou de résumer l’historique d’un fichier, autant de tâches qui facilitent le travail collectif.

6Le vibe coding

En février 2025, le chercheur Andrej Karpathy décrit une nouvelle façon de programmer qu’il baptise vibe coding, que l’on pourrait traduire par « programmation à l’intuition » : on décrit ce que l’on veut à l’IA, on accepte toutes ses modifications sans les lire, on lui colle les messages d’erreur jusqu’à ce que cela fonctionne, en « oubliant que le code existe ». L’expression connaît un succès foudroyant, au point d’être élue mot de l’année 2025 par le dictionnaire britannique Collins.

Pour un prototype jetable, un petit outil personnel ou une démonstration, cette approche permet à des personnes qui ne savent pas programmer de créer des applications en quelques heures, ce qui est un vrai progrès. Pour un logiciel destiné à durer, à manipuler des données personnelles ou à être exposé sur Internet, c’est une prise de risque : personne ne connaît vraiment le code, ses failles ou ses limites, et les corrections deviennent de plus en plus difficiles à mesure qu’il grossit. Des applications « codées à l’intuition » ont ainsi été publiées avec des bases de données ouvertes à tous ou des clés d’accès visibles dans le code envoyé au navigateur. La frontière n’est pas l’usage de l’IA, mais le fait de comprendre et de vérifier ce que l’on publie.