Staging and Committing

Recording work in Git is a two-step loop: git add selects changes into the index, and git commit writes them as a permanent snapshot with a message. The split feels like a chore at first, but the staging step is exactly what lets you turn a messy working tree into a series of clean, reviewable commits.

The commit is the unit everything downstream depends on — git log, code review, git revert, and git bisect all operate on commits. A commit that bundles three unrelated changes cannot be reverted surgically or reviewed cleanly, so the discipline you apply at this step is what makes the history worth reading later.

The Add-Then-Commit Loop

git add <paths> copies the current content of those paths into the index; git commit then writes whatever is in the index as a new commit and advances the branch. The two steps are separate because the index is a real layer you build up deliberately — you can stage some changes, leave others alone, and commit only the coherent subset, instead of being forced to commit the whole working tree at once.

Partial Staging

git add -p walks you through each changed hunk and asks whether to stage it. This is the lever that turns one chaotic afternoon of edits into separate commits: stage the hunks belonging to the bug fix, commit, then stage the refactor hunks and commit those separately. The result is a history where each commit is one logical change, which is what makes review and a later git revert precise rather than all-or-nothing.

Writing Commit Messages

A good message is a summary line under about 50 characters, a blank line, then a body that explains why the change exists — the diff already shows what changed. Future-you reading git log or git blame needs the reasoning, not a restatement of the patch. Conventions like Conventional Commits (fix:, feat:) add machine-readable structure on top, useful for generating changelogs, but the body explaining intent is the part that pays off.

Amending the Last Commit

git commit --amend replaces the most recent commit — to fix a typo in the message or add a file you forgot to stage. It does not edit the commit in place; it creates a new commit with a new hash and moves the branch to it. That is why it is safe only before pushing: once others have pulled the original commit, amending rewrites history they already have, and their next pull diverges.

Shortcuts and Their Traps

git commit -a auto-stages modified tracked files and commits in one step. The trap is in the word "tracked": it does nothing for new, untracked files, so a brand-new file is silently left out of the commit. It also skips the staging review the index gives you, so you lose the chance to confirm exactly what is going in. Convenient for a quick edit to known files, dangerous as a reflex.