Right Way to git undo commit before push: Zero Mistakes

Written by - Steve Alila
Reviewed by - Deepak Prasad

Introduction to Reverting and Undoing Commits in Git

In the dynamic world of software development, mistakes are common, and sometimes we might find ourselves needing a "do-over". The Git version control system, known for tracking changes and managing code, offers powerful tools to help with this. One such scenario developers often encounter is wanting to undo or revert changes they've committed, especially if they haven't yet shared those changes with others. The concepts of "git revert commit before push" and "git undo commit before push" come into play here. While both sound similar, they cater to slightly different needs.

The phrase "git revert commit before push" pertains to creating a new commit that undoes the changes made by the previous commit(s), ensuring your mistakes don't become a permanent part of the project history. On the other hand, "git undo commit before push" typically refers to erasing the last commit, making it as if the changes never happened in the first place.


How Git Revert Works

Git revert is a command that introduces a new commit which undoes changes from a specified commit or commits. Unlike operations like git reset, which effectively rewrite commit history, git revert maintains a record of both the original commit and the commit that reverted it. This ensures transparency in the commit history, making it a safer choice when working with shared repositories.

When you wish to "undo" a commit before you've pushed it to a remote repository, the git revert command comes to the rescue. This way, if you realize you've made a mistake in your last commit(s), you can revert them while keeping the history intact.


1. Reverting a Specific Commit

To revert a specific commit, you first need its commit hash. You can find this using:

git log --oneline

Once you've identified the commit hash, use the following command to revert it:

git revert [commit_hash]

For example, if the commit hash is a123bc4, you'd type:

git revert a123bc4

This will open an editor, prompting you to enter a commit message for the new revert commit. Save and exit the editor to complete the process.


2. Reverting Multiple Commits

To revert a range of commits, use the double-dot syntax. If you want to revert the last three commits, for example, you'd do the following:

git revert HEAD~2..HEAD

Here, HEAD~2 refers to the third most recent commit and HEAD refers to the latest commit. This will generate individual revert commits for each commit in the specified range.

If you want to group the reverts into a single commit, add the -n or --no-commit option:

git revert -n HEAD~2..HEAD

Then, finalize the grouped revert with:

git commit -m "Reverted the last three commits."


Imagine you've made three commits: Add feature A, Add feature B, and Fix bug in feature A. After some testing, you realized that both Add feature B and Fix bug in feature A were problematic and you haven't pushed these changes to the remote repository yet.

Your commit history might look something like this:

c3456f7 (HEAD) Fix bug in feature A
b2345c6 Add feature B
a1234b5 Add feature A

To revert the last two commits using git revert, you'd execute:

git revert -n HEAD~1..HEAD
git commit -m "Reverted recent changes to fix problems."

Your history would then look like this:

d4567g8 (HEAD) Reverted recent changes to fix problems.
c3456f7 Fix bug in feature A
b2345c6 Add feature B
a1234b5 Add feature A


Step-by-Step Workflow of git revert commit before push

1. Check the Commit History: Start by examining your recent commits to determine which commit(s) you want to undo. Use the following command:

git log --oneline

This command provides a condensed view of the commit history, showing one commit per line.

2. Decide on the Undo Strategy: To undo a commit before pushing, you have primarily two strategies:

  • git reset: To erase the commit(s).
  • git revert: To create a new commit that undoes the changes.

3. Using the Reset Command: If you decide to use git reset, you can specify which commit to "rewind" to:

git reset HEAD~1
  • HEAD~1: This refers to the commit before the most recent commit. Adjust the number to go back further (e.g., HEAD~2 for two commits back).
  • By default, git reset uses the --mixed option, which will unstage the changes but leave them in your working directory. If you wish to keep the changes staged, use --soft. If you want to discard the changes entirely, use --hard.

4. Using the Revert Command: If you opt for git revert, the command will create a new commit that undoes the changes from the specified commit:

git revert HEAD

If you need to revert multiple commits, specify the commit range, like git revert OLDEST_COMMIT^..NEWEST_COMMIT.

5. Verify Your Changes: After executing either the reset or revert strategy, check the commit history again using git log to ensure you've made the desired changes.

6. Staging and Committing (for git revert): If you've used git revert, the changes will be staged automatically. To commit the reverted changes, simply:

git commit -m "Reverted the undesired commit."

7. Continue Working: Once you've undone the commit(s), you can either:

  • Continue with your work and make new commits.
  • Push your changes to the remote repository if you're ready.


How to Revert a Merge Commit?

Merge commits combine two lines of development into a single branch. Reverting such commits requires a bit more care since you're effectively undoing a set of changes that brought together two separate branches. Let's delve deeper into this concept, focusing on the git revert commit before push process.

Before reverting a merge, you need to pinpoint which commit was the merge. This can be easily found using git log.

$ git log --oneline

From the log, identify the commit hash of the merge you want to revert. Let's say it's abcdef1.

Now, to revert the merge commit:

$ git revert -m 1 abcdef1

Here, the -m 1 flag specifies which parent you want to revert to. With merge commits, there's typically a primary parent (the branch you were on) and a secondary parent (the branch you merged). The -m 1 denotes the primary parent.


Suppose you have a feature branch and a main branch. You merge feature into main but later realize there's an issue. You'd revert this using:

$ git checkout main
$ git revert -m 1 abcdef1

If you hadn't pushed the changes, the process would match the git revert commit before push workflow.

It's possible to encounter conflicts when trying to revert a merge. Git will notify you of this.

$ git revert -m 1 abcdef1
error: could not revert abcdef1... Merge made by the 'recursive' strategy.

In such cases, resolve the conflicts manually. Once resolved, you can proceed to commit the revert.

If you're satisfied with the revert and have tested your changes, it's then time to push. If you had not yet pushed the merge to begin with, this would still be in line with the git revert commit before push strategy. If you had pushed the merge already, inform your team about the revert to avoid any confusion.


Top FAQs on "git revert commit before push"

What does "git revert commit before push" mean?

It refers to the process of undoing or reverting a commit you've made locally (i.e., it hasn't been pushed to the remote repository yet).

Is it possible to undo a commit that hasn't been pushed?

Absolutely! Using commands like git reset or git revert, you can undo local commits effectively before they are pushed to a remote repository.

What's the difference between git revert and git reset?

While both can be used to undo changes, git revert creates a new commit that undoes changes from a previous commit without altering the commit history. In contrast, git reset moves the commit pointer backward, essentially erasing the commit(s).

How do I undo multiple commits?

You can revert multiple commits using git revert OLDEST_COMMIT^..NEWEST_COMMIT. Ensure you haven't pushed these commits if you wish to adhere to the "git revert commit before push" approach.

I mistakenly pushed my commit. Can I still revert it?

Yes, you can! However, if others have pulled the changes or based work on that commit, reverting can create confusion. It's always a good idea to communicate with your team in such scenarios.

What happens if I encounter conflicts during a revert?

Git will alert you of the conflicts. You'll need to manually resolve these conflicts, stage the changes, and then complete the revert commit.

Will git revert delete my original commit?

No, git revert creates a new commit that undoes the changes from the specified commit. The original commit remains in the history.


Example-1: How to undo commit before push using git checkout command

Let us add some words into file1.txt.

echo "adding line 1" > file1.txt

git status shows we have an untracked file.

git undo commit before push [Practical Examples]

Let us git add . and git commit -m "put something in file1".

Let us recheck the commit hashes.

git log --oneline
git undo commit before push [Practical Examples]

Assume we want to undo the commits before pushing the changes to the remote repo. We can achieve that in two ways:

Let us undo the commit hash 5f5a3d1.

git checkout 5f5a3d1

git checkout <commit hash> matches the working repo's state to the commit we have done git checkout on.

We can also git checkout a branch to enable git undo commit before push.

git checkout -b additions 5f5a3d1


Example-2: How to undo commit before push using git reset command

git reset enables us to undo commit before push in three ways: git reset --soft, git reset --mixed, and git reset --hard.

Let us format the history's appearance to have a better look at the commit head.

git log --graph --decorate
git undo commit before push
  • git reset --soft HEAD~1 stacks the changes in the staging area.
  • git reset --mixed HEAD~1 is the default reset command. It keeps the changes in either staging or working directory.
  • git reset --hard HEAD~1 removes all the changes from the staging areas.

git reset --hard <commit hash> takes all changes to the state they were in at the specified commit hash, leaving untracked files untouched.

We can undo the last commit to our test project as follows:

git reset --hard c2eb392

If we redo git log --graph --decorate, we realize that one commit got discarded. The head is now in the commit hash we specified when undoing the changes.

Running git status shows that untracked files were not removed. To get rid of the untracked directories and files, run

git clean -df

git reset --hard <commit hash> is one of the most dangerous ways to perform git undo commit before push because you may not recover the commit history after performing the command.

You are probably wondering, "What if I want to recover commits after discarding them using git reset --hard?" It is simple.

If not much time has gone after running git reset --hard command, you can follow these steps to recover the commits:

Run git reflog to see if the git garbage has not collected changes. My log appears as follows:

git undo commit before push [Practical Examples]

git checkout the commit hash whose deletions you want to recover.

git checkout <commit hash>

Make a branch for the changes in the detached head.

And voila, you have your commits back!


Example-3: How to undo commit before push using git revert command

git revert <commit hash> creates new commits to inverse the effects of earlier commits without deleting the existing commits.

Let us check our commit history by running git log --oneline

git undo commit before push [Practical Examples]

We can now run git revert c2eb392 undo commit before push. It prompts us to enter a commit message by opening a code editor. After closing the editor, let us run git diff c2eb392 to inspect the changes made.

git undo commit before push [Practical Examples]

Let us repeat the process for the hash 4438e09. If we git log --oneline, we see the number of commits has changed. This time around, we have new commit hashes, as indicated in the screenshot below:

git undo commit before push [Practical Examples]


Example-4: How to undo commit before push using git restore command

git restore can help you undo changes to a commit at the file level. Here is how to use it.

git log --oneline shows we have four commits with hashes, e53a284, 0509e7b, c2eb392 and 4438e09. Assume we want to move back to when we did the commit c2eb392. We can do that by typing:

git restore --source=HEAD~2 file1.txt

git status reveals that file1.txt is now untracked.

git undo commit before push [Practical Examples]



Git is an indispensable tool in modern development workflows, allowing teams to track, manage, and collaborate on code changes. A key aspect of working with Git is understanding how to manage commits, especially if you wish to undo or adjust them before they are shared with others.

  • Git Basics: At its core, Git works on a series of commits. Each commit is essentially a snapshot of your code at a particular point in time. These commits are made in a local environment first, and then, when ready, they are pushed to a remote repository.
  • Reverting vs. Resetting: Understanding the difference between reverting and resetting is crucial. While both can undo changes, git revert undoes a commit by creating a new commit, keeping the history intact. In contrast, git reset moves your HEAD and current branch pointer to the referenced commit, essentially erasing commits.
  • Safe Undoing: Before pushing a commit, it's easier to make changes or undo it. This is because, once pushed, the commit is available to everyone who has access to the repository, and undoing it might disrupt others' work. The primary command to focus on for undoing a local commit is git reset.
  • Advanced Techniques: Sometimes, you might need to revert complex changes like merges or utilize the reflog to access commits that seem lost. These advanced techniques offer flexibility but come with their own set of challenges and should be approached with caution.


Further Reading


Steve Alila

He specializes in web design, WordPress development, and data analysis, with proficiency in Python, JavaScript, and data extraction tools. Additionally, he excels in web API development, AI integration, and data presentation using Matplotlib and Plotly. You can connect with him on LinkedIn or check his projects on GitHub page.

Categories GIT

Can't find what you're searching for? Let us assist you.

Enter your query below, and we'll provide instant results tailored to your needs.

If my articles on GoLinuxCloud has helped you, kindly consider buying me a coffee as a token of appreciation.

Buy GoLinuxCloud a Coffee

For any other feedbacks or questions you can send mail to admin@golinuxcloud.com

Thank You for your support!!

Leave a Comment