Finora abbiamo considerato lo scenario ideale: Lei scrive codice, crea commit e apre un Pull Request. Nella pratica, però, spesso qualcosa va storto: dimentica di aggiungere un file, fa un refuso nel messaggio del commit o si accorge di aver preso la direzione sbagliata. In questo articolo vediamo come risolvere i problemi più comuni con gli strumenti dell'IDE.
Gli esempi e le schermate si riferiscono agli 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.
Quando Claude Code lavora a un progetto, la cronologia salvata aiuta a recuperare un risultato precedente. Ma Git non registra ogni pressione di tasto: le modifiche non ancora incluse in un commit possono andare perse. Prima di annullare, controlli il branch, i file selezionati e che esista davvero una copia del lavoro che le serve.
Rollback - annullare le modifiche locali
Scenario: ha modificato un file, ma si è accorto che tutte le modifiche sono sbagliate e vuole riportarlo rapidamente allo stato dell'ultimo commit.

Usi l'azione Rollback:
- apra la scheda
Commitnel pannello a sinistra; - nell'elenco individui il file modificato da annullare (oppure ne selezioni più di uno);
- faccia clic con il tasto destro e scelga
Rollback(oppure prema l'icona con la freccia curva).
L'IDE avviserà che le modifiche locali selezionate andranno perse. Prima esamini il diff e salvi ciò che le serve. Confermi Rollback solo per le modifiche che vuole davvero scartare, poi controlli il risultato. Rollback elimina il lavoro non incluso in un commit, non ne crea una copia di sicurezza.
Prima di usare Rollback, separi le modifiche dell'agente da quelle precedenti nello stesso file. Rollback riporta i file selezionati allo stato dell'ultimo commit (HEAD) e scarta sia le modifiche aggiunte all'indice sia quelle non aggiunte. Non è la stessa cosa di git restore senza flag: quest'ultimo prende il contenuto dall'indice e modifica solo i file di lavoro.
Amend - completare l'ultimo commit
Scenario: ha appena premuto Commit e si è subito accorto di aver dimenticato un file importante (per esempio un test aggiornato) o di aver fatto un refuso nel messaggio. Se il commit non è ancora stato condiviso, può usare Amend. Va bene anche creare un commit separato con la correzione, soprattutto se la cronologia è già condivisa.

Per completare un commit non ancora condiviso, usi l'azione Amend (aggiungere o correggere):
- nella finestra
Commit, corregga il file dimenticato e selezioni la casella accanto; - nel pannello Commit Message individui la casella Amend (oppure l'icona a forma di ingranaggio -> Amend Commit) e la selezioni;
- l'IDE caricherà il messaggio del commit precedente, che potrà modificare;
- prema
Commit.
Amend crea un nuovo commit che sostituisce il precedente e ha un identificatore diverso. L'oggetto precedente non viene modificato sul posto. Se il commit è già stato inviato e altre persone lo usano, di solito è meglio creare una correzione separata.
Per saperne di più, consulti il tutorial ufficiale di JetBrains.
Undo Commit
Scenario: ha creato un commit, ma non lo ha ancora inviato con Push e si è accorto di aver agito troppo in fretta. Vuole rimuovere il commit dalla cronologia, mantenendo però le modifiche nell'editor per continuare a lavorare.
Usi l'azione Undo Commit:
- apra la cronologia: la scheda
Git -> Login basso; - individui l'ultimo commit del branch corrente (HEAD), non semplicemente la prima riga del grafo complessivo, e apra il menu contestuale;
- scelga
Undo Commit.

Scelga l'elenco delle modifiche (di solito Default Changelist) e prema OK. Il commit scomparirà dalla cronologia e i file torneranno nella finestra Commit con lo stato di file modificati. Non ha perso nulla e può continuare a scrivere codice con tranquillità.
Reset - spostare il branch e gestire lo stato dei file
L'azione Reset Current Branch to Here... è uno strumento potente che sposta il puntatore del branch su un commit a scelta. A seconda della situazione, può annullare con delicatezza gli ultimi passaggi oppure cancellare in modo drastico il codice che non funziona.
Scenario A - annullare gli ultimi commit locali
Ha creato diversi commit in locale (prima di Push) e si è accorto che tutto quel percorso di sviluppo era sbagliato.
- apra la scheda
Git -> Log; - individui l'ultimo commit valido su cui vuole tornare, quello precedente alla serie di commit sbagliati;
- faccia clic con il tasto destro e scelga
Reset Current Branch to Here....
Scenario B - ripristinare lo stato del server
Vuole ripristinare i file tracciati in base al branch remoto. Prima salvi il lavoro locale che le serve ed esegua Fetch: l'etichetta origin/main riflette l'ultimo stato ricevuto, non uno stato del server aggiornato in tempo reale. Se è in corso un'operazione con conflitti, prima li risolva e completi o annulli l'operazione; non usi Hard come rimedio universale.
- apra
Git -> Log; - individui il riferimento al branch remoto, di solito un commit con l'etichetta viola
origin/main(oorigin/nome_del_suo_branch). È l'ultimo stato noto del codice sul server; - faccia clic con il tasto destro su quel commit e scelga
Reset Current Branch to Here....

Modalità di reset
Nella finestra di reset scelga con attenzione la modalità. In tutti e tre i casi il branch corrente si sposta sul commit selezionato, ma l'indice e i file di lavoro vengono trattati in modo diverso:
- Soft conserva i file di lavoro e l'indice. Mixed conserva i file di lavoro, ma riporta l'indice al commit selezionato: le differenze restano fuori dallo staging. Sono modalità diverse, anche se entrambe consentono di continuare a lavorare sul contenuto dei file;
- Hard porta l'indice e i file tracciati allo stato del commit selezionato, cancellando le modifiche non ancora incluse in un commit. I normali file untracked estranei possono restare, mentre i percorsi che impediscono il ripristino possono essere eliminati. I commit non spariscono subito da ogni archivio, ma non conti di poter recuperare il lavoro in seguito.
Cosa fare dopo un push
Scenario: ha eseguito push e solo dopo si è accorto dell'errore.
Quando un commit arriva sul server, diventa parte della cronologia condivisa del progetto. Provare a riscriverla (con Reset o Amend) può creare grossi problemi ai colleghi: immagini che abbiano già scaricato le sue modifiche e iniziato a lavorarci sopra.
La soluzione corretta e sicura: crei semplicemente un nuovo commit che corregga l'errore e lo invii con un normale push. È una pratica comune. Una cronologia lineare, in cui al codice errato segue un commit di correzione chiaro, rende trasparente l'evoluzione del progetto per tutto il team.
Nell'IDE c'è anche l'azione specifica Revert Commit. Facendo clic con il tasto destro sul commit errato nel log Git -> Log e scegliendo Revert Commit, l'IDE crea un nuovo "anti-commit" che fa esattamente l'opposto di quello errato (per esempio, rimuove le righe aggiunte).

Revert è utile quando vuole annullare una modifica pubblicata creando un nuovo commit. Si applica sia al codice sia al testo, ma può entrare in conflitto con modifiche successive. Dopo aver risolto il conflitto, controlli il risultato; se le dipendenze sono complesse, a volte è più chiaro creare una correzione separata.
Stash / Shelve - mettere temporaneamente da parte le modifiche
Scenario: sta lavorando intensamente a una nuova feature e tutti i file sono rossi e blu. All'improvviso arriva il team lead: "lasci perdere tutto, c'è da correggere subito un bug nel branch main". Non può passare a main perché ha modifiche incomplete in conflitto. Un commit locale intermedio è possibile se le regole del progetto lo consentono, ma se in quel momento preferisce non registrare il lavoro, può metterlo da parte.
La soluzione è riporre temporaneamente il lavoro in una scatola virtuale. In Git si chiama Stash, mentre l'IDE offre un meccanismo distinto: Shelve (mettere sullo scaffale).
- apra la finestra
Commite selezioni i file modificati; - scelga Shelve Changes...; questi passaggi riguardano Shelve, mentre Git Stash si esegue separatamente;
- assegni un nome chiaro a questa voce e prema Shelve.

Dopo Shelve controlli i file rimasti: tutte le modifiche necessarie sono state davvero messe da parte? Ora può passare a main, correggere il bug e salvare il risultato secondo le regole del progetto. Poi torni al branch di lavoro, apra Shelf e scelga Unshelve.
Per Git Stash usi l'elenco stash separato e ripristini la voce che le serve. È un archivio diverso. Uno stash normale non include i nuovi file untracked senza un'opzione aggiuntiva; prima di cambiare branch controlli che tutto il lavoro necessario sia al sicuro. Il ripristino può generare conflitti, quindi controlli di nuovo i file al termine.
Usare il log in modo avanzato
La finestra Git -> Log non è solo un elenco di commit: è uno strumento efficace per ricostruire cosa è successo.
- Hash del commit - una sequenza di lettere e numeri, per esempio
a1b2c3d. È l'identificatore univoco di ogni snapshot del codice.![Hash del commit nel log]()
- può filtrare la cronologia per branch, autore, data o parola nel messaggio del commit: così trova rapidamente chi ha lavorato su una parte specifica e quando;
- per trovare il commit in cui è stata aggiunta o rimossa una determinata riga di codice, nella finestra
Logpuò cercare non solo nei messaggi, ma anche nel contenuto delle modifiche; - faccia clic con il tasto destro nel margine dell'editor (dove compaiono i numeri di riga) e scelga
Annotate with Git Blame: l'IDE mostrerà accanto a ogni riga chi l'ha modificata per ultimo e in quale commit. Poi apra il commit e la discussione collegata: Blame indica l'ultima modifica alla riga, ma non ne spiega il motivo.
Zona di rischio - Force Push
Abbiamo visto che modificare commit già inviati è una cattiva idea. Ma se ha comunque cambiato la cronologia locale (per esempio con Undo Commit o Amend) e sul server è ancora presente la versione precedente? Con un normale push, Git restituirà un errore per proteggere la cronologia condivisa dalla sovrascrittura.
Force push consente di sostituire il riferimento remoto selezionato anche quando la nuova cronologia non prosegue quella precedente. Non cancella l'intero server: le conseguenze dipendono dai riferimenti inviati. La protezione del branch può impedire questo tipo di invio.
Force push può rimuovere dal branch remoto commit che non esistono nella cronologia locale. Per questo, riscrivere un branch condiviso richiede una decisione specifica e concordata dal team. Per una correzione normale, usi un nuovo commit o Revert.
Un caso tipico da discutere è il force push sul proprio branch dopo averne riscritto la cronologia con l'accordo del team. Anche in questo caso, controlli che non ci siano nuovi commit di altri. L'opzione --force-with-lease verifica lo stato atteso del branch remoto, ma non elimina la necessità di capire quali commit verranno sostituiti.
Nella schermata, Force Push si trova nel menu a discesa del pulsante Push. Prima di usarlo, controlli quale modalità di invio forzato applica la versione del suo IDE.

Se non è sicuro al 100% di ciò che sta facendo, non usi force push. È più sicuro creare un nuovo commit con le correzioni (oppure usare Revert).
La regola vale sia per lei sia per Claude Code: riscrivere la cronologia condivisa è rischioso. Non consideri il force push una pratica normale e non lasci che venga eseguito sui branch condivisi. Se Claude propone un'azione che riscriverebbe la cronologia sul server, si fermi e verifichi se esiste un'alternativa sicura (un nuovo commit o Revert).
Aggiornare il progetto
Prima di iniziare una nuova attività, controlli il branch di partenza e le modifiche ancora in corso. Recuperi gli aggiornamenti quando serve e legga il risultato dell'integrazione. Update Project non garantisce che non ci siano conflitti e, in base alle impostazioni, può usare merge o rebase.
Dopo l'aggiornamento, controlli il branch corrente, l'elenco dei commit e lo stato dei file. Se sono comparsi conflitti, li risolva prima di continuare.
Menu contestuale di Git Log
Quando apre la scheda Git -> Log e fa clic con il tasto destro su un commit qualsiasi, compare un menu contestuale piuttosto ampio. Vediamo i comandi più utili, raggruppati per attività.

Gruppo 1 - consultazione e analisi (azioni sicure)
Copy Revision Number- copia l'hash univoco del commit negli appunti. È utile per inviare a un collega il riferimento al commit o citarlo in un ticket (Jira, YouTrack);Compare with Local- confronta il file nel vecchio commit con quello che ha ora nell'editor. Un ottimo modo per vedere com'era il codice un mese fa;Show Repository at Revision- apre la struttura di tutti i file del progetto nello stato in cui si trovavano al momento del commit (il branch corrente non cambia).
Gruppo 2 - lavorare con i branch
New Branch...- crea un nuovo branch direttamente dal commit passato selezionato. È utile se è andato molto avanti, si è accorto di aver rotto tutto e vuole ripartire dall'ultimo punto funzionante;Checkout Revision- porta il progetto locale a questo commit. Si troverà nello stato detached HEAD: può avviare il vecchio codice, ma i nuovi commit non saranno collegati a un branch. Se ha creato commit da conservare in detached HEAD, prima li salvi creando un branch. Per tornare indietro, faccia Checkout di un branch normale (per esempio,main).
Gruppo 3 - modificare e trasferire
Cherry-Pick- permette di prendere un commit specifico da un altro branch e copiarlo in quello corrente. Per esempio, in un altro branch qualcuno ha corretto un bug che le blocca il lavoro: può fare Cherry-Pick di quel commit senza integrare tutto il branch altrui;Edit Commit Message...- se il commit non è ancora stato inviato (non è stato eseguito Push), può modificarne rapidamente il messaggio. È più comodo di Amend se vuole cambiare solo il testo.
Gruppo 4 - annullare le modifiche
Abbiamo già visto in dettaglio questi comandi:
Reset Current Branch to Here...- sposta il branch corrente su questo commit, modificando la cronologia raggiungibile da quel branch;Revert Commit- crea un "anti-commit" che annulla il contenuto modificato con un nuovo commit locale, da inviare poi al server;Undo Commit...- rimuove un commit locale e ne riporta le modifiche nella finestra delle modifiche.
Gruppo 5 - riscrivere la cronologia
Nel menu ci sono anche comandi come Squash Commits... (unire più commit in uno), Drop Commits (rimuovere un commit dalla parte centrale della cronologia) o Interactively Rebase from Here.... Sono strumenti per intervenire con precisione sulla cronologia locale (Interactive Rebase).
Finché prende confidenza con Git, cerchi di non usare questi comandi: possono riscrivere i commit selezionati e la parte successiva della cronologia del branch. Nei team si usano per riordinare un branch locale ancora provvisorio prima di sottoporlo a revisione (aprire un Pull Request).
Git - la sua rete di sicurezza
Scelga come recuperare in base allo stato del lavoro: file senza commit, commit locali e cronologia condivisa richiedono azioni diverse. Salvare la versione che le serve e controllare le modifiche prima di intervenire è più utile che sperare di poter annullare qualsiasi errore.
Come funziona insieme a Claude Code
Quando Claude Code lavora a un progetto, questi strumenti sono la sua protezione principale. Ecco come usarli:
- crei commit di frequente: ognuno è un punto a cui tornare. Se l'agente prende la direzione sbagliata, può tornare all'ultimo stato funzionante;
- per annullare modifiche non ancora incluse in un commit, separi prima quelle da conservare, poi controlli l'ambito e la fonte del ripristino in Rollback o git restore;
- se il commit è stato creato ma non inviato,
Undo Commitriporterà le modifiche nell'editor; - se l'errore è già sul server, è più sicuro creare un nuovo commit di correzione o usare
Revert, invece di riscrivere la cronologia.
Non accetti alla cieca azioni che eliminano dati o riscrivono la cronologia (Reset hard, force push). Verifichi prima che cosa sta per fare Claude Code. Prima di un'attività importante, salvi lo stato che le serve e controlli che il punto di ripristino contenga davvero il suo lavoro.
Articolo precedente: Pull request: dalla creazione al merge · Articolo successivo: Creare un repository, rebase e segreti

GO TO FULL VERSION