AI CodeOps

Comment relire du code écrit par un agent IA

Mis à jour le

Une approche pratique pour relire les pull requests générées par l'IA : quoi lire en premier, les erreurs courantes des agents de codage, et comment éviter les approbations de pure forme.

Relire du code écrit par un agent IA, c'est vérifier trois choses avant le code lui-même : que le changement fait ce qui a été demandé et rien de plus, que les preuves qui l'accompagnent sont réelles, et que les tests n'ont pas été tordus pour s'y adapter. Le code écrit par un agent est généralement bien formaté et se lit avec assurance ; les problèmes se logent donc plutôt dans les hypothèses, le périmètre et la vérification que dans des erreurs évidentes. Une bonne revue lit d'abord la tâche, les résultats des tests et le diff des tests, puis se concentre sur les parties du changement où une erreur coûterait cher.

Cette page développe la section consacrée à la relecture du code écrit par l'IA dans Qu'est-ce que la revue de code par IA ?.

Ce qui distingue les changements écrits par un agent

Les changements humains et ceux de l'IA échouent de façons différentes, et un relecteur habitué aux uns peut manquer les autres.

  • Plausibilité. La production d'un agent compile, suit le style maison et comporte des commentaires utiles. La qualité de surface n'est pas un signe d'exactitude, comme elle l'est souvent pour le travail humain.
  • Volume. Un agent peut produire en quelques minutes un changement qui touche des dizaines de fichiers. C'est l'attention du relecteur, et non le temps de l'auteur, qui devient la limite.
  • Résumés assurés. Les agents décrivent leur propre travail comme terminé et testé. Cette description est une affirmation, et elle est parfois fausse d'une manière que l'agent n'a pas remarquée.
  • Pas de mémoire partagée. Un collègue se souvient pourquoi le code a été écrit d'une certaine façon. Un agent ne sait que ce qui figurait dans son contexte ; il peut donc défaire une décision délibérée dont il n'avait pas connaissance.
  • Dérive du périmètre. Les agents corrigent ce qu'ils remarquent en chemin : un renommage ici, un refactoring là. Chacun peut être raisonnable, mais ensemble ils rendent le changement plus difficile à relire et plus risqué à livrer.

Partir de la tâche, pas du diff

Lisez la tâche confiée à l'agent avant d'ouvrir le moindre fichier. Demandez-vous ensuite :

  1. Le changement fait-il ce que la tâche demandait ?
  2. Fait-il quelque chose que la tâche ne demandait pas ?
  3. L'agent a-t-il interprété une tâche ambiguë autrement que vous ne l'auriez fait ?

Un agent qui a mal compris la tâche peut produire une implémentation d'apparence correcte de la mauvaise chose. C'est plus facile à voir quand vous gardez la demande en tête que quand vous lisez d'abord le code pour en déduire l'intention.

Tout ce qui sort du périmètre de la tâche mérite un examen plus attentif ou un changement séparé. Les modifications non demandées de la configuration, des définitions de CI, des manifestes de dépendances ou du code d'authentification sont celles sur lesquelles il faut s'arrêter.

Lire les preuves avant le code

Avant de lire l'implémentation, regardez ce qui a été vérifié.

  • Les tests ont-ils été exécutés sur cette version exacte ? Une exécution de tests antérieure à la dernière modification ne dit rien du code actuel.
  • Quels tests ont été exécutés, et certains ont-ils été ignorés ? Un résultat vert issu d'une suite qui a ignoré les tests pertinents n'est pas une réussite.
  • Qu'a trouvé la revue automatisée, et comment cela a-t-il été trié ? Les constats ouverts de gravité élevée, ou les constats écartés sans justification, vous indiquent où regarder.
  • Quelque chose n'a-t-il pas du tout été vérifié ? « Aucun test exécuté » doit être visible, et non caché derrière un statut neutre.

Si les preuves manquent, la revue est plus difficile, et l'approbateur doit le savoir avant de décider.

Lire le diff des tests avant le diff du code

Les tests sont l'endroit où un agent pressé de faire passer les choses peut prendre des raccourcis. Cherchez :

  • des tests supprimés, commentés ou marqués comme ignorés ;
  • des assertions assouplies, par exemple une comparaison exacte remplacée par une vérification qu'une valeur existe ;
  • des valeurs attendues modifiées pour correspondre à ce que renvoie le nouveau code ;
  • des mocks si larges que le code testé ne s'exécute jamais vraiment ;
  • de nouveaux tests qui exécutent du code sans rien affirmer sur le résultat.

Un diff de tests qui ne fait qu'ajouter des tests et des assertions est bon signe. Un diff de tests qui modifie des attentes existantes a besoin d'une raison que vous pouvez retrouver dans la tâche.

Les erreurs que commettent souvent les agents de codage

Ces motifs reviennent assez souvent pour qu'on les recherche délibérément.

MotifCe qu'il faut chercher
API ou paquets inventésDes appels à des fonctions, options ou paquets qui n'existent pas dans la version que vous utilisez
Erreurs avaléesDes blocs catch trop larges, des erreurs journalisées puis ignorées, ou des échecs convertis en résultats vides
Replis silencieuxDes valeurs par défaut qui masquent un échec, comme renvoyer zéro ou une liste vide quand une recherche échoue
Autorisation manquanteDe nouveaux points de terminaison ou actions sans le contrôle de permission que possède le code similaire
Motifs obsolètesDes appels de bibliothèque dépréciés, une cryptographie ancienne ou des réglages par défaut non sûrs appris dans du code plus ancien
Utilitaires dupliquésUn nouvel utilitaire qui reproduit un utilitaire déjà présent dans la base de code
Nouvelles dépendancesUn paquet ajouté pour quelque chose que la bibliothèque standard ou une dépendance existante fait déjà
Changements sans rapportDu reformatage, des renommages ou des refactorings hors de la tâche, mêlés au vrai changement

Les erreurs avalées et les replis silencieux méritent une attention particulière. Ils font passer les tests et fonctionner les démos tout en transformant un échec visible en données erronées, ce qui coûte bien plus cher à trouver plus tard.

Garder les gros changements relisibles

Quand un changement est trop gros pour être relu correctement, il existe de meilleures options que de l'approuver sans le lire.

  • Découpez la tâche. Le travail d'un agent ne coûte pas cher à refaire. Demandez le changement en morceaux plus petits, chacun avec une limite claire.
  • Lisez selon le risque. Lisez ligne par ligne les fichiers qui gèrent l'argent, l'authentification, les données personnelles, les permissions et la persistance. Survolez les fichiers générés ou mécaniques.
  • Protégez les chemins sensibles. Une règle qui exige une revue supplémentaire pour les changements sous infra/ ou les définitions de CI garantit que ces fichiers ne passent jamais inaperçus dans un gros changement.
  • Rejetez plutôt que de réparer. Si l'approche est mauvaise, un rejet avec une raison claire et une meilleure tâche est souvent plus rapide que de modifier à la main le code de l'agent.

Approuver de manière responsable

Une approbation doit signifier qu'une personne a examiné le changement et les preuves, et accepte la responsabilité de le livrer. Trois habitudes lui gardent son sens :

  • Séparez l'auteur et l'approbateur. La personne qui a écrit la tâche ne doit pas être la seule à approuver le résultat quand quelqu'un d'autre le peut.
  • Réapprouvez après modification. Si le changement est modifié après approbation, l'approbation précédente ne s'applique plus à ce qui sera livré.
  • Écrivez une raison quand vous rejetez. Cela aide la tentative suivante, qu'elle soit faite par une personne ou par un agent.

Comment AI CodeOps accompagne la revue

Dans AI CodeOps, chaque changement de code issu d'une session ouvre une demande de revue. Sur la page de la session, l'approbateur voit les changements proposés, les constats et le panneau Quality gates avec les résultats des tests, qui indique aussi quand un changement n'a pas été vérifié parce que les tests n'ont pas pu s'exécuter. Un diff de plus de 60 KB est refusé avec « Split the task into smaller changes », pour que les relecteurs ne reçoivent pas de changements trop gros pour être lus.

La personne qui a lancé la session ne peut pas donner le vote d'approbation tant que quelqu'un d'autre dans l'espace de travail peut approuver. Un rejet exige une raison et clôt la demande. Modifier un changement après approbation le renvoie en approbation, et un résultat de test ne compte que pour la version sur laquelle il a été obtenu. Les politiques de l'espace de travail peuvent exiger une approbation pour les changements touchant des chemins comme infra/**, ou les refuser. Une session de suivi peut s'appuyer sur un changement au lieu de repartir de zéro.

Consultez Approbations et politiques pour savoir qui peut approuver et comment les votes sont comptés, Barrières qualité pour ce qui bloque un changement, et Qu'est-ce qu'une barrière qualité ? pour le principe général.

Questions fréquentes

Le code généré par l'IA doit-il être relu plus strictement que le code humain ?

Il doit être relu différemment. Le code est souvent propre et plausible ; les risques se cachent donc dans ce qu'il suppose, ce qu'il a omis et ce qu'il a modifié en dehors de la tâche. Lisez d'abord les preuves et le périmètre, puis le code.

Comment savoir si un agent a affaibli les tests ?

Lisez le diff des tests avant le diff du code. Cherchez les tests supprimés ou ignorés, les assertions assouplies, les mocks trop larges et les valeurs attendues modifiées pour correspondre à la nouvelle sortie. Vérifiez ensuite que les tests ont bien été exécutés sur cette version du changement.

Est-il acceptable d'approuver un gros changement produit par l'IA sans l'avoir entièrement lu ?

Pas pour du code qui compte. Demandez à découper la tâche, ou lisez entièrement les fichiers à risque et rapidement les fichiers mécaniques. Une approbation affirme que vous avez vérifié le changement, et elle doit avoir ce sens.

La personne qui a donné le prompt à l'agent doit-elle approuver son changement ?

Pas seule, quand quelqu'un d'autre peut relire. La personne qui a écrit la tâche est de fait l'auteur, et un second relecteur détecte ce que l'auteur a présupposé.