# Le nouveau MCP de Xcode 27 permet à Claude Code de tester votre app dans le Simulator

Claude Code a exploré une petite app SwiftUI avec les outils Simulator de Xcode 27 et trouvé un vrai bug en 23 actions, sans aucun faux signalement.

- Auteur : Mircea Dragota (https://www.linkedin.com/in/mircea-ioan-dragota-656019135/)
- Publié : 2026-10-29
- Genre : En construction
- Page : https://x2labs.ai/fr/notes/xcode-27-mcp-claude-code-simulator

**En bref**

- Depuis **Xcode 27**, un agent de code peut compiler votre app, la lancer dans le Simulator, **toucher, balayer et saisir du texte**, puis examiner le résultat. Après chaque action, il reçoit une capture d’écran, la hiérarchie de l’interface et les journaux de l’app.
- Le tout se présente sous la forme de **cinq outils MCP** et d’un **skill rédigé par Apple** qui explique à l’agent comment s’en servir. Claude Code et les autres agents compatibles MCP peuvent charger les deux.
- Je l’ai essayé une fois sur une petite app SwiftUI : en **23 actions** sur environ cinq minutes, il a trouvé **un vrai bug** et n’a fait aucun faux signalement.
- Il se trompe encore. Il ne peut **toucher que des coordonnées**, il ne voit pas l’intérieur de certaines vues, et chaque action coûte des tokens. Dans le seul benchmark public à ce jour, il a mené à bien **27 scénarios sur 30**.
- Avant de lui faire confiance, **introduisez des bugs connus** dans votre propre app et regardez ce qu’il trouve. C’est mon prochain essai.

Jusqu’à Xcode 27, un agent qui travaillait sur une app iOS s’arrêtait à la compilation. Il pouvait compiler, lancer des tests et afficher un aperçu SwiftUI. Il ne pouvait pas ouvrir l’app et vérifier qu’un bouton fait réellement quelque chose. Je voulais savoir si Claude Code peut désormais utiliser une app comme le ferait un testeur, alors j’ai configuré les nouveaux outils de Xcode 27 et je l’ai lâché sur une petite app.

## Où en est le projet

- **Configuration** (28 Oct, fait): Xcode 27.0, le serveur MCP et le skill d’Apple, Claude Code.
- **Première session** (29 Oct, fait): Un essai sur une app SwiftUI de trois écrans, sans bug introduit.
- **Bugs introduits** (Next, à venir): Dix bugs introduits, trois essais par partie et une référence QA.

## Ce qu’apporte Xcode 27

Xcode 27 comble cette lacune de trois façons :

1. **L’agent vérifie lui-même son travail sur l’interface** avant de le rendre, au lieu de dire « ça devrait marcher ».
2. **Il détecte les bugs qui n’apparaissent qu’à l’exécution :** un bouton qui ne fait rien, un écran qui mène au mauvais endroit, un plantage sur une liste vide, un titre tronqué avec une grande taille de texte.
3. **Il touche de vrais éléments, pas des pixels devinés.** Chaque élément de la hiérarchie de l’interface est accompagné d’un point à toucher, si bien que l’agent n’a pas à lire des coordonnées sur une capture d’écran.

**Ce que l’agent peut faire dans Xcode 26.3 et Xcode 27**

| Tâche                                            | Xcode 26.3 | Xcode 27 |
| ------------------------------------------------ | ---------- | -------- |
| Compiler le projet                               | Oui        | Oui      |
| Lancer les tests unitaires et d’interface        | Oui        | Oui      |
| Afficher un aperçu SwiftUI                       | Oui        | Oui      |
| Toucher, balayer et saisir du texte dans l’app   | Non        | Oui      |
| Lire la hiérarchie de l’app en cours d’exécution | Non        | Oui      |

Des outils tiers comme XcodeBuildMCP et RocketSim pouvaient déjà piloter le Simulator. La nouveauté, c’est que c’est intégré à Xcode et qu’Apple a rédigé les instructions. La contrepartie, c’est le coût : chaque action renvoie beaucoup de texte, et le [benchmark de SwiftLee](https://www.avanderlee.com/ai-development/xcode-mcp-simulator-token-costs/) a mesuré environ sept fois plus de texte qu’avec l’outil en ligne de commande de RocketSim pour les mêmes scénarios.

## Comment ça marche

Apple a écrit le skill pour deux agents, pas un seul. L’agent principal ouvre une session et transmet son identifiant à un agent auxiliaire, qui se charge de tout regarder et de tout toucher, puis rend compte.

**Vidéo :** Une animation explicative du déroulement, pas l’enregistrement d’une session. <https://x2labs.ai/media/xcode-27-mcp-claude-code-simulator/explainer.mp4>

**Transcription :** Nouveau dans Xcode 27 : un agent peut utiliser votre app. Un agent auxiliaire se charge des touchers. Claude Code se contente de lire son rapport. Il lit l’arborescence de l’interface et trouve le point exact à toucher. Toucher. Puis il regarde de nouveau.

L’agent principal voit le rapport écrit de l’auxiliaire, pas chaque capture.

Une session, dans l’ordre :

1. `DeviceInteractionStartWorkspaceSession` trouve et démarre un simulateur. Le skill d’Apple recommande de l’appeler tôt, car le démarrage prend du temps.
2. `DeviceInteractionInstallAndRun` compile, installe et lance l’app. Appelez-le de nouveau après chaque modification du code.
3. `DeviceInteractionSynthesize` agit et capture, autant de fois que nécessaire. La règle du skill : capturer, agir, capturer de nouveau et comparer.
4. `DeviceInteractionEndSession` la ferme. Selon le skill, les sessions ouvertes coûtent cher : fermez-les donc dès que le travail est terminé.

Un cinquième outil, `DeviceInteractionStartSession`, ouvre une session qui n’est liée à aucun projet. Le skill d’Apple indique de ne l’utiliser que pour une app déjà installée.

## Ce que l’agent peut faire

Chaque action passe par un seul outil, `DeviceInteractionSynthesize`, avec une courte commande dans la syntaxe documentée par le skill d’Apple. Une fois la commande terminée, l’outil capture de nouveau l’écran et renvoie une capture d’écran, la hiérarchie de l’interface et les journaux.

**Commandes que l’agent peut envoyer**

La syntaxe documentée par le skill d’Apple. Une commande vide regarde sans toucher : elle récupère la capture d’écran et la hiérarchie.

| Action                   | Commande                         |
| ------------------------ | -------------------------------- |
| Toucher, ou maintenir    | `t x y [duration]`               |
| Toucher deux fois        | `d x y`                          |
| Balayer                  | `t x1 y1 f x2 y2 [duration]`     |
| Glisser-déposer          | `drag x1 y1 x2 y2 [hold] [move]` |
| Pincement, multitouche   | `mt [x y, x y] duration …`       |
| Bouton matériel          | `b h`, `b p`, `b u`, `b d`       |
| Saisir du texte          | `sender keyboard kbd <text>`     |
| Faire pivoter l’appareil | `orientation <name>`             |
| Attendre                 | `w duration`                     |

Les mêmes commandes, avec des valeurs :

```text
t 125 215                                           tap
d 200 300                                           double tap
t 200 600 f 200 200 0.3                             swipe up
drag 100 300 100 100                                drag and drop
mt [100 300, 300 300] 0.5 [175 300, 225 300] 0.5    pinch
b h                                                 press Home
sender keyboard kbd hello\u{000A}                   type hello and press Return
orientation landscapeLeft                           rotate to landscape
w 0.3                                               wait 0.3 seconds
```

Le skill d’Apple documente le multitouche, mais [SwiftLee](https://www.avanderlee.com/ai-development/xcode-mcp-simulator-token-costs/) indique que les touchers à deux doigts n’étaient pas pris en charge lors de ses tests. Essayez un pincement sur votre propre configuration avant de compter dessus.

watchOS ajoute la Digital Crown et le bouton latéral. tvOS n’a pas d’écran tactile ; l’agent appuie donc sur les boutons de la Siri Remote.

L’agent trouve ses cibles dans la hiérarchie de l’interface, où chaque élément est accompagné d’un point de toucher calculé. Cet exemple provient du skill d’Apple :

```text
UIView {{100, 200}, {60, 30}}, hitPoint: {130.0, 215.0}
  UIButton "Login" {{110, 205}, {30, 20}}, hitPoint: {125.0, 215.0}
```

Le skill d’Apple demande à l’agent de toucher le `hitPoint` et de ne faire une estimation à partir de la capture d’écran qu’après l’échec d’un `hitPoint`. Il ne peut ni simuler Face ID ni lancer un audit d’accessibilité, d’après les [tests de SwiftLee](https://www.avanderlee.com/ai-development/xcode-mcp-simulator-token-costs/).

## Configuration

Quatre étapes. Les commandes sont pour Claude Code ; les autres agents chargent le même skill et le même serveur à leur manière.

### Étape 1 : activer les outils d’agent de Xcode

Dans Xcode 27, choisissez **Xcode → Settings**, sélectionnez **Intelligence**, puis, sous **Model Context Protocol**, activez **Allow external agents to use Xcode tools**. Sans cela, l’agent ne peut pas accéder aux outils de Xcode.

### Étape 2 : ajouter le serveur MCP et les skills d’Apple

Le serveur MCP d’Apple est livré avec Xcode sous la forme de `xcrun mcpbridge` : il n’y a donc rien à télécharger. Le guide d’Apple, [Donner aux agents externes l’accès à Xcode](https://developer.apple.com/documentation/xcode/giving-external-agents-access-to-xcode), l’ajoute à Claude Code en une seule commande :

```bash
claude mcp add --transport stdio xcode -- xcrun mcpbridge
claude mcp list   # check that xcode shows as connected
```

Pour Codex, le même guide donne `codex mcp add xcode -- xcrun mcpbridge`.

Cela ajoute les outils de Xcode, mais pas les skills d’Apple. Xcode 27 exporte aussi les deux ensemble sous forme de plugin Claude Code prêt à l’emploi, ce qui est la voie la plus simple pour ce guide. Indiquez-le à Claude Code dans `~/.zshrc` :

```bash
export CLAUDE_CODE_PLUGIN_DIRS="$(xcrun agent plugin path --plugin-format claude)"
```

Le skill apparaît alors sous le nom `xcode-integration:device-interaction`. Choisissez une seule voie, pas les deux : le plugin apporte son propre serveur `xcrun mcpbridge` ; si vous avez ajouté le serveur avec `claude mcp add`, supprimez-le donc avec `claude mcp remove xcode`. Sinon, chaque outil apparaît deux fois.

### Étape 3 : ouvrir le projet dans Xcode

Les outils passent par l’instance de Xcode en cours d’exécution : le projet doit donc y être ouvert. La première fois que l’agent se connecte, Xcode vous demande de l’autoriser.

### Étape 4 : donner à l’agent son propre simulateur

Utilisez un simulateur réservé à ces essais et effacez-le avant chacun d’eux, pour qu’aucun état ne subsiste de l’essai précédent :

```bash
xcrun simctl shutdown "iPhone 17 Pro"   # erase only works on a shut-down simulator
xcrun simctl erase "iPhone 17 Pro"
xcrun simctl io booted recordVideo run1.mp4   # after the session boots it
```

C’est l’enregistrement que vous montrerez : les touchers de l’agent sont difficiles à croire à partir d’un simple journal.

## Ce qui s’est passé lors de la première session

J’ai demandé à Claude Code d’écrire une petite app SwiftUI de liste de courses à trois écrans : la liste, une feuille New item et un écran de détail de l’article. Puis j’ai lancé une session dessus, le 29 octobre 2026. Aucun bug n’avait été introduit : il s’agit donc de la partie B du test ci-dessous, et j’ai arrêté l’auxiliaire au bout d’environ cinq minutes.

La configuration : Claude Code 2.1.312 avec Claude Opus 5.5, Xcode 27.0 (27A266a), un nouveau simulateur iPhone 18 Pro sous iOS 27.0, et le prompt de la section « Le prompt » ci-dessous. L’auxiliaire a d’abord lu le fichier du skill d’Apple et a reçu d’emblée le vrai nom de l’outil (voir les pièges).

**Vidéo :** Un enregistrement de la session, accéléré 4×. L’app et ses données sont réelles ; Claude Code a écrit l’app pour ce test. <https://x2labs.ai/media/xcode-27-mcp-claude-code-simulator/session.mp4>

**Transcription :** L’agent auxiliaire capture la liste Groceries, puis passe en paysage et revient. Accéléré 4×. Il ouvre la feuille New item et essaie un nom vide, un nom de 200 caractères et les limites de quantité. De retour sur la liste, il ouvre l’article Milk. Il efface le nom en entier. Le titre devient vide. De retour sur la liste, la ligne n’a plus de nom, seulement ×2. C’est le bug qu’il signale. Il poursuit avec l’écran de détail et la liste : un nom long, la limite de quantité, le paysage et le marquage d’articles comme achetés.

**La première session**

Un essai le 29 octobre 2026, arrêté au bout d’environ cinq minutes. Une action correspond à un appel à DeviceInteractionSynthesize.

| Mesure                               | Résultat                                  |
| ------------------------------------ | ----------------------------------------- |
| Écrans atteints                      | 3 sur 3                                   |
| Actions                              | 23, aucune n’étant une nouvelle tentative |
| Durée                                | environ 5 minutes                         |
| Problèmes signalés                   | 1                                         |
| Réels                                | 1                                         |
| Faux                                 | 0                                         |
| Doublons                             | 0                                         |
| Plantages                            | 0                                         |
| Hiérarchie de l’interface par action | 8,1 Ko en moyenne                         |
| Hiérarchie de l’interface au total   | 187 Ko                                    |
| Tokens de l’agent auxiliaire         | environ 100 000                           |

Les tokens correspondent au décompte de Claude Code lui-même pour l’agent auxiliaire, lecture du fichier du skill et des captures d’écran comprise. Les chiffres de la hiérarchie correspondent à la taille des 23 fichiers texte écrits par Xcode, un par action ; SwiftLee a mesuré environ 10 Ko sur un écran de liste.

Le bug qu’il a trouvé est réel, et je ne le connaissais pas. La feuille New item refuse d’enregistrer un nom vide, mais l’écran de détail de l’article permet d’effacer le nom en entier. L’article se retrouve sans nom dans la liste, avec seulement sa quantité.

![À gauche : l’écran de détail de l’article, avec le champ Name vidé et un titre vide. À droite : la liste Groceries, où la ligne Milk n’affiche plus qu’un cercle et ×2.](https://x2labs.ai/_astro/bug-before-after.ZBL-8YVY_2rbBht.webp)

La hiérarchie de l’interface le montre aussi. Le bouton de la ligne, avant et après :

```text
Button, {{59.7, 224.2}, {308.0, 20.3}}, label: 'Milk, ×2', hitPoint: {213.7, 234.3}
Button, {{327.7, 224.2}, {40.0, 20.3}}, label: '×2', hitPoint: {347.7, 234.3}
```

Il a aussi écarté deux choses que le skill d’Apple dit de ne pas signaler : un défaut visuel pendant l’animation de transition, qui avait disparu à la capture suivante, et le clavier qui masquait la ligne Quantity en paysage. Comme je l’ai arrêté tôt, il n’a pas testé le balayage pour supprimer, le bouton Cancel de la feuille New item, ni un nom composé uniquement d’espaces sur l’écran de détail.

## Comment le tester sur votre propre app

Une liste de bugs trouvés par un agent ne veut pas dire grand-chose si vous ne savez pas ce qu’il y avait à trouver. Avant de compter dessus, testez-le donc deux fois : une fois sur des bugs que vous avez introduits, une fois sur une app où rien n’a été introduit.

### Partie A : bugs introduits

Sur une branche, introduisez une dizaine de bugs et gardez-en la liste hors du dépôt, là où l’agent ne peut pas la lire. Couvrez différents types de problèmes, par exemple :

**Bugs à introduire, par exemple**

| Type           | Bug introduit                                             |
| -------------- | --------------------------------------------------------- |
| Fonctionnel    | Un bouton qui ne fait rien                                |
| Fonctionnel    | Le retour mène au mauvais écran                           |
| Plantage       | Un force unwrap qui plante sur une liste vide             |
| État           | Un article modifié qui ne se met pas à jour dans la liste |
| Visuel         | Un titre tronqué avec la plus grande taille de texte      |
| Visuel         | Du texte qui se chevauche en paysage                      |
| Visuel         | Un contraste faible en mode sombre                        |
| Saisie         | Le clavier masque le champ Save                           |
| Geste          | Le balayage pour supprimer retire la mauvaise ligne       |
| Élément masqué | Un menu derrière une superposition transparente           |

Le dernier est là exprès. L’agent ne peut toucher que des coordonnées, et les éléments masqués étaient le seul cas où les outils de Xcode ont échoué dans le benchmark de SwiftLee.

### Partie B : la même app, sans bug introduit

Lancez le même prompt sur l’app non modifiée et classez chaque signalement comme réel, faux ou doublon. C’est cette partie qui montre ce que l’agent invente.

### La référence

Confiez le même passage à un ingénieur QA sur les deux builds, avec une limite de temps, par exemple 30 minutes, et sans la liste. Sans référence, vous ne pouvez pas savoir si l’agent est bon ou si les bugs étaient faciles.

### Le prompt

Utilisez le même prompt sur un simulateur fraîchement effacé pour chaque essai, et faites au moins trois essais par partie, car les résultats varient d’un essai à l’autre :

```text
Using the device-interaction skill, explore the app on session <session id>.
Visit every screen you can reach from the start screen. In every form, try
empty, very long and invalid input. Rotate the device once on each screen.
For each problem, report the screen, the steps to reproduce, what you
expected, what happened and the screenshot path. Don't change any code.
```

Pour les vérifications du mode sombre et de la taille du texte, changez le réglage du simulateur entre les essais avec `xcrun simctl ui booted appearance dark` et `xcrun simctl ui booted content_size accessibility-extra-extra-extra-large`. Si votre app a besoin de ses propres arguments de lancement ou variables d’environnement, `DeviceInteractionInstallAndRun` accepte `commandLineArguments` et `environmentVariables` pour un seul lancement, sans toucher au schéma.

Pour chaque essai, notez les bugs introduits trouvés, les vrais bugs que vous n’aviez pas introduits, les faux signalements, les doublons, la durée, les appels d’outils, les tokens et le coût. Ces chiffres vous indiquent quelle place lui donner dans votre façon de travailler.

## Ce qu’a mesuré un benchmark

Les seuls chiffres publics à ce jour viennent de [SwiftLee](https://www.avanderlee.com/ai-development/xcode-mcp-simulator-token-costs/). Il a scripté dix scénarios Simulator sur une petite app de test et a exécuté chacun trois fois, avec les outils de Xcode 27.1 et avec l’outil en ligne de commande de RocketSim :

**Le benchmark de SwiftLee : outils de Xcode 27.1 et CLI de RocketSim**

Dix scénarios scriptés sur une petite app de test, trois essais chacun, sur une seule machine.

| Mesure                          | Outils de Xcode 27.1 | CLI de RocketSim |
| ------------------------------- | -------------------- | ---------------- |
| Scénarios menés à bien (sur 30) | 27                   | 30               |
| Appels d’outils                 | 41                   | 88               |
| Durée (s)                       | 114                  | 94               |
| Texte lu par l’agent (Ko)       | 400                  | 56               |
| Tokens de texte estimés         | environ 100 000      | environ 14 000   |

Les trois échecs concernaient le même scénario : un élément masqué derrière une superposition, que des touchers par coordonnées ne parvenaient pas à ouvrir. Les outils de Xcode ont nécessité moins d’appels et compilent et lancent aussi l’app, ce que RocketSim ne fait pas. SwiftLee développe RocketSim et le dit, et il s’agit d’une seule machine et d’une seule app de test : considérez-le comme un premier point de données.

## D’où viennent les faux signalements

Attendez-vous à ce que certains signalements soient faux, et vérifiez chacun d’eux avant que quiconque ne corrige quoi que ce soit.

Le skill d’Apple cite les causes les plus probables :

- **Un instant pris pour un état.** Le skill demande à l’agent de ne pas signaler les indicateurs de chargement, les animations ni l’apparition du clavier, mais une capture prise en pleine transition peut quand même sembler défectueuse.
- **Une vue dont il ne voit pas l’intérieur.** Les éléments marqués `isRemoteLeafPlaceholder` ne listent pas leurs enfants : l’agent doit donc deviner les positions à partir de la capture d’écran.
- **Un toucher arrivé ailleurs.** Si un élément se déplace pendant une animation, le toucher atteint ce qui se trouve à cet endroit à ce moment-là. Le skill autorise une nouvelle tentative, puis un signalement.
- **Un comportement attendu.** Les états vides, un bouton désactivé sur un formulaire incomplet et les boîtes de dialogue d’autorisation ne sont pas des bugs, et le skill le précise. Comptez combien de fois l’agent les signale malgré tout.

## Pièges qui font perdre du temps

Ils proviennent de la configuration, de la documentation et du fichier du skill d’Apple pour Xcode 27.0, et du benchmark de SwiftLee.

- **Chaque outil de Xcode apparaît deux fois.** Le plugin apporte son propre serveur `xcrun mcpbridge`, en plus de celui que vous avez ajouté à la main. Lancez `claude mcp remove xcode` et gardez celui du plugin.
- **L’agent ne peut pas accéder aux outils de Xcode.** **Allow external agents to use Xcode tools** est désactivé. Activez-le dans **Settings → Intelligence**.
- **Les outils échouent faute d’espace de travail.** Les outils passent par l’instance de Xcode en cours d’exécution. Gardez le projet ouvert dans Xcode.
- **Le skill demande à l’agent d’appeler `DeviceEventSynthesize`.** L’outil s’appelle `DeviceInteractionSynthesize` dans Xcode 27.0. Si l’agent se bloque, donnez-lui le vrai nom dans le prompt.
- **Il ne peut pas ouvrir un menu sous une superposition.** Il ne peut toucher que des coordonnées. Vérifiez ces écrans à la main.
- **L’agent a du mal à trouver ou à nommer un élément.** L’élément n’a pas de libellé d’accessibilité. Ajoutez-en un ; tous les outils fonctionnent mieux avec des libellés.
- **La consommation de tokens grimpe vite.** Chaque action renvoie une hiérarchie complète de l’interface, environ 10 Ko sur un écran de liste. Faites des essais courts, n’utilisez les captures d’écran que pour les vérifications visuelles et fermez chaque session.

## Prérequis

Il s’agit d’un outil de développement : rien ne change pour vos utilisateurs.

**Ce qu’il vous faut**

- Xcode 27 avec le projet ouvert. Ce guide a été rédigé avec Xcode 27.0 (27A266a).
- Des simulateurs sous iOS, watchOS ou tvOS 27 ou version ultérieure. Les descriptions des outils mentionnent aussi les appareils physiques ; ce guide ne couvre que les simulateurs.
- **Allow external agents to use Xcode tools** activé dans **Settings → Intelligence**.
- Un agent qui prend en charge MCP et les skills, comme Claude Code.

**Coût**

- Les outils de Xcode sont gratuits. Vous payez les tokens de l’agent.
- Dans le [benchmark de SwiftLee](https://www.avanderlee.com/ai-development/xcode-mcp-simulator-token-costs/), 30 scénarios scriptés ont consommé environ 100 000 tokens de texte avec les outils de Xcode et environ 14 000 avec l’outil en ligne de commande de RocketSim.
- Mesurez vos propres essais avant de les planifier. La consommation de tokens augmente avec chaque écran que l’agent visite.

## Pour aller plus loin

- [Apple : Donner aux agents externes l’accès à Xcode](https://developer.apple.com/documentation/xcode/giving-external-agents-access-to-xcode)
- [MCP de Xcode 27 : des coûts en tokens plus élevés pour naviguer dans le Simulator (SwiftLee)](https://www.avanderlee.com/ai-development/xcode-mcp-simulator-token-costs/)
- [Essai des skills officiels de Xcode 27 depuis Claude Code (Classmethod)](https://dev.classmethod.jp/en/articles/xcode-agent-skills-claude-code/)
- [Xcode 26.3 adopte le codage agentique : ce qu’il sait faire (awesomeagents.ai)](https://awesomeagents.ai/news/xcode-26-3-agentic-coding-teardown/)

## Mon avis à ce stade

Lors de ma première session, il a bien fonctionné : il a parcouru l’app de lui-même et trouvé un bug que je n’avais pas remarqué. Utilisez-le là où un rapide coup d’œil à de vrais écrans évite à quelqu’un un détour par le Simulator. Gardez des humains là où le jugement compte.

### Où il a sa place

- **Vérifier une modification juste après que l’agent l’a faite.** C’est le cas pour lequel le skill d’Apple est écrit : il est censé s’exécuter après une fonctionnalité qui touche l’interface.
- **Les apps dotées de bons libellés d’accessibilité.** L’agent lit la hiérarchie de l’interface : les éléments étiquetés lui sont donc plus faciles à trouver et à nommer dans un rapport.

### Où il n’a pas encore sa place

- **Remplacer un passage de QA exploratoire.** Tant que vous ne l’avez pas mesuré sur des bugs introduits dans votre propre app, vous ne savez pas ce qu’il rate.
- **Les écrans construits sur des superpositions, ou sur des vues dont il ne voit pas l’intérieur.** Il ne touche que des coordonnées, et certaines vues ne listent pas leurs enfants.
- **Les longs essais sans surveillance.** Chaque action renvoie une hiérarchie complète de l’interface : le coût augmente donc avec chaque écran.
