Limites de l'intelligence artificielle : elle ne peut pas auto-évaluer ses résultats.

L'intelligence artificielle transforme rapidement la conception, le développement et les tests logiciels. Les équipes de développement peuvent désormais l'utiliser pour générer du code, créer des cas de test, identifier les défauts potentiels et automatiser les tâches répétitives d'assurance qualité à une vitesse qui paraissait irréaliste il y a encore quelques années.

Cette rapidité est très précieuse, mais elle crée en même temps un nouveau problème en matière d'assurance qualité.

Lorsque le même type de technologie est utilisé pour créer et valider un logiciel, les organisations risquent de créer un cercle vicieux de méfiance . Un modèle d'IA peut générer du code à partir d'une interprétation particulière d'une exigence, puis générer des tests à partir de cette même interprétation. Si l'hypothèse initiale est erronée, le code et le test peuvent être cohérents tout en ne répondant pas aux besoins de l'utilisateur.

En d'autres termes, l'intelligence artificielle ne peut être la seule juge de ses propres performances. Il est donc tout à fait imprudent de s'y fier.

Il ne s'agit pas d'un argument contre le développement assisté par l'IA. Les erreurs, les dysfonctionnements et les résultats incohérents sont inhérents à une technologie encore en développement. J'ai personnellement constaté comment ces erreurs et dysfonctionnements peuvent se manifester. La question cruciale est de savoir si les organisations disposent de mécanismes autonomes pour détecter ces défaillances avant qu'elles n'affectent les clients, les employés ou les processus métier critiques.

Les hypothèses partagées créent des angles morts partagés

Les processus traditionnels d'assurance qualité logicielle reconnaissent déjà l'intérêt de séparer le développement des tests. Ceux qui conçoivent un système le maîtrisent parfaitement, mais cette familiarité peut rendre difficile la remise en question des hypothèses sur lesquelles il a été construit. Les testeurs indépendants abordent le même système sous un angle différent , en examinant non seulement ce que le programme est censé faire, mais aussi sa probabilité de défaillance.

Le même principe s'applique à l'intelligence artificielle.

Des modèles entraînés sur des données similaires, recevant les mêmes exigences ou fonctionnant dans le même environnement de développement peuvent reproduire les mêmes angles morts. Un modèle générant une fonctionnalité peut ignorer une exigence ambiguë, un parcours utilisateur inhabituel ou une condition limite spécifique à un appareil. Un second modèle chargé de tester cette fonctionnalité risque alors de renforcer cette omission au lieu de la détecter.

Cela devient particulièrement risqué lorsque les tests générés par l'IA sont considérés comme une preuve de qualité simplement parce qu'ils fonctionnent correctement. Un test réussi confirme seulement que les conditions de test ont été remplies. Il ne prouve pas que ces conditions étaient complètes, indépendantes ou pertinentes.

Il peut en résulter un système techniquement cohérent mais pratiquement défaillant.

La contradiction fondamentale entre l'IA générative et l'assurance qualité logicielle formelle réside dans la reproductibilité. Les agents de programmation d'IA modernes sont conçus pour générer et s'adapter. Autrement dit, face à un objectif apparemment identique, ils peuvent opter pour des étapes différentes, utiliser des outils différents, interpréter le contexte différemment et produire un code ou des tests non identiques.

Cela n'est pas toujours dû à l'apprentissage du système à chaque exécution ; c'est aussi le résultat de la génération probabiliste, des changements de contexte et de l'évolution du modèle. Cette variabilité peut s'avérer extrêmement utile lors de la recherche de solutions, mais elle contredit un principe fondamental de l'assurance qualité (AQ). En effet, un test contrôlé doit être reproductible sur la même version, dans les mêmes conditions, avec des résultats attendus clairement définis et des preuves de succès ou d'échec.

Sans ce contrôle, les organisations risquent de n'avoir qu'une activité d'IA au lieu d'une véritable assurance, et des résultats qui semblent raisonnables, mais qui ne peuvent être reproduits, mesurés, audités ou défendus de manière fiable.

La réussite professionnelle n'est pas synonyme de réussite utilisateur.

De nombreux tests automatisés évaluent les logiciels à partir de signaux au niveau du code. Ils vérifient si le service renvoie la réponse attendue, si la page contient un élément spécifique ou si un bouton peut être localisé via un identifiant ou un sélecteur.

Ces tests sont importants, mais ils ne remplacent pas la vérification de l'expérience utilisateur. Un test peut confirmer la présence d'un bouton même s'il est masqué par un autre élément. Il peut également vérifier qu'un champ contient du texte sans se rendre compte que ce texte est tronqué, mal positionné ou formaté de manière à le rendre illisible.

Le test pourrait trouver une liste qui existe techniquement, mais qui est inaccessible sur un écran plus petit. Il pourrait également confirmer qu'une transaction est terminée sans tenir compte du fait que la confirmation affichée à l'utilisateur contient un montant, un compte ou un statut incorrect.

Du point de vue du système, le logiciel a peut-être fonctionné correctement. Du point de vue de l'utilisateur, il a échoué.

Cette distinction est importante car les services numériques modernes reposent de plus en plus sur des combinaisons complexes de code d'application, de comportement du navigateur, de systèmes d'exploitation, de tailles d'écran, de bureaux à distance, d'environnements virtuels et de composants tiers.

Toute modification apportée à l'une de ces couches peut altérer l'affichage à l'écran sans pour autant entraîner l'échec d'un test fonctionnel classique. Par conséquent, le test doit examiner non seulement les informations fournies par la plateforme, mais aussi ce que l'utilisateur voit et peut faire.

Pourquoi la vérification visuelle est-elle importante ?

La vérification visuelle de l'interface utilisateur offre une perspective indépendante, car elle teste le résultat affiché à l'utilisateur plutôt que de se fier uniquement à la structure interne de l'application.

Cette indépendance est cruciale. Les tests basés sur le code s'appuient souvent sur la connaissance du système testé : identifiants d'objets, structures de documents, étiquettes d'accessibilité, API ou réponses de données attendues. La vérification visuelle, quant à elle, permet d'évaluer l'interface finale telle qu'elle est présentée à l'utilisateur, notamment la mise en page, le positionnement, le contenu, l'état et l'ergonomie dans différents environnements.

La vérification visuelle ne constitue pas une étape distincte de l'assurance qualité logicielle et ne remplace pas les tests fonctionnels, d'intégration, de sécurité ou de performance. Elle est plutôt appliquée par tous les services d'assurance qualité, à chaque étape de la conception, du développement, de la modification ou du test de l'interface utilisateur : des contrôles unitaires et des composants individuels aux tests d'acceptation utilisateur, en passant par les tests d'intégration et système.

Les tests fonctionnels confirment la bonne exécution du processus ; la vérification visuelle confirme la précision et la cohérence du résultat, ainsi que son applicabilité. Une assurance qualité fiable exige ces deux types de vérifications tout au long du cycle de développement.

Ce besoin se fait de plus en plus sentir à mesure que la part des modifications logicielles générées par l'intelligence artificielle augmente. Les outils d'IA peuvent produire du code rapidement, mais cette rapidité accroît le volume et la fréquence des modifications que les équipes qualité doivent évaluer. Sans un mécanisme d'assurance qualité axé sur l'expérience utilisateur, les défauts peuvent se propager tout au long de la chaîne de livraison plus rapidement que les organisations ne peuvent les détecter.

La vérification visuelle sert de garantie pour combler le fossé entre la mise en œuvre technique et l'expérience humaine.

L'itération transforme l'automatisation en un guide fiable

L'intelligence artificielle est efficace pour générer des idées, des scripts et des scénarios de test potentiels. Cependant, ses résultats peuvent varier d'une exécution à l'autre. Un modèle peut interpréter différemment les mêmes instructions selon le contexte, la configuration ou les variations de probabilité. Cette flexibilité peut être utile lors de la phase d'exploration, mais elle ne suffit pas à garantir la qualité formelle.

Le test utilisé pour approuver une version logicielle doit être reproductible. Les mêmes entrées doivent entraîner la même action, les mêmes points de contrôle et les mêmes critères de réussite/échec. Les équipes doivent pouvoir identifier ce qui a été testé, quand cela a été fait, quelle version de l'application était concernée et pourquoi le résultat a été accepté.

L'intelligence artificielle excelle dans la génération d'idées, de scripts et de scénarios de test potentiels, mais les systèmes génératifs et multi-agents ne sont pas intrinsèquement déterministes. Leurs résultats peuvent varier en raison de la génération probabiliste, des modifications des commandes et du contexte, des mises à jour des modèles, des résultats de recherche et des décisions de l'agent lors du choix des outils et de la planification de ses actions futures. Pour le développement logiciel, cette flexibilité peut accélérer la phase de découverte. Cependant, pour l'assurance qualité formelle, elle pose un problème de contrôle fondamental.

Le test utilisé pour approuver une version logicielle doit être reproductible et vérifiable. Une même version d'application, les mêmes données d'entrée et le même environnement doivent produire les mêmes procédures, points de contrôle et critères de réussite définis, permettant ainsi aux équipes de déterminer précisément ce qui a été testé, quand cela a été fait, quelle version était concernée et pourquoi le résultat a été accepté.

Ce n’est qu’alors que les succès et les échecs pourront être mesurés dans le temps, les défauts reproduits et les preuves utilisées lors d’audits ou dans des environnements structurés.

C’est là toute la différence entre utiliser l’intelligence artificielle pour accélérer la création de tests et la laisser devenir l’autorité incontestable en matière de tests. Il est essentiel de savoir à quel moment il convient de cesser de s’en remettre entièrement à l’IA.

L'intelligence artificielle peut aider les équipes à concevoir des cas de test, à identifier les lacunes et à réduire les efforts nécessaires à l'automatisation des tâches routinières. Toutefois, une fois les tests intégrés au processus d'assurance qualité, ils doivent être contrôlés, axés sur des résultats précis, traçables et auditables. Les résultats attendus doivent être clairs et explicites. Les modifications doivent être examinées. Les échecs doivent être reproductibles. Enfin, les preuves de réussite et d'échec doivent être conservées.

Sans ces contrôles, une organisation pourrait savoir qu'un système d'IA a effectué « certains tests », sans pouvoir prouver précisément ce qui s'est passé. Cela fragilise la confiance opérationnelle et compromet encore davantage la responsabilisation.

Les environnements réglementés augmentent les risques

Les conséquences des erreurs d'interface ne sont pas réparties de manière égale.

Dans une application grand public, un champ incohérent ou un message erroné peut engendrer de la frustration et des pertes de revenus. Dans des secteurs comme la finance, la santé, la défense ou l'administration publique, un défaut similaire peut impacter un processus de paiement, une décision clinique, des instructions opérationnelles ou un service public. Une interface affichant un statut incorrect, masquant un avertissement ou présentant des informations obsolètes peut avoir des conséquences bien au-delà de l'écran.

Les organismes de réglementation doivent également être en mesure d'expliquer leurs contrôles et d'en apporter la preuve. Affirmer simplement qu'un système a été testé est insuffisant. Ces organismes peuvent devoir démontrer que les tests ont été menés de manière cohérente, que les résultats ont été analysés et que le logiciel a fonctionné comme prévu dans les environnements où il a été déployé. Combler ce manque de transparence est essentiel pour y parvenir.

L'assurance fournie par l'intelligence artificielle, variable d'une exécution à l'autre, complexifie la tâche. Il en va de même pour les stratégies de test qui privilégient les réponses internes du système au détriment de l'interface utilisateur utilisée par les employés ou les clients.

Une vérification visuelle indépendante et reproductible permet d'établir une chaîne de preuves plus claire. Elle démontre non seulement que l'application a renvoyé les données attendues, mais aussi que l'information correcte était présente au bon endroit et dans un format exploitable au moment où une décision ou une action humaine était requise.

Ceci est crucial, surtout lorsque des erreurs d'affichage apparemment mineures peuvent modifier le comportement de l'utilisateur. Un avertissement masqué, une virgule mal placée, une unité de mesure incorrecte ou un indicateur d'état obsolète n'empêchent peut-être pas l'application de fonctionner, mais peuvent néanmoins inciter l'utilisateur à effectuer une action erronée.

Dans ces environnements, l'interface n'est pas qu'une simple couche décorative ; elle fait partie intégrante du système de contrôle opérationnel.

Allier vitesse et contrôle

L'approche optimale ne consiste pas à choisir entre l'intelligence artificielle et les pratiques de qualité établies, mais à attribuer à chacune le rôle le plus approprié.

L'intelligence artificielle peut accélérer le développement, étendre la couverture des tests et réduire les interventions manuelles nécessaires à l'automatisation de la production. Une vérification indépendante permet de remettre en question les hypothèses sous-jacentes aux résultats. Des tests déterministes peuvent transformer les informations utiles générées par l'IA en contrôles reproductibles. Des contrôles visuels confirment qu'un logiciel techniquement performant fonctionne également efficacement pour l'utilisateur.

Ce modèle à plusieurs niveaux permet aux organisations de tirer parti de l'intelligence artificielle sans confondre productivité et preuve.

Ce modèle reconnaît également qu'aucune méthode de test ne peut à elle seule garantir une fiabilité absolue. Les tests au niveau du code permettent de confirmer le comportement des composants individuels.

Les tests d'intégration permettent de vérifier la bonne communication entre les systèmes. Les tests de sécurité révèlent les vulnérabilités. Les tests de performance examinent le comportement du système en situation de charge. La vérification visuelle, à tous les niveaux du développement de l'interface utilisateur, permet de s'assurer que le résultat final est précis, accessible et utilisable.

L'intérêt réside dans la combinaison de ces méthodes, et non dans l'exigence qu'une méthode remplace toutes les autres.

À mesure que l'IA s'intègre davantage au développement logiciel, l'assurance qualité doit gagner en indépendance, et non l'inverse. Les organisations doivent partir du principe que les logiciels générés par l'IA peuvent présenter des défauts, des lacunes ou des incohérences inattendus. L'objectif n'est pas d'éliminer toutes les erreurs dès la création du logiciel, mais de garantir leur détection avant qu'ils n'atteignent l'utilisateur, contribuant ainsi à réduire le déficit de visibilité susceptible d'introduire des risques dans le code de l'IA.

L'intelligence artificielle peut apporter une aide à la réalisation des travaux et même suggérer des méthodes de correction. Toutefois, la note finale doit être attribuée à l'issue d'un processus d'assurance qualité indépendant, reproductible et transparent.