Pour accéder à l’index complet de la documentation, consultez llms.txt. Pour obtenir la version Markdown d’une page de documentation, ajoutez .md à la fin de l’URL de la page.
Navigation principale
Oct 14, 2026 Codex

Maintenir des logiciels avec la famille GPT-6

Comment l’équipe Core Experimentation d’OpenAI utilise Codex pour supprimer le code inutilisé, retirer les expérimentations obsolètes et améliorer l’intégration continue.

Auteur: Rodrigo Roim

Maintenir des logiciels avec la famille GPT-6

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 :

Pouvez-vous m’aider à repérer et nettoyer le code mort dans le dépôt svp, n’hésitez pas à consulter Slack, statsig [une plateforme que nous utilisons pour gérer les feature flags et les expérimentations] ou toute autre source pour vérifier que les éléments en question ne servent vraiment plus et qu’on peut les nettoyer ou les simplifier
GPT-6 Astra

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 :

Repérez et supprimez les portions importantes de code mort liées à des gates ou configurations Statsig obsolètes dont la valeur est constante, ou à des expérimentations abandonnées dans les projets {A} et {B}. Vérifiez la configuration Statsig en vigueur, l’historique Git et les pull requests qui touchent au même code. Préservez le comportement en production, les protections opérationnelles et les gates ou configurations prévus pour servir d’interrupteurs d’urgence ou jouer un rôle similaire. Ignorez les valeurs de repli du SDK et les surcharges locales. Pour chaque nettoyage, ouvrez une petite pull request en brouillon et incluez dans son résumé un lien vers la configuration dans la console Statsig.
GPT-6 Astra

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é :

/goal Dans l’ensemble du dépôt, recensez tous les objets Statsig (gates, configurations, expérimentations et couches) qui sont obsolètes, ont une valeur constante, ont été abandonnés ou sont entièrement déployés, et dont le retrait est sans risque et ne change rien en production. Examinez tous les projets et inventaires Statsig, y compris les objets qui ne sont pas marqués comme obsolètes. Recherchez les usages indirects via les énumérations, constantes, wrappers, alias, schémas, noms construits dynamiquement et appels provenant d’autres services. Recoupez les informations pour chaque constante référencée en production. Poursuivez au-delà d’une première liste limitée aux cas les plus évidents. Examinez les ressources cloud que consomme chaque objet, y compris le CPU. Exploitez la télémétrie et les profils de production lorsqu’ils sont disponibles pour repérer les vérifications inutiles et coûteuses. [Pour faire court, nous avons omis les instructions détaillées qu’Astra a rédigées pour vérifier le comportement en production, traiter en priorité les objets les plus anciens, préserver les protections mises en place à dessein et interpréter les valeurs de repli du SDK.] Rédigez un rapport Markdown regroupant tous les candidats vérifiés par responsable et par fichier, de façon à pouvoir répartir le travail en parallèle. Indiquez les valeurs en production, les éléments de preuve, les responsables, les sites d’appel et, si les données sont disponibles, le coût observé des évaluations ou leur consommation CPU. Ne modifiez aucune configuration ni aucun service en production.
GPT-6 Astra

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 :

Nettoyage des expérimentations obsolètes

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 :

/goal Examinez toutes les exécutions récentes de la CI pour repérer les tests instables. Pour chacun, essayez un correctif et, s’il fonctionne, ouvrez une pull request. Concentrez-vous sur les problèmes simples pour lesquels la correction est claire. Il n’est pas nécessaire de corriger tous les tests instables.
GPT-6.1 SolMedium

Améliorer le contexte fourni aux agents :

Parcourez mes sessions Codex récentes et repérez une instruction du fichier AGENTS.md qui semble avoir induit un agent en erreur ou occasionné du travail inutile. Retrouvez le prompt initial de la session concernée. Relancez ce prompt deux fois avec le même modèle et à partir du même instantané du dépôt : 1. Conservez l’instruction actuelle du fichier AGENTS.md telle quelle. 2. Supprimez ou corrigez uniquement cette instruction. Comparez la qualité du travail, le comportement de l’agent, les appels d’outils, la consommation de tokens, le temps d’exécution et le coût. Citez l’instruction et indiquez si sa modification a amélioré les résultats.
GPT-6.1 SolMedium

Réduire le coût et la durée de l’intégration continue :

Comment alléger la charge de la CI dans ce dépôt ? Présentez toutes vos idées dans un tableau et classez-les selon le nombre de minutes de CI qu’elles permettraient d’économiser par jour, d’après l’historique des exécutions de la CI du dépôt
GPT-6.1 SolMedium

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 !