Leaders d’opinion

Pourquoi les tests doivent être intégrés à la chaîne de production de l’IA dès le départ

Ole Lensmar
Ajouter Unite.AI à vos sources préférées sur Google
Points clésL'IA accélère le codage mais expose des tests en aval faibles et réduit la stabilité de…
Voir plus
  • L'IA accélère le codage mais expose des tests en aval faibles et réduit la stabilité de la livraison.
  • Les agents qui jugent leurs propres tests peuvent tricher en modifiant les tests échoués au lieu de corriger le code.
  • Les tests doivent être une station à part, en dehors de la CI, afin que chaque changement reçoive le même verdict.

Je développe des outils de test depuis plus de vingt ans et, pendant la majeure partie de cette période, mes échanges avec les équipes d’ingénierie se ressemblaient beaucoup. Les testeurs avaient l’impression d’être des citoyens de seconde zone dans le cycle de vie des logiciels. Les tests intervenaient tardivement, souvent relégués au peu de temps restant avant une mise en production, et ajoutés à un pipeline d’intégration continue conçu pour autre chose. L’IA a désormais transformé notre façon d’écrire du code, et son impact sur les tests est bien réel, pour le meilleur comme pour le pire. À bien des égards, l’IA a rendu le problème plus visible.

Ces derniers mois, j’ai participé à quelques conférences sur les tests et le cloud natif (LeadDev, CloudX, StarWest), et presque toutes les équipes avec lesquelles j’ai échangé travaillent sur une variante d’un même projet : un cycle de livraison logicielle piloté par l’IA, dans lequel des agents prennent en charge le travail depuis la spécification jusqu’à la mise en production, avec le niveau d’intervention humaine adapté à chaque étape. Je me le représente comme une chaîne de montage. Des agents écrivent le code, d’autres le relisent, et des pipelines le compilent et le déploient. Les humains gardent un œil sur les opérations. En revanche, j’entends beaucoup moins parler de la place des tests dans cette chaîne.

Personne n’a encore trouvé la solution

Pour l’instant, c’est un peu le Far West. De nouvelles capacités des agents apparaissent toutes les quelques semaines, les grands laboratoires d’IA continuent de lancer de nouveaux modèles, et les équipes comme les fournisseurs essaient toutes sortes de choses pour voir ce qui fonctionne.

Certaines données laissent penser que des lacunes se manifestent déjà. Le dernier rapport DORA sur le développement logiciel assisté par l’IA de Google, qui a interrogé près de 5 000 professionnels des technologies, a révélé que l’adoption de l’IA est associée à une hausse du débit de livraison, ce qui est une bonne nouvelle. Elle reste aussi associée à une baisse de la stabilité des livraisons. Selon les chercheurs, l’IA accélère le développement et expose les faiblesses plus loin dans la chaîne, et ils citent des tests automatisés robustes parmi les garde-fous qui empêchent qu’une augmentation du nombre de changements n’entraîne une instabilité accrue.

Cela ne me surprend pas. Si l’on fait passer beaucoup plus de code dans un processus conçu pour en traiter bien moins, quelque chose ralentit ou finit par se casser quelque part.

Les développeurs vont plus vite, mais la plupart des mises en production, non

Quand on imagine les problèmes que peut causer du code généré par l’IA, on pense généralement à un agent qui met en production quelque chose de catastrophique. Je suis sûr que cela arrive et, dans ce cas, les conséquences ne sont pas réjouissantes : des bogues, des clients mécontents, peut-être un incident de sécurité. Mais, franchement, ce n’est pas ce que je rencontre le plus souvent.

L’enquête 2026 de Stack Overflow auprès des développeurs montre où se concentre aujourd’hui l’utilisation de l’IA. Les développeurs s’en servent surtout pour générer du code dans des domaines qu’ils connaissent déjà (67 %) et pour déboguer (61 %), tandis que seuls 20 % l’utilisent pour déployer, exploiter ou dépanner des systèmes de production. Jusqu’à présent, l’IA a surtout accéléré l’écriture du code. La vérification de ce code et sa mise en production fonctionnent encore, dans l’ensemble, comme avant.

Cela correspond aussi à ce que je constate : les équipes produisent beaucoup plus de code sans accélérer leurs mises en production. Un développeur ou une équipe peut avoir l’impression de créer deux fois plus de fonctionnalités, mais celles-ci restent bloquées plus loin dans la chaîne, en attente d’une revue, de tests ou d’un environnement où les exécuter. Tout ce code supplémentaire engorge le pipeline et, dans bien des cas, ralentit même la livraison globale des équipes.

Les questions sur les garde-fous viennent des responsables

Si les inquiétudes concernant les goulots d’étranglement dans la livraison causés par l’IA sont très concrètes, ce n’est pas la seule question que les équipes nous posent. Les développeurs veulent surtout savoir comment écrire plus vite un meilleur code. Les questions sur les garde-fous viennent des responsables de l’ingénierie et des personnes qui mettent en place ces flux de travail pilotés par des agents. Comment s’assurer que les agents ne dérapent pas ? Comment savoir s’ils n’introduisent pas de régressions ou s’ils ne passent pas discrètement à côté de tâches qu’ils étaient censés effectuer ? Comment s’assurer que les tests qu’ils écrivent vérifient réellement (et honnêtement !) ce qu’ils sont censés vérifier ?

Je pense que c’est parce qu’ils ne regardent pas la même chose. Un développeur examine une demande de fusion à la fois. Un responsable de l’ingénierie est responsable de tout ce qui est mis en production par de nombreux agents et collaborateurs, et c’est à lui de rendre des comptes lorsqu’un problème survient en production.

Et ils ont raison d’être prudents. Des chercheurs ont créé un banc d’essai appelé ImpossibleBench, composé de tâches de programmation dont les tests unitaires contredisent les spécifications : la seule façon de réussir consiste donc à tricher. Les modèles de pointe l’ont souvent fait, par exemple en modifiant ou en supprimant les tests en échec au lieu de corriger le code (!!). Une autre étude des demandes de fusion rédigées par des agents a révélé des lacunes dans la capacité des agents à tester leurs propres modifications. Elle cite également des recherches antérieures montrant que près d’un tiers des demandes de fusion d’agents acceptées ont nécessité des corrections ou une refactorisation ultérieures.

Ce que j’en retiens, c’est que les garde-fous ne peuvent pas se limiter à l’environnement propre à l’agent ni intervenir uniquement après la livraison du code. Si l’agent qui a écrit le code décide aussi s’il a réussi les tests, le résultat ne nous apprend pas grand-chose. Cela ne veut pas dire que les agents ne devraient pas écrire de tests. Cela signifie que le verdict doit venir d’un dispositif que l’agent ne peut pas modifier. Les tests doivent constituer leur propre étape dans la chaîne, par laquelle passe chaque changement, qu’il ait été réalisé par une personne ou par un agent.

Ce que cette étape doit assurer

La solution ne consiste pas à inventer une toute nouvelle forme de test. La plupart des pratiques nécessaires sont celles que les bonnes équipes d’assurance qualité réclament depuis toujours. Elles sont simplement plus importantes aujourd’hui.

Il faut vérifier que les tests sont conformes aux exigences, tout comme le code qu’ils testent. Ils doivent également s’exécuter dans l’environnement où le logiciel fonctionne. Un test qui réussit dans le bac à sable d’un agent n’apprend pas grand-chose sur la préproduction ou la production, et peut masquer les dépendances simulées — ou la façon dont elles l’ont été. Une récente étude portant sur près de 180 000 fichiers de test générés par des agents a révélé que les agents couvraient davantage de cas limites que les tests écrits par des humains, mais que leurs tests présentaient davantage de signes d’instabilité, en grande partie parce que les agents connaissaient mal l’environnement dans lequel les tests allaient s’exécuter. Exécuter les tests tôt sur une infrastructure réelle permet de détecter ce problème.

Les tests et leurs résultats doivent être conservés. Si un agent écrit un test, il devrait disposer des tests existants et de leurs résultats comme contexte, afin de tirer des enseignements à la fois de la couverture et de l’instabilité potentielle. Comme tout autre code, les tests doivent être révisés et versionnés, pour être exécutés de nouveau à la prochaine modification au lieu de disparaître à la fin de la session.

Un résultat positif devrait avoir la même signification, qu’il ait été demandé par un pipeline, un développeur ou un agent. Cela suppose d’utiliser les mêmes tests, de les exécuter sur la même infrastructure et de réunir les résultats au même endroit.

Les humains doivent aussi conserver leur capacité de jugement. Je veux bien confier aux agents le code répétitif et le raccordement des éléments. Décider de ce qui mérite d’être testé et de ce que signifie un échec reste une tâche humaine — du moins pour l’instant…

Cela signifie aussi que les tests ne peuvent pas se limiter à la CI/CD (si vous ne deviez retenir qu’une seule chose de cet article, que ce soit celle-ci !). Les pipelines d’intégration continue ont été conçus pour compiler et livrer du code ; ils n’ont jamais été conçus pour exécuter des tests automatisés à grande échelle. À mesure que nous adoptons un cycle de développement logiciel agentique (SDLC) et que le volume de code continue d’augmenter, la CI se prête encore moins à l’exécution des tests. Les tests doivent faire partie intégrante du processus de livraison des logiciels, plutôt que d’être une étape ajoutée en bout de pipeline. Cela suppose de les orchestrer comme un système à part entière, à travers tous les outils et environnements utilisés par une équipe, quel que soit celui qui pilote le processus : un agent ou un humain.

Par où commencer

La plupart des équipes disposent déjà de tests auxquels elles font confiance dans Playwright, Cypress, k6, Postman ou l’outil qu’elles ont choisi d’adopter. C’est un excellent point de départ. Voici quelques suggestions :

  1. Cartographiez le parcours d’une modification, de la requête initiale à la production, et indiquez chaque étape à laquelle un test est exécuté. S’il n’y en a qu’une, vers la fin, je commencerais par là.
  2. Veillez à ce que les agents ne modifient pas discrètement les tests existants. Les chercheurs d’ImpossibleBench ont constaté que restreindre l’accès des agents aux tests réduisait la triche. Lorsqu’un agent doit modifier un test, la modification devrait faire l’objet d’une demande de fusion examinée par une personne, comme pour tout autre code.
  3. Exécutez vos tests dans des environnements de test — de préférence réels — plutôt que dans les bacs à sable des agents, et ce le plus tôt possible, même s’il ne s’agit que d’une petite suite de tests de fumée lancée en préproduction pour chaque modification générée par un agent. Si vous utilisez l’IA pour écrire des tests, ne les acceptez pas tant qu’ils n’ont pas été exécutés dans cet environnement.
  4. Centralisez les résultats de vos tests dans un plan de contrôle unique — qu’il s’agisse d’un outil de suivi, de votre solution de gestion des performances des applications (APM) ou d’une plateforme de test spécialisée. Veillez à ce que ces résultats soient accessibles aux humains comme aux agents.
  5. Mesurez les résultats de la livraison plutôt que l’activité. Le nombre de demandes de fusion ne signifie pas grand-chose. Les métriques de livraison de DORA, comme le délai de mise en production des modifications et le taux d’échec des modifications, vous en diront bien davantage sur l’utilité de l’IA.
  6. Permettez aux agents d’utiliser la même infrastructure de test que vos équipes, afin que leur travail soit évalué selon les mêmes critères.

Optimiste, sous conditions

Je vois plutôt le bon côté des choses en ce qui concerne l’IA, et je pense qu’elle rendra les équipes de développement logiciel bien plus capables et, à terme, plus productives. Mais pour y parvenir, les équipes doivent suffisamment faire confiance aux résultats produits par leurs agents pour les mettre en production, et adopter une approche globale des tests dans le cycle de développement logiciel agentique (SDLC) — car c’est là que cette confiance se construit ou se perd.

Si vous visez un cycle de développement logiciel agentique (SDLC), quelle place les tests y occupent-ils aujourd’hui ?

Ole Lensmar est cofondateur et directeur technique de Testkube, une plateforme ouverte de tests destinée aux équipes d’ingénierie qui s’appuient sur l’IA. Il a créé SoapUI, l’un des outils de test d’API les plus utilisés, et a auparavant présidé l’OpenAPI Initiative.