The Git Survival Guide: Fixing Mistakes Like a Pro

Git can be incredibly powerful but also a bit intimidating, especially when things go wrong. Don’t worry; I’ve been there too, and I’ve finally figured out some solutions to common Git mishaps. Here’s a straightforward guide to help you navigate through those “oh no!” moments.

1. The Magic Time Machine: Fixing Big Mistakes

Situation: You did something terribly wrong, and it seems like there’s no way out.

Solution: Git has a magic command called `reflog` that logs everything you’ve done. Here’s how to use it:

git reflog

You’ll see a list of actions with their respective indexes, like `HEAD@{index}`. To go back in time, pick an index before things went wrong:

git reset HEAD@{index}

Boom! You’ve traveled back in time.

2. Oops, Small Mistake Right After a Commit

Situation: You committed your changes, and then realized you missed something small.

Solution: Just make your change, add the file(s), and amend the commit:

git add .
git commit --amend --no-edit

Your last commit now includes your new change. Avoid this on public/shared branches!

3. Changing the Last Commit Message

Situation: You need to fix the commit message of your last commit.

Solution: Amend the commit message using:

git commit --amend

Follow the prompts to edit and save the new message.

4. Wrong Commit on Master Branch

Situation: You committed something to `master` that should have been on a new branch.

Solution: Create a new branch and move your commit:

git branch new-branch
git reset HEAD~ --hard
git checkout new-branch

Your commit is now safely on the new branch.

5. Committed to the Wrong Branch

Situation: You committed to the wrong branch by mistake.

Solution: Undo the commit but keep the changes, then move to the correct branch:

git reset HEAD~ --soft
git stash
git checkout correct-branch
git stash pop
git add .
git commit -m "Your message here"

Your changes are now on the right branch.

6. Diff Not Showing Changes

Situation: You know you made updates, but `git diff` shows nothing.

Solution: Use the staged diff:

git diff --staged

This shows the changes you’ve added to the staging area.

7. Reverting a Commit from Way Back
Situation: You need to undo a commit from several commits ago.

Solution: Find the commit, then create a new commit that undoes it:

git log
# Find and copy the commit hash
git revert [commit-hash]

Follow the prompts to complete the revert.

8. Undoing Changes to a Specific File
Situation: You need to revert changes for a single file.

Solution: Check out the file from an earlier commit:

git log
# Find and copy the commit hash
git checkout [commit-hash] -- path/to/file
git commit -m "Revert changes to specific file"

This brings back the old version of the file.

9. Starting Over with a Fresh Clone
Situation: Your branch is so messed up that you need a fresh start.

Solution: Fetch the latest state from the remote repo and hard reset:

git fetch origin
git checkout master
git reset --hard origin/master
git clean -d --force

Repeat for each borked branch.

I hope this guide helps you master your Git mistakes, turning frustration into productivity! Happy coding!

Disclaimer

This guide isn’t meant to cover everything about Git. While there are other ways to fix these issues, I’ve developed these steps through a lot of trial and error (and some swearing). I decided to share them with a bit of humor and honesty.