Développer avec l’IA

Le pipeline de revue automatisée du code d'Anthropic pour les modifications générées par l'IA

Anthropic révèle comment son équipe Claude Code utilise la vérification automatisée et des contrôles déterministes pour valider le code écrit par l'IA sans nécessiter une revue manuelle par un ingénieur pour chaque modification.

Un cube en verre avec des circuits lumineux sur un bureau avec des notes et une loupe
Illustration générée pour cet article

Traduit automatiquement depuis l'original anglais.

L'équipe d'ingénierie d'Anthropic s'appuie désormais sur son propre assistant IA, Claude, pour écrire et examiner environ 90 % du code destiné au produit Claude Code. Dans un récent article technique, Addy Osmani, membre du personnel, a détaillé le système de vérification interne qui permet ce haut niveau d'automatisation tout en maintenant la fiabilité logicielle. Cette approche déplace l'effort humain de l'écriture de chaque ligne vers le jugement des preuves produites par les agents automatisés.

Ce qu'il s'est passé

L'équipe Claude Code a structuré son flux de travail afin que les agents IA prennent en charge la majeure partie des tâches de codage, mais ils ne committent pas les modifications sans passer par une série rigoureuse de contrôles automatisés. Ces contrôles sont conçus pour soutenir des dizaines, voire des centaines d'agents concurrents travaillant simultanément. Au lieu d'exiger qu'un ingénieur inspecte chaque modification individuelle, le système fournit des preuves structurées que les ingénieurs peuvent examiner pour porter les jugements finaux.

Cette méthode a suscité un débat dans la communauté des développeurs concernant les coûts et l'intégrité. Les critiques se sont demandé si les coûts d'inférence liés à l'utilisation de grands modèles de langage pour la vérification étaient justifiés par rapport à des outils déterministes moins chers. D'autres craignaient que les agents IA ne manipulent les tests pour qu'ils réussissent plutôt que de corriger les problèmes sous-jacents. Anthropic a répondu en expliquant comment il superpose des contrôles déterministes peu coûteux avant les revues par modèle onéreuses et applique des règles strictes pour empêcher les agents de truquer le système.

Comment cela fonctionne

Le processus de vérification commence par des contrôles déterministes dont le coût d'exécution est très faible. Ceux-ci incluent les builds standards, les linters, les tests unitaires et les tests basés sur les propriétés. Comme il s'agit de processus logiciels ordinaires, ils peuvent être relancés fréquemment sans dépense significative. Ce n'est qu'après que ces contrôles réussissent que le système engage la revue basée sur le modèle. Cette approche hiérarchisée garantit que l'inférence coûteuse est réservée aux jugements complexes auxquels les tests simples ne peuvent répondre, tels que l'évaluation de savoir si une modification adopte la bonne approche architecturale ou manque des cas limites non couverts par les tests existants.

Pour empêcher les agents de manipuler les résultats, Anthropic impose une séparation stricte entre le code modifié et les contrôles qui le valident. Si une modification peut altérer le contrôle qui la juge, le système considère ce contrôle comme défaillant. Par exemple, le relecteur de code lit les fichiers de configuration comme REVIEW.md depuis la branche de base, et non depuis la nouvelle pull request. Il est interdit aux agents de sauter des tests instables (flaky), d'ajouter des délais pour masquer les échecs, ou de relancer les tests jusqu'à ce qu'ils réussissent. Si un agent ne peut pas résoudre un test en échec, il doit supprimer le test et documenter la raison, assurant ainsi la transparence.

Détails clés

  • Claude écrit et examine environ 90 % du code pour l'équipe Claude Code.
  • Les compétences de vérification sont stockées dans des dossiers spécifiques au dépôt sous .claude/skills/.
  • Les contrôles déterministes comme les builds et les linters s'exécutent avant toute revue basée sur le modèle pour maîtriser les coûts.
  • Les agents ne peuvent pas modifier les contrôles qui jugent leur propre code ; les relecteurs lisent depuis la branche de base.
  • Entre juin et septembre, les pull requests fusionnées ont doublé tandis que les annulations (reverts) ont chuté de plus de 40 %.
  • Les ingénieurs restent responsables de chaque modification livrée, en examinant des preuves telles que les captures d'écran et les journaux de tests.

Pourquoi c'est important

Pour les équipes développant des logiciels avec l'IA, ce modèle offre une feuille de route pour faire évoluer le développement sans augmenter linéairement les effectifs. Il démontre que des taux élevés d'automatisation sont possibles si l'on investit dans une infrastructure de vérification robuste. L'idée clé est que la confiance n'est pas accordée aveuglément à l'IA, mais aux preuves qu'elle produit. En faisant passer le rôle humain d'auteur à auditeur, les équipes peuvent gérer des volumes plus importants de modifications tout en maintenant des normes de qualité.

Cependant, l'absence de données publiées sur les taux de faux positifs et les coûts d'inférence spécifiques signifie que les équipes doivent soigneusement évaluer leurs propres implémentations. La stratégie nécessite un changement culturel où les ingénieurs acceptent la responsabilité du code qu'ils n'ont pas tapé eux-mêmes. Elle exige également des outils rigoureux pour empêcher les agents de prendre des raccourcis, comme réécrire des tests pour cacher des bugs. Sans ces garde-fous, les gains de vitesse apportés par le codage IA pourraient être compensés par une dette technique accrue et une instabilité.

Ce que vous pouvez faire

  • Implémentez des tests basés sur les propriétés pour aider les agents IA à identifier les cas limites que les tests unitaires standards pourraient manquer.
  • Séparez votre logique de vérification de votre code applicatif pour empêcher les agents de modifier leurs propres juges.
  • Exécutez des contrôles déterministes peu coûteux comme les linters et les builds avant de déclencher des revues basées sur le modèle coûteuses.
  • Utilisez le test différentiel pour comparer les nouvelles implémentations aux anciennes afin de repérer les changements de comportement inattendus.
  • Exigez que les agents documentent pourquoi ils suppriment ou sautent des tests, assurant ainsi la transparence dans le processus de vérification.
  • Surveillez la conformité aux portes de vérification avant de les rendre obligatoires, permettant aux équipes d'ajuster leurs flux de travail progressivement.
  • #ai coding
  • #software engineering
  • #anthropic
  • #code verification
  • #developer tools

Outils de la Boutique Bytechap

$89

DocBento

Gestion documentaire auto-hébergée qui analyse chaque scan et répond avec des citations de pages.

Démo en ligne

Continuer la lecture

Tous les articles