Come far lavorare Claude Code in parallelo: la guida completa

Di solito si usa Claude Code in una conversazione sola: tu chiedi, lui fa, una cosa alla volta. Per gran parte del lavoro va benissimo. Quando però il compito diventa grande, ripetitivo o fatto di pezzi indipendenti, conviene mettere più "lavoratori" Claude a girare insieme, invece di stare lì ad aspettare che ne finisca uno per partire col prossimo.

Claude Code offre quattro modi per farlo, più due strumenti di supporto. Si assomigliano, ma servono a cose diverse, e scegliere quello sbagliato si paga in tempo e in token. Questa guida li affronta uno per uno: cosa sono, quando si usano, come si fa in pratica con i comandi giusti, e gli errori in cui è facile cadere.

La domanda da cui parte tutto è una sola: chi tiene in mano il piano del lavoro? Lo tieni tu, lo tiene Claude dentro la conversazione, lo tiene un capo-agente che dirige dei colleghi, oppure lo tiene uno script. Da qui discende lo strumento giusto.

Strumento	Chi coordina	Quando
Sub-agenti	Claude, nella tua chat	un compito secondario riempirebbe la conversazione
Agent view	tu	più lavori indipendenti che affidi e ricontrolli
Agent teams	un capo-agente	un problema che si esplora meglio in gruppo
Workflow	uno script	un lavoro enorme o da verificare a fondo
Worktree	(supporto)	isolare i file quando più sessioni lavorano insieme
/batch	(supporto)	la stessa modifica su tanti punti, una PR ciascuno

1. Sub-agenti: delegare un pezzo dentro la stessa conversazione

Un sub-agente è un lavoratore che Claude lancia dentro la sessione in cui sei. Fa il suo compito in una finestra di contesto separata e ti riporta solo il risultato.

Quando usarlo: quando un'attività secondaria riempirebbe la tua conversazione di roba che non riguarderai più, come una ricerca lunga, log, il contenuto di tanti file. Il sub-agente fa quel lavoro per conto suo e ti restituisce il riassunto, così la chat principale resta leggera. È utile anche per dare a un compito solo gli strumenti che servono, o per dirottarlo su un modello più economico come Haiku e tenere bassi i costi.

Come si fa: il comando /agents apre un pannello con due schede, una con i sub-agenti in esecuzione e una libreria dove crei e modifichi quelli personalizzati. Un sub-agente personalizzato è un file nella cartella .claude/agents/ del progetto (oppure ~/.claude/agents/ se lo vuoi in tutti i progetti). L'intestazione dice nome, descrizione, strumenti concessi e modello:

---
name: code-reviewer
description: Rivede il codice per qualità e best practice
tools: Read, Glob, Grep
model: sonnet
---
Sei un revisore di codice. Concentrati su leggibilità, bug e sicurezza.

La descrizione conta più di quanto sembri, perché Claude decide quando delegare proprio leggendo quella. Scrivila chiara.

Sugli strumenti hai mano libera. Puoi elencare solo quelli ammessi con tools, oppure partire da tutti e toglierne alcuni con disallowedTools:

---
name: no-writes
description: Eredita tutti gli strumenti tranne la scrittura sui file
disallowedTools: Write, Edit
---

Puoi persino limitare quali altri sub-agenti uno è autorizzato a lanciare, con Agent(worker, researcher). E un sub-agente può avere skill e server MCP dedicati, o partire isolato su una sua copia del codice aggiungendo isolation: worktree (le worktree le vediamo dopo).

Due varianti utili. Il sub-agente "forkato" non parte da zero ma eredita tutto il contesto della tua conversazione, comodo quando deve continuare un ragionamento già avviato. E per usarne uno al volo basta chiederlo a parole, per esempio "usa il sub-agente code-reviewer su questi file".

2. Agent view: lanciare sessioni in background e sorvegliarle

Agent view è una schermata sola, che apri con claude agents, da cui lanci sessioni che girano in sottofondo e ne controlli lo stato. Le righe sono raggruppate in "ne ha bisogno", "al lavoro" e "completate".

Quando usarlo: quando hai più compiti indipendenti, vuoi affidarli e tornare al tuo lavoro, dare un'occhiata allo stato a colpo d'occhio e intervenire solo quando una sessione si blocca o ha finito. Esempio tipico: affidi un bugfix, la revisione di una pull request e l'indagine su un test ballerino come tre righe, continui a lavorare in un'altra finestra, e torni quando una riga chiede di te.

Come si fa: lanci claude agents, scrivi un prompt nella casella in basso e premi Invio per far partire una sessione. Ogni prompt che scrivi qui avvia una sessione nuova, quindi puoi lanciarne diverse di fila. Da lì:

claude agents              apre la schermata
claude agents --cwd ~/app  mostra solo le sessioni di quel progetto

Sui comandi rapidi: con le frecce selezioni una riga, Spazio apre l'anteprima con l'ultimo output o la domanda in sospeso (puoi rispondere senza entrare), Invio o freccia destra ti attacca alla sessione completa, e freccia sinistra su una casella vuota ti stacca e ti riporta alla tabella. Una sessione che hai già aperto la mandi in background con /bg, e la rinomini con Ctrl+R.

Due cose importanti. Le sessioni in background girano anche se chiudi la schermata o il terminale, perché le tiene in piedi un processo separato. E ogni sessione affidata da qui viene messa in automatico in una sua worktree, quindi più sessioni non si toccano sui file. Attenzione però quando cancelli una riga: se Claude le aveva creato una worktree, cancellandola butti via anche quella e le modifiche non salvate dentro.

3. Agent teams: una squadra coordinata da un capo

Gli agent team sono più sessioni di Claude Code che lavorano insieme come una squadra. Una fa da capo, coordina, assegna i compiti e tira le fila; le altre lavorano in autonomia, ciascuna nel suo contesto, e possono parlarsi tra loro. È la differenza chiave con i sub-agenti, che invece riferiscono solo a chi li ha lanciati e non comunicano tra di loro.

Quando usarlo: quando il valore sta nell'esplorazione parallela e nel confronto. Una revisione di codice con tre punti di vista diversi, un bug affrontato con più ipotesi in competizione che si sfidano a vicenda, una funzione nuova divisa in pezzi indipendenti. Costa parecchi token in più di una sessione singola, quindi conviene solo quando i colleghi possono davvero lavorare in parallelo.

Come si fa: è una funzione sperimentale e spenta di default. Si attiva mettendo una variabile nelle impostazioni:

{
  "env": { "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1" }
}

Da lì basta descrivere a parole cosa vuoi e chi vuoi nella squadra:

Lancia tre colleghi per rivedere la PR 142: uno sulla sicurezza,
uno sulle prestazioni, uno sui test. Ognuno rivede e riporta.

Claude crea i colleghi, riempie una lista di compiti condivisa, li fa lavorare e sintetizza i risultati alla fine. Puoi parlare a ogni collega per nome (con le frecce lo selezioni nel pannello, Invio apre la sua sessione e gli scrivi), e per i lavori delicati puoi chiedere che presentino un piano da approvare prima di toccare il codice. Di default i colleghi girano tutti dentro il tuo terminale; se vuoi un riquadro per ciascuno serve tmux o iTerm2.

Quattro accortezze che fanno la differenza:

• I colleghi non ereditano la cronologia della tua conversazione, quindi metti i dettagli del compito direttamente nel prompt con cui li lanci.
• Tieni la squadra piccola: tre-cinque colleghi, con cinque-sei compiti a testa, di solito è il punto giusto. Tre concentrati rendono più di cinque sparsi.
• Spartisci i file, perché i colleghi non sono isolati in worktree tra loro: se due lavorano sullo stesso file, si sovrascrivono.
• Se il capo si mette a fare lui invece di delegare, diglielo: "aspetta che i colleghi finiscano prima di procedere".

Essendo sperimentale, ha dei limiti: dopo aver ripreso una sessione i colleghi in-process non tornano, e i token salgono in fretta. Per cominciare, le cose migliori sono la ricerca e le revisioni, che mostrano il valore del parallelo senza le complicazioni della scrittura simultanea.

4. Workflow dinamici: uno script che orchestra decine di agenti

Un workflow dinamico è uno script che mette in fila e coordina tanti sub-agenti, da poche unità a centinaia. Lo scrive Claude in base a quello che chiedi, e un motore lo esegue in sottofondo mentre la tua sessione resta libera. La differenza con gli altri modi è che qui il piano sta nel codice, non nel ragionamento turno per turno: il ciclo, le diramazioni e i risultati intermedi vivono nello script, e nella tua conversazione torna solo la risposta finale. Questo permette anche schemi di qualità veri, come far rivedere i risultati di un agente da un altro in modo critico prima di accettarli.

Quando usarlo: quando il lavoro supera quello che una conversazione riesce a coordinare, o quando vuoi i risultati verificati uno contro l'altro. Una caccia ai bug su tutto il codice, una migrazione da cinquecento file, una ricerca a fonti incrociate, un piano difficile buttato giù da più angolazioni prima di sceglierne uno.

Come si fa: il modo più veloce per vederlo è il workflow già pronto, a cui dai una domanda e che restituisce un report con le fonti verificate:

/deep-research Cosa è cambiato nel modello dei permessi di Node tra la v20 e la v22?

Per un tuo compito puoi chiederlo a parole ("usa un workflow per...") oppure mettere la parola ultracode nel messaggio, e Claude scrive lo script:

ultracode: controlla ogni endpoint sotto src/routes/ per controlli di autenticazione mancanti

Mentre gira, /workflows mostra le fasi, quanti agenti hanno finito e i token consumati, e ti fa entrare in ogni fase per vedere cosa ha trovato ciascun agente. Quando un workflow fa quello che volevi, lo salvi premendo s: finisce in .claude/workflows/ del progetto (condiviso con chi clona il repo) o in ~/.claude/workflows/ personale, e da lì diventa un comando tuo, /nome, che rilanci quando vuoi, anche passandogli dei dati in ingresso.

Da sapere: serve una versione recente di Claude Code e un piano a pagamento; il motore tiene un tetto di sedici agenti in parallelo e mille in tutto, così uno script impazzito non scappa di mano; e un workflow si può riprendere nella stessa sessione, con gli agenti già finiti che restituiscono il risultato in cache.

5. Worktree: una copia del codice per ogni sessione

La worktree non è un modo di lanciare agenti, è lo strumento che impedisce loro di pestarsi i piedi sui file. È una cartella di lavoro separata, con i suoi file e il suo ramo, che condivide la stessa storia del repository. Sessioni diverse in worktree diverse non si toccano: puoi avere Claude che costruisce una funzione in un terminale mentre in un altro sistema un bug.

Come si fa:

claude --worktree nome-funzione   crea una copia isolata e ci avvia Claude
claude -w bugfix-123              come sopra, in forma breve, in un altro terminale
claude --worktree "#1234"        parte da una pull request

La copia finisce sotto .claude/worktrees/ su un ramo dedicato. Se ometti il nome lo genera lui. Puoi anche chiedere a Claude di "lavorare in una worktree" durante la sessione. Siccome la copia è pulita, i file ignorati da git come .env non ci sono: per portarli dentro in automatico li elenchi in un file .worktreeinclude:

.env
.env.local
config/secrets.json

Un consiglio pratico: aggiungi .claude/worktrees/ al tuo .gitignore così le copie non compaiono come file da committare. La pulizia è automatica quando esci da una worktree senza modifiche; se hai cambiato qualcosa, Claude ti chiede se tenerla. Per gestirle a mano ci sono i comandi git di sempre, git worktree add, git worktree list, git worktree remove.

C'è infine /batch, una funzione pronta che prende una modifica grossa e la spezza in cinque-trenta sub-agenti isolati in worktree, ognuno dei quali apre una pull request. È un uso impacchettato di sub-agenti e worktree, comodo quando devi applicare la stessa modifica in tanti punti.

Come scegliere lo strumento giusto

Tre domande risolvono quasi sempre il dubbio.

Chi coordina? Se è Claude dentro una conversazione, sono i sub-agenti. Se sei tu che affidi e ricontrolli, è l'agent view. Se è un capo-agente che dirige dei colleghi, sono gli agent team. Se è uno script, sono i workflow.

I lavoratori devono parlarsi? I sub-agenti riferiscono solo a chi li ha lanciati, le sessioni dell'agent view rispondono solo a te, mentre i colleghi di un team condividono una lista di compiti e si scrivono tra loro.

Toccano gli stessi file? Se sì, isola il lavoro con le worktree, così non si sovrascrivono.

Come controllare cosa sta girando

Ogni modo ha il suo comando per vedere a che punto è il lavoro:

claude agents   tutte le sessioni in background (agent view)
/agents         i sub-agenti della sessione corrente
/tasks          tutto ciò che gira in sottofondo nella sessione
/workflows      i workflow, la fase e quanti agenti hanno finito

Una parola sui costi

Far girare più sessioni o più agenti insieme moltiplica il consumo di token, perché ogni lavoratore ha la sua finestra di contesto e spende per conto suo. Per ricerca, revisioni e funzioni nuove di solito ne vale la pena; per il lavoro di routine una sessione singola resta la più economica. Un modo prudente è provare prima su una fetta piccola, una cartella sola invece di tutto il repository, guardare i token mentre il lavoro va, e poi decidere se scalare.

Un esempio dall'inizio alla fine

Mettiamo una migrazione che tocca un centinaio di file. Si parte leggeri: un sub-agente che esplora il codice e ti riporta dove serve intervenire, senza intasare la chat di output. Capito il quadro, se la modifica è meccanica e ripetitiva la passi a un workflow, che la applica file per file e fa verificare i risultati a vicenda. Se invece i pezzi sono pochi ma indipendenti, li affidi come sessioni separate dall'agent view e torni quando una chiede di te. In tutti i casi, ogni lavoratore che mette mano ai file lo fa nella sua worktree, così non si calpestano. Alla fine raccogli, controlli e unisci.

La regola

Parti dalla cosa più leggera che risolve il problema e sali solo quando serve davvero. Un compito secondario dentro una chat è un sub-agente. Più lavori indipendenti che segui tu sono l'agent view. Un problema che si esplora meglio in gruppo è un team. Una cosa enorme o da verificare a fondo è un workflow. E ogni volta che più lavoratori toccano gli stessi file, le worktree tengono tutto separato. Scelto lo strumento giusto, il resto viene da sé.