Most Git tutorials hand you 40 commands and a diagram that looks like a subway map. Real work is smaller than that. Week after week, my Git usage comes down to about a dozen commands. The rest is reference material I look up twice a year.

Here is the working set, what each one is actually for, and the three commands I have retired because they cost me more time than they saved.


The official Git site at git-scm.com — still the fastest place to check exact command flags.

The 12

1. git status
The first command of every session and the last one before I commit. It tells me what changed, what is staged, and what branch I am standing on. Half the "Git is confusing" stories start with committing from the wrong mental picture of the tree. Status fixes the picture.

2. git add -p
Stages a file in pieces instead of all at once. I use it when a file holds two unrelated changes that belong in separate commits. It walks me through each chunk and asks yes or no. Slower than git add ., and worth it.

3. git commit
With a message written for the person who reads it in six months. That person is usually me, tired, at 11 pm. "Fix null check in parser" beats "fix bug" every single time.

4. git log --oneline --graph --all
A compressed map of recent history across branches. When a merge looks odd, this is where I go before touching anything. Ten lines of output answer most "how did we get here" questions.

5. git diff
Shows unstaged changes. I read it before every commit the way you re-read an email before sending. It has caught debug print statements, test passwords, and one very embarrassing TODO addressed to myself.

6. git diff --staged
The same check for what is about to be committed. diff and diff --staged are a pair. Running only the first one is how a staged mistake slips through while you review the wrong set of changes.

7. git branch
Lists branches, and with a name after it, creates one. I keep branches short-lived and named after the task: fix/login-redirect, not new-stuff-2.

8. git switch
Moves between branches. It replaced git checkout in my muscle memory because it does one job. checkout also restores files, which is exactly how people wipe out work they meant to keep.

9. git stash
Parks half-finished work so I can jump to an urgent fix. git stash pop brings it back. It is the polite way to interrupt yourself.

10. git pull --rebase
Fetches new work and replays my local commits on top of it. The history stays a straight line instead of a braid of merge commits, and git log stays readable.

11. git blame
Shows who last touched each line of a file and in which commit. I use it to find the commit, then read that commit's message for the reasoning. Blame is archaeology, not accusation.

12. git reflog
The safety net. Reflog records where HEAD has been, including commits you think you deleted. A bad reset usually stops being bad the moment you learn this command exists.


GitHub's docs and pull request views pair with the local commands — most reviews happen there, most fixes happen in the terminal.

The 3 I stopped using

git reset --hard as an undo button. It throws away uncommitted work permanently. There is no trash folder. I once cleared an afternoon of edits with it because I wanted a "clean slate," and the slate was clean in the worst way. Now, if I want changes gone, I git stash them first. Stash is reversible. If I truly need a reset, git reflog is open in another tab before I run it, so the commit I am leaving is written down.

git push --force. It rewrites the remote branch to match mine and silently drops commits that teammates pushed after my last fetch. The replacement is git push --force-with-lease, which refuses to run if the remote has moved since I last looked. Same power, one seatbelt. On shared branches, the plain force push is off the table completely.

git add . on autopilot. It stages everything in sight: the fix, the scratch file, the local config with the test key in it. git add -p is slower by a minute and cheaper by a lot. Blind staging is how secrets end up in public repos.

The short version

Learn status, diff, add, commit, log, and stash until they are reflexes. Add switch, pull --rebase, blame, and reflog as the work demands them. Treat reset --hard and force push the way you treat a table saw: sometimes the right tool, never a casual one.

Git gets much less scary once you accept that about 12 commands carry the whole week, and that reflog forgives almost everything else.