Git Undoing Changes & Debugging

Edit PagePage History

Introduction

Even the most experienced developers make mistakes. Fortunately, Git provides powerful tools to undo changes, recover from errors, and maintain a clean working history. This guide will show you how to safely reverse changes, temporarily store work in progress, and recover from common Git mishaps.

🎥 Video: How to Undo Almost Anything With Git (7 mins)

Undoing commits and reverting changes

Git offers multiple ways to undo changes, each appropriate for different situations.

Reverting uncommitted changes

If you've made changes to files but haven't staged or committed them yet:

# Discard changes to a specific file
$ git checkout -- file.txt

# Discard all changes in your working directory
$ git checkout -- .

# In Git 2.23+, the newer syntax is:
$ git restore file.txt

⚠️ Warning: This permanently discards your changes with no way to recover them. Use with caution!

Unstaging changes

If you've staged changes but haven't committed them:

# Unstage a specific file
$ git reset HEAD file.txt

# Unstage all staged changes
$ git reset HEAD

# In Git 2.23+, the newer syntax is:
$ git restore --staged file.txt

💡 Tip: In Git, HEAD is a pointer to the current commit you are working on. It typically points to the latest commit on the currently checked-out branch. When you switch branches, HEAD updates to point to the new branch’s latest commit. If in a detached state, HEAD points directly to a specific commit instead of a branch.

Amending the last commit

If you need to modify your most recent commit:

# First, make any changes you want to include
$ git add file.txt

# Then amend the commit (optionally with a new message)
$ git commit --amend -m "New commit message"

# Or keep the same commit message
$ git commit --amend --no-edit

💡 Tip: Only amend commits that haven't been pushed to a shared repository. Amending pushed commits can cause problems for collaborators.

Reverting a commit

To undo the changes from a specific commit while keeping the history:

# Create a new commit that undoes a previous commit
$ git revert a1b2c3d

# Revert the last commit
$ git revert HEAD

Reset: Moving HEAD and branch pointer

Reset allows you to move the current branch to a specific commit:

# Soft reset: Move HEAD but keep changes staged
$ git reset --soft HEAD~1

# Mixed reset (default): Move HEAD and unstage changes
$ git reset HEAD~1
# or
$ git reset --mixed HEAD~1

# Hard reset: Move HEAD and discard all changes
$ git reset --hard HEAD~1

⚠️ Warning: Hard reset is destructive! It permanently discards commits and working directory changes. Use with extreme caution.

Reflog: Your safety net

Git keeps a record of all HEAD updates with the reflog. This is particularly useful if you've committed to the wrong branch or accidentally deleted a branch.

# View the reflog
$ git reflog

# Restore to a specific reflog entry
$ git reset --hard HEAD@{2}

Stashing changes temporarily

Stashing allows you to save uncommitted changes temporarily so you can switch branches or perform other operations.

🎥 Video: Git Tutorial: Using the Stash Command (11 mins)

Common Stash Commands

# Stash your current changes
$ git stash

# Same as above but with a descriptive message
$ git stash save "Work in progress for feature X"

# List all stashes
$ git stash list

# Apply the most recent stash without removing it
$ git stash apply

# Apply a specific stash
$ git stash apply stash@{2}

# Apply and remove the most recent stash
$ git stash pop

# Remove a stash without applying it
$ git stash drop stash@{1}

# Clear all stashes
$ git stash clear

When to use stashing

Stashing is particularly useful when:

1. You need to switch branches quickly but have unfinished work
2. You want to pull changes but have local modifications
3. You want to try an idea but might want to discard it
4. You need to pause work on one task to address a higher priority

What to do if you mess up a repo?

Even with careful work, Git repositories can sometimes end up in unexpected states. Here are solutions for common problems:

Committed to the wrong branch

# 1. Create a new branch with your current commits
$ git branch correct-branch

# 2. Reset the wrong branch to before your commits
$ git reset --hard origin/main

# 3. Checkout your new branch
$ git checkout correct-branch

Accidentally deleted a branch

If you've deleted a branch but need to recover it:

# 1. Find the SHA of the branch's last commit
$ git reflog

# 2. Create a new branch at that commit
$ git checkout -b recovered-branch a1b2c3d

Fixing a detached HEAD state

A detached HEAD means you're not on a branch:

# If you have changes you want to keep
$ git checkout -b new-branch

# If you want to get back to a branch
$ git checkout main

🎥 Video: Git Detach Explained (7 mins)

Recovering deleted files

If you've deleted files and need them back:

# If the file was committed previously
$ git checkout HEAD~1 -- path/to/file

# If it was just deleted but not committed
$ git checkout -- path/to/file

Fixing a broken repository

For more serious issues, you may need to:

# Check for corruption
$ git fsck

# Try to recover
$ git reflog

# If all else fails, clone the repository again
$ cd ..
$ git clone https://github.com/username/repo.git fresh-repo
$ cd fresh-repo

Cherry-picking commits to move them

If you committed to the wrong branch and have already pushed or can't use the approach above:

# 1. Get the commit SHAs from the wrong branch
$ git log

# 2. Checkout the correct branch
$ git checkout correct-branch

# 3. Cherry-pick each commit
$ git cherry-pick a1b2c3d
$ git cherry-pick e5f6g7h

# 4. Remove commits from wrong branch (if needed)
$ git checkout wrong-branch
$ git reset --hard HEAD~2  # Reset 2 commits back

🎥 Video: Git Cherry Pick Tutorial (5 mins) - How to use cherry-pick to move commits between branches

Common Git debugging commands

Git bisect for finding bugs

Git bisect helps you find which commit introduced a bug:

# Start a bisect session
$ git bisect start

# Mark the current commit as bad
$ git bisect bad

# Mark a known good commit
$ git bisect good a1b2c3d

# Git will checkout a commit halfway between good and bad
# Test your code, then mark it:
$ git bisect good  # If this commit works
# or
$ git bisect bad   # If this commit has the bug

# Continue until Git finds the first bad commit
# When done:
$ git bisect reset

🎥 Video: Finding Bugs with Git Bisect (9 mins) - How to use git bisect to track down when a bug was introduced

Git blame to find who changed code

To see who last modified each line of a file:

# Basic blame
$ git blame file.txt

# Show specific line range
$ git blame -L 10,20 file.txt

# Ignore whitespace changes
$ git blame -w file.txt

🎥 Video Short: Git Quick: Git Blame (1 min) - Quick tutorial on using git blame effectively

Git grep to search the code

Search across your repository:

# Search for a string
$ git grep "function findUser"

# Search with context
$ git grep -n --context=3 "TODO"

# Search in a specific commit
$ git grep "bug" a1b2c3d

Best practices for safer Git usage

1. Commit frequently with clear messages to make recovery easier
2. Create branches for experimental work
3. Push regularly to have remote backups
4. Pull before pushing to avoid conflicts
5. Use .gitignore to prevent committing unwanted files
6. Verify what you're committing with git status and git diff --staged
7. Understand dangerous commands like reset, force push, and how to use them safely

💡 Tip: Keep a cheat sheet of common Git commands, especially the ones for undoing changes, until they become second nature.

More References

🎥 Video: Recovering Lost Commits with Git Reflog (6 mins) 🎥 Video: Git Tutorial: Fixing Common Mistakes and Undoing Bad Commits (22 mins) 🎥 Video: How to Undo Mistakes With Git Using the Command Line (55 mins) 🗒️ Git Cheat Sheet