En bref
- Tester une application à la main avant chaque version est lent, et les scripts de test automatisés cassent dès qu’un bouton bouge. Laisser une IA cliquer sur chaque test tous les jours fonctionne… mais c’est trop lent et trop cher.
- PromptQA laisse un agent IA parcourir une fois un cas de test écrit, comme le ferait une personne, et transforme ce qu’il a fait en script de test ordinaire. Ce script s’exécute ensuite chaque jour sans IA. Quand l’application change et qu’une étape casse, l’IA revient pour cette seule étape.
- Le même moteur teste aussi les tickets du tableau de notre équipe. Il décide comment chaque ticket peut être testé, publie un verdict avec captures d’écran et interroge l’équipe quand un ticket n’est pas clair. Les personnes gardent le dernier mot.
- Jusqu’ici : 35 parcours de test enregistrés sur 35 rejoués au vert sans aucune IA. Un juge visuel plus précis a fait passer les validations à tort de 7 sur 36 à 3 sur 36. Une vérification backend coûte environ 11 à 14 cents.
Toute application a une liste de choses que quelqu’un vérifie avant une version… se connecter, changer de mot de passe, s’assurer que la petite pastille rouge affiche le bon nombre. Nous voulions qu’une machine parcoure cette liste, sans payer une machine pour y réfléchir tous les jours. Nous avons donc construit PromptQA, et les premiers chiffres sont là.
#Le problème
Les tests de régression consistent à vérifier que ce qui fonctionnait hier fonctionne encore aujourd’hui. La plupart des équipes consignent ces vérifications sous forme de cas de test dans un outil de gestion des tests : un titre, quelques étapes et un résultat attendu pour chaque étape. Des phrases simples.
C’est généralement là que ça s’arrête. Les cas de test existent sous forme de texte, pas le code de test, parce que l’écrire demande un temps d’ingénierie que personne n’a. Et quand le code existe, il casse dès que l’écran change. Un bouton bouge, un libellé est renommé, et un script qui allait bien le lundi échoue le mardi.
La réponse évidente côté IA consiste à laisser un modèle de vision, une IA capable de lire des captures d’écran, cliquer sur chaque test tous les jours. Cela fonctionne, mais c’est lent et cher : une vérification d’une application pilotée par l’IA prend des minutes et peut coûter quelques dollars. Multipliez cela par quelques centaines de cas de test, chaque jour, et la facture dépasse le problème.
#Ce que nous avons construit
PromptQA, ce sont deux outils sur un même moteur.
Le moteur est un agent IA capable de voir un écran et d’agir dessus. Il fonctionne dans un navigateur ou sur un émulateur Android, c’est-à-dire un téléphone simulé sur un ordinateur. Il regarde une capture d’écran, décide quoi faire, puis touche, tape ou fait défiler, comme le ferait une personne. À côté se trouve un juge : un second modèle qui regarde la capture d’écran après chaque étape et dit si le résultat attendu de l’étape est vraiment à l’écran, avec un score de confiance de 0 à 1.
Mode 1 : une suite de régression qui s’écrit toute seule
- Lire. Il lit les cas de test écrits dans l’outil de gestion des tests.
- Piloter une fois. L’agent parcourt chaque cas sur l’application, étape par étape, et le juge vérifie chaque étape.
- Compiler. Chaque toucher et chaque mot tapé est enregistré, et l’enregistrement devient un vrai script de test, du même type que celui qu’un ingénieur écrirait à la main.
- Exécuter sans IA. Dès lors, le script s’exécute chaque jour tout seul. Aucun modèle n’est appelé, donc c’est rapide et cela ne coûte rien au-delà de la machine sur laquelle il tourne.
- Réparer en cas de casse. Quand l’application change et qu’une étape échoue, l’IA revient pour cette étape seulement, trouve le nouveau chemin et répare le script. Au-delà d’un nombre fixé de réparations, elle demande un nouvel enregistrement au lieu de rapiécer indéfiniment.
Les résultats retournent dans l’outil de gestion des tests, avec captures d’écran. En bref : compiler une fois, exécuter indéfiniment, se réparer en cas de casse.
Mode 2 : un agent QA pour le tableau de l’équipe
Le second mode travaille sur des tickets plutôt que sur des cas de test. Il surveille une colonne du tableau de notre équipe dans un outil de suivi des tickets comme Jira, celle où le travail terminé attend d’être testé. Pour chaque ticket, il fait cinq choses.
Il décide comment le tester. Un ticket portant sur l’écran est testé sur l’application, dans un émulateur ou un navigateur. Un ticket portant sur le serveur est testé sur le backend avec de petites requêtes en lecture seule, que nous appelons des sondes. Un ticket qu’une machine ne peut pas tester part chez un ingénieur, avec une raison en une ligne.
Il le teste. Les sondes sont encadrées : adresses approuvées uniquement, lecture seule en production, une liste d’actions qu’il ne peut jamais appeler et une limite de requêtes par étape. Avant de tester, il vérifie que le correctif est bien déployé.
Il rend compte. Il publie sur le ticket un verdict structuré avec des captures d’écran ou les preuves recueillies, et ajoute une étiquette : réussi, échoué, à revoir, à confier à l’ingénierie ou ignoré.
Il se souvient. Il garde des notes sur ce qu’il a appris, pour que l’exécution suivante démarre en étant plus avisée.
Il demande. Quand un ticket n’est pas clair, il pose une question à l’équipe au lieu de deviner. Si personne ne répond sous trois jours, le ticket passe à une personne.
Deux règles protègent l’équipe. L’agent étiquette les tickets mais ne les déplace jamais, si bien qu’une personne décide de la suite. Et quand la machine de test elle-même tombe en panne, le ticket ne reçoit aucune étiquette : un émulateur en panne est signalé comme un émulateur en panne, jamais comme une fonctionnalité en échec.
#Comment nous l’utilisons
C’est le tableau qui décide quand le travail se fait. Quand un ticket arrive dans la colonne QA, une exécution démarre en quelques secondes.
Tout tourne dans le cloud, à la demande. Une vérification backend est une courte tâche cloud qui démarre, s’exécute et disparaît. Une vérification d’application a besoin d’un émulateur, donc une machine démarre pour elle et s’éteint d’elle-même ensuite. Rien ne reste inactif à attendre du travail.
Les dépenses sont plafonnées par ticket : au plus deux exécutions par passage, plus un plafond en dollars. Atteindre un plafond envoie le ticket à une personne, jamais en « échoué ». Une fois par semaine, l’équipe reçoit un récapitulatif de ce qui a été testé et de ce que cela a coûté.
#Xylo, la voix dans Slack
Xylo est notre assistant d’équipe IA, et il vit dans Slack. Pour la QA, c’est lui qui répartit le travail et qui prend la parole.
Il lance les exécutions quand un ticket arrive dans la colonne QA, avec une vérification planifiée comme filet de sécurité.
Il publie chaque verdict dans le canal de l’équipe, où chacun peut le confirmer avec ✅ ou l’infirmer avec ❌.
Il fait circuler les questions dans les deux sens. La question de l’agent part vers l’équipe, la réponse revient, et le ticket est testé à nouveau.
Il suit l’avancement, si bien que chacun peut demander « que fait la QA en ce moment ? » et obtenir une vraie réponse.
Il envoie le récapitulatif hebdomadaire : exécutions et coût.
PromptQA fait les tests. Xylo décide quand ils démarrent et dit à l’équipe ce qui s’est passé.
#Ce que nous avons mesuré
Le juge qui examine chaque étape
Le juge compte le plus, parce qu’une validation à tort laisse passer un bug. Nous avons donc construit un test étiqueté pour lui : 49 vraies captures d’écran d’étapes, pour chacune desquelles une personne a décidé si elle devait réussir ou échouer. Chaque capture a été jugée trois fois, et chaque configuration a tourné deux fois.
Tout est parti d’une seule erreur de lecture. Sur une application de sport, un minuscule « 2 » sur une pastille a été lu comme un « 3 ». Pour réduire les coûts, nous donnions au juge une copie de la capture réduite à 1024 pixels sur le grand côté, et le chiffre ne faisait plus qu’environ 8 à 10 pixels de haut. Celle-là, c’était donc de notre faute.
Le juge d’origine (un petit modèle avec la capture réduite) a validé à tort 7 vérifications sur 36 qui auraient dû échouer.
Le nouveau juge (un modèle plus puissant avec la capture en pleine résolution) : 3 sur 36. Les trois concernaient la même capture de test obsolète, écrasée par un enregistrement ultérieur, si bien que son étiquette ne correspondait plus à l’image. Sans elle, 0 sur 33.
Le cas à l’origine de tout : les vérifications qui auraient dû réussir sont passées de 1 sur 6 à 6 sur 6.
Coût : environ 2 cents par étape jugée avec le modèle plus puissant, contre environ 0.6 cent auparavant.
Environ trois fois le prix par étape, pour un juge qui a cessé de valider ce qu’il devait rejeter. Nous avons changé.
Rejouer sans IA
Sur une vraie application mobile, nous avons rejoué les 35 parcours de test enregistrés sans aucune IA. 35 sur 35 ont réussi, et aucun compte de test n’est resté modifié. Ce dernier point compte plus qu’il n’y paraît… un test qui modifie son propre point de départ fait mentir l’exécution suivante.
Une semaine sur un vrai tableau
En une semaine sur un tableau de production, l’agent de tickets a traité 22 tickets. 10 ont réussi et 8 sont partis chez un ingénieur, chacun avec une raison. 2 sont devenus des questions pour l’équipe, 1 a été mis de côté pour une revue humaine et 1 a été ignoré. Et aucun ticket n’a été marqué « échoué » à cause d’un problème d’infrastructure.
Ce que coûte une vérification
Un ticket backend prend environ 25 à 30 secondes et environ 11 à 14 cents de temps de modèle.
Un ticket d’application prend quelques minutes sur un émulateur et environ $1 à $2.50 au total. Le test lui-même coûte $0.30 à $1.50, et le raisonnement propre de l’agent autour de celui-ci coûte $0.10 à $0.95.
Un tableau vide ne coûte rien. Une vérification gratuite du tableau s’exécute avant tout appel à un modèle.
Lire les réponses de l’équipe
Quand quelqu’un répond dans Slack, Xylo doit savoir de quel type de réponse il s’agit : une réponse à la question de l’agent, un passage de relais à un collègue (« aucune idée, demandez-lui »), ou une question pour l’assistant lui-même. Un petit modèle tranche. Sur un ensemble étiqueté de 36 réponses de style réel, trois exécutions chacune, il a eu juste 108 fois sur 108, et aucune réponse n’a été perdue.
Deux leçons chiffrées
Un coût que personne ne communique est inconnu, pas gratuit. Pendant un temps, le récapitulatif hebdomadaire indiquait que la QA coûtait $0.00. La QA la moins chère de l’histoire… sauf que nous n’envoyions tout simplement jamais le coût. Désormais, un coût manquant apparaît comme « non communiqué », pas comme zéro.
Ne pas aller chercher le travail, se le faire signaler. Au début, l’agent se réveillait toutes les 15 minutes pour demander au tableau si quelque chose devait être testé. Sur une journée, cela représentait 81 réveils qui n’ont rien trouvé. Désormais, c’est le tableau lui-même qui déclenche l’exécution, et le planning n’est qu’un filet de sécurité.
#Ce qui ne fonctionne pas encore
Il manque quelques éléments, et certains chiffres sont moins solides qu’ils n’en ont l’air.
iOS. La cible iPhone n’est que partiellement construite et n’a jamais tourné en conditions réelles. Aujourd’hui, ce sont Android et le web.
« À revoir ». Le juge plus puissant est plus prudent. Dans le test étiqueté, il a répondu « à revoir » sur 8 ou 9 des 111 étapes qui auraient dû réussir, au lieu de trancher. C’est plus sûr qu’une validation à tort… et cela coûte quand même un coup d’œil à une personne.
Les coûts ne comprennent que le temps de modèle. Les chiffres ci-dessus excluent les machines cloud, et le compteur de la partie test facture chaque modèle à un tarif unique, ce qui surestime le coût du modèle le moins cher.
#Mon avis
Ce que je préfère, c’est l’endroit où l’IA intervient. Elle parcourt un test une fois, le consigne et s’efface. Ensuite, un simple script fait le travail quotidien, et l’IA ne revient que lorsque quelque chose a changé.
L’autre point, c’est que l’agent sait quand s’arrêter. Il confie des tickets aux ingénieurs, pose des questions et ne déplace jamais un ticket de lui-même. Huit tickets sur 22 sont partis chez un ingénieur cette semaine-là, et je considère que c’est l’agent qui fait son travail, pas qu’il échoue.
