Come padroneggiare i Dynamic Workflows in Claude Code: 6 pattern e 14 passaggi utilizzati dagli ingegneri di Anthropic

La maggior parte degli utenti di Claude Code scrive ancora i propri flussi di lavoro a mano. Incatenano prompt, copiano output, li incollano nel prompt successivo, sistemano gli errori, ripetono.

9 costruttori su 10 non hanno mai provato i Flussi di Lavoro Dinamici, nonostante siano stati rilasciati due settimane fa.

Scrivono 50 prompt quando un singolo flusso di lavoro basterebbe. Questa è la roadmap in 14 passaggi e i 6 modelli che gli stessi ingegneri di Anthropic usano realmente - per migrazioni, ricerca, smistamento, analisi delle cause profonde, triage e valutazioni.

Segui il mio Substack per ricevere le ultime novità sull'AI:

movez.substack.com

I Flussi di Lavoro Dinamici sono stati rilasciati in Claude Code il 28 maggio 2026. L'infrastruttura predefinita di Claude Code è progettata per la programmazione - e funziona bene per la maggior parte dei compiti di codifica. Ma esistono categorie di lavoro in cui una singola finestra di contesto inizia a mostrare i suoi limiti: processi di lunga durata, massicciamente paralleli, altamente strutturati o avversari.

Per questi, Anthropic costruiva personalmente infrastrutture su misura (Ricerca, Revisione del Codice, team di agenti). Con i Flussi di Lavoro Dinamici, Claude scrive quell'infrastruttura per te al volo, costruita su misura per il tuo compito, in JavaScript.

14 passaggi. 6 modelli. Un flusso di lavoro invece di cinquanta prompt.

Parte 1 · Il Modello Mentale

01. Un flusso di lavoro è un'infrastruttura scritta da Claude.

L'infrastruttura predefinita di Claude Code fa sì che Claude pianifichi ed esegua nella stessa finestra di contesto. Per la maggior parte del lavoro di codifica, questo è ottimo. Per lavoro di lunga durata, parallelo o avversario, mostra i suoi limiti.

Un Flusso di Lavoro Dinamico è Claude che scrive la propria infrastruttura personalizzata per il compito - un file JavaScript con alcune funzioni speciali che generano e coordinano sotto-agenti, più JavaScript standard (Math, JSON, Array) per elaborare i dati che fluiscono tra di loro.

Tre cose che questo ti offre che l'infrastruttura predefinita non può:

• Isolamento per agente. Ogni sotto-agente ottiene la propria finestra di contesto con un obiettivo focalizzato. Nessuna contaminazione incrociata.
• Scelta del modello per agente. Il flusso di lavoro sceglie quale modello usa ogni sotto-agente - Opus per ragionamenti complessi, Haiku per esplorazioni economiche, Sonnet per la via di mezzo.
• Livello di isolamento per agente. Worktree (checkout git isolato) o remoto (nessun checkout). Il flusso di lavoro decide cosa serve a ogni agente.

Avviane uno chiedendo direttamente a Claude ("crea un flusso di lavoro che...") o con la parola chiave ultracode. Se un flusso di lavoro viene interrotto - azione dell'utente, chiusura del terminale - riprendere la sessione riparte da dove era stato interrotto.

02. Le 3 modalità di fallimento che i flussi di lavoro risolvono.

Per sapere quando un flusso di lavoro è lo strumento giusto, devi capire cosa risolve. Più a lungo Claude lavora su un compito complesso in una singola finestra di contesto, più diventa suscettibile a tre specifiche modalità di fallimento - nominate direttamente nei documenti di lancio di Anthropic:

• Pigrizia agentica - Claude si ferma prima di completare un compito complesso e multi-parte e dichiara di aver finito dopo un progresso parziale. Affronta 20 dei 50 elementi in una revisione di sicurezza e definisce il resto "gestito".
• Bias di auto-preferenza - Claude preferisce i propri risultati quando gli viene chiesto di verificarli o giudicarli rispetto a una rubrica. Un verificatore con un interesse in gioco non può essere un verificatore imparziale.
• Deriva dell'obiettivo - la graduale perdita di fedeltà all'obiettivo originale attraverso molti passaggi, specialmente dopo la compattazione. Ogni passaggio di riepilogo comporta una perdita. I vincoli "Non fare X" scompaiono silenziosamente al turno 47.

Un flusso di lavoro risolve tutti e tre strutturalmente: Claude separati con i propri contesti, obiettivi focalizzati e stato isolato. Se il tuo compito soffre di uno qualsiasi di questi modelli - questo è il segnale per ricorrere a un flusso di lavoro.

03. Flussi di lavoro Statici vs Dinamici.

Potresti aver già costruito flussi di lavoro statici usando l'Agent SDK di Claude o claude -p - coordinando più istanze di Claude Code insieme.

• I flussi di lavoro statici sono generici: scritti una volta per gestire ogni caso limite. Funzionano, ma devono essere conservativi.
• I Flussi di Lavoro Dinamici sono diversi: Claude scrive questo flusso di lavoro per questo compito. L'infrastruttura è fatta su misura. Qui sotto c'è la stessa domanda gestita in entrambi i modi:

Il motivo per cui la versione dinamica vince non è il passaggio di ricerca - entrambi possono cercare.

È che il flusso di lavoro riesce a modellarsi attorno al tuo contesto: leggere il tuo codice di fatturazione, verificare ogni funzionalità rispetto alla documentazione del nuovo fornitore, calcolare il prezzo in base al tuo volume di transazioni ed eseguire un passaggio avversario "perché non migrare" contro la propria risposta emergente.

Un'infrastruttura statica non può farlo perché non sa che il tuo codice esiste.

04. L'API principale. agent(), parallel(), pipeline().

Tre funzioni fanno la maggior parte del lavoro in un flusso di lavoro. Conoscerle è sufficiente per leggere qualsiasi flusso di lavoro che Claude scrive per te e per guidare Claude quando vuoi una forma specifica.

parallel() è una barriera: si dirama, poi attende tutto prima di restituire. pipeline() è in streaming: ogni elemento scorre attraverso ogni fase in modo indipendente.

Scegli in base alla domanda: ho bisogno di tutti i risultati prima di poter fare qualcos'altro? Sì → parallel. No → pipeline (più economico, più veloce in generale).

05. Classifica e agisci. Instrada il lavoro prima di eseguirlo.

Un agente classificatore decide il tipo di compito, poi il flusso di lavoro instrada verso diversi agenti o comportamenti in base alla risposta. Oppure un classificatore viene eseguito alla fine, ordinando gli output grezzi in categorie per ciò che verrà dopo.

Quando questo modello dà il meglio di sé:

• Il compito è eterogeneo - diversi sotto-tipi necessitano di trattamenti diversi.
• Vuoi spendere il modello costoso solo dove la complessità lo richiede (classificatore su modello economico, poi instrada a Opus solo quando necessario).
• La scomposizione del lavoro è di per sé non banale e beneficia della decisione di un modello sulla forma.

Esempio: "Spiega come funziona il modulo di autenticazione." Un sotto-agente classificatore legge prima il codebase, stima la complessità, poi instrada il compito di spiegazione effettivo a Sonnet per un modulo di 10 file o a Opus per uno di 100 file. Il modello giusto per il lavoro, deciso dopo aver compreso il lavoro.

06. Diramazione e sintesi. Molti piccoli passaggi, un risultato unificato.

Dividi un compito in molti passaggi più piccoli. Esegui un agente su ogni passaggio in parallelo. Sintetizza i risultati in un'unica risposta.

Il passaggio di sintesi è una barriera - attende ogni agente diramato, poi unisce i loro output strutturati.

Perché questo modello domina nella pratica: risolve il fallimento del "troppe cose contemporaneamente" del lavoro a contesto singolo. Ogni sotto-agente vede solo il suo pezzo. L'orchestratore non viene mai distratto da 50 dettagli non correlati.

Ogni passaggio beneficia della propria finestra pulita in modo che non si contaminino a vicenda.

Usalo quando:

• Hai una lista chiaramente enumerabile di elementi di lavoro (50 file, 200 endpoint, 100 revisioni).
• Ogni elemento è indipendente - nessun elemento ha bisogno dell'output di un altro per iniziare.
• Vuoi un'unica risposta consolidata alla fine, non un mucchio di rapporti parziali.

1// Diramazione: un agente per file. Barriera: attendi tutti.
2const reviews = await parallel(
3  files.map(file => () => agent(
4    `Revisiona ${file} per problemi di sicurezza`,
5    { model: "haiku", schema: IssueList }
6  ))
7)
8
9// Sintesi: un agente Opus unisce tutto.
10const report = await agent(
11  `Unisci queste revisioni in un unico rapporto prioritario:\n${JSON.stringify(reviews)}`,
12  { model: "opus" }
13)

07. Verifica avversaria

Questa è la soluzione strutturale per il bias di auto-preferenza. Per ogni agente generato, esegui un agente generato separato che verifichi avversariamente il suo output rispetto a una rubrica. Il verificatore non ha mai visto il lavoro originale; non può favorirlo.

Il modello è più importante per:

• Verifica delle affermazioni - ogni affermazione fattuale in un rapporto ottiene il proprio sotto-agente verificatore, che controlla rispetto alla fonte originale.
• Revisione del codice - l'agente autore scrive la correzione, l'agente revisore (contesto separato) la revisiona. Mai lo stesso Claude che giudica se stesso.
• Controlli di qualità - prima che qualsiasi artefatto venga rilasciato, un avversario cerca di trovare il caso più debole contro di esso. Se l'avversario non ci riesce, rilasci.

La regola dell'abbinamento: il verificatore dovrebbe conoscere solo la rubrica e l'artefatto, non chi lo ha prodotto. Altrimenti l'auto-preferenza si insinua di nuovo attraverso indizi nel prompt.

08. Genera e filtra.

Genera un numero di idee su un argomento, poi filtralo in base a una rubrica o a una verifica. Deduplica i duplicati. Restituisci solo le idee di altissima qualità e testate.

Dove questo modello brilla:

• Brainstorming - 30 nomi di prodotto, poi un verificatore elimina cliché, conflitti di marchio e fonetica debole. Ne vedi 3.
• Generazione di ipotesi - 5 approcci diversi a un problema, poi ognuno viene valutato in base ai tuoi vincoli. Il vincitore se lo è guadagnato.
• Progettazione di soluzioni - 5 approcci diversi a un problema, poi ognuno viene valutato in base ai tuoi vincoli. Il vincitore se lo è guadagnato.

L'opposto di chiedere a Claude "la risposta migliore". Chiedere la risposta migliore fa sì che Claude si impegni presto. Genera e filtra fa sì che Claude si impegni tardi, dopo che ogni opzione è stata messa in discussione.

09. Torneo. Il confronto a coppie batte la valutazione assoluta.

Invece di dividere il lavoro, fai competere gli agenti su di esso. Genera N agenti che tentano ciascuno lo stesso compito usando approcci diversi, poi giudica i risultati in modo a coppie finché uno non vince.

Il giudizio comparativo è più affidabile della valutazione assoluta - specialmente per il lavoro basato sul gusto.

Perché questo batte l'ordinamento per punteggio: cercare di ordinare 1.000 elementi in un unico prompt fallisce su due fronti - la qualità degrada e non entrerà nel contesto. Un torneo divide la parentesi tra agenti nuovi, ognuno confrontando solo due elementi.

La parentesi stessa vive in codice di ciclo deterministico, non nel contesto. Ogni confronto è veloce, equo e isolato. La stessa idea funziona per la classificazione basata sul gusto: scelte di design, selezione di candidati, priorità dei contenuti.

10. Cicla fino al completamento.

Per compiti con una quantità di lavoro sconosciuta, cicla la generazione di agenti finché non viene soddisfatta una condizione di arresto - nessun nuovo risultato, nessun altro errore nei log, teoria verificata - invece di eseguire un numero fisso di passaggi.

Questo modello è la risposta a "continua finché non è effettivamente finito":

• Debug di test instabili - riproduci, formula teorie, testale, finché una teoria non regge.
• Caccia ai bug - continua a trovare bug finché un passaggio completo non ne restituisce zero.
• Estrazione di modelli - raggruppa, identifica regole, finché non appaiono nuovi cluster.

Combina questo modello con /goal per impostare un requisito di completamento rigoroso ("non fermarti finché una teoria non funziona") e con /loop se vuoi che l'intero flusso di lavoro stesso venga eseguito secondo una pianificazione ricorrente.

La parentesi e la condizione di arresto vivono nel codice; solo l'iterazione attiva rimane nel contesto.

11. Combina modelli per casi d'uso reali. Un flusso di lavoro, diversi modelli.

I 6 modelli raramente appaiono da soli. Un flusso di lavoro reale combina 2-4 di essi. La matrice qui sotto abbina ogni caso d'uso dai documenti di lancio di Anthropic con i modelli che tende a utilizzare:

• Migrazioni e refactoring. Diramazione (un agente per callsite/test fallito in un worktree) → verifica avversaria (un agente separato revisiona ogni correzione) → ciclo fino al completamento. Questo è il modello che Anthropic ha usato per riscrivere Bun da Zig a Rust.
• Ricerca approfondita (la skill /deep-research). Diramazione (ricerche web parallele) → verifica avversaria (ogni affermazione verificata indipendentemente) → sintesi (un rapporto citato).
• Verifica approfondita di una bozza. Identifica tutte le affermazioni fattuali (un agente) → diramazione (un verificatore per affermazione, ogni agente controlla rispetto alla fonte) → meta-verificatore (controlla che le fonti del verificatore siano di alta qualità).
• Ordinamento di 1.000+ elementi. Torneo (passaggi 5-9) - confronto a coppie, classificazione a bucket o parentesi. Giudizio comparativo, mai valutazione assoluta.
• Memoria e aderenza alle regole. Verificatore per regola (diramazione) → una persona scettica revisiona le regole stesse per evitare falsi positivi.
• Indagine sulle cause profonde. Genera teorie da prove disgiunte (diversi agenti leggono log, file, dati) → pannello di verificatori e confutatori per ogni teoria → ciclo finché una non sopravvive.
• Triage su larga scala. Classifica e agisci → deduplica rispetto ai ticket esistenti → tenta la correzione o scala. Combina con /loop per triage continuo.
• Esplorazione e gusto (design, naming, scelte UI). Genera e filtra (5-20 opzioni) → torneo con una rubrica → classifica o scegli.
• Valutazioni leggere. Esegui il candidato in un worktree → agenti di confronto valutano rispetto alla rubrica → perfeziona e rivaluta. Stessa forma di un torneo ma per la valutazione, non per la classifica.

Il modo giusto per interiorizzarli: identifica quale modalità di fallimento sta colpendo il tuo compito attuale, poi scegli il modello che la previene strutturalmente.

Deriva → diramazione. Auto-preferenza → verifica avversaria. Aperto → ciclo fino al completamento. Difficile da valutare → torneo.

12. Combina con /goal, /loop e budget di token.

I flussi di lavoro possono essere costosi. Tre controlli li trasformano da "belli ma costosi" in "uno strumento che eseguo senza supervisione".

• /goal imposta un requisito di completamento rigoroso. Combinalo con il modello di ciclo: "non fermarti finché una teoria non funziona." Senza /goal, un flusso di lavoro si ferma a un punto di completamento morbido. Con /goal, itera finché la condizione finale effettiva non viene soddisfatta.
• /loop esegue l'intero flusso di lavoro secondo una pianificazione ricorrente. Usalo per flussi di lavoro che vuoi in esecuzione continua - triage, aggiornamenti di ricerca settimanali, verifica ricorrente.
• Budget di token espliciti. Dì a Claude nel prompt: "usa 10k token." Questo imposta un limite per l'esecuzione del flusso di lavoro. Senza un limite, un flusso di lavoro ambizioso può gonfiarsi fino a 5-10× i token che ti aspettavi.

1> ultracode revisione avversaria rapida di questa ipotesi:
2  "passare a Postgres elimina il nostro ribilanciamento degli shard."
3  Usa 5k token. /goal non fermarti finché non hai
4  un controesempio o tre conferme indipendenti.

Citando direttamente il team di Claude Code: "Le migliori pratiche sono ancora in fase di sviluppo. I flussi di lavoro dinamici spesso usano più token, quindi pensa attentamente a quando e come usarli." La maggior parte dei compiti di codifica tradizionali non ha bisogno di un pannello di 5 revisori.

Chiediti: questo compito ha davvero bisogno di più potenza di calcolo? Se una normale sessione di Claude Code lo finirebbe in cinque minuti, non hai bisogno di un flusso di lavoro.

13. Usa il modello di quarantena per input non fidati.

Qualsiasi flusso di lavoro che legge contenuti pubblici non fidati - ticket di supporto, segnalazioni di bug, feedback degli utenti, dati raschiati - deve presumere che quei contenuti possano contenere iniezioni di prompt.

La soluzione: quarantena. Impedisci agli agenti che leggono i contenuti non fidati di intraprendere qualsiasi azione ad alto privilegio. Agenti separati, senza esposizione ai contenuti grezzi, eseguono le azioni.

Qualsiasi flusso di lavoro che elabora contenuti inviati dagli utenti (ticket di supporto, segnalazioni di bug, feedback dei clienti, social media), raschia pagine web pubbliche o viene eseguito su output di un'API di terze parti.

Se l'input non è stato scritto da te o da un compagno di squadra fidato, mettilo in quarantena. Un agente lettore di sola lettura di 30 righe costa quasi nulla e rimuove un'intera classe di rischio di iniezione di prompt.

14. Salva i flussi di lavoro. Rilasciali come Skill.

Una volta che un flusso di lavoro funziona, salvalo: premi s nel menu del flusso di lavoro. I flussi di lavoro salvati vanno in ~/.claude/workflows. Da lì hai due percorsi:

• Tienilo in locale - riutilizzalo nei tuoi progetti.
• Rilascialo come Skill - impacchetta il file JavaScript all'interno di una cartella Skill, referenzialo in SKILL.md, e chiunque installi la Skill esegue lo stesso flusso di lavoro.

Una sfumatura pratica che vale la pena conoscere: quando impacchetti un flusso di lavoro in una Skill, chiedi a Claude di trattare il flusso di lavoro come un modello, non come uno script da eseguire alla lettera.

Questo lascia spazio a Claude per adattare la forma del flusso di lavoro al compito specifico da svolgere mantenendo intatta la struttura generale. Particolarmente utile per flussi di lavoro come "verifica approfondita" o "triage" che devono flettersi per caso d'uso.

Gli errori che sprecano token sui flussi di lavoro

• Ricorrere a un flusso di lavoro quando una normale sessione di Claude Code basterebbe. La maggior parte dei compiti di codifica tradizionali non ha bisogno di un pannello di 5 revisori.
• Nessun budget di token. I flussi di lavoro ambiziosi si gonfiano fino a 5-10× quanto ti aspettavi senza un limite esplicito.
• Un agente che fa sia il lavoro che la verifica. Il bias di auto-preferenza fa sì che il verificatore favorisca il lavoratore. Devono essere separati.
• Trattare parallel() e pipeline() come intercambiabili. La barriera è importante - parallel attende tutti, pipeline è in streaming.
• Saltare /goal sui modelli di ciclo. Il flusso di lavoro si ferma presto al primo punto di completamento morbido. /goal forza il completamento rigoroso.
• Lasciare che i contenuti non fidati raggiungano l'attore. La quarantena non è facoltativa una volta che elabori qualsiasi cosa inviata dall'utente.
• Ordinare con punteggi assoluti. Il giudizio comparativo è più affidabile. Usa un torneo.
• Non salvare mai i flussi di lavoro funzionanti. Richiedere la stessa forma ogni settimana. Salva con s, rilascia come Skill.

Conclusione:

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