Day 17/30 - Git Revert --no-commit: Revert Multiple Commits Without Auto-Committing

Introduction

Git is a powerful version control system that helps developers manage code changes efficiently. One of its useful features is the ability to revert commits---undoing changes from previous commits. The git revert command is commonly used for this, but the --no-commit flag adds extra flexibility, especially when reverting multiple commits.

In this guide, we'll explore git revert --no-commit for beginners, intermediate, and advanced users, with practical examples at each level.

1. Understanding git revert

What is git revert?

git revert creates a new commit that undoes the changes from a previous commit. Unlike git reset, it doesn't delete history---making it safe for shared repositories.

Basic Syntax:

git revert <commit-hash>

This creates a new commit that reverses the changes from <commit-hash>.

Example:

Suppose we have commits:

A -- B -- C (HEAD)

To revert commit B:

git revert B

This adds a new commit D that undoes B:

A -- B -- C -- D (HEAD)

2. Introducing --no-commit

Why Use --no-commit?

By default, git revert auto-commits changes. But sometimes, you want to:

• Revert multiple commits at once.

• Review changes before committing.

• Combine multiple reverts into a single commit.

Syntax:

git revert --no-commit <commit-hash>

This applies the revert but does not commit it.

Example: Reverting Multiple Commits

Given:

A -- B -- C (HEAD)

To revert both B and C in one commit:

git revert --no-commit C
git revert --no-commit B
git commit -m "Reverted B and C together"

Now, the history looks like:

A -- B -- C -- D (HEAD)

Where D undoes both B and C.

Pro Tips & Tricks for Efficient Undoing

Using git revert --no-commit effectively requires more than just knowing the syntax. Here are pro tips and tricks to help you master reverting commits like a Git expert!

1. Reverting a Range of Commits (Without Auto-Commit)

Problem:  

You want to undo multiple commits in a range (e.g., commitA to commitD), but don't want separate revert commits.

Solution:  

Use git revert --no-commit with a commit range.

Example:

git revert --no-commit oldest-commit^..newest-commit

• oldest-commit^ ensures the oldest commit is included.

Demo:

# Revert commits B, C, and D in one go

git revert --no-commit B^..D

git commit -m "Reverted commits B, C, and D together"

Result:

• A single commit undoes all changes from B to D.

2. Interactive Revert (Selectively Undoing Changes)

Problem:

You want to revert a commit but keep some changes from it.

Solution:

1. Revert with --no-commit.  

2. Manually edit files before committing.

Example:

git revert --no-commit C

# Check changes with git status

git status

# Manually edit files to keep desired changes

git add .

git commit -m "Partial revert of C (kept critical fixes)"

Use Case:  

• You revert a feature but want to keep a bug fix from the same commit.

3. Combining Reverts with Fixes (Atomic Undo + Patch)

Problem:  

You want to revert a commit but immediately apply a fix in the same commit.

Solution:  

1. Revert with --no-commit.  

2. Apply fixes.  

3. Commit everything together.

Example:

git revert --no-commit B

# Fix a related bug

echo "Hotfix for edge case" >> file.txt

git add .

git commit -m "Reverted B + added critical hotfix"

Result:

• Clean history with one commit for both revert and fix.

4. Reverting a Merge Commit (Advanced Conflict Handling)

Problem:  

Merge commits (git merge) are tricky to revert because they involve multiple parents.

Solution:  

Use -m to specify the mainline parent (usually 1 for the branch you merged into).

Example:

git revert --no-commit -m 1 MERGE_COMMIT_HASH

# Resolve conflicts if any

git commit -m "Reverted problematic merge"

When to Use:  

• When a git merge introduced bugs and needs undoing.

5. Dry Run Before Reverting (Safety Check)

Problem:  

You want to preview what git revert will do before applying it.

Solution:

Use git revert -n --no-commit + git diff to inspect changes.

Example:

git revert -n B  # Same as --no-commit

git diff         # See what changes will be undone

# If okay:

git commit -m "Reverted B after review"

# If not okay:

git reset --hard

Benefit:

• Avoids accidental reverts by checking changes first.

Conclusion

git revert --no-commit is a powerful, flexible tool for undoing changes without immediately committing them. Whether you're a beginner learning Git basics, an intermediate user optimizing workflows, or an advanced developer handling complex reverts, this command helps you:

• Revert multiple commits in one go (cleaner history).
• Partially undo changes while keeping critical fixes.
• Resolve conflicts before finalizing (safer reverts).
• Combine reverts with new fixes in a single commit.

Quick Cheat Sheet

Up Next in the Series: git stash --patch – Stash only specific changes interactively

Daily advance GIT tips in your inbox---worth starting? Respond to my poll here🚀

For more useful and innovative tips and tricks, Let's connect on Medium