Sta lavorando con Claude Code a una guida di locale: la ricerca nell'elenco è a metà. Poi si accorge che nella versione salvata della pagina la didascalia sotto il titolo è sbagliata. Correggerla richiede due minuti, ma preferirebbe verificarla a parte, senza mescolarla alla ricerca ancora incompleta.

Vediamo come assegnare alla seconda attività una propria directory di lavoro nello stesso repository, aprire lì una sessione separata di Claude Code e salvare il risultato alla fine senza confondere le modifiche. Una seconda directory, da sola, non accelera il lavoro. Serve a una cosa precisa: tenere separate le due attività e i rispettivi file.

Quando una directory di lavoro non basta

Il progetto didattico locale-guide è una pagina web con un elenco di locale. Nella sua directory è in corso l'attività A: la ricerca, sul branch feature/search, con una modifica ancora incompleta:

git status --short
M app.js

Non può perdere questa modifica, ma è presto per considerarla un risultato pronto. E proprio ora arriva l'attività B, che non ha nulla a che fare con la ricerca: correggere la didascalia in index.html nella versione salvata in main.

La prima idea potrebbe essere aprire un secondo terminale e avviare un altro claude nella stessa directory. Le conversazioni sarebbero diverse, ma i file resterebbero gli stessi. Se entrambi gli agenti modificassero le stesse parti, le modifiche potrebbero sovrapporsi. Nel nostro semplice esempio la didascalia e la ricerca sono ancora in file diversi, ma entrambe le sessioni vedono lo stesso progetto incompleto. Anche cambiare branch richiede di gestire le modifiche correnti.

La soluzione è assegnare all'attività B uno spazio di lavoro proprio. Git consente di avere una directory di lavoro separata per lo stesso repository, un worktree; Claude Code offre il flag --worktree, che prepara quella directory e avvia subito una sessione al suo interno. Vediamo prima il meccanismo e poi il flag.

Un repository e tre directory di lavoro, ciascuna con il proprio branch: main, feature-a e feature-b
Un repository, più directory di lavoro, ciascuna con il proprio branch. I nomi nell'immagine sono arbitrari; nel nostro esempio ci sono due directory di lavoro e tre branch: main, feature/search e fix/label.

Una precisazione: questo non è il modo obbligatorio di lavorare su ogni attività. Se l'albero di lavoro è pulito e la modifica è breve, una seconda directory aggiunge solo complicazioni. Anche alternare le attività nella stessa directory va benissimo.

Branch, directory di lavoro e sessione

Ci sono tre elementi facili da confondere, perché spesso li si usa contemporaneamente:

Che cos'èChe cosa contieneDove si trova
branchun riferimento a un commit e alla linea della cronologianel repository, condiviso da tutte le directory di lavoro
directory di lavoro (worktree)i file su cui si lavora e ciò che è pronto per il commitsul disco, ogni directory ha i suoi
sessionela conversazione con l'agente e il relativo contestoin Claude Code

Ecco la risposta alla domanda sul secondo terminale: una nuova sessione separa la conversazione, non i file. Per separare i file serve una seconda directory di lavoro.

Un repository, due directory di lavoro, ciascuna con il proprio branch e la propria sessione di Claude CodeUn repositorylocale-guidebranchfeature/searchsessione di Claude Codeattività A, ricercabranchfix/labelsessione di Claude Codeattività B, didascaliaDirectory di lavorolocale-guideDirectory di lavorolocale-guide-labelLe modifiche non committate restano nella propria directory
La cronologia e l'elenco dei branch sono condivisi; file e sessioni restano separati

La cronologia e i branch sono condivisi: entrambe le directory sono collegate allo stesso repository. Per impostazione predefinita è condivisa anche la configurazione Git, sebbene Git supporti impostazioni distinte per worktree. I file di lavoro e le modifiche preparate per il commit, invece, sono separati per ogni directory. La ricerca non committata dalla prima directory non comparirà da sola nella seconda.

Di solito non è possibile aprire lo stesso branch contemporaneamente in due directory: Git rifiuterà l'operazione e indicherà la directory che lo sta già usando:

fatal: 'fix/label' is already used by worktree at '/projects/locale-guide-label'

Scegliere lo stato di partenza

Nel nostro esempio didattico, il repository è già stato creato e contiene almeno un commit, il branch locale main e il branch feature/search. Per ora puntano entrambi allo stesso commit, mentre la ricerca esiste solo come modifica non committata. Vediamo lo stato iniziale con tre comandi nella directory principale:

git status --short        # modifiche non salvate in questo momento
git branch --show-current # branch della directory principale
git log -1 --oneline main # ultimo commit su main
 M app.js
feature/search
d5ec405 add locale guide page

Per correggere la didascalia senza dipendere dalla ricerca, scegliamo main: all'attività B serve la versione salvata della pagina, non lo stato attuale della ricerca. Tenga presente che si tratta del branch main locale sul suo computer. Non è detto che coincida con il branch omonimo sul server, e il comando non scarica nulla dalla rete.

Se la seconda attività dipende dal risultato della prima, decida prima quale commit salvato le serve e crei la directory a partire da quello. Un semplice git worktree add non trasferisce automaticamente le modifiche non committate. Copiare file separatamente o preparare l'ambiente con altri strumenti sono operazioni distinte.

Creare una seconda directory di lavoro

Dalla directory locale-guide:

git worktree add -b fix/label ../locale-guide-label main

Si legge da sinistra a destra: crea il nuovo branch fix/label, colloca accanto la directory di lavoro al percorso ../locale-guide-label e usa main come punto di partenza. L'ultimo argomento rende esplicita la scelta della base. Senza di esso, con questo comando Git userebbe il commit corrente HEAD del branch feature/search, ma non le modifiche non committate. Nel nostro esempio i branch puntano ancora allo stesso commit, quindi i file sarebbero identici; dopo i commit della ricerca, la scelta della base influirà sul risultato. Git risponde più o meno così:

Preparing worktree (new branch 'fix/label')
HEAD is now at d5ec405 add locale guide page

Ora verifichiamo il risultato. Il flag -C dice a Git di eseguire il comando nella directory indicata, senza spostarsi lì:

git worktree list
git -C ../locale-guide-label branch --show-current
git -C ../locale-guide-label status --short

Un output di esempio con percorsi fittizi; nel suo caso saranno diversi:

/projects/locale-guide        d5ec405 [feature/search]
/projects/locale-guide-label  d5ec405 [fix/label]

fix/label

L'elenco mostra entrambe le directory e il branch associato a ciascuna. La principale è rimasta su feature/search con la ricerca incompleta; la nuova è su fix/label. Il comando status nella seconda directory non ha stampato nulla: è pulita, proprio come volevamo.

Se non è possibile usare il percorso o il nome del branch, Git rifiuterà l'operazione e spiegherà il motivo, per esempio already exists o is already used by worktree. Controlli l'elenco dei worktree, i branch e il contenuto della directory indicata. Potrebbe trattarsi di un tentativo precedente o di un'altra attività. Non aggiunga --force alla cieca: prima verifichi che cosa esiste già e se serve.

Aprire la seconda attività in Claude Code

Apra locale-guide-label in una finestra IDE separata oppure vi acceda da un nuovo terminale e avvii claude da lì. La nuova sessione non conosce l'attività A, ed è giusto così, le serve solo il proprio contesto:

Directory prevista: locale-guide-label, branch: fix/label.
Per prima cosa, verifica qual è la directory effettiva e quale branch è attivo. Se non corrispondono, fermati.
Leggi index.html.
Sostituisci la didascalia sotto il titolo con "Elenco di locale: codice, lingua e paese".
Non modificare altro nel file e mostrami la modifica.
Verifichi la directory prima di qualsiasi modifica

Chieda a Claude Code di indicare la directory di lavoro e il branch attivo prima che tocchi i file, poi confronti la risposta con ciò che si aspettava. Un agente avviato nella directory sbagliata lavora con la stessa sicurezza di uno avviato in quella giusta.

Dopo la modifica, controlli git status e git diff in entrambi i terminali: nella seconda directory è cambiata solo la didascalia in index.html, mentre nella prima è rimasta la modifica precedente a app.js. Un semplice status mostra i nomi dei file, ma non dimostra che il loro contenuto sia intatto. Per un confronto accurato, sospenda per un momento il lavoro sulla ricerca. Controlli la directory principale dal relativo terminale: non chieda all'agente della sessione isolata di spostarsi lì. Apra la pagina proprio dalla seconda directory, altrimenti vedrà la didascalia precedente.

C'è anche una scorciatoia. Il comando claude --worktree label-fix crea da solo una directory di lavoro e vi avvia una sessione. Secondo la documentazione attuale, la directory viene creata nel repository, in .claude/worktrees/label-fix/; il branch si chiama worktree-label-fix e la base è il branch predefinito del repository remoto (di solito main), non il commit corrente. Se il repository remoto non è configurato, la base sarà il commit locale corrente. Non è quindi la stessa cosa che indicare esplicitamente main nel comando precedente, anche se in un progetto semplice il risultato spesso coincide. L'impostazione predefinita si può modificare; verifichi i dettagli nella documentazione della sua versione.

Il flag è comodo quando la base predefinita le va bene e deve creare rapidamente uno spazio separato per l'attività. Non lo esegua sopra una directory già creata: ne verrà creata un'altra. Conviene anche aggiungere .claude/worktrees/ a .gitignore, altrimenti il contenuto delle nuove directory comparirà nella directory principale come file non tracciati.

Che cosa resta condiviso

Una directory separata isola meno di quanto sembri a prima vista:

SeparatoCondivisoNon isolato affatto
file di lavoro, modifiche preparate per il commit, branch corrente della directorycronologia, tutti i branch, impostazioni del repository, indirizzo del repository remotoporte del server locale, database esterno, servizi cloud, accesso del processo al resto del disco

La terza colonna è il punto che si dimentica più facilmente. Un worktree riguarda i file Git, non isola la macchina. Due server locali non possono usare la stessa porta e, se la configurazione punta a un database esterno, le richieste da entrambe le directory raggiungeranno lo stesso database. Anche i controlli che Claude Code esegue quando lavora in una directory separata non la trasformano in una sandbox per l'intero sistema.

La seconda directory riceve i file del commit scelto. Se le dipendenze e le impostazioni locali non sono salvate in Git, di solito l'ambiente va preparato a parte; altri strumenti possono automatizzare questa preparazione. Eviti di copiare .env alla cieca: credenziali identiche potrebbero indirizzare entrambe le sessioni allo stesso servizio. La nostra guida statica non ha bisogno né di un server né di segreti: la pagina si apre come file.

Salvare e trasferire il risultato

Nella directory B, controlli la didascalia nel browser, esamini git diff e registri solo il file necessario:

git add index.html
git diff --cached
git commit -m "fix: correct locale list label"

Prima del commit, si assicuri di aver preparato solo la modifica necessaria. Se git diff --cached mostra altre modifiche, prima verifichi di cosa si tratta.

Il commit è entrato nel repository condiviso ed è già visibile dalla directory principale. Ma non è finito né in main né in feature/search: si trova nel suo branch e aspetta che decida se unirlo.

Trasferisca il risultato solo quando l'attività A è terminata o almeno salvata e la directory principale è pulita. Non passi a main nel mezzo di una ricerca incompleta: prima la sistemi. Quando la directory principale è pulita:

git checkout main
git merge fix/label
Fast-forward
index.html | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)

Questo output corrisponde al caso in cui main non sia cambiato da quando è stato creato fix/label. Se Git segnala un conflitto, si fermi e lo risolva seguendo le regole di merge: è un argomento a parte, trattato nell'articolo "Branch e merge in Git". Dopo il merge, riapra la pagina: la didascalia dovrebbe essere quella nuova e l'elenco di locale dovrebbe essere rimasto invariato. Il branch feature/search non è stato aggiornato: prima di riprendere la ricerca, decida separatamente se trasferirvi la correzione da main.

Rimuovere una directory non più necessaria

Per prima cosa, chiuda la sessione nella seconda directory e tutto ciò che vi ha avviato. Poi controlli che non contenga più nulla di cui ha bisogno:

git -C ../locale-guide-label status --short --ignored

I file modificati e quelli nuovi sono visibili subito; il flag --ignored mostra quelli ignorati, che spesso contengono proprio impostazioni locali e note. Una volta verificato che il risultato è salvato nel branch giusto, la rimuova dalla directory principale:

git worktree remove ../locale-guide-label
git worktree list

Di solito, se ci sono file tracciati modificati o file nuovi non ignorati, Git rifiuta di rimuovere la directory:

fatal: '../locale-guide-label' contains modified or untracked files, use --force to delete it

Non esegua subito il comando suggerito dal messaggio. Controlli i file e salvi quelli che le servono. Dopo la rimozione, Git potrebbe non riuscire a recuperare i dati non committati. E non faccia affidamento sul rifiuto come protezione completa: i file ignorati possono essere eliminati anche senza --force, perciò li abbiamo controllati separatamente.

C'è un altro dettaglio facile da fraintendere. Il comando Git rimuove la directory di lavoro, ma non il branch: fix/label resterà nell'elenco di git branch. È comodo: il risultato non è sparito. Quando il branch non servirà più e tutto ciò che occorre sarà stato unito, lo elimini con un'operazione separata.

Il dialogo di Claude Code è un altro percorso

Quando esce da una sessione avviata con --worktree, Claude Code controlla la directory. Se non contiene modifiche né nuovi commit e la sessione non ha un nome, elimina da solo la directory e il branch, senza chiedere. Se invece c'è del lavoro, le chiede se vuole conservare o rimuovere la directory. Se in questo dialogo sceglie di eliminarla, vengono rimossi sia la directory sia il branch creato da Claude Code, insieme a tutto ciò che contengono. Non è la stessa cosa del comando Git qui sopra. Se le serve il risultato, scelga "conserva" e lo trasferisca manualmente.

Eviti di rimuovere la directory al di fuori di Git, per esempio da Esplora file: il repository continuerà a considerarla esistente e nell'elenco dei worktree resterà un riferimento a una directory che non c'è più.

Gestire una seconda attività in Claude Code

La procedura si riassume in sei passaggi:

  1. definisca la seconda attività separatamente dalla prima e scelga da quale stato salvato partire;
  2. crei una directory di lavoro indicando esplicitamente la base oppure avvii claude --worktree, se l'impostazione predefinita va bene;
  3. nella nuova directory, verifichi il percorso e il branch prima di modificare qualsiasi cosa;
  4. dia alla sessione solo il contesto di questa attività, senza la cronologia dell'altra;
  5. verifichi la modifica nella stessa directory in cui l'ha fatta e ne faccia il commit;
  6. decida come unire il lavoro e solo dopo rimuova la directory.

Una directory separata non verifica il codice e non accetta il lavoro al posto suo. Permette a ogni attività di avere i propri file di lavoro. Nel nostro esempio il vantaggio è concreto: la didascalia è stata corretta e verificata a parte, mentre la ricerca incompleta è rimasta nella prima directory.

Verifichi di aver capito

Nella seconda directory non c'è la ricerca non committata. Qualcosa è andato storto?
No, è proprio quello che volevamo. La directory è stata creata dal commit in main, non dai file correnti dell'attività A. Le modifiche non committate restano nella loro directory.

Due sessioni sono aperte nella stessa directory. Le attività sono separate?
Sono separate le conversazioni, ma i file sono condivisi. Le modifiche possono sovrapporsi se le attività toccano le stesse parti.

È stato creato un commit nel branch B, ma la didascalia non è in main.
È corretto: il commit si trova nel suo branch. Non modifica gli altri branch; per questo serve un merge.

Il secondo server locale non si avvia sulla stessa porta.
Le directory separate non isolano le porte. Avvii il server su un'altra porta.

Git ha rifiutato di rimuovere la directory di lavoro.
Legga il motivo del rifiuto: oltre ai file non salvati, la directory potrebbe essere bloccata o essere la directory di lavoro principale. Salvi ciò che serve e verifichi lo stato. Non aggiunga --force alla cieca.

Se vuole fare una prova pratica, usi un repository didattico separato con un paio di commit: crei due directory, modifichi il testo solo nella seconda, controlli entrambe e rimuova quella che non serve. Non occorrono servizi né account.