How do you undo changes in Git?

Question

IT Interview Practice · Accepted Answer

Git offers several ways to **undo changes** depending on the situation — discarding uncommitted changes, unstaging, amending the last commit, reverting a commit, or resetting. Knowing the right tool for each situation is important, valuable practical skill. ## Undo uncommitted changes (working directory) ```bash git restore # discard unstaged changes to a file (revert to last commit) git checkout -- # older equivalent git restore . # discard ALL unstaged changes (careful!) git clean -fd # remove untracked files/directories ``` ## Unstage (keep the changes, just unstage) ```bash git restore --staged # unstage a file (changes stay in working dir) git reset # older equivalent ``` ## Fix or amend the last commit ```bash git commit --amend -m "New message" # change the last commit's message git commit --amend # add staged changes to the last commit # ⚠️ amend REWRITES the commit — don't amend commits already pushed/shared ``` ## Undo a committed change ```text TWO main approaches: REVERT → creates a NEW commit that undoes a previous commit (SAFE for shared history) git revert → history preserved; the undo is itself a commit RESET → moves the branch pointer BACK (rewrites history — for LOCAL commits only) git reset --soft HEAD~1 → undo commit, KEEP changes staged git reset --mixed HEAD~1 → undo commit, keep changes unstaged (default) git reset --hard HEAD~1 → undo commit AND DISCARD changes (⚠️ destructive!) ``` ## revert vs reset (the key choice) ```text REVERT → safe for PUBLIC/shared commits (adds a new undoing commit; doesn't rewrite history) RESET → rewrites history (only for LOCAL, unpushed commits; never on shared branches) → Rule: use REVERT to undo commits others may have; RESET only for local cleanup. ``` ## Why it matters Knowing how to undo changes in Git is important, frequently-needed practical skill, because mistakes and the need to undo work are inevitable in development, and Git provides powerful (but situation-specific) ways to recover. Understanding the **right tool for each situation** is the key skill: discarding **uncommitted changes** (`git restore` to revert working-directory edits, `git clean` for untracked files), **unstaging** (`git restore --staged` to keep changes but unstage them), **amending** the last commit (changing its message or adding to it — with the important caveat not to amend pushed commits since it rewrites history), and undoing **committed** changes. For undoing commits, understanding the **critical distinction between revert and reset** is especially important: **`revert`** creates a new commit that undoes a previous one and is **safe for shared/public history** (it doesn't rewrite history, so it won't disrupt others), while **`reset`** moves the branch pointer back and **rewrites history**, making it appropriate only for **local, unpushed commits** (and `reset --hard` is destructive, discarding changes). The rule — use `revert` for commits others may have, `reset` only for local cleanup — is vital because rewriting shared history (via reset on pushed commits) causes serious problems for collaborators. Knowing these options prevents both losing work (using destructive commands carelessly) and disrupting collaboration (rewriting shared history). Since undoing changes is a common, inevitable need and Git offers multiple situation-specific approaches with important safety implications (especially revert vs reset for shared history), knowing how to undo changes in Git — the right tool for each scenario and the crucial revert-vs-reset distinction — is valuable, frequently-applied practical knowledge for working confidently and safely with Git, a skill that turns the anxiety of mistakes into routine recovery while avoiding the serious pitfall of rewriting shared history.

Undo uncommitted changes (working directory)

Unstage (keep the changes, just unstage)

Fix or amend the last commit

Undo a committed change

revert vs reset (the key choice)

Why it matters

Related questions