Cinq IA, un seul bug : deux l'ont corrigé, trois ont cassé davantage de choses
Un auteur de Habr a soumis à cinq IA le même bug de publication de site. Claude Code et Codex l'ont corrigé, les trois autres ont cassé encore plus de choses. Mais on ne peut pas choisir le meilleur modèle sur un seul bug : même sur SWE-bench Verified, qui compte 500 tâches, les dix premiers ne se distinguent que sur 164 d'entre elles. Plus qu'un bug non corrigé, c'est un correctif qui casse silencieusement le code voisin qui est dangereux, car on le découvre plus tard. Validez donc un correctif d'après le diff et vos propres exécutions de tests, pas d'après le rapport de l'IA.
Traité par IA depuis Habr AI ; édité par Hamidun News
Un bug, cinq IA, deux résultats. L'auteur d'un billet sur Habr a confié à cinq modèles d'IA la même correction d'une erreur de publication de site sur un serveur. Claude Code et Codex ont corrigé le bug. Les trois autres ont cassé davantage de choses qu'il n'y en avait au départ. On voudrait sacrer les deux premiers meilleurs modèles, mais l'auteur lui-même refuse cette tentation. L'expérience illustre en revanche très bien quelle erreur est la plus dangereuse, et comment l'attraper avant que le correctif n'entre dans le projet.
Pourquoi un seul bug ne permet pas de choisir la meilleure IA
Une expérience isolée montre la manière de travailler d'un modèle précis, pas un classement. Les grands benchmarks le confirment. SWE-bench Verified est un ensemble de 500 tâches à vérification automatique, tirées de problèmes réels sur GitHub et sélectionnées par des humains avec OpenAI. Les deux meilleurs résultats résolvent chacun 396 tâches sur 500. Les dix premiers ne se distinguent que sur 164 tâches (Liu et al., arXiv). Un test apparié, qui vérifie si l'écart entre voisins du tableau est dû au hasard, n'a séparé aucune des 29 paires voisines au sein des trente premiers.
Il y a aussi un second facteur : l'environnement d'exécution (« harness »). Il s'agit du programme qui entoure le réseau de neurones et par lequel celui-ci lit les fichiers du projet et lance des commandes. D'après les mêmes auteurs, pour un même modèle, l'écart entre environnements peut atteindre 29,8 points de pourcentage de part de tâches résolues. Pour l'ensemble des trente premiers, l'écart n'est que de 8,8 points. Autrement dit, l'environnement fait varier le résultat trois fois plus que la différence entre la première et la trentième place. Si 500 tâches ne départagent pas des voisins, un seul bug ne le fera certainement pas : sur une autre tâche, la hiérarchie pourrait être différente.
Qu'est-ce qui est le plus dangereux : un bug non corrigé ou une régression silencieuse ?
Un bug non corrigé se voit tout de suite. Le danger vient d'un correctif après lequel ce qui fonctionnait avant cesse de fonctionner. On appelle cela une régression, et on la découvre généralement plus tard.
Il y a deux causes. La première : les modifications superflues. L'agent touche à plus que ce qu'on lui demandait et ne vérifie pas le reste.
Anthropic l'écrit sans détour dans la documentation de Claude Code : si l'agent n'a rien à exécuter pour savoir si le travail est terminé, il s'arrête quand celui-ci lui semble terminé. Le rôle des tests revient alors à l'humain. Le benchmark SlopCodeBench (analysé par TechRadar) a montré que le code des agents est 2,2 fois plus verbeux et plus confus que celui de 48 projets Python maintenus par des humains.
La verbosité augmentait au fil de la tâche dans 89,8% des exécutions, la confusion dans 80%. Plus un correctif touche de lignes, plus il y a de place pour une régression.
La seconde cause : des tests trop faibles. Un code peut passer tous les tests automatiques et malgré tout laisser passer des cas importants. Dans l'étude Probe to Generate, les chercheurs ont renforcé les tests et revérifié les dix meilleurs agents de correction de code. La part de tâches résolues a chuté de 4,2–9,0%. Une partie des correctifs acceptés jusque-là était passée à travers des trous dans les tests et ne faisait pas tout ce que la tâche exigeait. La conclusion est simple : un rapport de l'IA affirmant « corrigé » ne prouve rien. Ce qu'il faut vérifier, ce sont les modifications et les résultats des tests.
Comment cadrer l'agent et vérifier son correctif
Une consigne étroite réduit le risque avant même le début du travail. Voici ce qu'il vaut la peine d'indiquer :
- le fichier et la fonction où se trouve le bug ;
- comment reproduire le bug et quel résultat est attendu ;
- une interdiction explicite de toucher au reste du code ;
- la demande de présenter d'abord un plan, et de n'écrire le code qu'après votre réponse ;
- un test qui échoue avant le correctif et réussit après.
Il est pratique de consigner les interdictions permanentes dans un fichier de règles pour l'agent, afin de ne pas les répéter à chaque tâche. C'est d'autant plus important que, dans Claude Code, les nouvelles sessions dans le terminal et dans VS Code démarrent par défaut en mode automatique, où les commandes s'exécutent sans confirmation une à une. Moins vous confirmez les étapes, plus vous devez examiner attentivement le résultat final.
Vérification du correctif, étape par étape :
- Ouvrir l'intégralité du diff et repérer les fichiers et fonctions qu'on n'avait pas demandé de toucher. Trois lignes dans une fonction et deux cents lignes dans six fichiers ne présentent pas le même risque, même si les deux correctifs s'appellent « une correction ».
- Comparer les modifications avec la tâche. Une variable renommée, une fonction voisine réécrite ou une validation d'entrée supprimée sont autant de raisons de rejeter le correctif.
- S'assurer qu'il existe un test sur le bug lui-même. Sinon, demander d'en écrire un.
- Lancer soi-même la suite complète de tests et vérifier que l'agent n'a pas modifié les tests eux-mêmes. S'il n'y a pas de tests dans le projet, il faut d'abord un test qui reproduit le bug.
- Relancer l'exécution après chaque retouche : un nouveau correctif peut affecter ce qui passait la fois précédente.
- Demander un second avis. La documentation de Claude Code conseille de confier à un sous-agent, c'est-à-dire une instance distincte du réseau de neurones, la vérification du diff d'après la spécification et les cas limites, sans remarques de style. Elle décrit aussi un stop hook : un script qui renvoie l'agent au travail tant que la vérification n'est pas passée.
Comment choisir un modèle pour son projet
On ne peut pas désigner de vainqueur sur un seul bug. Le résultat vient d'un couple modèle-environnement, et l'environnement, c'est en grande partie vous qui le configurez : mode de confirmation, fichier de règles, vérifications. Il est plus pragmatique de confier les correctifs au modèle dont le travail est le plus facile à vérifier sur vos tâches : celui qui modifie peu de lignes, écrit un test pour le bug et ne s'aventure pas dans des fichiers qu'on ne lui a pas demandé de toucher. Quelques tâches dans votre dépôt suffisent à le voir ; un classement ne vous aidera pas ici.
L'histoire a une limite assumée : il s'agit d'une seule expérience menée par un seul auteur, qui précise lui-même que sur un autre bug tout aurait pu se passer différemment. Mais cela n'affaiblit pas la conclusion pratique. Le modèle le plus dangereux est celui qui a annoncé avec assurance avoir corrigé le bug tout en touchant au code voisin. La décision d'accepter un correctif doit revenir à un humain : d'après les lignes modifiées et les tests qu'il a lancés lui-même.
- 18 nov. 2026Un développeur donne des mains au chat IA web : un serveur MCP de 14 outils et 21 000 lignes
- 18 nov. 2026OpenAI lance GPT-6.2 Astra : deuxième place au classement et prix en baisse de 20%
- 18 nov. 2026Trois outils d'« économie de tokens » ont gonflé de 18% à 46% la facture des agents IA
- 18 nov. 2026Meituan publie les poids d'un modèle agentique de 1,6 billion de paramètres, entraîné sans Nvidia
Questions clés sur cet article
Qu'est-ce qui est le plus dangereux : un bug non corrigé ou une régression silencieuse ?
Un bug non corrigé se voit tout de suite. Le danger vient d'un correctif après lequel ce qui fonctionnait avant cesse de fonctionner. On appelle cela une régression, et on la découvre généralement plus tard. Il y a deux causes. La première : les modifications superflues. L'agent touche à plus que ce qu'on lui demandait et ne vérifie pas le reste.
Pourquoi un seul bug ne permet pas de choisir la meilleure IA?
Une expérience isolée montre la manière de travailler d'un modèle précis, pas un classement. Les grands benchmarks le confirment. SWE-bench Verified est un ensemble de 500 tâches à vérification automatique, tirées de problèmes réels sur GitHub et sélectionnées par des humains avec OpenAI. Les deux meilleurs résultats résolvent chacun 396 tâches sur 500. Les dix premiers ne se distinguent que sur 164 tâches (Liu et al., arXiv).
Comment cadrer l'agent et vérifier son correctif?
Une consigne étroite réduit le risque avant même le début du travail. Voici ce qu'il vaut la peine d'indiquer : le fichier et la fonction où se trouve le bug ; comment reproduire le bug et quel résultat est attendu ; une interdiction explicite de toucher au reste du code ; la demande de présenter d'abord un plan, et de n'écrire le code qu'après votre réponse ; un test qui échoue avant le correctif et réussit après.
Build & Ship Production AI Agents Without Boilerplate Code
Start your free 72-hour trial at Hamidun Academy (academy.hamidun.com) — interactive lessons on Claude Code & Cursor, live Tech Radar, and production agent templates.
L'essentiel de l'IA — une fois par semaine
Sept actus qui ont vraiment compté, choisies à la main. Sans bruit ni communiqués.
C'est fait ! Vérifiez votre boîte mail pour la confirmation.