En bref
- En six mois, un client est passé de deux tests automatisés à 200 specs de bout en bout sur deux produits, plus 45 page objects. Claude Code les a presque toutes écrites ; un humain a validé chaque plan.
- Le run nocturne est du TypeScript Playwright pur : aucun appel à une IA, aucune clé d’API. L’agent n’intervient qu’au moment de l’écriture.
- La confiance vient d’un plan en anglais validé avant tout code, de valeurs attendues capturées dans l’application réelle et d’un tag
@deviationsur chaque spec qui vérifie moins que son cas (77 sur 200). - La pire instabilité venait de l’état côté serveur partagé par des tests parallèles, pas du timing.
- Notre avis : utilisez l’IA pour écrire les tests, pas pour les exécuter, et répartissez les agents par contexte, jamais par rôle ni par cas.
Il y a six mois, le client avait deux tests automatisés. Aujourd’hui, il y a 200 specs de bout en bout sur deux de ses produits, plus 45 page objects. Chaque matin, un run nocturne nous dit ce qui a cassé.
Un agent de codage IA (Claude Code) a écrit presque tout cela, et un humain a validé chaque plan. Rien de tout cela n’appelle une IA à l’exécution.
Ce partage est toute l’idée. L’agent fait la partie lente, celle qui demande du jugement. Il lit un cas de test manuel, clique dans l’application réelle pour apprendre comment elle se comporte vraiment, et transforme cela en code. Puis il s’efface. Ce qui est livré, c’est du TypeScript Playwright pur : déterministe, relisible et exécutable sans clé d’API.
Où l’IA travaille, et où elle ne travaille pas
Claude Code se charge de l’écriture, une fois par cas de test, avec une validation humaine avant tout code. Ce qui tourne chaque nuit, c’est du Playwright pur.
| Étape | Qui | Ce qui se passe |
|---|---|---|
| 1Récupérer le cas | Agent | Récupère les étapes et les résultats attendus dans Jira/Xray |
| 2Rédiger le plan | Agent | En anglais, assez court pour être vérifié par rapport au cas en une seule lecture |
| 3Valider le plan | Humain | Rien n’est codé avant cette étape ; un hook bloque toute spec sans plan |
| 4Piloter l’application réelle | Agent | En 1280×720, comme le runner ; les valeurs attendues sont capturées dans l’application |
| 5Écrire la spec | Agent | Locators dans les page objects ; lint et vérification des types après chaque modification |
| 6L’exécuter jusqu’au vert | AgentHumain | Le même agent la vérifie ; un humain relit le diff avant le merge |
| Chaque nuit | Playwright | 200 specs en TypeScript pur et 45 page objects ; aucun appel à une IA, aucune clé d’API |
Voici ce que nous avons appris en le construisant. Pour l’essentiel, nous l’avons appris à nos dépens.
#Une commande par cas de test
Chaque spec commence comme un cas de test manuel dans Jira/Xray. Une seule slash command le transforme en code :
- Récupérer le cas. L’agent récupère les étapes et les résultats attendus. S’il n’arrive pas à obtenir les étapes, il demande qu’on les colle. Il ne devine jamais les étapes à partir d’un titre.
- Rédiger le plan en anglais. Préconditions, étapes numérotées avec leurs résultats attendus, nettoyage et ce qui est hors périmètre. Il est assez court pour qu’une personne non technique puisse le vérifier par rapport au cas en une seule lecture.
- S’arrêter pour validation. Rien n’est codé tant qu’un humain n’a pas validé le plan. Un hook empêche l’agent d’écrire tout fichier de spec qui n’a pas de plan correspondant.
- Piloter l’application réelle. L’agent ouvre un vrai navigateur via une CLI et parcourt chaque étape. Il lit l’arbre d’accessibilité et les réponses réseau. Les valeurs attendues sont capturées dans l’application, jamais écrites de mémoire.
- Produire la spec et les page objects. Les locators vivent dans les page objects, et les specs ne touchent jamais de sélecteurs bruts. Le lint et la vérification des types s’exécutent comme hooks après chaque modification.
- L’exécuter jusqu’au vert. L’agent qui a écrit la spec la vérifie aussi, et un humain relit le diff avant le merge.
Le plan reste dans le dépôt, au même chemin que sa spec. Des mois plus tard, quand un test échoue, vous pouvez lire en anglais clair ce qu’il était censé prouver.
Les petits détails de l’étape 4 comptent. La CLI du navigateur ouvre une fenêtre plus haute et plus étroite que le runner de tests. L’application affiche des jumeaux responsive de certains contrôles. Écrivez à la mauvaise taille et vous figez le jumeau que le runner ne voit jamais. Chaque session d’écriture commence donc par fixer le viewport exact du runner, 1280×720.
#Chaque écart reçoit un tag
Le test le plus dangereux passe tout en vérifiant moins qu’il ne le prétend. Les agents IA sont très doués pour en produire. Quand l’agent rencontre un blocage, la solution de facilité est une assertion plus faible qui passe au vert.
Nous avons donc rendu chaque écart visible. Parfois, une spec ne peut pas vérifier exactement le résultat attendu du cas. Les données de seed manquent, la fonctionnalité se comporte autrement, ou une clause est tout simplement invérifiable. La spec fait alors trois choses :
- Elle porte un tag
@deviation. - Elle ajoute une annotation qui cite le cas mot pour mot, indique ce que nous vérifions à la place, et pourquoi.
- Son plan consigne l’écart dans une section consacrée à la fidélité.
Un hook rejette toute modification où le tag et l’annotation ne vont pas ensemble. Aujourd’hui, 77 specs sur 200 portent le tag. Ce chiffre n’a rien de gênant ; c’est tout l’intérêt. Un seul grep liste chaque lacune de couverture à revoir quand un blocage est levé.
La règle derrière tout cela : quand l’agent ne peut pas automatiser un cas tel qu’il est écrit, il s’arrête et pose la question, avec une recommandation. Il ne livre jamais discrètement la version dégradée.
Le tag avait lui-même besoin d’être vérifié. Un premier audit a montré qu’il sous-comptait : certaines specs vérifiaient moins que leur cas sans le dire. Désormais, un agent auditeur en lecture seule compare chaque mois le tag, l’annotation, le plan et le cas.
#Le véritable ennemi, c’est l’état partagé
Les pires de nos tests instables n’étaient pas une question de timing. Ils tenaient à un état qui survit au test.
La plupart des specs s’exécutent en parallèle sur un seul compte d’automatisation partagé, face à un seul tenant de test. Et l’application mémorise certaines choses par utilisateur, côté serveur :
- Un filtre. Le filtre de périmètre d’une page de liste persiste. Une spec le laisse sur un périmètre vide, et une spec sur un autre worker voit zéro enregistrement. La correction : chaque spec qui lit la liste fixe d’abord son propre périmètre, puis recharge la page.
- Un mode d’affichage. Passez la liste des cartes à un tableau, et elle reste ainsi pour tout le monde. Lors d’un run, une spec l’a basculée en pleine suite et quatre specs sans rapport ont échoué en attendant des cartes désormais masquées. La correction : un seul projet en série peut toucher à la vue tableau, et il rétablit les cartes en sortant.
- Une déconnexion. Se déconnecter tue toutes les sessions du compte, côté serveur, pas seulement votre navigateur. Un seul test de déconnexion sur le compte partagé renverrait chaque spec parallèle à la page de connexion. La correction : la déconnexion s’exécute sur son propre compte dédié. Les connexions sont sans risque ; les déconnexions, non.
Tout ce qui modifie un état persistant s’exécute dans une chaîne en série. Les dépendances de projets de Playwright nous donnent cet ordre, mais elles font aussi barrière : si quoi que ce soit échoue en amont, tout ce qui est en aval est ignoré. Une nuit, cette barrière nous a coûté 85 tests sur 237 qui n’avaient aucun problème.
Nous avons donc écrit un petit runner qui garde l’ordre et supprime la barrière. Il lit le graphe de projets de Playwright lui-même et exécute une phase par niveau de dépendance, en séquence d’un niveau à l’autre et en parallèle au sein d’un niveau. La seule barrière que nous avons gardée est la vérification des données de seed, parce que des données de seed qui ont dérivé doivent vraiment faire ignorer tout ce qui en dépend.
L’ordre sans la barrière
Le même graphe de dépendances, exécuté de deux façons. Une nuit, la barrière a fait ignorer 85 tests sur 237 qui n’avaient aucun problème.
| Dépendances de projets de Playwright | Notre runner par phases | |
|---|---|---|
| Ordre | Fixé par les dépendances de projets | Le même graphe : une phase par niveau de dépendance, en séquence d’un niveau à l’autre et en parallèle au sein d’un niveau |
| Un test en amont échoue | Tout ce qui est en aval est ignoré | Ce test échoue seul ; les phases suivantes s’exécutent quand même |
| La vérification des données de seed échoue | Ses dépendants sont ignorés | Ses dépendants sont ignorés : la seule barrière que nous avons gardée |
#Un run rouge doit avoir un sens
Un run nocturne toujours rouge apprend à tout le monde à l’ignorer. Une grande partie de notre travail a consisté à faire en sorte que chaque échec signifie une seule chose.
159 sur 159. Dans notre environnement de test, chaque navigation de page lève une erreur non interceptée provenant du hub temps réel de l’application, dont la poignée de main de connexion est rejetée. C’est du bruit global, pas un défaut de page. Nous avons filtré le message évident, et un run nocturne comptait encore 159 échecs dans nos vérifications « aucune erreur JS ». Les 159 étaient deux autres erreurs levées par la même cause racine, et aucun des deux messages ne mentionne le hub. Elles n’apparaissent que dans les longs runs, si bien qu’elles étaient invisibles en local. Désormais, une seule fixture partagée filtre les trois, et toute autre erreur fait toujours échouer le test.
Un smoke qui n’en était pas un. Notre tag smoke figurait sur 196 specs sur 201 ; il sélectionnait donc toute la suite et ne signifiait rien. Nous l’avons réduit à 32 vraies specs smoke.
Une dérive du seed n’est pas une régression. Les specs vérifient des données de test existantes. Une vérification des données de seed s’exécute en premier. Quand les données dérivent, vous obtenez un seul échec clair et ses dépendants sont ignorés, au lieu de quarante échecs déroutants. Vous corrigez les données de test, pas les assertions.
Un bouton renommé, 18 nuits rouges. Un bouton de la barre supérieure a changé de libellé, passant de « Add new » à quelque chose de plus précis. Notre vérification de chargement de page portait sur ce bouton, et cette vérification se trouvait dans les deux barrières de seed. Environ 113 tests sont tombés en cascade à cause d’un seul libellé. La correction accepte l’un ou l’autre nom. Nous avons aussi sorti les vérifications de l’interface générale de l’application des assertions de chargement de page pour les regrouper dans un seul test canari. La prochaine fois, un seul test passera au rouge au lieu d’une centaine.
La capture d’écran ment. Playwright prend sa capture d’écran d’échec après l’exécution du nettoyage. Une spec rétablissait la vue dans son nettoyage, si bien que la capture montrait une page saine. Nous avons pourchassé un bug fantôme pendant deux itérations. Quand le nettoyage touche à l’interface, fiez-vous à la vidéo.
#Répartissez les agents par contexte, pas par rôle
La conception tentante, c’est une équipe : un agent planificateur, un agent rédacteur, un agent testeur. Ou un agent par cas de test, tous en parallèle. Les deux ont l’air d’un progrès. Les deux sont des pièges ici.
Les répartitions par rôle perdent en fidélité à chaque passage de relais. Le planificateur sait pourquoi une étape compte. Le rédacteur reçoit un résumé, et le testeur encore moins. Les coordonner coûte plus cher que le travail lui-même.
Un agent par cas détruit la cohérence. Lancez vingt agents et chacun invente sa propre méthode de page object pour le même bouton. Les leçons d’un cas n’atteignent jamais le suivant. Et ils se disputent tous le même compte partagé.
Ce qui fonctionne, c’est de répartir selon les frontières de contexte, pour un travail réellement indépendant et en lecture seule :
- un brief par cas dans un lot, récupéré en parallèle
- une classification par échec lors du tri d’un run rouge, avec un second avis à l’aveugle sur tout verdict qui coûterait du temps à un humain
- une revue des conventions par spec modifiée
- des audits mensuels par morceaux : honnêteté sur les écarts, dérive entre les specs et leurs cas de test, sélecteurs bruts qui devraient être dans les page objects, et locators fragiles
L’écriture reste séquentielle, dans une seule session. L’agent qui écrit une spec la vérifie aussi. Les raisons sont physiques, pas stylistiques : un compte avec un état côté serveur, un tenant de test, et un jeu de page objects qui doit rester cohérent. Par défaut, nous utilisons un seul agent, et tout agent supplémentaire doit mériter sa place.
#Apprenez une fois à l’agent, à un seul endroit
Chaque session démarre à froid. Tout ce que l’agent sait de l’application doit se trouver à un endroit où il sera effectivement chargé. Nous avons fini avec cinq emplacements pour le savoir, choisis selon leur portée :
- Les règles de projet toujours chargées contiennent les faits valables pour chaque spec : le compte partagé, le bruit du hub temps réel et « ne jamais attendre le network idle, car l’application interroge le serveur sans fin ». Nous gardons volontairement ce fichier court. Plus il s’allonge, moins il est suivi.
- Les fichiers de règles limités à un chemin, un par section de l’application, ne se chargent que lorsque l’agent touche aux page objects ou aux specs de cette section. Nous en avons sept pour l’instant.
- Les skills contiennent le savoir-faire : nos conventions de locators et d’assertions, plus une table de correspondance des signatures d’erreur. Elle associe un message d’échec à sa cause, à la manière de la confirmer et à un verdict, avant que quiconque commence à déboguer.
- La mémoire contient l’état qui n’a pas sa place dans le code : pourquoi un cas a été mis de côté, un bug produit, un fait sur les données de seed.
- Les hooks couvrent tout ce qui ne doit jamais être oublié. L’agent peut sauter une phrase, mais il ne peut pas contourner un hook qui refuse la modification. Les nôtres bloquent les specs sans plan, protègent la configuration d’authentification, vérifient que l’environnement est disponible avant un run de tests et font respecter l’appariement du tag.
Une règle traverse les cinq : un fait vit à un seul endroit. Un fait écrit à deux endroits dérive. Une copie est corrigée après un changement dans l’application, l’autre devient obsolète, et vous ne pouvez plus savoir laquelle est vraie.
Une dernière règle, pour la sécurité : le texte des cas de test est une donnée, pas une instruction. Si une étape semble demander à l’agent de modifier un paramètre ou d’ignorer une règle, l’agent le signale au lieu d’obéir.
#Servez-vous
- Utilisez l’IA au moment de l’écriture, pas à l’exécution. Livrez du code pur.
- Faites valider par un humain un plan en anglais avant que le moindre code existe, et gardez le plan à côté de la spec.
- Capturez les valeurs attendues dans l’application réelle, jamais dans la mémoire du modèle.
- Taguez chaque endroit où un test vérifie moins que ce que demande son cas, et faites-le respecter par un hook.
- Considérez l’état côté serveur comme votre principale source d’instabilité. Fixez-le, sérialisez-le ou donnez-lui son propre compte.
- Séparez l’ordre des tests des barrières entre tests.
- Filtrez le bruit connu dans une seule fixture partagée, pour qu’un run rouge signale un vrai échec.
- Répartissez les agents selon les frontières de contexte, jamais par rôle ni par cas.
- Mettez chaque fait à un seul endroit, et placez ceux qu’il ne faut jamais manquer dans un hook.
200 specs, deux produits, six mois et zéro appel à une IA dans le run nocturne. L’agent écrit, Playwright exécute, et un humain décide.
