Maîtriser les flux de travail dynamiques dans Claude Code : 6 modèles et 14 étapes utilisés par les ingénieurs d'Anthropic

La plupart des utilisateurs de Claude Code écrivent encore leurs workflows à la main. Ils enchaînent les prompts, copient les sorties, les collent dans le prompt suivant, corrigent ce qui ne va pas, et recommencent.

9 builders sur 10 n'ont jamais essayé les Dynamic Workflows, même s'ils ont été publiés il y a deux semaines.

Ils écrivent 50 prompts quand un seul workflow suffirait. Voici le plan en 14 étapes et les 6 modèles que les ingénieurs d'Anthropic utilisent réellement — pour les migrations, la recherche, le tri, l'analyse des causes racines, le triage et les évaluations.

Suivez ma page Substack pour recevoir les dernières actualités IA :

movez.substack.com

Les Dynamic Workflows ont été publiés dans Claude Code le 28 mai 2026. Le harnais par défaut de Claude Code est conçu pour le codage — et cela fonctionne bien pour la plupart des tâches de codage. Mais il existe des catégories de travaux où une seule fenêtre de contexte commence à montrer ses limites : les tâches longues, massivement parallèles, hautement structurées ou adversariales.

Pour celles-ci, Anthropic construisait auparavant ses propres harnais (Recherche, Revue de code, équipes d'agents). Avec les Dynamic Workflows, Claude écrit ce harnais pour vous à la volée, personnalisé pour votre tâche, en JavaScript.

14 étapes. 6 modèles. Un seul workflow au lieu de cinquante prompts.

Partie 1 · Le modèle mental

01. Un workflow est un harnais que Claude écrit.

Le harnais par défaut de Claude Code fait planifier et exécuter Claude dans la même fenêtre de contexte. Pour la plupart des travaux de codage, c'est parfait. Pour les tâches longues, parallèles ou adversariales, cela montre ses limites.

Un Dynamic Workflow, c'est Claude qui écrit son propre harnais personnalisé pour la tâche — un fichier JavaScript avec quelques fonctions spéciales qui créent et coordonnent des sous-agents, ainsi que du JavaScript standard (Math, JSON, Array) pour traiter les données qui circulent entre eux.

Trois choses que cela vous apporte et que le harnais par défaut ne peut pas :

• Isolation par agent. Chaque sous-agent obtient sa propre fenêtre de contexte avec un objectif ciblé. Pas de contamination croisée.
• Choix du modèle par agent. Le workflow choisit quel modèle chaque sous-agent utilise — Opus pour le raisonnement difficile, Haiku pour l'exploration économique, Sonnet pour le juste milieu.
• Niveau d'isolation par agent. Worktree (clone git isolé) ou remote (pas de clone). Le workflow décide de ce dont chaque agent a besoin.

Pour en lancer un, demandez directement à Claude (« crée un workflow qui… ») ou utilisez le mot-clé ultracode. Si un workflow est interrompu — action utilisateur, fermeture du terminal — la reprise de la session reprend là où elle s'était arrêtée.

02. Les 3 modes de défaillance que les workflows résolvent.

Pour savoir quand un workflow est l'outil approprié, il faut comprendre ce qu'il corrige. Plus Claude travaille longtemps sur une tâche complexe dans une seule fenêtre de contexte, plus il devient susceptible de rencontrer trois modes de défaillance spécifiques — nommés directement dans les écrits de lancement d'Anthropic :

• Paresse agentique — Claude s'arrête avant d'avoir terminé une tâche complexe en plusieurs parties et déclare le travail fini après un progrès partiel. Il traite 20 des 50 éléments d'une revue de sécurité et considère le reste comme « géré ».
• Biais d'autopréférence — Claude préfère ses propres résultats lorsqu'on lui demande de les vérifier ou de les juger selon une grille. Un vérificateur qui a un intérêt dans le résultat ne peut pas être un vérificateur impartial.
• Dérive de l'objectif — la perte progressive de fidélité à l'objectif initial au fil de nombreux tours, surtout après la compaction. Chaque étape de résumé est avec perte. Les contraintes « Ne fais pas X » disparaissent silencieusement au tour 47.

Un workflow résout les trois structurellement : des Claude séparés avec leurs propres contextes, des objectifs ciblés et un état isolé. Si votre tâche souffre de l'un de ces schémas — c'est le signal pour utiliser un workflow.

03. Workflows statiques vs dynamiques.

Vous avez peut-être déjà construit des workflows statiques avec le SDK Claude Agent ou claude -p — en coordonnant plusieurs instances de Claude Code ensemble.

• Les workflows statiques sont génériques : écrits une fois pour gérer tous les cas particuliers. Ils fonctionnent, mais ils doivent être prudents.
• Les Dynamic Workflows sont différents : Claude écrit ce workflow pour cette tâche. Le harnais est sur mesure. Ci-dessous, la même question traitée des deux manières :

La raison pour laquelle la version dynamique l'emporte n'est pas l'étape de recherche — les deux peuvent chercher.

C'est que le workflow peut se modeler autour de votre contexte : lire votre code de facturation, vérifier chaque fonctionnalité par rapport à la nouvelle documentation du fournisseur, tarifer en fonction de votre volume de transactions, et exécuter un passage adversarial « pourquoi ne pas migrer » contre sa propre réponse émergente.

Un harnais statique ne peut pas faire cela car il ne sait pas que votre code existe.

04. L'API de base. agent(), parallel(), pipeline().

Trois fonctions font la plupart du travail dans un workflow. Les connaître suffit pour lire n'importe quel workflow que Claude écrit pour vous et pour orienter Claude lorsque vous souhaitez une forme spécifique.

parallel() est une barrière : elle se déploie, puis attend que tout soit terminé avant de retourner le résultat. pipeline() est en flux : chaque élément traverse chaque étape indépendamment.

Choisissez selon la question : Ai-je besoin de tous les résultats avant de pouvoir faire quoi que ce soit ensuite ? Oui → parallel. Non → pipeline (moins cher, plus rapide dans l'ensemble).

05. Classifier et agir. Router le travail avant de l'exécuter.

Un agent classificateur détermine le type de tâche, puis le workflow achemine vers différents agents ou comportements selon la réponse. Ou un classificateur s'exécute à la fin, triant les sorties brutes dans des catégories pour la suite.

Quand ce modèle est utile :

• La tâche est hétérogène — différents sous-types nécessitent un traitement différent.
• Vous voulez utiliser le modèle coûteux uniquement là où la complexité l'exige (classificateur sur un modèle économique, puis routage vers Opus uniquement quand c'est nécessaire).
• La décomposition du travail est elle-même non triviale et bénéficie d'une décision du modèle sur la forme.

Exemple : « Explique comment fonctionne le module d'authentification. » Un agent classificateur lit d'abord le code source, estime la complexité, puis achemine la tâche d'explication réelle vers Sonnet pour un module de 10 fichiers ou Opus pour un module de 100 fichiers. Le bon modèle pour le travail, décidé après avoir compris le travail.

06. Déploiement et synthèse. Beaucoup de petites étapes, un seul résultat fusionné.

Divisez une tâche en de nombreuses petites étapes. Exécutez un agent sur chaque étape en parallèle. Synthétisez les résultats en une seule réponse.

L'étape de synthèse est une barrière — elle attend que tous les agents déployés aient terminé, puis fusionne leurs sorties structurées.

Pourquoi ce modèle domine en pratique : il résout l'échec « trop de choses à la fois » du travail en contexte unique. Chaque sous-agent ne voit que son morceau. L'orchestrateur n'est jamais distrait par 50 détails sans rapport.

Chaque étape bénéficie de sa propre fenêtre propre afin qu'elles ne se contaminent pas mutuellement.

Utilisez-le quand :

• Vous avez une liste clairement énumérable d'éléments de travail (50 fichiers, 200 points de terminaison, 100 révisions).
• Chaque élément est indépendant — aucun élément n'a besoin de la sortie d'un autre pour commencer.
• Vous voulez une réponse unique consolidée à la fin, pas un tas de rapports partiels.

1// Fan out: one agent per file. Barrier: wait for all.
2const reviews = await parallel(
3  files.map(file => () => agent(
4    `Review ${file} for security issues`,
5    { model: "haiku", schema: IssueList }
6  ))
7)
8
9// Synthesize: one Opus agent merges everything.
10const report = await agent(
11  `Merge these reviews into one prioritized report:\n${JSON.stringify(reviews)}`,
12  { model: "opus" }
13)

07. Vérification adversarial

C'est la correction structurelle du biais d'autopréférence. Pour chaque agent créé, exécutez un agent créé séparément qui vérifie de manière adversarial sa sortie par rapport à une grille. Le vérificateur n'a jamais vu le travail original ; il ne peut pas le favoriser.

Ce modèle est le plus important pour :

• Vérification des affirmations — chaque déclaration factuelle dans un rapport obtient son propre sous-agent vérificateur, qui vérifie par rapport à la source originale.
• Revue de code — l'auteur écrit le correctif, le relecteur (contexte séparé) le relit. Jamais le même Claude qui se juge lui-même.
• Passerelles de qualité — avant qu'un artefact ne soit livré, un adversaire tente de trouver le cas le plus faible contre lui. Si l'adversaire n'y arrive pas, on livre.

La règle d'appariement : le vérificateur ne doit connaître que la grille et l'artefact, pas qui l'a produit. Sinon, l'autopréférence revient par des indices dans le prompt.

08. Générer et filtrer.

Générez un certain nombre d'idées sur un sujet, puis filtrez-les selon une grille ou par vérification. Dédupliquez les doublons. Ne renvoyez que les idées de la plus haute qualité, testées.

Où ce modèle excelle :

• Brainstorming — 30 noms de produits, puis un vérificateur élimine les clichés, les conflits de marque et les phonétiques faibles. Vous en voyez 3.
• Génération d'hypothèses — 5 approches différentes d'un problème, puis chacune est notée selon vos contraintes. Le gagnant l'a mérité.
• Conception de solutions — 5 approches différentes d'un problème, puis chacune est notée selon vos contraintes. Le gagnant l'a mérité.

Le contraire de demander à Claude « la meilleure réponse ». Demander la meilleure réponse fait que Claude s'engage tôt. Générer et filtrer fait que Claude s'engage tard, après que toutes les options ont été contestées.

09. Tournoi. La comparaison par paires bat la notation absolue.

Au lieu de diviser le travail, faites concourir les agents. Créez N agents qui tentent chacun la même tâche en utilisant des approches différentes, puis jugez les résultats par paires jusqu'à ce qu'un gagnant émerge.

Le jugement comparatif est plus fiable que la notation absolue — surtout pour les travaux basés sur le goût.

Pourquoi cela bat le tri par note : essayer de trier 1 000 éléments en un seul prompt échoue sur deux fronts — la qualité se dégrade, et cela ne tient pas dans le contexte. Un tournoi répartit les matchs sur des agents frais, chacun ne comparant que deux éléments.

Le bracket lui-même vit dans un code de boucle déterministe, pas dans le contexte. Chaque comparaison est rapide, juste et isolée. La même idée fonctionne pour le classement basé sur le goût : choix de design, sélection de candidats, priorisation de contenu.

10. Boucle jusqu'à la fin.

Pour les tâches avec une quantité de travail inconnue, bouclez la création d'agents jusqu'à ce qu'une condition d'arrêt soit remplie — plus de nouvelles découvertes, plus d'erreurs dans les journaux, théorie vérifiée — au lieu d'exécuter un nombre fixe de passes.

Ce modèle est la réponse à « continue jusqu'à ce que ce soit vraiment fini » :

• Débogage de tests intermittents — reproduisez, formulez des théories, testez-les, jusqu'à ce qu'une théorie tienne.
• Chasse aux bugs — continuez à trouver des bugs jusqu'à ce qu'un passage complet retourne zéro.
• Recherche de motifs — regroupez, identifiez des règles, jusqu'à ce qu'aucun nouveau groupe n'apparaisse.

Associez ce modèle avec /goal pour définir une exigence de terminaison stricte (« ne t'arrête pas avant qu'une théorie fonctionne ») et avec /loop si vous voulez que le workflow lui-même s'exécute selon un calendrier récurrent.

Le bracket et la condition d'arrêt vivent dans le code ; seule l'itération active reste dans le contexte.

11. Composer des modèles pour des cas d'utilisation réels. Un workflow, plusieurs modèles.

Les 6 modèles apparaissent rarement seuls. Un workflow réel en compose 2 à 4. Le tableau ci-dessous associe chaque cas d'utilisation des écrits de lancement d'Anthropic avec les modèles qu'il a tendance à utiliser :

• Migrations et refontes. Déploiement (un agent par site d'appel/test défaillant dans un worktree) → vérification adversarial (un agent séparé révise chaque correctif) → boucle jusqu'à la fin. C'est le modèle qu'Anthropic a utilisé pour réécrire Bun de Zig en Rust.
• Recherche approfondie (la compétence /deep-research). Déploiement (recherches web parallèles) → vérification adversarial (chaque affirmation vérifiée indépendamment) → synthèse (un rapport cité).
• Vérification approfondie d'un brouillon. Identifiez toutes les affirmations factuelles (un agent) → déploiement (un vérificateur par affirmation, chaque agent vérifie par rapport à la source) → méta-vérificateur (vérifie que les sources du vérificateur sont de haute qualité).
• Tri de 1 000+ éléments. Tournoi (étapes 5-9) — comparaison par paires, classement par seaux ou bracket. Jugement comparatif, jamais de notation absolue.
• Mémoire et respect des règles. Vérificateur par règle (déploiement) → un persona sceptique examine les règles elles-mêmes pour éviter les faux positifs.
• Enquête sur la cause racine. Générez des théories à partir de preuves disparates (différents agents lisent les journaux, les fichiers, les données) → panel de vérificateurs et de réfutateurs pour chaque théorie → boucle jusqu'à ce qu'une survive.
• Triage à grande échelle. Classifier et agir → dédoubler par rapport aux tickets existants → soit tenter le correctif, soit escalader. Associez avec /loop pour un triage continu.
• Exploration et goût (design, choix de noms, choix d'interface). Générer et filtrer (5-20 options) → tournoi avec une grille → classer ou choisir.
• Évaluations légères. Exécutez le candidat dans un worktree → agents de comparaison notent selon une grille → affiner et renoter. Même forme qu'un tournoi mais pour la notation, pas le classement.

La bonne façon d'intérioriser ces modèles : identifiez quel mode de défaillance votre tâche actuelle subit, puis choisissez le modèle qui l'empêche structurellement.

Dérive → déploiement. Autopréférence → vérification adversarial. Tâche ouverte → boucle jusqu'à la fin. Difficile à noter → tournoi.

12. Associer avec /goal, /loop et les budgets de tokens.

Les workflows peuvent être coûteux. Trois contrôles les transforment de « cool mais chers » en « outil que j'exécute sans surveillance ».

• /goal définit une exigence de terminaison stricte. Associez-le au modèle de boucle : « ne t'arrête pas avant qu'une théorie fonctionne. » Sans /goal, un workflow s'arrête à un point de terminaison souple. Avec /goal, il itère jusqu'à ce que la condition finale réelle soit remplie.
• /loop exécute l'ensemble du workflow selon un calendrier récurrent. Utilisez-le pour les workflows que vous voulez exécuter en continu — triage, mises à jour de recherche hebdomadaires, vérification récurrente.
• Budgets de tokens explicites. Dites à Claude dans le prompt : « utilise 10k tokens. » Cela fixe un plafond pour l'exécution du workflow. Sans plafond, un workflow ambitieux peut gonfler jusqu'à 5-10× les tokens attendus.

1> ultracode quick adversarial review of this assumption:
2  "moving to Postgres eliminates our shard rebalancing."
3  Use 5k tokens. /goal don’t stop until you have either
4  a counterexample or three independent confirmations.

Pour citer directement l'équipe Claude Code : « Les bonnes pratiques sont encore en développement. Les Dynamic Workflows utilisent souvent plus de tokens, alors réfléchissez bien au moment et à la manière de les utiliser. » La plupart des tâches de codage traditionnelles n'ont pas besoin d'un panel de 5 relecteurs.

Demandez-vous : cette tâche a-t-elle vraiment besoin de plus de calcul ? Si une session Claude Code normale la terminerait en cinq minutes, vous n'avez pas besoin d'un workflow.

13. Utiliser le modèle de quarantaine pour les entrées non fiables.

Tout workflow qui lit du contenu public non fiable — tickets de support, rapports de bugs, retours utilisateurs, données scrapées — doit supposer que ce contenu peut contenir une injection de prompt.

La solution : la quarantaine. Empêchez les agents qui lisent le contenu non fiable de prendre des actions à privilèges élevés. Des agents séparés, sans aucune exposition au contenu brut, exécutent les actions.

Tout workflow qui traite du contenu soumis par l'utilisateur (tickets de support, rapports de bugs, retours clients, réseaux sociaux), scrape des pages web publiques, ou s'exécute sur la sortie d'une API tierce.

Si l'entrée n'a pas été écrite par vous ou un coéquipier de confiance, mettez-la en quarantaine. Un agent lecteur en lecture seule de 30 lignes ne coûte presque rien et supprime toute une classe de risque d'injection de prompt.

14. Sauvegarder les workflows. Les expédier en tant que Skills.

Une fois qu'un workflow fonctionne, sauvegardez-le : appuyez sur s dans le menu du workflow. Les workflows sauvegardés vont dans ~/.claude/workflows. De là, deux possibilités :

• Gardez-le en local — réutilisez-le dans vos propres projets.
• Expédiez-le en tant que Skill — regroupez le fichier JavaScript dans un dossier Skill, référencez-le dans SKILL.md, et quiconque installe le Skill exécute le même workflow.

Une nuance pratique à connaître : lorsque vous regroupez un workflow dans un Skill, demandez à Claude de traiter le workflow comme un modèle, pas comme un script à exécuter textuellement.

Cela laisse la place à Claude d'adapter la forme du workflow à la tâche spécifique tout en conservant la structure globale. Particulièrement utile pour les workflows comme « vérification approfondie » ou « triage » qui doivent s'adapter à chaque cas d'utilisation.

Les erreurs qui gaspillent des tokens sur les workflows

• Utiliser un workflow alors qu'une session Claude Code normale suffirait. La plupart des tâches de codage traditionnelles n'ont pas besoin d'un panel de 5 relecteurs.
• Pas de budget de tokens. Les workflows ambitieux gonflent jusqu'à 5-10× ce que vous attendiez sans plafond explicite.
• Un seul agent qui fait à la fois le travail et la vérification. Le biais d'autopréférence fait que le vérificateur favorise le travailleur. Ils doivent être séparés.
• Traiter parallel() et pipeline() comme interchangeables. La barrière compte — parallel attend tout, pipeline est en flux.
• Omettre /goal sur les modèles de boucle. Le workflow s'arrête tôt au premier point de terminaison souple. /goal force la terminaison stricte.
• Laisser le contenu non fiable atteindre l'acteur. La quarantaine n'est pas optionnelle dès que vous traitez quelque chose soumis par l'utilisateur.
• Trier avec des notes absolues. Le jugement comparatif est plus fiable. Utilisez un tournoi.
• Ne jamais sauvegarder les workflows qui fonctionnent. Re-prompting la même forme chaque semaine. Sauvegardez avec s, expédiez en tant que Skill.

Conclusion :

https://x.com/_catwu/status/2060054180379689074