Introduction

When someone says they want to "go back to a certain commit," Git offers several different ways to do it. The right command depends on whether you need to preserve history, rewrite your own branch, or just inspect an older snapshot. Using the wrong command can create unnecessary merge conflicts or rewrite shared history.

Use git revert on Shared Branches

git revert is the safest option when commits have already been pushed and other people may have based work on them. It does not move the branch pointer backward. Instead, it creates a new commit that undoes an older one.

To revert a single commit:

git log --oneline
git revert a1b2c3d

Git opens an editor for the revert commit message unless you pass --no-edit.

If you need to undo a sequence of commits, revert the range in order from oldest to newest:

git log --oneline
git revert 9f8e7d6^..c3d4e5f

The ^ before the first hash includes that starting commit in the range. Git will apply the inverse of each commit and create new history that clearly records what happened.

This is why git revert is the normal answer for production branches such as main or release. Everyone keeps the same history, and the undo operation is explicit.

Use git reset When Rewriting Your Own Branch

If the commits are local or nobody else depends on them, git reset can move your branch back to an earlier commit. This does rewrite history, so it is best reserved for private work or coordinated cleanup.

These are the main reset modes:

1# Move HEAD, keep changes staged
2git reset --soft a1b2c3d
3
4# Move HEAD, keep changes unstaged
5git reset --mixed a1b2c3d
6
7# Move HEAD, discard changes in index and working tree
8git reset --hard a1b2c3d

--soft is useful when you want to rebuild a commit sequence. --mixed is the default and is helpful when you want the files back for editing. --hard is the most dangerous because it throws away local tracked changes.

If you already pushed the branch and still choose to reset, you will usually need a force push:

git push --force-with-lease

That command is safer than plain --force because it refuses to overwrite remote work you do not have locally.

Inspect or Branch From an Older Commit

Sometimes you do not want to undo anything yet. You just want to look at the repository at a previous point in time. In that case, detach HEAD temporarily:

git switch --detach a1b2c3d

You can build, test, or inspect files in that state. If you decide to continue working from there, create a new branch:

git switch -c investigate-old-state

This approach is useful when debugging regressions because it avoids modifying the current branch until you know what you actually want to keep.

Choosing the Right Command

A simple rule works most of the time:

• Use git revert when the history is already shared.
• Use git reset when you are cleaning up your own unpublished branch.
• Use git switch --detach when you only want to inspect an old snapshot.

That distinction matters more than memorizing command syntax. Git problems usually come from using a history-rewriting tool when the team expected a history-preserving one.

Common Pitfalls

One frequent mistake is using git reset --hard on a branch that contains uncommitted work. That command resets tracked files in the working tree as well as the branch pointer, so it is easy to lose changes you still needed.

Another mistake is force-pushing after a reset on a shared branch. If teammates already pulled the old commits, their histories no longer line up cleanly with the remote branch.

People also confuse "revert commit" with "restore file contents." git revert creates a new commit. It does not simply move HEAD backward. If you only need one file from an older commit, git restore --source may be a better fit.

Finally, reverting a merge commit has extra rules and often requires the -m option to choose the mainline parent. If the commit you want to undo is a merge, inspect it carefully before running the revert.

Summary

• "Go back to a commit" can mean revert, reset, or temporarily inspect an older snapshot.
• 'git revert is the safe choice for shared history because it adds a new undo commit.'
• 'git reset moves the branch pointer and is best for local or unpublished cleanup.'
• 'git switch --detach lets you inspect an older commit without rewriting anything.'
• The main risk is rewriting shared history when the team expected a reversible, auditable undo.