I branch consentono di portare avanti in parallelo più linee di lavoro nello stesso progetto, senza intralciarsi. In questo articolo scoprirà che cosa sono e a che cosa servono; imparerà a crearli, a passare dall'uno all'altro, a unire le modifiche e a risolvere con calma i conflitti di merge usando gli strumenti dell'IDE. Sono le basi che Le servono per capire che cosa fa Claude Code quando lavora con il Suo repository in un branch separato.
Gli esempi e le schermate si riferiscono all'IDE JetBrains; i nomi e la posizione delle azioni possono variare a seconda della versione. Per gli esercizi usi un repository di prova separato. Nel progetto di lavoro, segua le regole previste per i branch, i commit e l'invio delle modifiche.
Che cosa sono i branch e a che cosa servono
Un branch dà un nome a una linea separata di commit. Crearlo non copia la cartella del progetto e non salva i file non ancora committati. In una normale directory di lavoro, quando cambia branch Git aggiorna i file in base al branch selezionato; le modifiche non completate possono seguirLa oppure impedire il cambio.
Dal branch principale main parte un nuovo branch feature/new-idea per una linea di sviluppo separata. Al termine del lavoro, le modifiche vengono unite di nuovo in main.
Immagini di voler rivedere a fondo una parte del progetto o fare un esperimento rischioso. Come farebbe senza Git? Probabilmente copierebbe l'intero progetto in una nuova cartella e lavorerebbe lì. Se il risultato Le piacesse, lo riporterebbe nella cartella principale. Altrimenti, basterebbe eliminare la copia.
L'analogia della copia aiuta a capire le diverse linee di lavoro, ma tecnicamente un branch è un puntatore a un commit. Vediamolo con l'esempio di un libro:
- ha un manoscritto completo (è il Suo branch principale
main); - vuole scrivere un finale alternativo (crea un nuovo branch, per esempio
feature/new-idea); - scrive il nuovo finale senza modificare il testo principale del manoscritto (lavora nel nuovo branch);
- se il nuovo finale Le piace di più, sostituisce quello vecchio (fa il merge dei branch -
merge); - può eliminare la vecchia bozza con il finale scartato (elimina il branch).
Chieda prima a Claude Code di mostrarLe il branch e le modifiche già presenti. Crei un branch separato solo se è previsto dalle regole del progetto. I commit salvati offrono un punto a cui tornare; eliminare il nome di un branch, da solo, non annulla le modifiche ai file né ripristina lo stato iniziale.
Creare un branch e lavorarci
Passaggio 1. Apra il menu di gestione dei branch.
Nella barra degli strumenti principale, accanto al nome del progetto, trova il widget che mostra il nome del branch corrente (per impostazione predefinita, main). Faccia clic e scelga + New Branch.

Passaggio 2. Dia un nome al nuovo branch.
È buona pratica dare ai branch un nome che descriva il lavoro da fare. Per esempio, feature/add-usage-examples.

Se durante la creazione seleziona Checkout branch, l'IDE passerà al nuovo branch. Prima di modificare i file, verifichi il nome nel widget.
Passaggio 3. Apporti le modifiche e crei un commit.
Aggiunga al README.md una sezione con esempi d'uso. Esamini le modifiche e crei un commit nel modo consueto: nella cronologia del nuovo branch comparirà uno snapshot salvato.

Quando Claude Code propone di creare un commit, fa proprio questo: salva le modifiche correnti come punto a cui tornare in seguito. Prima di accettare, legga il messaggio del commit: descrive che cosa cambia ed è facile da correggere.
Passare da un branch all'altro
Le modifiche con gli esempi d'uso sono al sicuro nel branch feature/add-usage-examples. Torniamo al branch principale main e vediamo che cosa contiene.
Passaggio 1. Faccia di nuovo clic sul widget con il nome del branch corrente, nell'angolo in alto a sinistra.
Passaggio 2. Nell'elenco Local o Recent scelga il branch main e nel sottomenu che appare faccia clic su Checkout.

Passaggio 3. Verifichi il risultato.
Dopo il cambio di branch, apra il file README.md. Vedrà che la sezione con gli esempi d'uso non c'è: è rimasta nell'altro branch. In questo modo può lavorare su nuove funzionalità senza toccare la versione stabile nel branch main.

Unire i branch
merge integra la cronologia del branch scelto in quello corrente. Se main non è avanzato da quando è stato creato il branch, è possibile un fast-forward: main si sposta su C3 senza un nuovo commit. Se le linee di sviluppo si sono separate, un merge normale crea un commit con due genitori.
Nel caso lineare illustrato, main può avanzare fino a C3. Anche il branch feature/add-usage-examples punta ancora a C3; non è necessario eliminarlo per completare il merge.
Ha terminato il lavoro nel branch feature/add-usage-examples e vuole integrare queste modifiche nel progetto principale.
Passaggio 1. Passi al branch di destinazione.
Si assicuri di trovarsi nel branch IN CUI vuole integrare le modifiche. In questo caso è main.
Passaggio 2. Esegua il merge.
Faccia di nuovo clic sul widget di gestione dei branch. Nell'elenco scelga il branch DA CUI vuole prendere le modifiche (feature/add-usage-examples) e nel sottomenu selezioni Merge 'feature/add-usage-examples' into 'main'.

Passaggio 3. Verifichi il risultato.
Ora nel file README.md del branch main trova la nuova sezione con gli esempi. Ha integrato correttamente il Suo lavoro nella versione principale del progetto.

Conflitti durante il merge
Si verifica un conflitto quando Git non riesce a integrare automaticamente le modifiche. Succede spesso quando le stesse righe sono state modificate in modo diverso; può capitare anche se un branch elimina un file e un altro lo modifica. La soluzione dipende dal risultato desiderato.
È qui che si rivelano utili gli strumenti integrati nel Suo IDE (CLion o IntelliJ IDEA). Risolvere i conflitti dal terminale non è il massimo; lo strumento di merge a tre vie (3-way merge) dell'IDE rende invece tutto più chiaro e semplice.
Entrambi i branch hanno ricevuto commit a partire dall'antenato comune C1. La divergenza della cronologia, da sola, non basta a provocare un conflitto: questo si presenta quando Git non riesce a combinare automaticamente le modifiche. Nell'esercizio seguente, testi diversi sostituiscono la stessa riga originale.
Simuliamo un conflitto:
- si assicuri di trovarsi nel branch
maine che nella finestra Commit non ci siano modifiche non committate né nuovi file; - crei un nuovo branch
feature/new-title, ma per ora non ci passi. Verifichi che la casella Checkout branch non sia selezionata; - ora, mentre si trova nel branch
main, modifichi la prima riga diREADME.mdin "My Awesome Project" e crei uncommit; - passi al branch
feature/new-title. Vedrà che la prima riga diREADME.mdè ancora quella vecchia: è lo stato del file al momento della creazione del branch. Modifichi la stessa riga in "My Super Project" e crei uncommit; - torni al branch
mained esegua il merge confeature/new-title.
A questo punto Git rileverà che le due cronologie hanno modifiche diverse nello stesso punto. Le mostrerà la finestra per risolvere il conflitto (Merge Conflicts).

Faccia clic sul pulsante Merge per aprire lo strumento di risoluzione dei conflitti. Qui trova:
- a sinistra (Your changes) - la versione del file dal branch corrente, quello in cui integra le modifiche (
main); - a destra (Changes from branch) - la versione del file dal branch che sta integrando;
- al centro (Result) - la versione finale del file, da comporre manualmente.

Può fare clic sulle frecce >> o << (oppure sulle crocette per annullare) per accettare per intero una delle due versioni. In alternativa, può scrivere il testo corretto direttamente nel pannello centrale.
Controlli il risultato nel pannello centrale e faccia clic su Apply o sul pulsante equivalente per concludere. Poi verifichi lo stato di Git: se il merge non è ancora stato registrato, crei un commit dall'IDE. Risolvere le righe in conflitto e completare il merge sono due passaggi distinti. Verifichi il comportamento del codice risultante.
Se si verifica un conflitto mentre lavora con Claude Code, non è un errore: Claude può fermarsi e chiederLe aiuto, oppure suggerire come separare le modifiche. Può risolverlo con lo stesso strumento di merge a tre vie dell'IDE usato per gli altri conflitti.
Perché a volte non si verifica un conflitto
Se nell'esercizio non compare alcun conflitto, controlli da quale commit è stato creato il secondo branch e verifichi che entrambe le parti abbiano davvero sostituito la stessa riga con testi diversi. Git riesce a integrare automaticamente anche modifiche compatibili in branch divergenti. Un'altra possibilità è una cronologia lineare, in cui può avvenire un fast-forward:
Esempio:
- ha un commit qualsiasi in
main(per esempio, C1); - crea un nuovo commit nel branch
maincon il testo "My Awesome Project". Il branchmainora punta al commit C2; - crea un branch
feature/new-titledalla posizione corrente dimain: anche il nuovo branch parte dal commit C2; - crea un commit in
feature/new-titlecon il testo "My Super Project". Il branch avanza e punta al commit C3; - torna in
main(che è ancora sul commit C2) e integrafeature/new-title.
Git rileva che il branch main è un antenato diretto di feature/new-title: nella cronologia di main non sono comparsi nuovi commit mentre lavorava nell'altro branch. Perciò sposta semplicemente in avanti il puntatore di main fino al commit C3, senza conflitti.
La cronologia di main prosegue in quella di feature/new-title senza divergenze. Git può quindi far avanzare main: non c'è conflitto.
Esaminare la cronologia delle modifiche
Per capire meglio che cosa succede nel progetto, è utile consultarne la cronologia.
Apra la finestra dello strumento Git (di solito è un'icona nella barra laterale sinistra o nella parte inferiore dell'IDE) e selezioni la scheda Log o Show Git Log nella barra dello strumento Git. Vedrà una rappresentazione grafica di tutti i branch e i commit. Potrà così seguire con chiarezza da quale branch ne è nato un altro e dove sono stati uniti.

Faccia clic su un commit per vedere quali modifiche contiene, chi l'ha creato e quando. È una vera macchina del tempo per il Suo codice.
Le modifiche di Claude Code entreranno in questa cronologia quando saranno registrate con normali commit. Nel Git Log le vedrà insieme alle Sue: può aprire qualsiasi commit e verificare che cosa è cambiato.
Come funziona con Claude Code
Ora che conosce i branch, sarà più facile capire che cosa fa Claude Code quando lavora con il Suo repository. Ecco quali operazioni può svolgere per Lei e che cosa conviene controllare:
- crea un branch separato, se previsto dall'incarico e dalle regole del progetto;
- propone un
commitnei momenti chiave: Lei legge il diff e decide se accettarlo o modificarlo; - aiuta a trovare il commit salvato che Le serve e a scegliere come tornare indietro, tenendo conto delle modifiche non committate;
- in caso di conflitto durante il merge, può chiederLe aiuto: si risolve con lo stesso strumento dell'IDE;
- sa preparare e commentare una pull request (PR, una proposta per integrare un branch in quello principale, per esempio tramite GitHub CLI).
Prima di accettare, controlli il diff, soprattutto se Claude propone di eliminare file o eseguire un merge. Così saprà sempre che cosa entrerà nella cronologia del progetto.
Articolo precedente: Il lavoro quotidiano con Git · Articolo successivo: Pull request: dalla creazione al merge
GO TO FULL VERSION