How to Remove a Commit from GitHub?

In Git version control, commits record changes to a repository over time. But sometimes, you may need to remove a commit from GitHub for reasons like correcting errors, removing sensitive information, or simply tidying up the commit history. Knowing how to remove a commit is essential for clean, manageable version control.

In this blog, we’ll explore several ways to remove a commit from GitHub, including reverting, resetting, and force-pushing, along with best practices and when each method is appropriate.

Understanding Commit Removal Options

When it comes to removing a commit, there are several approaches depending on your goal:

1. Revert: Creates a new commit that undoes the changes from a specific commit without modifying history.
2. Reset: Modifies commit history by removing one or more commits and can optionally delete the changes from the working directory.
3. Amend: Edits the last commit (e.g., to change the message or add/remove files) before pushing.
4. Force Push: Used to overwrite remote history, often after a local reset or amendment.

Each of these methods has its uses, and choosing the right one depends on whether you want to keep a record of the commit or erase it entirely from history.

---

Method 1: Reverting a Commit (Non-Destructive)

Reverting is a safe way to “undo” a commit, especially if it’s already been pushed to GitHub and other collaborators might have pulled it. Instead of modifying the commit history, git revert creates a new commit that reverses the changes of the specified commit.

Steps to Revert a Commit

1. Identify the Commit Hash: Use git log to find the commit hash of the commit you want to revert.

   git log

2. Revert the Commit: Run the following command, replacing commit-hash with the hash of the commit you want to revert.

   git revert commit-hash

3. Push the Reverted Commit:

   git push origin main

This creates a new commit that undoes the specified commit’s changes, which is useful for preserving history.

When to Use git revert

• When you need to undo changes but want to keep the history intact.
• When collaborating, to avoid breaking other team members’ repositories.

---

Method 2: Resetting a Commit (Destructive)

git reset is a powerful command that can delete one or more commits from the commit history. Be cautious with this method if other collaborators are using the same repository, as it modifies history and requires a force push.

Types of git reset

• Soft: Removes the commit(s) from history but keeps the changes in the staging area.
• Mixed (default): Removes the commit(s) from history and un-stages the changes, but keeps them in the working directory.
• Hard: Removes the commit(s) from history and deletes the changes entirely from the working directory.

Steps to Remove the Last Commit Using git reset

1. To Remove the Last Commit with a Soft Reset:

   git reset --soft HEAD~1

This keeps the changes in the staging area, allowing you to modify or re-commit them.

2. To Remove the Last Commit with a Hard Reset:

   git reset --hard HEAD~1

This deletes the changes from the history and your working directory.

3. Push the Changes with a Force Push: After a reset, push the changes with --force:

   git push origin main --force

When to Use git reset

• When you need to rewrite the history before sharing with others (e.g., fixing mistakes before the initial push).
• If working alone or in a private branch where others won’t be affected.

---

Method 3: Amending the Last Commit

If you’ve just made a commit and want to make changes (e.g., update the message or add files), git commit --amend allows you to edit the last commit without creating a new one.

Steps to Amend the Last Commit

1. Edit the Last Commit: Use --amend to modify the last commit message or add/remove files:

   git commit --amend

2. Force Push the Amended Commit: After amending, force push the changes to GitHub:

   git push origin main --force

When to Use git commit --amend

• When you need to change the most recent commit before pushing it or correcting minor mistakes.
• When you want to update commit messages or add missed files.

---

Best Practices for Removing Commits on GitHub

1. Use Revert When Collaborating: If the commit has been pushed to a shared repository, use git revert to maintain history and avoid disrupting others’ work.
2. Use Reset and Force Push with Caution: Resetting is ideal for commits that haven’t been shared yet. Force pushing rewritten history can lead to conflicts, so inform team members if you use it.
3. Review Commits Before Pushing: Regularly review your commits to catch errors early. You can use git log to view recent changes or git diff to check for unstaged changes.
4. Create Backups: If you’re making significant history changes, consider creating a backup branch or tag to save the original state.

---

Common Scenarios and Recommended Approaches

1. Accidental Commit with Sensitive Information: Use git reset --hard or git filter-branch to remove the commit if it’s already pushed, and then force push.
2. Removing Multiple Commits: To remove multiple commits, use git reset with the HEAD~N syntax, where N is the number of commits to remove, followed by a force push.
3. Correcting a Mistake in the Last Commit: Use git commit --amend if it’s the most recent commit and hasn’t been pushed to the remote repository yet.

---

Troubleshooting Tips

• Rejected Force Pushes: If your force push is rejected, it could be due to branch protection settings on GitHub. Disable branch protection temporarily if needed or seek approval from the repository owner.
• Undoing a Revert: If you accidentally revert the wrong commit, you can revert the revert commit to reapply the changes.
• Collaborative Conflicts: If you force push and others have already pulled the previous history, they may encounter conflicts. Communicate with your team and provide steps to re-sync if necessary.

---

Conclusion

Removing a commit from GitHub requires a clear understanding of your goals, as each approach affects your repository differently. Whether you’re working alone or with a team, knowing when to revert, reset, or amend can help keep your Git history clean and manageable. By following the methods in this guide and adhering to best practices, you can confidently manage commit history in GitHub while minimizing potential conflicts.