Blog · 12 novembre 2026

L’IA code, ok ! Mais qui vérifie ?

Écrire du code n’est plus un problème : l’IA le fait vite et bien. Le point clé, désormais, c’est de vérifier et sécuriser son code avant la prod !

Fin 2025 : l’IA écrit, l’humain relit

Claude Code a définitivement et radicalement changé notre façon de coder. Un agent lit le code, écrit la correction, lance les tests en TDD (tests d’abord) et ouvre une Pull Request (PR), en quelques dizaines de minutes. Avec plusieurs agents en parallèle, les PRs arrivent par dizaines. Mais l’ancien paradigme tient toujours : rien ne passe en production sans revue humaine. S’en passer ? « Ô sacrilège ! », diraient les plus réfractaires.

Pour l’instant, l’IA écrit, l’humain relit.

Mais l’humain ne suit pas : une seule PR peut demander des heures de relecture, et tout relire devient impossible. Résultat : les burn-out se multiplient. Comment faire ? Ralentir l’IA au rythme de l’humain, ou valider sans vraiment relire : deux mauvais choix !

La relecture doit changer d’échelle… avec l’IA !

2026 : les IA se relisent entre elles

L’IA code mieux que l’humain, c’est acquis. Elle relit aussi mieux que lui : elle lit chaque ligne, ne se lasse jamais, et peut ajouter en prime une analyse de sécurité systématique, que l’humain ne fait que rarement, le plus souvent après coup dans un audit.

Aussi, nous avons décidé de confier notre revue de code à des IA, mais de façon maîtrisée, au travers d’un skill nommé /full-review. Plusieurs IA relisent à tour de rôle la PR. Chaque problème détecté est fixé de suite, puis la revue repart, avec un autre relecteur. Et le skill s’améliore lui-même au fil des PRs, en fonction des problèmes rencontrés.

skill/full-reviewla revue de code en boucle, par plusieurs IA la boucle repart avec une autre IA deux revues sans bug ? oui non 1. ÉcrireUne IA écrit la PR2a. Chercher les bugsUne IA relit la PR3. MergeLa PR sort de la boucle2b. Corriger les findingsLes bugs trouvés, en TDD
Le skill /full-review
la boucle repart avec une autre IA deux revues sans bug ? oui non 1. ÉcrireUne IA écrit la PR2a. Chercher les bugsUne IA relit la PR2b. Corriger les findingsLes bugs trouvés, en TDD3. MergeLa PR sort de la boucle

Après deux revues sans bug d’affilée, faites par deux IA différentes, la PR sort de la boucle.

Notre retour d’expérience

Le contexte : la maintenance d’un logiciel existant de 300 000 lignes de code. L’objectif : corriger les nombreux bugs détectés en production, puis réaliser les évolutions fonctionnelles demandées par le client, et ce sans jamais casser en prod ce qui marche déjà…

Depuis neuf mois, chaque correction ou évolution passe par une PR écrite par l’IA. Plus de 600 PRs sont passées par notre skill /full-review de revue de code. Voici ce que l’analyse de ces chiffres nous a appris.

Neuf mois en quatre temps

Chronologie du projet
  1. Février à avril : une IA, une passe136 PRs, petites et fusionnées vite. Une sur deux environ est relue une seule fois, par une seule IA.
  2. Mai à juillet : le rodageNaissance du skill /full-review. Les règles changent chaque semaine, les relecteurs tombent en panne.
  3. Juillet à septembre : trois fournisseursLe skill passe en v2, puis Grok (xAI) rejoint Claude (Anthropic) et Codex (OpenAI).
  4. Octobre : la boucle converge3 passes par PR en médiane, contre 7 en août.

Ce que montrent les chiffres

Depuis la fin du rodage, le 13 juillet :

376PRs 2 542passes de revue 11 090problèmes relevés 97 %des PRs avec au moins un problème

Il faut 5 passes par PR en médiane. Seules 11 sur 376 ont été livrées telles que l’IA les avait écrites.

Problèmes trouvés par passe de revue, en moyenne
1re passePasses suivantes
Rodage (jusqu’au 13 juillet)

En mai, la deuxième passe ne trouvait rien sept fois sur dix. Le code n’était pas meilleur : la revue était moins exigeante. Durcie en juin et juillet, elle trouve deux à quatre fois plus de problèmes dès la première passe.

Août est le pic : les PRs doublent de taille, près de 1 000 lignes en médiane, et tout grimpe avec elles. En octobre, la première passe trouve encore six problèmes, mais les suivantes presque plus : la deuxième passe est propre une fois sur deux, contre une fois sur dix en août.

Passes de revue par PR et délai de fusion, en médiane
Passes par PRDélai entre l’ouverture et la fusion, en heures
Rodage (jusqu’au 13 juillet)

En avril, sans processus, une PR était fusionnée en 1 h 20. Pendant le rodage, le délai explose : jusqu’à près de 15 heures en juin. Une fois le processus stable, il revient à 4 à 6 heures. C’est le prix de la validation, et il se lit directement sur ce graphique.

Voir les données mois par mois
MoisPRsFull-review (%)Taille méd.Passes méd.Pb 1re passePb passes suiv.2e passe propre (%)Délai méd. (h)
févr.40712––––0
mars439255––––13
avril891201––––1,3
mai1085828553,40,8707
juin1657531753,01,72914,6
juil.1348347655,92,5283,6
août11786961712,74,695,8
sept.1448356449,43,0376
oct.769147136,40,9503,9

Méthode : chiffres tirés des lignes de bilan laissées par chaque passe de revue sur plus de 600 PRs du projet, du 18 février au 11 novembre 2026. Les mois sont ceux de l’ouverture de la PR. Novembre, incomplet, est exclu des graphiques. Le rapport entre écriture et revue est mesuré sur 7 sessions d’octobre et novembre, temps actif seulement.

Ce que nous avons appris

Chaque règle du processus vient d’un retour d’expérience. Nous en avons consigné plus d’une centaine. Voici les leçons qui ont le plus changé notre façon de valider.

1. Faire jouer la concurrence

Faire relire à une IA le code qu’elle vient d’écrire apporte peu. Changer son niveau d’effort, ou passer à un autre modèle du même fournisseur, aide un peu. Le mieux reste de faire jouer la concurrence : Codex (OpenAI) relit le code écrit par Claude Code (Anthropic), ou inversement. Chacun traque chez l’autre le moindre détail.

Les chiffres le confirment : dans 38 % des PRs, une IA a jugé le code propre, puis celle d’un autre fournisseur y a trouvé un problème. Même code, autre regard. C’est la raison d’être des trois fournisseurs.

Un cas réel

Une PR remplaçait une erreur par une valeur de secours, quand une source externe envoyait des données corrompues. La première revue n’y a vu qu’un détail de documentation. La deuxième l’a décrite comme une amélioration, « plus sûre ».

À la quatrième passe, le modèle d’un autre fournisseur a suivi cette valeur jusqu’à ses usages : elle servait à calculer des montants réels. Problème classé critique, changement annulé.

Un trait très humain, au passage. Quand une IA reçoit les bugs trouvés dans son propre code, elle les accepte presque toujours. Mais elle les minimise volontiers : « D’accord, c’est un bug, mais il est moins grave que tu ne le dis. » Un échange entre deux IA, sans aucun humain dans la boucle.

2. Valider coûte cinq à dix fois plus qu’écrire

Sur les sessions où nous avons pu mesurer les deux phases, la revue prend cinq fois plus de temps que l’écriture en médiane, et jusqu’à dix fois. Écrire prend quelques dizaines de minutes, valider prend des heures. La revue consomme aussi bien plus de tokens, avec trois relecteurs par PR.

C’est pourtant là que l’IA a le plus progressé en 2026. Elle est devenue bien meilleure que l’humain pour valider du code, trouver les failles de sécurité et les corriger avant la mise en production. Aucun relecteur humain ne garde la même attention de la première à la centième revue.

3. Régler les paramètres pour que la boucle converge

Deux réglages décident quand la boucle s’arrête. D’abord le seuil d’exigence : chaque relecteur classe ce qu’il trouve sur sa propre échelle, du bug bloquant à la faute de frappe dans la documentation, et le skill fixe le niveau à partir duquel un problème relance la boucle. Ensuite, le nombre de revues sans bug d’affilée exigé pour merger : deux par défaut, un paramètre du skill.

Mal réglée, la boucle tourne sans fin. En comptant les relances du skill sur une même PR, 34 PRs ont atteint 20 passes, et sept ont dépassé les 30, jusqu’à 41. Un détail de style dans un test relançait toute la boucle, au même titre qu’un bug en production.

Nous avons donc placé la barre selon l’enjeu : haute sur le code exécuté et les scripts, plus basse sur les tests et la documentation. Moins exigeante sur les détails, la revue demande moins de passes. C’est l’un des changements qui expliquent la convergence d’octobre.

4. Documenter chaque PR pour garder la mémoire du projet

Chaque PR s’accompagne d’un fichier Markdown versionné dans le dépôt : le contexte, la cause du problème, la correction, les fichiers touchés et le plan de test. Plus de 600 PRs sont documentées ainsi. C’est la mémoire du projet : une IA qui reprend un sujet des mois plus tard n’a pas à tout redécouvrir, elle relit ce fichier comme le ferait un nouveau développeur. Ce fichier passe lui aussi en revue, au même titre que le code.

5. Les bugs se cachent dans les cas limites

Les relecteurs ne s’arrêtent pas aux fautes évidentes. Les problèmes qu’ils relèvent touchent surtout les conditions aux limites, les cas rares et les failles de sécurité : une valeur vide, un nombre négatif, une source externe qui renvoie des données corrompues. Avant, ces cas n’étaient traités que partiellement, et souvent imparfaitement. C’est là que la revue par IA apporte le plus.

6. Un problème trouvé en cache d’autres

Corriger la seule ligne signalée ne suffit pas : le même défaut se trouve souvent ailleurs dans le code. Avant chaque correction, l’IA cherche le même motif dans tout le dépôt, et corrige chaque occurrence, avec un test pour chacune.

7. Le processus se corrige lui-même

À la fin de chaque revue, l’IA propose des améliorations de ses propres règles. Nous les relisons et les intégrons par lots, plusieurs fois par mois. Le processus d’octobre n’est plus celui de juillet, et c’est voulu.

8. Orchestrer les relecteurs

Automatiser une revue entre plusieurs IA demande un chef d’orchestre : lancer chaque relecteur sur la PR, récupérer son verdict, relancer celui qui ne répond plus. Plusieurs outils le font. Nous avons choisi Orca, qui coordonne les agents de chaque fournisseur tout en gardant leur outil d’origine, en ligne de commande : Claude Code, Codex et Grok Build tournent tels quels, sans couche d’adaptation.

Mais aussi

9. Une revue en panne n’est pas une revue propre

Un relecteur qui plante ne renvoie aucun problème. Compté comme « propre », il pouvait faire livrer une PR que personne n’avait lue. Depuis, une revue en erreur est ignorée, jamais comptée.

10. Un seul relecteur ne doit jamais pouvoir conclure

Deux revues propres d’affilée ne suffisent pas si elles viennent du même relecteur : il conclurait seul, avec ses propres angles morts. Le cas arrive dès qu’un relecteur ne répond plus, quota atteint ou service indisponible : depuis juillet, 56 passes ont échoué ainsi, sur 40 PRs. Désormais, une PR ne sort de la boucle qu’une fois validée par au moins deux relecteurs différents, sur sa version finale.

11. Vérifier chaque soupçon avant de corriger

Les IA relèvent beaucoup de faux problèmes. Chaque soupçon est donc vérifié dans le code avant d’être corrigé. Depuis septembre, 8 504 fausses alertes ont été écartées, et transmises aux relecteurs suivants pour qu’ils n’y reviennent pas.

12. Une règle non lue n’est pas appliquée

Les instructions du processus avaient grossi jusqu’à 91 000 tokens, relus en entier à chaque passe. Nous les avons découpées : chaque étape charge seulement ce dont elle a besoin, et chaque passe tourne dans un agent neuf, sans le bruit des précédentes.

Pour les développeurs
  • Les relecteurs : Claude (Anthropic), Codex (OpenAI) et Grok (xAI), dans un ordre fixe.
  • Chaque correction suit le TDD : un test qui échoue d’abord, le correctif ensuite. 2 979 corrections prouvées ainsi depuis le 13 juillet.
  • Garder les PRs petites : en août, quand leur taille médiane a doublé, passes et problèmes ont grimpé avec elle.
  • Chaque passe laisse une ligne de bilan sur la PR : relecteur, problèmes, fausses alertes, corrections. C’est d’elles que viennent tous les chiffres de cet article.

Conclusion

Neuf mois et plus de 600 PRs plus tard, le constat est net : écrire du code ne coûte presque plus rien, le valider coûte plus cher. Une seule IA qui relit ne suffit pas. Plusieurs IA de fournisseurs différents, encadrées par un processus strict, relisent avec une attention qu’aucun relecteur humain ne tient sur des centaines de revues.

Ce processus a un prix : plus de temps et de tokens par PR, et des réglages à affiner en continu. C’est pourtant un tel processus qui permet de confier sereinement à l’IA l’évolution de votre logiciel en production.

L’humain ne disparaît pas pour autant. Il décide quoi construire, fixe le niveau d’exigence, écrit et ajuste les règles de validation, tout en gardant la maîtrise de bout en bout.

Déléguez l’exécution à l’IA, mais gardez la compréhension !

P.S. Travaux connexes :

Nous mettons également cette démarche en place avec vos équipes dev, sur votre code et vos outils.

Découvrir la démarche