Conception ultime d'agents pour activer Claude × Codex [Dernière version]

Même si l'on vous dit « donnez des instructions plus précises », j'aimerais qu'on m'aide à partir de cette fameuse « partie précise ».

Vous avez quelque chose à construire, mais vos mains s'arrêtent dès la phase de recherche préliminaire nécessaire pour interroger l'IA. C'est frustrant.

Par exemple, imaginez que vous vouliez une application permettant d'enregistrer des dossiers et de les trier par date d'échéance. Jusque-là, c'est facile à formuler. Mais si l'on vous interroge sur les méthodes de stockage des données ou sur la façon de détecter les bugs, le volume de recherches explose soudainement.

Pendant vos recherches, vous commencez à supprimer des fonctionnalités que vous vouliez initialement inclure, en vous disant « ce n'est peut-être pas indispensable cette fois-ci ». Non pas parce que leur développement semble difficile, mais parce que vous voulez rester dans un périmètre que vous pouvez gérer seul en cas de problème.

En réalité, je ne veux pas préparer chaque petite instruction avant de poser ma question. Je veux que tu repères ce que j'aurais pu oublier. Ce serait utile si tu pouvais me demander de trancher clairement entre deux options, puis avancer dans le travail en te basant sur ces décisions.

L'équipe de développement que nous assemblons dans cet article est conçue pour se rapprocher de ce type d'attente, en utilisant Claude Code et Codex.

• Claude Code : Le point de contact pour les demandes. Organise les confirmations nécessaires et la répartition du travail.
• Codex : Gère l'implémentation et l'inspection.

Pour une application de gestion de dossiers, en plus de créer l'écran, vous devez aussi préparer des tâches de vérification. Que se passe-t-il si l'on valide un formulaire avec des champs vides ? Les enregistrements persistent-ils après un rechargement ? Si un bug n'est pas corrigé, résumez les tentatives de correction et les symptômes restants pour transmettre le tout à un autre agent.

Le rôle de l'humain consiste à prendre les décisions nécessaires en cours de route et à vérifier le fonctionnement réel à la fin. Pour faciliter cela, créez une structure où les spécifications, les modifications et les résultats de vérification vous reviennent systématiquement. Construisons cela étape par étape, des méthodes de connexion jusqu'à la transmission des tâches et aux conditions d'arrêt.

Confier du travail à Codex tout en gardant Claude ouvert

Il existe un moyen de transmettre des requêtes de Claude Code à Codex sans avoir à copier-coller les réponses précédentes dans une autre IA. Il s'agit du « plugin Codex pour Claude Code » publié par OpenAI.

Selon la documentation officielle, il prend en charge des usages tels que :

• Les revues inspectant les modifications actuelles

• La délégation d'investigations ou de corrections

• Le transfert de conversations

Cet article détaille la procédure pour l'utiliser depuis un Claude Code installé en local, en s'appuyant sur les documents officiels vérifiés le 16 octobre 2026.

Prérequis

• Un environnement où Claude Code est disponible

• Git

• Node.js (exigence officielle : 18.18 ou version ultérieure)

• Un compte ChatGPT authentifié auprès de Codex, ou une clé API OpenAI

Le plugin appelle votre Codex local. Se connecter ne signifie pas que Codex tourne sur le quota d'utilisation de Claude ; l'utilisation de Codex consomme son propre quota.

De plus, bien que cette configuration gère des fichiers locaux, l'inférence de l'IA ne s'exécute pas nécessairement en totalité sur votre PC. Commencez par un dossier d'entraînement ne contenant aucune information confidentielle.

Installer le plugin

Dans le champ de saisie de Claude Code, exécutez les commandes suivantes une par une, de haut en bas. Ce sont des opérations pour ajouter des plugins au sein de Claude Code, et non des commandes à coller dans un terminal classique.

1/plugin marketplace add openai/codex-plugin-cc
2/plugin install codex@openai-codex
3/reload-plugins
4/codex:setup

La dernière commande /codex:setup permet de vérifier l'installation et le statut d'authentification de Codex. Si Codex n'est pas trouvé et que npm est disponible, des instructions d'installation s'afficheront ; lisez-les et suivez-les.

Si vous n'êtes pas authentifié, lancez codex login dans le terminal et suivez les instructions.

Sous Windows, assurez-vous que l'environnement exécutant Claude et celui où Codex a été installé ne sont pas séparés. Évitez de réinstaller en boucle simplement parce que le message « not found » s'affiche.

Commencez par essayer la revue

Débutez par une revue qui ne modifie pas le code. Préparez une petite modification dans un projet d'entraînement géré par Git et exécutez :

1/codex:review --background

• Vérifier l'avancement : /codex:status

• Consulter les résultats terminés : /codex:result

Lorsque plusieurs requêtes sont actives, précisez le Job ID affiché pour éviter de mélanger les résultats.

Les exemples publics d'Amazon sont utiles pour diviser les tâches

Pour vous inspirer sur la répartition des rôles, consultez les exemples de développement publiés par AWS, la division cloud d'Amazon. Sur le GitHub aws-samples, deux dépôts sont pertinents :

• sample-codex-agent-team (pour Codex)

• sample-claude-code-agent-team (pour Claude Code)

La version Codex comporte six rôles :

Décider comment construire un écran de saisie et réfléchir à l'évolutivité ou aux coûts de maintenance sont deux métiers différents. Séparer l'implémentation des fonctionnalités du conseil opérationnel rend les questions posées à des agents spécifiques beaucoup plus concrètes.

Une revue légère ne sert pas à traiter négligemment des modifications risquées. C'est une méthode de répartition visant à éviter de soumettre systématiquement des tâches à faible risque, comme des modifications de documents ou des remplacements mécaniques, à des inspections lourdes.

Les méthodes de transmission des tâches diffèrent entre les deux exemples :

• Version Claude Code : Les agents récupèrent les tâches depuis une liste partagée (utilise les équipes d'agents expérimentales, nécessite une configuration supplémentaire)

• Version Codex : Avance selon un plan de travail avec des fichiers de responsabilité divisés

Ce sont des exemples distincts. Ils ne fusionnent pas automatiquement en une seule équipe si vous installez les deux.

De plus, la version Codex inclut des spécifications de modèles supposant des paramètres de connexion non publiés. L'exemple lui-même indique qu'il ne fonctionnera pas directement sur tous les comptes. Plutôt que de le copier tel quel dans des projets d'entreprise critiques, n'adoptez que la logique de répartition des rôles et adaptez-la à votre environnement utilisable.

Cet article commence par une structure simple où Claude Code agit comme interface, en déléguant des tâches limitées d'implémentation et d'inspection à Codex.

Remarque : Il s'agit d'un exemple d'utilisation original s'inspirant d'échantillons publics. Ce n'est ni un produit garantissant l'intégration AWS de Claude et Codex, ni un rapport de comportement mesuré.

Alignez le sens de « sauvegardable » avant de construire

Quand vous ne pouvez pas décrire en détail ce que vous voulez construire, ne lancez pas immédiatement l'implémentation. Demandez d'abord à Claude d'organiser les points à confirmer. Vous n'avez pas besoin de connaître tous les termes techniques ; transformez-les simplement en questions auxquelles vous pouvez répondre.

Je veux créer une application personnelle de gestion de dossiers. Commence par organiser les spécifications nécessaires et pose-moi une question à la fois sur les décisions à prendre. Pour les choix techniques, explique brièvement l'impact sur l'utilisateur et les raisons de ta recommandation. Ne commence pas l'implémentation avant mon accord.

Par exemple, concernant la sauvegarde : suffit-il que les enregistrements persistent dans le même navigateur, ou souhaitez-vous un partage entre smartphone et PC ? Ces deux cas nécessitent des mécanismes totalement différents. En choisir un silencieusement entraînera des reprises de travail plus tard.

Pour cet exercice, réduisez le périmètre :

• Inclus : Utilisation sur le même PC/navigateur, persistance des enregistrements après rechargement

• Exclu : Synchronisation multi-appareils, connexion, publication externe, données clients réelles

Définissez les critères de réussite par les résultats opérationnels, et non par la notion vague de « facile à utiliser » :

• Peut enregistrer des dossiers

• Triés par date d'échéance

• Peut modifier le statut

• Une validation vide affiche la raison du refus

• Le contenu persiste après rechargement

Sauvegardez les spécifications et les demandes de tâches dans des fichiers

Enregistrez le contenu validé dans docs/spec.md en tant que spécification de référence pour tous. Les noms de fichiers donnés ici sont des exemples ; ils ne sont pas distribués automatiquement à toutes les IA, vous devrez donc préciser « lis ceci » à chaque requête.

Sauvegarde les spécifications décidées, les critères de réussite et les fonctionnalités hors périmètre dans docs/spec.md. N'écris pas les points non décidés comme s'ils étaient confirmés. Sépare les éléments nécessitant un arrêt de l'implémentation de ceux pouvant avancer avec des paramètres temporaires.

Ensuite, résumez les demandes de tâches pour les développeurs dans docs/tasks.md. Nommer la tâche ne suffit pas. Incluez les documents à lire, les fichiers modifiables, les parties non modifiables, les méthodes de vérification et les livrables attendus.

Découpe les spécifications en unités implémentables. Écris les fichiers assignés, les tâches préalables et les méthodes de vérification dans docs/tasks.md. Définis à l'avance les éléments partagés entre la logique d'interface et celle de stockage. Ne prévois pas que deux agents modifient le même fichier simultanément.

Montrez la même spécification aux deux IA

Les instructions continues peuvent être écrites dans CLAUDE.md pour Claude et AGENTS.md pour Codex. Ce sont des mécanismes documentés. Cependant, ne supposez pas qu'un fichier fonctionne à l'identique pour l'autre. Faites plutôt référence au même fichier de spécification depuis les deux.

Gardez les instructions courtes :

• Emplacement du fichier de spécification

• Ne pas apporter de modifications en dehors des demandes

Dupliquer les spécifications risque de rendre l'une des versions obsolète. Cette approche évite ce problème.

Séparez les espaces de travail avant les tâches parallèles

Faire travailler plusieurs IA semble plus rapide, mais réécrire le même fichier avec des politiques différentes ne fait que créer du travail de nettoyage pour l'humain.

Pour un premier travail en parallèle, associez un « constructeur d'interface » à un « planificateur de tests ». Implémenter l'interface et le stockage séparément avant que le format ne soit finalisé augmente les risques d'incompatibilité.

Utilisez Git Worktree pour séparer les dossiers

Git worktree est très utile ici. C'est une fonctionnalité officielle de Git permettant d'avoir des dossiers de travail séparés pour le même projet, avec des modifications différentes.

Avant de les créer, assurez-vous que les spécifications et la base sont commitées dans Git. Les fichiers brouillons non commités pourraient ne pas être transférés vers les nouveaux emplacements. Vérifiez que les noms de branches et les dossiers cibles ne sont pas déjà utilisés.

1git worktree add -b feature/ui ../case-app-ui
2git worktree add -b feature/storage ../case-app-storage
3git worktree list

Trois précautions :

1. Créer des dossiers ne change pas l'espace de travail de l'IA. Ouvrez des sessions distinctes dans chaque répertoire et vérifiez l'emplacement et la branche avant de commencer.

1. Les plugins utilisent l'environnement de l'appelant. Connecter Claude et Codex n'isole pas automatiquement les processus. Au début, tenez-vous-en à la règle « un éditeur par emplacement ».

1. Les worktrees isolent principalement les fichiers. Les bases de données ou ports partagés provoqueront des conflits. Séparez les stockages/ports de test ou séquencez les démarrages.

Limitez les tâches simultanées dans Codex

Pour augmenter le nombre de sous-agents dans Codex, limitez les threads simultanés. Les sous-agents reçoivent des tâches limitées de l'IA parente. Configuration actuelle dans .codex/config.toml :

1[agents]
2enabled = true
3max_concurrent_threads_per_session = 2

• Ne dupliquez pas les entrées

• À n'utiliser que dans des projets de confiance (les paramètres du projet ne se chargent que dans des contextes fiables)

• La limite s'applique aux « threads simultanés excluant l'agent principal de cette session », et non au total cumulé entre Claude et les sessions.

Les 14 threads de l'exemple AWS ne sont que leur choix. Ce n'est pas une obligation. Leur paramètre max_threads est un alias hérité ; utilisez les noms actuels.

N'expliquez pas tout aux développeurs depuis zéro à chaque fois

Dans Codex, définissez des agents personnalisés via des fichiers TOML dans .codex/agents. Créez task-builder.toml avec les conditions nécessaires :

1name = "task-builder"
2description = "Implémenter uniquement le périmètre assigné à partir des spécifications confirmées"
3developer_instructions = """
4Lis d'abord docs/spec.md et docs/tasks.md.
5Implémente uniquement le périmètre assigné ; arrête-toi et fais un rapport si des changements de spécifications sont nécessaires.
6Ne révoque pas les modifications des autres agents, ne lis pas de secrets et ne publie rien en externe.
7Renvoie les fichiers modifiés, les tests exécutés, les résultats et les points non confirmés.
8"""

Évitez de figer les noms de modèles ici. Par défaut, l'agent hérite des paramètres du parent. Les modèles des exemples publics peuvent ne pas être disponibles avec votre contrat ; coder en dur des noms indisponibles bloquera le démarrage avant même la lecture de la description du rôle.

Après avoir placé le fichier, vérifiez sa reconnaissance dans une nouvelle session Codex et déléguez une petite tâche. Si vous faites la demande depuis Claude, précisez qu'il faut utiliser task-builder dans Codex.

Demande à Codex de déléguer uniquement la logique de stockage de docs/tasks.md à task-builder. Vérifie la reconnaissance de l'agent et le dossier réel avant de commencer. S'il n'est pas disponible, fais un rapport au lieu de changer de méthode silencieusement.

Remarque : Écrire « ne pas modifier » est différent de retirer les droits d'écriture. La documentation officielle indique que les agents enfants de Codex héritent des permissions du parent (paramètres du bac à sable). Nommer un rôle « reviewer » ne crée pas magiquement un environnement sécurisé en lecture seule.

Changez d'agent si les corrections tournent en boucle

Si l'IA dit « j'ai trouvé la cause » mais que la même opération échoue à nouveau, notez ce qui a changé ou non plutôt que de vous précipiter sur la correction suivante. Ce sera plus facile à transmettre.

Le plugin officiel possède une entrée rescue pour déléguer des investigations ou corrections à Codex. Malgré son nom, elle sert à des tâches délimitées, pas seulement aux bugs.

Marquez explicitement l'investigation comme étant en lecture seule

Pour une simple analyse de cause, précisez clairement qu'aucune écriture n'est autorisée. Par défaut, les procédures internes donnent des droits d'écriture à rescue, sauf indication contraire. Gardez l'investigation et la correction bien distinctes.

1/codex:rescue --fresh Investigue pourquoi l'enregistrement disparaît au rechargement, en lecture seule. Compare docs/spec.md et le code. Renvoie les étapes de reproduction, les causes prouvées et les vérifications nécessaires. Ne modifie aucun fichier.

--fresh lance une nouvelle requête ; --resume reprend la précédente (une invite apparaît si omis). Précisez les permissions lors de la reprise. Si vous passez à la correction, définissez-en le périmètre.

1/codex:rescue --resume Corrige uniquement la logique de stockage avec des modifications minimales basées sur la cause confirmée. Ne change ni l'interface ni les spécifications. Montre le test en échec avant et le résultat après.

Transférez toute la conversation avec Transfer

• Transmettre uniquement la tâche → rescue

• Déplacer la conversation vers Codex → transfer

1/codex:transfer

Documentation officielle : Cela crée un fil de discussion Codex qui poursuit la conversation actuelle de Claude Code, en affichant la commande de reprise. Mettez Codex à jour si cette option n'est pas prise en charge.

Transférer la conversation ≠ transférer l'état du PC. Les modifications non sauvegardées, les authentifications et les applications en cours d'exécution ne suivent pas. Vérifiez les fichiers et le statut à destination.

Vérifiez avec une autre IA après le « C'est fait »

Les tests réalisés par le développeur sont utiles, mais s'il a mal compris les spécifications, des tests réussis ne correspondront pas au comportement souhaité.

Fournissez aux inspecteurs les spécifications validées par l'humain et les modifications réelles, et non les explications du développeur. Ne partagez pas d'évaluations du type « parfaitement corrigé » ; laissez-les vérifier indépendamment la conformité.

Compare indépendamment docs/spec.md et les modifications réelles. Identifie les critères de réussite non remplis avec des preuves. Ne te fie pas à l'auto-évaluation du développeur. Sépare les problèmes reproductibles, les inquiétudes potentielles et les éléments non vérifiés. Ne corrige rien pour l'instant.

Associez les opposés :

• Claude a implémenté → Ajoutez une revue Codex standard comme vérification séparée

• Codex a implémenté → Demandez à Claude d'inspecter, et ajoutez éventuellement une nouvelle revue Codex

Revue standard vs Revue contradictoire

Appelez la revue standard avec /codex:review. Elle compare la branche à main :

1/codex:review --base main

Utilisez la vraie branche de base s'il n'y a pas de main. Ne touchez pas aux modifications pendant la revue.

Remarque : La revue standard n'accepte pas d'instructions textuelles libres comme « vérifie uniquement le stockage ». La spécification officielle interdit les directives de priorité. Pour challenger des hypothèses de conception ou des risques spécifiques, utilisez adversarial-review.

1/codex:adversarial-review --background Vérifie si les échecs de sauvegarde s'affichent comme des succès, si l'édition depuis deux onglets entraîne la perte d'enregistrements, et valide les hypothèses de conception actuelles.

Il ne s'agit pas d'adopter un ton agressif, mais de remettre en question les approches et hypothèses choisies. Les deux types de revues identifient les problèmes sans corriger le code. Confirmez les résultats, puis déléguez les corrections séparément.

Organise les constats avec les critères de réussite applicables, l'impact utilisateur et les méthodes de vérification. Ne corrige pas automatiquement les problèmes nécessitant un changement de spécifications ; présente les options et les différences à l'humain.

Ignorez la passerelle de revue au début

Option d'automatisation : la « Review gate » insère une revue Codex à chaque fois que Claude termine une réponse. Activez-la avec /codex:setup --enable-review-gate.

Attention : La documentation officielle signale le risque de longues boucles de correction consommant rapidement les quotas entre Claude et Codex.

Commencez par des revues manuelles pour comprendre les constats. Désactivez l'option lorsque vous vous absentez. Arrêtez-la avec /codex:setup --disable-review-gate et vérifiez les requêtes en attente.

Conservez les requêtes réussies pour les prochaines tâches

Au lieu de recoller de longues instructions, sauvegardez les flux de travail qui ont fonctionné. Les Skills permettent de stocker des procédures de tâches dans des fichiers pour les réutiliser.

Documentation Anthropic : Placez les procédures dans .claude/skills. Créez un dossier team-brief avec un fichier SKILL.md contenant les vérifications préalables à la transmission.

1---
2name: team-brief
3description: Organiser le périmètre et la vérification à partir des spécifications
4disable-model-invocation: true
5---
6Lis docs/spec.md et docs/tasks.md, en ciblant uniquement les modifications actuelles.
7Organise le périmètre, les modifications interdites, les prérequis, les critères de réussite et la vérification.
8Crée les textes de requête pour les agents, en laissant les points indécis à la confirmation humaine.
9Ne modifie pas le code, ne publie rien en externe et ne lance pas Codex durant cette procédure.

Invocation dans Claude Code :

1/team-brief Je veux ajouter un tri par date d'échéance

C'est une commande personnalisée, et non une commande standard. disable-model-invocation: true garantit que c'est l'humain qui déclenche le moment opportun. Claude ne se lancera pas automatiquement. Les procédures ne forcent pas le lancement d'IA ou d'inspections ; essayez d'abord de « réutiliser uniquement la préparation ».

Workflows dynamiques pour les grandes tâches

Pour des périmètres plus vastes, Claude Code propose les workflows dynamiques (annoncés en mai 2026), permettant de scripter plusieurs agents. Disponible dans les forfaits payants et via l'API.

• Chat normal : Claude choisit la tâche suivante à chaque fois

• Workflows dynamiques : Scriptez les embranchements et la collecte des résultats, réexécutable

Exemple : Investiguer séparément les échecs de sauvegarde, les contrôles de saisie et les cassures de mise en page sur plusieurs écrans, puis croiser les constats. Ne lancez pas d'agents massifs depuis une petite application ; envisagez cette approche lorsque vous devez appliquer les mêmes vérifications à grande échelle.

Crée un workflow dynamique investiguant des écrans séparés et vérifiant les constats avec des agents distincts. Présente d'abord les cibles, le nombre d'agents et les conditions de sortie. Aucune modification de code ; exécute un petit périmètre après validation.

Astuces :

• À activer via /config dans le forfait Pro

• Surveillez l'avancement et l'utilisation avec /workflows, arrêtable à tout moment

• Choisissez l'échelle (petite, etc.) dans /config ; la documentation officielle considère ces valeurs comme des estimations, et non des limites strictes. Ne partez pas du principe que le nombre d'agents est garanti.

Cela exécute des agents côté Claude. Codex ne se joint pas automatiquement. Utilisez-le d'abord pour l'investigation et la vérification internes à Claude ; traitez la délégation à Codex comme une étape distincte.

Exécutez l'application de gestion de dossiers de bout en bout

Reliez les composants pour former une seule application. Ce qui suit est un exemple de développement explicatif, et non un rapport d'expérience abouti ; vérifiez le tout dans votre propre environnement.

Cible de construction

• Champs : Nom du dossier, échéance, statut, notes

• Statut : Non commencé / En cours / Terminé

• Recherche par nom de dossier

• Affichage des dossiers incomplets triés par échéance

Demande initiale

Transmettez-la à Claude. Ciblez un nouveau dossier d'entraînement, et non des projets critiques existants.

Construis une application personnelle de gestion de dossiers dans le dossier d'entraînement. Confirme d'abord l'environnement et les spécifications. Inclus l'enregistrement, la modification, la recherche, le tri et la persistance pour le nom, l'échéance, le statut et les notes. Exclus la connexion, la synchronisation et la publication externe.

Stockage candidat : localStorage. Pas de synchronisation ni de sauvegarde multi-appareils ; effacer les données du navigateur supprimera les enregistrements. N'y placez aucune information de production précieuse.

Construisez la base, définissez les parties partagées

Un seul agent construit la base. Vérifiez que l'application se lance et que l'écran vide s'affiche. Committez les spécifications et la base dans Git avant de séparer les espaces de travail si nécessaire.

• Donnez à l'agent UI : Les champs à afficher, le mappage des actions

• Donnez à l'agent Stockage : Le format des enregistrements, les méthodes de lecture/ajout/mise à jour, la gestion des erreurs

Ne laissez aucun des deux inventer des noms de champs. Si le champ de statut est status, les deux doivent l'utiliser. Ne changez pas unilatéralement pour state par facilité ; renvoyez les modifications partagées à Claude pour ajustement.

Demande d'implémentation à Codex

Précisez les emplacements modifiables ET les preuves de sortie exigées.

1/codex:rescue --fresh Lis docs/spec.md et docs/tasks.md. Implémente uniquement la logique de stockage et les tests assignés. Renvoie les fichiers modifiés, les commandes, les résultats des tests et les points non confirmés. Arrête-toi et fais un rapport si des changements de spécifications ou des modifications par un autre agent sont nécessaires.

Pendant ce temps, Claude ne doit pas modifier les mêmes fichiers de son côté. Concentrez-vous sur les vérifications de fin et la préparation des données de test ; décidez des prochaines étapes une fois les résultats revenus.

Préparez les données de vérification

• Échéance hier, « Non commencé »

• Échéance aujourd'hui, « En cours »

• Échéance la semaine prochaine, « Terminé »

• Plusieurs dossiers avec la même échéance

• Noms de dossiers très longs

Cela permet des vérifications concrètes de tri et d'affichage.

Documentez les règles détaillées dans les spécifications :

• Tri : Ordre d'enregistrement pour les mêmes échéances

• Champs vides : Nom et échéance obligatoires ; notes facultatives. Afficher les champs manquants.

• Dates : Définissez l'hypothèse de changement de jour. Un décalage de fuseau horaire ou de gestion de l'heure entraînant un changement de jour rendrait l'application inutilisable malgré une belle apparence.

Prédéfinir les règles empêche des vérifications incohérentes après l'implémentation.

Intégrez et testez

Une fois les implémentations prêtes, demandez à Claude de lire les listes de modifications et les résultats de tests, puis de confirmer l'intégration. Si vous utilisez des worktrees, rassemblez les modifications dans une seule branche de vérification. Relancez les tests réussis individuellement après l'intégration.

Utilisez Playwright pour l'automatisation de l'interface. Les guides actuels proposent des CLI et des Skills pour les agents IA ; le MCP n'est pas la seule méthode.

Séparez le « mécanisme de contrôle du navigateur par l'IA » des « tests reproductibles ». Utilisez Playwright Test pour les flux réexécutables allant de l'enregistrement au rechargement.

Crée des tests Playwright vérifiant l'enregistrement, le rejet des formulaires vides, la recherche, le changement de statut, le tri par échéance et la persistance. Sépare la configuration de lancement et les données de test. Ne modifie ni le comportement de l'application ni les critères de réussite pour faire passer les tests.

Configuration pour un nouveau projet d'entraînement :

1npm init playwright@latest

S'il est déjà installé, vérifiez les configurations de lancement et de test existantes avant d'en ajouter.

Assurez-vous que les navigateurs sont installés, configurez le lancement de l'application, puis exécutez :

1npx playwright test
2npx playwright show-report

Point crucial : Ne considérez pas des tests introuvables ou tous ignorés comme un « succès ».

En cas d'échec, isolez la cause : Est-ce un bug de stockage ou le test qui cherche un bouton inexistant ? Ne supprimez pas les tests pour obtenir du vert ; décidez de la cible de correction en vous référant aux spécifications d'origine.

Vérification humaine finale

Vérifiez le visuel manuellement. Y a-t-il du texte caché ? Est-il facile de trouver les dossiers dont l'échéance est proche ? Des rapports de tests réussis ne garantissent pas une bonne expérience utilisateur.

Recevez quatre éléments de la part de Claude, et non de longs journaux :

• Méthode de lancement

• Comportements vérifiés

• Contraintes restantes

• Prochaines corrections candidates

Enregistrez vous-même un élément, rechargez la page, vérifiez la persistance. Marquez ensuite la tâche comme terminée.

Où arrêter les corrections acharnées

À mesure que le périmètre de l'équipe s'élargit, définissez des fins. Sommes-nous en train de boucler sur le même bug ou de résoudre des problèmes successifs ? Un état flou empêche de donner de nouvelles instructions.

Définissez des critères d'arrêt

Utilisez la règle de « deux corrections maximum par problème » comme ligne directrice. Ce n'est pas une recommandation officielle, mais une règle opérationnelle pour redonner le pouvoir de décision à l'humain en cas de blocage.

Si le même bug n'est toujours pas corrigé après deux tentatives, arrête les modifications supplémentaires. Résume les actions essayées, les changements effectués, les symptômes restants et les décisions nécessaires. Ne t'étends pas à des fonctionnalités non liées.

Les instructions seules ne garantissent pas l'arrêt. Surveillez l'utilisation, annulez les requêtes en arrière-plan inutiles avec /codex:cancel. Vérifiez que les agents se sont réellement arrêtés.

Suivez les coûts séparément

Les quotas de Codex authentifié via ChatGPT diffèrent de la tarification par clé API. Les agents parallèles consomment des ressources d'inférence et d'outils.

Ne faites pas passer de simples modifications de texte par les deux IA ou par de grandes revues.

Catégorisez :

• Les tâches réalisables seul

• Les tâches nécessitant un second avis

• Les tâches parallélisables indépendamment

Cela aide à décider de l'allocation de l'effort et des quotas.

Attention aux spécifications de modèles obsolètes

Les anciennes spécifications de modèles provoquent des échecs. Mise à jour OpenAI : GPT-5.5 a pris fin pour le Codex authentifié via ChatGPT le 15 octobre 2026 (JST). L'authentification par clé API n'est pas concernée.

Mettez à jour les anciens fichiers de spécifications et de rôles vers les modèles actuellement disponibles. Vérifiez les modèles sélectionnables et les paramètres de raisonnement acceptés, ne vous contentez pas de renommer.

Vérifiez les permissions et les hooks

Les permissions de Claude ne se propagent pas toujours à Codex. Vérifiez les droits d'exécution des deux côtés. Entraînez-vous sans identifiants de production. Exigez une approbation distincte pour les suppressions, les publications externes et la facturation.

Inspectez les hooks dans les exemples publics avant de les utiliser. Les hooks s'exécutent automatiquement à des moments précis ; vérifiez ce qui est réellement lancé, et pas seulement les ajouts pratiques.

Mesurer le « Développé rapidement »

Ne comparez pas uniquement le temps de génération.

• Le nombre de fois où vous devez réexpliquer

• Le temps d'intégration/de correction

• Les défauts restants par rapport aux critères de validation

Prenez ces éléments en compte pour décider si la même répartition des tâches fonctionnera la prochaine fois.

Commencez par de petits outils hebdomadaires

Les non-développeurs obtiennent les meilleurs résultats là où ils peuvent juger eux-mêmes de l'exactitude.

• Suivi des demandes

• Vérification des délais de commande

• Formatage CSV avec des tris cohérents

Commencez par des cas d'usage faciles à décrire.

Vous voulez voir les échéances proches en premier ? Supprimer les éléments terminés ? Être alerté en cas de données manquantes ? Vos besoins quotidiens deviennent les critères de réussite de l'IA.

Pas besoin de maîtriser le code au préalable : créez des prototypes basés sur vos conditions, utilisez-les, puis corrigez-les. Remarque : les systèmes de données clients ou les services publics nécessitent une validation professionnelle qui va au-delà du simple succès du prototype.

L'équipe de départ suffit :

1. Claude structure le cahier des charges

1. Codex exécute une tâche

1. Vérifiez les résultats obtenus avec un regard neuf

Conservez les requêtes et méthodes de vérification utiles pour éviter de tout réexpliquer lors de la prochaine application.

Merci de votre lecture.

Le LINE Open Chat « Niku's AI Speed Strategy » distribue gratuitement un kit en 8 points.

• Guide d'initiation à Codex/Claude Code

• Instructions de copier-coller

• Tableaux de référence rapide

• 50 mini-applications

• 50 prompts d'images

• Installation de yomiyasu

• Générateur de titres

• Flux et montants de monétisation X

Récupérez-le ici 👇 https://x.gd/VtPmw