Git: How to undo commits

Use reset --soft to keep files staged

If you want to commit again with the same changes, it can be tiresome to re-add them. The --soft option keeps the changes staged in Git’s index, so you don’t need to git add them again:

$ git reset --soft @~

Neat. This is the git reset form that I normally use.

Say you were in the same state as before:

$ git log --oneline
54f058d (HEAD -> soil) Add compost
7372df9 Loosen soil
...

If you undo the last commit with --soft:

$ git reset --soft @~

…then the “Add compost” commit would again be undone:

$ git log --oneline
7372df9 (HEAD -> soil) Loosen soil
...

…but this time its changes would be added:

$ git status
On branch soil
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
  modified:   garden.txt

Ready for you to tweak the changes and commit again.

Use reset --hard to discard changes

If the last commit is no longer relevant, use the --hard option to throw away its changes:

$ git reset --hard @~

Useful to drop temporary commits made for testing.

Going back to the same initial scenario:

$ git log --oneline
917da50 (HEAD -> soil) Add compost
7372df9 Loosen soil
...

If you use a hard reset:

$ git reset --hard @~
HEAD is now at 7372df9 Loosen soil

…then the “Add compost” commit is undone:

$ git log --oneline
7372df9 (HEAD -> soil) Loosen soil
...

…and no changes are pending:

$ git status
On branch soil
nothing to commit, working tree clean

All gone!

Undo several commits with @~<n>

You can specify the number of commits to undo with a number after the ~:

$ git reset @~<n>

This will undo the last commit “n” times at once.

Combine with --soft or --hard as appropriate.

For example, say you wanted to undo the last two commits to undo:

$ git log --oneline
68ae947 (HEAD -> soil) Add fertilizer
37b7eb0 Add compost
7372df9 Loosen soil
...

You could use @~2 to undo “Add fertilizer” and “Add compost”:

$ git reset HEAD~2
Unstaged changes after reset:
M garden.txt

…and you’d be back at “Loosen soil”:

$ git log --oneline
7372df9 (HEAD -> soil) Loosen soil
...

Bee-rilliant.

Handle merge conflicts if necessary, or abort

If the changes in the previous commit have been built on, reverting the commit will cause merge conflicts. This looks like:

$ git revert bdcc361
Auto-merging garden.txt
CONFLICT (content): Merge conflict in garden.txt
error: could not revert bdcc361... Loosen soil
hint: After resolving the conflicts, mark them with
hint: "git add/rm <pathspec>", then run
hint: "git revert --continue".
hint: You can instead skip this commit with "git revert --skip".
hint: To abort and get back to the state before "git revert",
hint: run "git revert --abort".

The revert commit hasn’t yet been made. Instead, you need to resolve the conflicts in order to continue, or you can abort. The hint messages tell you the main commands you’ll need here.

If you check git status you’ll see the files that are still in conflict:

$ git status
On branch soil
You are currently reverting commit bdcc361.
  (fix conflicts and run "git revert --continue")
  (use "git revert --skip" to skip this patch)
  (use "git revert --abort" to cancel the revert operation)

Unmerged paths:
  (use "git restore --staged <file>..." to unstage)
  (use "git add <file>..." to mark resolution)
  both modified:   garden.txt

no changes added to commit (use "git add" and/or "git commit -a")

The message “You are currently reverting commit ...” will remain until you complete the revert, or abort it. You won’t be able to do many other things, like commit or switch branch, until you handle the revert.

If you manage to fix the conflicts, use git add to mark the conflicted files as ready to commit. Then run git revert --continue to complete the revert, which will again allow you to edit the commit message:

$ git add garden.txt

$ git revert --continue
[soil 3399fa4] Revert "Loosen soil"
 1 file changed, 1 deletion(-)

If you cannot fix the conflicts, you can give up on the revert with:

$ git revert --abort

…which will reset things as they were before you tried to revert:

$ git log --oneline
93cc4de (HEAD -> soil) Add compost
bdcc361 Loosen soil
...

$ git status
On branch soil
nothing to commit, working tree clean

Back to the way things were.

Use revert -n to revert without committing

If you only want to temporarily revert a previous commit’s changes, you probably don’t want to create an undo commit. You can use the -n option, short for --no-commit, to skip creating the undo commit:

$ git revert -n <commit>

This is useful for before/after testing.

Returning to this two commit setup:

$ git log --oneline
1c13e39 (HEAD -> soil) Add compost
5c87687 Loosen soil
...

You could undo “Loosen soil” without a commit like so:

$ git revert -n 5c87687
Auto-merging garden.txt

This leaves the repo in the “currently reverting” status:

$ git status
On branch soil
You are currently reverting commit 5c87687.
  (all conflicts fixed: run "git revert --continue")
  (use "git revert --skip" to skip this patch)
  (use "git revert --abort" to cancel the revert operation)

Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
  modified:   garden.txt

In this state, you can use one of several commands to affect the revert:

• git revert --abort will discard the revert changes, as above for handling conflicts. Handy if you want to temporarily test something with the prior commit undone, then forget about it.
• git revert --continue will continue to create a commit. Useful if you want to check that undoing the commit has the expected effect before committing.
• git revert --quit will forget about the revert, but leave its changes in place. This is useful if you want to further test or adjust the revert, and maybe combine it with another change.

Choose your own adventure!

Undo several previous commits

You can pass several commit references to git revert to undo them all:

$ git revert <commit1> <commit2> ...

Git will revert each one at a time, potentially pausing for a merge conflict at each step.

Once more, let’s take that three commit history:

$ git log --oneline
e0bec77 (HEAD -> soil) Add fertilizer
1c13e39 Add compost
5c87687 Loosen soil
...

You can create revert commits for both “Loosen soil” and “Add compost” by using their SHAs:

$ git revert 5c87687 1c13e39
Auto-merging garden.txt
[soil 73dc801] Revert "Loosen soil"
 1 file changed, 1 insertion(+), 1 deletion(-)
Auto-merging garden.txt
[soil 06213d6] Revert "Add compost"
 1 file changed, 1 insertion(+), 1 deletion(-)

Git will open your editor for each commit message in turn.

If you want to end up with a single revert commit, you can use -n:

$ git revert -n 5c87687 1c13e39
Auto-merging garden.txt
Auto-merging garden.txt

The repo will then be in the “currently reverting” status:

$ git status
On branch soil
You are currently reverting commit 1c13e39.
  (all conflicts fixed: run "git revert --continue")
  (use "git revert --skip" to skip this patch)
  (use "git revert --abort" to cancel the revert operation)

Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
  modified:   garden.txt

From there, you can use any of the revert sequencer commands as necessary.

Handle merge conflicts if necessary, or abort

If the changes in the previous commit has been built on, removing the commit in a rebase will cause merge conflicts. In this case, Git will stop the rebase part way to tell you:

$ git rebase -i main
Auto-merging garden.txt
CONFLICT (content): Merge conflict in garden.txt
error: could not apply 02b3262... Add compost
hint: Resolve all conflicts manually, mark them as resolved with
hint: "git add/rm <conflicted_files>", then run "git rebase --continue".
hint: You can instead skip this commit: run "git rebase --skip".
hint: To abort and get back to the state before "git rebase", run "git rebase --abort".
Could not apply 02b3262... Add compost

Don’t panic!

The hint messages summarize the actions you can take.

git status will show you the files that have conflicts, and further hints:

$ git status
interactive rebase in progress; onto 07a4556
Last command done (1 command done):
   pick 02b3262 Add compost
No commands remaining.
You are currently rebasing branch 'soil' on '07a4556'.
  (fix conflicts and then run "git rebase --continue")
  (use "git rebase --skip" to skip this patch)
  (use "git rebase --abort" to check out the original branch)

Unmerged paths:
  (use "git restore --staged <file>..." to unstage)
  (use "git add <file>..." to mark resolution)
  both modified:   garden.txt

no changes added to commit (use "git add" and/or "git commit -a")

As with a conflicted revert, this is a special state. You can’t do many things, like switch branch, until you finish or abort the rebase.

Your main options are:

• git rebase --continue to complete the rebase, after you fix the conflicts and git add the affected files.

  This option is mostly likely what you want to do.

  For example:

  $ open garden.txt
  
  $ git add garden.txt
  
  $ git rebase --continue
  [detached HEAD 48a4936] Add compost
   1 file changed, 7 insertions(+)
  Successfully rebased and updated refs/heads/soil.
  

• git rebase --skip to skip the current commit.

  This is rarely useful, as it means the resulting history won’t have all the commits you selected during rebase. In the example, this would remove the “Add compost” commit, leaving the branch without any commits.

• git rebase --abort to give up on the rebase.

  This will reset your repo to the way things were before rebasing, with the full commit history, including the commit you attempted to drop.

…and that’s a wrap!