How to undo last local commit in Git

Git is one of the most widely used version control systems in modern software development. While Git provides powerful tools to manage code changes, mistakes can happen, especially when working with commits. Sometimes you make a commit locally and later realize that it was incorrect, incomplete, or you simply want to modify it. Knowing how to undo last local commit in Git is crucial for every software engineer to maintain a clean and manageable code history. In this post, we will explore the root cause of this issue, how to reproduce it, and multiple solutions that are safe and effective.

Understanding the Root Cause

The need to undo a local commit usually arises due to human errors or changes in development priorities. Common scenarios include:

  • Accidental Commit: You commit a file by mistake that shouldn’t have been included.
  • Incomplete Commit: You realize you forgot to add some changes or files after committing.
  • Wrong Commit Message: You committed with an incorrect message and need to correct it.
  • Testing Mistakes: During testing or experimentation, you may commit code that is not ready for the main branch.

In all these situations, it is important to understand that undoing a local commit in Git does not affect remote repositories unless you explicitly push changes. This makes undoing local commits relatively safe if done correctly.



How to Reproduce the Issue

To understand how to undo the last local commit, let’s first reproduce a scenario. Suppose you are working on a project and accidentally commit a change you didn’t intend to include:

# Navigate to your project directory
cd MyProject

# Check git status
git status

# Add a file accidentally
echo "Temporary change" > temp.txt
git add temp.txt

# Commit the change
git commit -m "Accidental commit"

After running the above commands, you now have a commit in your local repository that you want to undo.

Solution 1: Undo Last Commit but Keep Changes

Sometimes you want to undo the commit but retain your changes in the working directory. This is useful if you forgot to include some files in the commit or need to modify the code before recommitting.

# Undo last local commit but keep changes in the staging area
git reset --soft HEAD~1

Explanation:

  • git reset moves the current branch pointer to a previous commit.
  • --soft ensures that changes from the undone commit remain staged, ready to recommit.
  • HEAD~1 points to one commit before the current commit.

After running this, you can modify your files or commit again with a corrected message:

# Modify your changes or add new files
git add .

# Commit with a corrected message
git commit -m "Corrected commit message"

Solution 2: Undo Last Commit and Unstage Changes

If you want to undo the last commit and also remove changes from the staging area but keep them in your working directory, use:

# Undo last commit and unstage changes
git reset --mixed HEAD~1

Explanation:

  • --mixed resets the commit and un-stages the changes.
  • Your changes remain in the working directory but are no longer staged for commit.

You can now selectively stage files before committing again:

# Stage selected files
git add file1.txt file2.txt

# Commit the selected files
git commit -m "Updated commit after un-staging changes"


Solution 3: Undo Last Commit and Discard Changes

If you want to completely remove the last commit along with all associated changes, the following command works:

# Undo last commit and discard all changes
git reset --hard HEAD~1

Explanation:

  • --hard resets the commit and discards all changes permanently.
  • Be careful: this cannot be undone unless you have a reference or backup.

This solution is useful when a commit is entirely wrong and you want to revert to the previous state without keeping any files.

Solution 4: Undo Last Commit Using Git Revert

In situations where you want to undo the last commit without changing the commit history (especially when working in shared branches), git revert is the safest option:

# Revert the last commit
git revert HEAD

Explanation:

  • git revert creates a new commit that undoes the changes introduced by the previous commit.
  • This method preserves history, making it suitable for collaborative environments.

After reverting, Git will open a commit message editor. Save the message and exit to complete the revert.

How to Verify the Undo Operation

After applying any of the above solutions, it is good practice to verify the repository state:

# Check the git log to see commit history
git log --oneline

# Check status of working directory
git status

By inspecting the log, you can confirm that the last commit has been undone or reverted successfully.



Best Practices for Undoing Local Commits

  • Always Verify Branch: Ensure you are on the correct branch before resetting commits.
  • Avoid Hard Reset on Shared Branches: git reset --hard should only be used on local branches to prevent affecting collaborators.
  • Use Revert for Shared Branches: In team projects, prefer git revert to maintain history integrity.
  • Commit Frequently with Meaningful Messages: Proper commit practices reduce the need for undoing commits.
  • Backup Before Resetting: If unsure, create a temporary branch before running reset commands: 
    git branch backup-branch

    This ensures you can recover changes if needed.

Advanced Scenarios

Undo Multiple Commits

To undo multiple recent commits, you can extend HEAD~1 to HEAD~N where N is the number of commits:

# Undo last 3 commits but keep changes staged
git reset --soft HEAD~3

Undo a Commit with Unpushed Changes

If you have commits that are not pushed yet, all the above methods are safe. If the commits were already pushed, you must coordinate with your team before performing resets or consider using git revert.

Changing Last Commit Message

If the issue is only with the commit message, you can amend it without affecting the content:

git commit --amend -m "Updated commit message"

This avoids creating a new commit while correcting the message.

Conclusion

Understanding how to undo last local commit in Git is essential for any software engineer. Whether you need to keep changes, unstage them, discard them entirely, or revert safely in a shared repository, Git provides flexible options to handle these scenarios. By following the solutions outlined above, developers can maintain clean commit histories, correct mistakes efficiently, and avoid unnecessary errors in collaborative projects.

Mastering these commands ensures better workflow management, reduces mistakes, and improves confidence when managing code changes in professional development environments. Always remember: practice on a local branch first if unsure, and use git revert for shared branches to maintain history integrity.