Gitoryxgit add is the first step in every Git commit workflow. This tutorial explains how staging works, how to add specific files or hunks, and how to avoid the common mistake of committing unwanted changes.
You've made changes to several files but you only want to commit one of them. Or you ran `git commit` and nothing happened because you forgot to stage anything first. Sound familiar?
The staging area is what makes Git so precise. It lets you build exactly the commit you want — including partial changes within a single file — rather than blindly committing everything at once. Mastering `git add` is the first step to writing a clean, readable Git history.
Common mistakes developers make with this:
Gitoryx: In Gitoryx, staging is visual: you see every changed file in a panel and can check individual files — or even individual lines — into the staging area before committing.
`git add` moves changes from your working directory into the staging area (also called the index). Only staged changes are included in your next commit. You can stage entire files, specific files, or even individual hunks within a file.
Before staging anything, get a clear picture of what's modified in your working directory.
git status
# Output:
# Changes not staged for commit:
# modified: src/app.ts
# modified: src/utils.ts
# Untracked files:
# README.mdRed = not staged. Green = staged. Untracked files have never been added to Git before.
Pass the file path to `git add` to stage only that file. You can list multiple files separated by spaces.
# Stage one file
git add src/app.ts
# Stage multiple files
git add src/app.ts src/utils.ts
# Stage all files in a directory
git add src/`git add .` stages every modified and untracked file in the current directory and below. Useful when you want to commit everything, but be careful — it picks up files you may not intend to track.
git add .
# Verify what's now staged
git statusAlways check your `.gitignore` before running `git add .` to make sure build artifacts, secrets, and node_modules aren't being staged.
If you only want to commit some of the changes in a file, use the `-p` (patch) flag. Git will show you each changed hunk and ask: stage it (y), skip it (n), split it (s), or edit it manually (e).
git add -p src/app.ts
# Git shows each hunk:
# @@ -10,6 +10,7 @@
# - const old = true;
# + const updated = true;
# Stage this hunk? [y,n,s,e,?]Patch mode is the key to writing atomic commits — one logical change per commit.
See this workflow in Gitoryx. See all changed files color-coded in the commit panel
Free downloadUse `git diff --staged` (or `--cached`) to see the exact diff of everything that will go into your next commit.
git diff --stagedIf you staged something by mistake, you can remove it from the staging area without losing your changes.
# Modern Git (2.23+)
git restore --staged src/utils.ts
# Older Git
git reset HEAD src/utils.tsThis often results in committing debug code, editor config files, or environment variables.
Fix: Run `git status` and `git diff` first. Use `git add -p` for fine-grained control.
Git records the state of the file at the moment you run `git add`. Any edits after that are not staged.
Fix: Re-run `git add <file>` after every edit, or use `git diff --staged` to confirm what's actually staged.
`git add .` is needed for new files that Git has never seen before — they won't be staged by other means.
Fix: Check `git status` for the 'Untracked files' section and add them explicitly.
Gitoryx — macOS, Windows & Linux`git add .` stages all changes in the current directory and subdirectories. `git add -A` stages all changes across the entire repository, including deletions and renames in any directory. In modern Git (2.x) the behavior is nearly identical when run from the repo root.
Yes. Use `git add -p` (patch mode) to interactively select which hunks within a file to stage. You can also use `git add -e` to edit the patch manually.
The new edits are not automatically staged. Git tracks the file state at the time of `git add`. You need to run `git add` again to include the latest changes.
Use `git restore --staged <file>` (Git 2.23+) or `git reset HEAD <file>` on older versions. This removes the file from the staging area without discarding your changes.
Everything in this tutorial is faster and clearer with a visual Git client. Gitoryx is free, runs natively on macOS, Windows, and Linux, and built for developers who want to move fast without breaking things.