How to Revert git add: A Complete Guide

Accidentally staging files or directories with git add is a common occurrence when working with Git. Whether you’ve staged the wrong files or want to review your changes before committing, it’s helpful to know how to revert git add without affecting the actual files. In this post, we’ll walk through the methods to unstage files, unstage directories, and manage staged changes effectively.

---

What Does git add Do?

The git add command stages files, making them ready for a commit. This moves changes from the working directory to the staging area, allowing you to commit specific changes to your Git repository. However, once a file is staged, it’s not yet committed—meaning you can still make adjustments to what is staged or unstaged as needed.

---

Why Unstage Files After Using git add?

There are several reasons to revert git add:

1. You accidentally staged the wrong files or directories.
2. You need to make additional changes to staged files before committing.
3. You want to stage only certain portions of a file.

Let’s go over the ways to revert git add to correct these situations.

---

1. Using git restore --staged (Recommended)

Starting with Git 2.23, git restore provides a safer, more targeted way to unstage files, particularly when you need to undo git add for specific files or directories.

Unstage a Single File

To remove a single file from the staging area, use:

git restore --staged <file>

Replace <file> with the path to the specific file you want to unstage. This command moves the file back to the working directory without modifying the file itself.

Unstage Multiple Files

To unstage multiple files at once, you can use:

git restore --staged <file1> <file2>

Or, if you want to unstage all files:

git restore --staged .

Note: git restore --staged only unstages files; it doesn’t discard the changes. Your files will remain modified in the working directory.

---

2. Using git reset (Another Common Approach)

Before git restore, developers used git reset to unstage files. This command is still widely used and can achieve the same effect.

Unstage a Single File with git reset

To unstage a specific file, use:

git reset <file>

This command removes the file from the staging area, keeping it in the working directory without discarding any changes.

Unstage All Staged Files

To unstage all files, use:

git reset

This moves all staged changes back to the working directory, effectively undoing git add for all files. As with git restore --staged, your modifications remain intact in the working directory.

---

3. Reviewing Staged Files with git status

To confirm which files are staged, use git status. This command provides a clear overview of your working directory and staging area, so you can identify which files you’ve added to the staging area.

git status

You’ll see sections labeled Changes to be committed for staged files and Changes not staged for commit for modified but unstaged files. This review step can be helpful when determining which files you need to unstage.

---

4. Unstaging Portions of a File (Interactive Mode)

Sometimes you may want to unstage only specific changes within a file rather than removing the entire file from staging. You can do this using interactive mode with git restore -p (patch mode).

Unstaging Lines or Hunks with git restore -p

To use patch mode for selective unstaging, enter:

git restore --staged -p <file>

You’ll be prompted with each “hunk” (or group of changes) within the file and can choose whether to unstage it. Options include:

• y: Stage this hunk.
• n: Skip this hunk.
• q: Quit.
• s: Split the hunk into smaller sections.

This interactive approach is especially useful when you need fine control over which parts of a file are staged.

---

Examples of git restore --staged and git reset

Let’s look at a few examples to make these commands clearer.

Example 1: Unstage a Single File

Suppose you’ve accidentally staged file1.txt:

git add file1.txt

To unstage it, you can use either:

git restore --staged file1.txt

or

git reset file1.txt

Both commands will move file1.txt back to the working directory.

Example 2: Unstage All Files

If you’ve staged multiple files by mistake, you can undo git add for all files:

git add .

Then, unstage everything with:

git restore --staged .

or

git reset

---

A Note on Untracked Files

If you accidentally staged an untracked file, it will be moved back to the working directory, but still remain untracked. For example:

1. Suppose you have an untracked file, newfile.txt.
2. You run git add newfile.txt.
3. You decide to unstage it:

   git restore --staged newfile.txt

This will return newfile.txt to its untracked status.

---

Comparison of git restore --staged vs. git reset

Feature	git restore --staged	git reset
Unstages files	Yes	Yes
Recommended for	Git 2.23+ users	Older versions of Git
Can unstage portions	Yes (with -p for patch mode)	No
Affects working directory	No	No

---

Conclusion

Reverting git add is straightforward with the right commands. Whether you’re using git restore --staged or git reset, these commands allow you to manage staged files without affecting the actual contents of your working directory. By understanding the difference between staged and unstaged changes, you can avoid unintended commits and ensure your staging area reflects exactly what you intend to commit. This control over your code is essential for clean, manageable, and collaborative Git workflows.