How to Undo Pushed Git Commits Locally & Remotely

The quick guide to undoing consecutive and non-consecutive git commits locally and remotely via the terminal command line.

By Adam Durrant

@adamddurrant

Published: March 25, 2025

Manipulating Git history is a common task for devs. For me, it's a task I forget how to do until I have to do it so, I thought i'd write it down somewhere. This quick guide will walk you through removing/undoing commits quickly and safely from your local and remote repositories.

Before you go ahead with the commands, please note that the commands below, although are relatively safe and shouldn't cause you to lose your work, be vigilant and practice them on a test branch first to be as safe as possible.

How to undo last commit

Step 1: Check local status

Before making any changes to your Git history, ensure your working directory is clean and up to date:

$ git status

On branch master
Your branch is up to date with 'origin/master'.

nothing to commit, working tree clean

This will alert you to any uncommitted changes, you'll want to stash anything uncommitted so your branch is clean before proceeding.

Step 2: Reset changes locally

Use the following command to reset your local HEAD back one commit:

$ git reset HEAD~

Step 3: Check the reset

Rerun git status and you'll now see that, locally, you have reset one commit and your original changes are saved in your IDE as unstaged. You'll also notice that, running git status again you are one commit behind master, this is expected:

$ git status

Your branch is behind 'origin/master' by 1 commit, and can be fast-forwarded.
  (use "git pull" to update your local branch)

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        page-test.php

nothing added to commit but untracked files present (use "git add" to track)

Step 4: Remove the commit from remote

Now that you have got your local back to its original spot, if you need to update your remote repo (Github, Bitbucket etc) to reflect the same change, you'll need to run the following command (be mindful here that you are forcing a removal of the your last commit):

$ git push origin HEAD --force-with-lease
    
Total 0 (delta 0), reused 0 (delta 0), pack-reused 0 (from 0)
To https://github.com/adamddurrant/coolrepo.git
 + 9302d5f...604b13e HEAD -> master (forced update)

--force-with-lease is necessary here as your local history is not the same as remote (i.e it's divergent) so we need to rewrite the remote commit to match our local changes. Without --force-with-lease, Git would reject the push because it sees your history as being behind the tip of your remote repo.

--force-with-lease is safer than --force as it will check if the remote branch has changed (while you've been undoing things) before force-pushing.

Now, you can refresh your remote repo and rejoice, you're back where you started, nobody suspects a thing.

How to undo consecutive commits

To undo consecutive commits from the top of your branch, in order, follow the same steps above but, for step 2, append the number of commits you wish to consecutively reset. For example the following command will undo the last 3 consecutive commits:

$ git reset HEAD~3

How to undo non-consecutive commits

For non-consecutive commits (i.e a undoing numerous commits that happened at various times with other commits in between), the most appropriate and safest method is to use an interactive rebase.

Note: Interactive rebasing can be fiddly. Practice using it on a test branch before applying changes to your main branch. In any case, you can stop the next command without making changes by typing :qa! (if you're using vim) and then running git rebase --abort.

To get started, complete step 1 from earlier, then, run the following command to initiate an interactive rebase using the number of commits back that you want to review. For example, the following command will allow us to review and undo any commits within the last 5 commits:

$ git rebase -i HEAD~5

Note: To illustrate how this works, I started a new repo and committed six times - the rebasing command will not count the very first commit made.

After running the command, you'll now see something like this in your terminal:

pick 3e67142 Second commit
pick 85c2865 Third commit
pick f0dcf05 Fourth commit
pick f0ab22d Fifth commit
pick 3a96ff4 Sixth commit

# Rebase fbcf6b2..3a96ff4 onto fbcf6b2 (5 commands)
#
# Commands:
# p, pick <commit> = use commit
# r, reword <commit> = use commit, but edit the commit message
# e, edit <commit> = use commit, but stop for amending
# s, squash <commit> = use commit, but meld into previous commit
# f, fixup [-C | -c] <commit> = like "squash" but keep only the previous
#                    commit's log message, unless -C is used, in which case
#                    keep only this commit's message; -c is same as -C but
#                    opens the editor
# x, exec <command> = run command (the rest of the line) using shell
# b, break = stop here (continue rebase later with 'git rebase --continue')
# d, drop <commit> = remove commit
# l, label <label> = label current HEAD with a name
# t, reset <label> = reset HEAD to a label
# m, merge [-C <commit> | -c <commit>] <label> [# <oneline>]
#         create a merge commit using the original merge commit's
#         message (or the oneline, if no original merge commit was
#         specified); use -c <commit> to reword the commit message
# u, update-ref <ref> = track a placeholder for the <ref> to be updated
#                       to this position in the new commits. The <ref> is
#                       updated at the end of the rebase
#
# These lines can be re-ordered; they are executed from top to bottom.
#
# If you remove a line here THAT COMMIT WILL BE LOST.
#
# However, if you remove everything, the rebase will be aborted.
#

At the top, you'll see the last 5 commit messages and their associated commit hashes, there's also some useful command guidance in the form of comments.

In my case, my editor defaults to use vim with a rebase. While I have the above information in the terminal, using vim, type i to enter insert mode, then, with arrow keys, navigate to pick the commits you want to change.

While in insert mode, simply change the word pick to drop. For example, lets drop the third and fifth commit like so:

pick 3e67142 Second commit
drop 85c2865 Third commit
pick f0dcf05 Fourth commit
drop f0ab22d Fifth commit
pick 3a96ff4 Sixth commit

Now hit esc and then type :wq to save and quit vim.

Rerun git status and you'll see the following:

$ git status

interactive rebase in progress; onto fbcf6b2
Last commands done (2 commands done):
   pick 3e67142 Second commit
   drop 85c2865 Third commit
Next commands to do (3 remaining commands):
   pick f0dcf05 Fourth commit
   drop f0ab22d Fifth commit
  (use "git rebase --edit-todo" to view and edit)
You are currently editing a commit while rebasing branch 'master' on 'fbcf6b2'.
  (use "git commit --amend" to amend the current commit)
  (use "git rebase --continue" once you are satisfied with your changes)

nothing to commit, working tree clean

Now run:

$ git rebase --continue

It's likely you'll have merge conflicts. If you do, you'll need to resolve and save each conflict one by one. Run git add . and then git rebase --continue after each conflict resolved.

In my example case, I had two merge conflicts (as my commits were all changes to the same file). After resolving those we need to push the rebase to the remote repo.

First you must be sure that the changes you have made and conflicts you have resolved are correct as the next command will overwrite your remote history.

If you're happy, run:

$ git push --force-with-lease 

--force-with-lease is necessary here as your local history will overwrite the remote history.

Without --force-with-lease, Git would reject the push because it sees your history as being behind the tip of your remote repo.

All being well, after running this command, you should now have removed your non-consecutive commits locally and remotely!

← Back to blog