Undoing Changes in Git

Undoing Changes in Git

Git gives you multiple tools for undoing changes. Choose the right one based on whether the commit is local or shared, and how far back you need to go.

Before You Commit

# Discard all changes in working tree (cannot be recovered)
git restore .
git restore path/to/file.ts

# Unstage a file (keep changes in working tree)
git restore --staged path/to/file.ts

# Unstage everything
git restore --staged .

Amending the Last Commit

Fix the most recent commit — message, files, or both:

# Change the commit message
git commit --amend -m "Better commit message"

# Add a forgotten file to the last commit
git add forgotten-file.ts
git commit --amend --no-edit

# Change both files and message
git add fixed-file.ts
git commit --amend -m "Correct message and files"

Only amend commits that have not been pushed — amending rewrites history.

git revert (Safe for Shared History)

Creates a new commit that undoes the changes from a previous commit. Safe because it doesn’t rewrite history:

# Revert the last commit
git revert HEAD

# Revert a specific commit
git revert abc1234

# Revert without automatically committing (preview changes first)
git revert -n abc1234
git revert --no-commit abc1234

# Revert a range of commits
git revert abc1234..ghi9012

Use revert when the commit has been pushed to a shared branch.

git reset (For Local History Only)

git reset moves HEAD (and the branch pointer) to a different commit. Three modes:

# --soft: keeps staged changes and working tree
git reset --soft HEAD~1    # undo last commit, keep changes staged

# --mixed (default): unstages changes, keeps working tree
git reset HEAD~1           # undo last commit, changes in working tree
git reset --mixed HEAD~1   # same

# --hard: discards staged and working tree changes
git reset --hard HEAD~1    # undo last commit, LOSE all changes
git reset --hard origin/main   # match remote exactly

Never use --hard unless you’re certain you don’t need those changes.

Recovering with reflog

git reflog records every change to HEAD — even after reset or rebase:

git reflog
# abc1234 HEAD@{0}: reset: moving to HEAD~1
# def5678 HEAD@{1}: commit: Add user profile page
# ...

# Recover the lost commit
git reset --hard def5678
# or create a branch at it
git switch -c recovery-branch def5678

The reflog is local only and entries expire after 90 days (default).

Removing a File from Tracking

# Stop tracking a file but keep it on disk
git rm --cached secrets.env

# Stop tracking a directory
git rm --cached -r config/local/

# Then add to .gitignore to prevent re-tracking

Cleaning Untracked Files

# Preview what would be deleted
git clean -n

# Delete untracked files
git clean -f

# Delete untracked files and directories
git clean -fd

# Delete files including ignored ones
git clean -fxd

Checkout vs Restore vs Reset

Command	What it does
git restore <file>	Discard working tree changes
git restore --staged <file>	Unstage file
git revert <commit>	Create new commit undoing changes (safe)
git reset --soft HEAD~n	Undo commits, keep changes staged
git reset --mixed HEAD~n	Undo commits, changes go to working tree
git reset --hard HEAD~n	Undo commits, discard all changes

Summary Decision Tree

Did you push the commit to a shared branch?
├── YES → git revert (creates a new "undo" commit)
└── NO  → What do you want to undo?
          ├── Just the commit message → git commit --amend
          ├── Last commit (keep changes) → git reset --soft HEAD~1
          └── Last commit + changes → git reset --hard HEAD~1