Safely Undoing a Git Rebase: Your Guide to reflog and --abort

git rebase is a powerful tool for rewriting commit history, but it can sometimes lead to unexpected or broken states. We’ve all been there: you finish a rebase, and suddenly your project is in a worse state than when you started. Don’t panic! Git provides excellent safety nets to recover your work.

This guide covers two key scenarios:

1. Aborting a rebase that is currently in progress.
2. Reverting a rebase that has already been completed, using Git’s “time machine,” the reflog.

The Escape Hatch: Aborting an In-Progress Rebase

You’re in the middle of a rebase, resolving conflicts, and you realize it’s not going as planned. Perhaps the conflicts are too complex, or you’ve made a mistake. This is the simplest scenario to fix.

Git provides a clean exit hatch. To stop the rebase and return your branch to the state it was in right before you started, simply run:

git rebase --abort

This command will immediately halt the rebase process and restore your branch to its original commit sequence. No harm done.

The Time Machine: Reverting a Completed Rebase with reflog

This is the more complex scenario. You’ve completed the rebase, but now you see that it introduced a bug, or you accidentally dropped a commit. Your previous commit history seems to be gone.

This is where git reflog comes to the rescue. The reflog is a record of all the recent positions of HEAD. It tracks every time a branch tip was updated, making it the perfect tool for finding your “lost” commits.

Here’s how to use it to revert your rebase:

Step 1: Find Your Pre-Rebase State

Run the git reflog command to see the history of your HEAD:

git reflog

You’ll see a list of your recent actions. The output will look something like this:

a1b2c3d (HEAD -> feature-branch) HEAD@{0}: rebase finished: returning to refs/heads/feature-branch
a1b2c3d (HEAD -> feature-branch) HEAD@{1}: rebase: checkout main
e4f5g6h HEAD@{2}: rebase: commit-one
i7j8k9l HEAD@{3}: rebase: commit-two
m0n1o2p HEAD@{4}: checkout: moving from main to feature-branch
q3r4s5t (main) HEAD@{5}: commit: This was my last commit before the rebase
...

Look through this log to find the state right before you started the rebase. In the example above, HEAD@{5} points to the commit on main right before the rebase began. This is the commit we want to go back to.

Step 2: Reset Your Branch to the Previous State

Once you’ve identified the correct reflog entry (like HEAD@{5}), you can reset your branch to that point using git reset:

git reset --hard HEAD@{5}

This command moves the feature-branch pointer back to the commit it had at HEAD@{5}, effectively undoing the entire rebase. The --hard flag ensures that your working directory and index are also updated to match that commit.

Your branch is now exactly as it was before you attempted the rebase.

A Word of Caution: Pushed Rebases

If you’ve already pushed your rebased branch to a remote repository, be very careful. After using git reset, your local branch history will diverge from the remote. Pushing again would require a force push (git push --force-with-lease).

Force pushing is a destructive action that can cause problems for any collaborators who have pulled the rebased branch. If you’re in this situation, it’s best to communicate with your team before rewriting public history.

Happy coding!