Toute base de code qui grandit demande de l’entretien. Il faut supprimer le code inutilisé, retirer ce qui reste des expérimentations terminées et corriger les tests. Chez OpenAI, les agents de programmation nous ont permis de développer plus vite, ce qui a aussi accru nos besoins de maintenance.
Je travaille au sein de l’équipe Core Experimentation d’OpenAI. Nous développons et maintenons les logiciels qui permettent aux équipes de toute l’entreprise de mener des expérimentations, qu’il s’agisse de faire évoluer une interface ou de réduire les ressources nécessaires pour servir les modèles.
Avec la sortie de GPT-6 Astra, nous avons gagné du temps sur le développement et la maintenance de nos logiciels. GPT-6.1 Sol a donné des résultats similaires à moindre coût. Dans cet article, je montre comment nous utilisons ces modèles pour repérer le code à nettoyer, réunir les éléments qui justifient chaque modification et préparer la revue de code.
Supprimer le code inutilisé
Avant la programmation agentique, de nombreuses équipes de développement s’appuyaient sur des systèmes complexes qui combinaient analyse statique et journaux d’exécution pour détecter et supprimer le code inutilisé. Même avec ces systèmes et des revues de code minutieuses, des erreurs se produisent. Je me souviens de plusieurs incidents causés par du code supprimé à tort. Les cas particuliers sont trop nombreux pour qu’on puisse tous les anticiper. La réflexion peut, par exemple, fausser l’analyse statique, et un chemin de code aujourd’hui inutilisé peut servir demain à atténuer un incident.
Avec GPT-5.6 Sol dans Codex, il me suffisait de préciser quelle partie du code examiner et quels critères appliquer pour valider les résultats. Le modèle pouvait alors écrire le code d’analyse statique et supprimer le code mort. Ces prompts ciblés étaient plus faciles à mettre au point et à maintenir que nos systèmes d’analyse statique, pour une fiabilité comparable.
Quand nous avons eu accès à GPT-6 Astra, nous avons voulu savoir si le modèle pouvait partir d’une demande plus large et déterminer lui-même où chercher et quels éléments réunir pour justifier chaque suppression. Nous avons commencé par un court prompt dans Codex. La demande était trop vague pour que GPT-5.6 Sol puisse la traiter entièrement. Voici le prompt, coquilles comprises :
Astra s’est bien débrouillé malgré l’imprécision de la demande. Il a examiné d’anciennes pull requests, consulté des fils de discussion Slack pour comprendre le contexte et parcouru nos outils internes de suivi de projet. Il a vérifié dans les tables de profilage des performances en production que les lignes supprimées n’étaient jamais exécutées. Astra a aussi expliqué ce qui justifiait chaque suppression, ce qui a accéléré nos revues de code.
Au vu de ces résultats, cinq ingénieurs ont travaillé ensemble pour essayer des variantes de ce prompt dans plusieurs dépôts. Nous avons fusionné plus de 1 400 pull requests et supprimé plus de 800 000 lignes de code. Nous avons fait l’essentiel de ce travail en deux semaines, en y consacrant une partie de notre temps tout en travaillant principalement sur d’autres projets. Nous avons réparti les revues de code entre les équipes qui connaissaient les projets concernés. Ces suppressions ont eu des effets mesurables. Par exemple, l’image de conteneur d’un service est passée de 3,31 Go à 1,72 Go, soit une réduction de 48 %. Une autre série de modifications a éliminé environ 400 variantes de captures de référence de nos tests visuels.
Repérer les expérimentations obsolètes
Retirer les expérimentations obsolètes est un problème de maintenance plus difficile à résoudre. Ces expérimentations peuvent encore servir. Leur code peut s’exécuter en production ou dépendre de vérifications d’éligibilité dont le résultat peut changer à tout moment, ce qui complique considérablement l’analyse statique. Jusqu’alors, notre équipe repérait et retirait les expérimentations obsolètes par analyse statique déterministe, complétée par des requêtes en base de données. Nous utilisions notre modèle le plus puissant, à l’époque GPT-5.6 Sol, pour écrire et améliorer les scripts correspondants. Nous savions que cette méthode produisait de nombreux faux négatifs : des expérimentations bel et bien obsolètes échappaient à notre analyse.
Après nos bons résultats sur le code mort avec GPT-6 Astra, j’ai décidé d’essayer un autre prompt court, cette fois pour les expérimentations obsolètes. Comme je ne savais pas par où commencer, j’ai exploré quelques pistes avec Astra, puis je lui ai demandé de rédiger un court prompt à essayer dans un nouveau fil de discussion :
Astra a respecté les précautions du prompt et préparé des modifications que notre équipe pouvait examiner avec les éléments qui les justifiaient. J’ai commenté ses pull requests, puis je lui ai demandé de lire mes commentaires et d’en tenir compte pour rédiger un nouveau prompt qui couvrirait toute notre base de code. Je craignais de me retrouver avec trop d’éléments à nettoyer sans savoir par lesquels commencer. J’ai donc aussi demandé à Astra de m’aider à établir des priorités. Voici le prompt qu’il m’a proposé :
Le rapport était prometteur. Grâce à nos outils de mesure, Astra a examiné la consommation CPU de chaque expérimentation obsolète. Les premiers résultats du classement laissaient entrevoir des gains d’efficacité importants sur des expérimentations dont personne n’avait repéré l’obsolescence depuis des années. Après avoir soigneusement validé les gains les plus importants, j’ai lancé le nettoyage complet, qui a permis de supprimer des centaines d’expérimentations et de feature flags.
Un exemple illustre le discernement d’Astra. Il y a plusieurs années, un de nos ingénieurs a créé un feature flag Statsig qui permettait aux développeurs en interne de remplacer, pour leurs tests, la valeur de tous les autres flags liés aux nouvelles fonctionnalités. Une seule ligne de Python suffisait pour associer ce flag à toutes les autres fonctionnalités. Au milieu de centaines d’associations similaires, cette ligne passait inaperçue.
Astra a constaté que cette ligne multipliait les opérations CPU, précisément parce qu’elle associait le flag à toutes les fonctionnalités. Il a analysé la consommation CPU, puis nous a soumis le cas pour examen. Le flag avait été explicitement marqué « Permanent » dans notre console de gestion des feature flags et pouvait encore servir en exploitation. Après vérification, nous l’avons supprimé. Nous estimons à 0,42 % l’économie de CPU sur le principal service concerné.
Réduire le coût des audits avec GPT-6.1 Sol
Plus récemment, nous avons testé GPT-6.1 Sol sur les mêmes workflows pour voir s’il pouvait égaler l’efficacité de GPT-6 Astra tout en consommant moins de ressources.
Pour comparer les modèles sur le nettoyage des expérimentations obsolètes, j’ai repris le prompt ci-dessus avec plusieurs combinaisons de modèle et de niveau d’effort. J’ai demandé à Codex de rechercher les expérimentations obsolètes dans des sous-répertoires précis d’un de nos dépôts. Ces sous-répertoires comptent plus de 6 000 fichiers et un million de lignes de code en Python, TypeScript, Go et Rust. J’ai examiné les cas signalés pour les valider. Le graphique ci-dessous présente les résultats pour trois combinaisons de modèle et de niveau d’effort :
API cost
- GPT-6 Astra Ultra
- $109.06
- GPT-6.1 Sol Ultra
- $15.12
- GPT-6.1 Sol Medium
- $5.27
Findings
- GPT-6 Astra Ultra
- 142
- GPT-6.1 Sol Ultra
- 131
- GPT-6.1 Sol Medium
- 86
Cost per finding
- GPT-6 Astra Ultra
- $0.77
- GPT-6.1 Sol Ultra
- $0.12
- GPT-6.1 Sol Medium
- $0.06
Les coûts sont calculés au tarif standard de l’API. Ils incluent le travail des sous-agents chargés des recherches et les tours supplémentaires que Codex a exécutés automatiquement pour atteindre chaque objectif.
Dans cette comparaison, le nombre de cas repérés par GPT-6.1 Sol Ultra atteint 92 % de celui obtenu avec GPT-6 Astra Ultra, pour seulement 14 % des frais d’API de ce dernier. Avec GPT-6.1 Sol Moyen, nous avons validé moins de cas, mais le coût était plus faible.
En examinant les écarts selon le modèle et le niveau d’effort, j’ai relevé quelques tendances. Par exemple, au niveau Ultra, la plupart des écarts entre les modèles concernaient des feature flags de valeur constante dont dépendaient d’autres feature flags. GPT-6 Astra les a repérés, tandis qu’ils ont échappé à GPT-6.1 Sol.
Quand nous repérons des erreurs récurrentes de ce type, nous pouvons adapter nos prompts pour les corriger. Le modèle le moins cher peut ainsi obtenir des résultats proches de ceux du modèle le plus coûteux. Ces ajustements peuvent toutefois devenir superflus avec les modèles suivants. Il est donc important de réexaminer les prompts à la sortie de nouveaux modèles.
D’autres idées à essayer
Certaines de mes découvertes préférées avec Codex sont parties de prompts aussi courts que ceux qui suivent. Essayez-les avec GPT-6.1 Sol Moyen. Si les résultats sont prometteurs, envisagez d’augmenter le niveau d’effort pour les audits de plus grande ampleur.
Corriger les tests instables :
Améliorer le contexte fourni aux agents :
Réduire le coût et la durée de l’intégration continue :
Cette dernière idée nous a permis de réduire la durée de la CI. Après avoir essayé le prompt et donné suite aux suggestions, nous avons fusionné une trentaine de pull requests d’optimisation de la CI. La durée médiane d’une exécution est passée d’environ 10 minutes à 4,5 minutes, et le 90ᵉ percentile de 12,5 à 6 minutes. Par la suite, en ajoutant un mock qui manquait, nous avons ramené de 592,6 à 29,8 secondes la durée d’exécution d’une suite de 63 tests de résolveur, soit une réduction de 95 % tout en conservant les 63 tests.
Commencez à petite échelle, examinez les résultats, puis élargissez le périmètre
Les modèles de la série GPT-6 ont amélioré la façon dont notre équipe Core Experimentation assure la maintenance des logiciels à grande échelle et nous ont permis de gagner en efficacité sur plusieurs fronts.
À ce jour, mon équipe a fusionné plus de 1 400 pull requests de maintenance issues de propositions de GPT-6. Les tests s’exécutent plus vite, les images sont plus petites et la consommation CPU a baissé, entre autres bénéfices. Certaines propositions introduisaient toutefois une complexité excessive au regard du gain attendu. Mesurer les effets des changements et décider lesquels traiter en priorité reste donc une part importante de notre travail.
Sur une grande base de code, le nombre d’optimisations que les modèles GPT-6 peuvent repérer a vite fait de nous dépasser. Grâce à nos outils de mesure et aux techniques de rédaction de prompts présentées plus haut, Codex nous a aidés à déterminer quelles améliorations traiter en priorité.
Si vous souhaitez essayer cette approche sur votre base de code, je vous conseille de commencer par une petite tâche de maintenance : du code inutilisé, un feature flag obsolète ou un test instable. Demandez à Codex de repérer un cas, de réunir les éléments qui justifient la modification et de préparer une petite pull request en brouillon. Comparez plusieurs modèles et niveaux d’effort sur cette tâche, car une configuration moins coûteuse peut suffire.
Si ce premier essai donne de bons résultats, étendez la recherche à un sous-répertoire ou à un projet bien délimité. À chaque étape, demandez à Codex d’intégrer au prompt suivant vos commentaires de revue de code. Une fois que les performances du modèle vous inspirent confiance, élargissez la recherche à toute la base de code.
Notre équipe Core Experimentation recrute en ingénierie, en science des données et en gestion de produit. Si cet article vous donne envie de nous rejoindre, postulez depuis notre page carrières !