Git Essentials

Git fluency gets probed two ways: directly ("what's the difference between rebase and merge," a near-universal screen question) and indirectly - pairing sessions and take-homes where the reviewer watches you drive. The mental model that makes all of it click: a commit is an immutable snapshot, a branch is just a movable pointer to a commit, and HEAD is a pointer to the branch you're on. Almost nothing in git is destructive once committed - the reflog keeps everything reachable for ~90 days.

Committed to the wrong branch

git switch correct-branch && git cherry-pick <hash>, then back on the wrong branch: git reset --hard HEAD~1. If the right branch doesn't exist yet: git branch new-branch first, then reset the wrong one back.

Typo in the last commit message

git commit --amend -m 'fixed message'. Only if not pushed - amending rewrites the hash.

Forgot a file in the last commit

git add the-file && git commit --amend --no-edit.

Undo last commit, keep the changes

git reset --soft HEAD~1 (changes stay staged) or git reset HEAD~1 (mixed - changes back in working tree, unstaged).

Undo last commit, discard the changes

git reset --hard HEAD~1. Destructive to uncommitted work - check git status first. The commit itself is still recoverable via reflog.

Undo a commit that's already pushed

git revert <hash> - creates a new commit that inverses the old one. Never reset shared history; revert is the only polite option on main.

Unstage a file (keep edits)

git restore --staged path/to/file.

Throw away local edits to a file

git restore path/to/file. Gone for real (it was never committed) - the one genuinely destructive everyday command.

Mid-merge or mid-rebase and regretting it

git merge --abort / git rebase --abort returns you to the pre-operation state.

Deleted a branch / lost commits after a bad reset

git reflog, find the hash where life was good, then git branch rescue <hash> or git reset --hard <hash>. See the reflog section.

pick

Keep the commit as-is. The default.

reword

Keep the change, stop to edit the message.

edit

Stop at the commit to amend its contents (split it, fix a file). Continue with git rebase --continue.

squash

Meld into the previous commit; combine both messages in the editor.

fixup

Meld into the previous commit, discard this message. With git commit --fixup <hash> + git rebase -i --autosquash, git arranges these lines for you.

drop

Delete the commit (or just remove the line).

Reordering

Move lines to reorder commits. Conflicts can appear if commits touch the same lines - resolve, then --continue.

When to bother

Before opening a PR: squash the "fix typo" and "oops" commits into their parents so reviewers see a coherent story. Never on already-pushed shared branches.

git bisect start

Begin a bisect session.

git bisect bad

Mark the current (broken) commit bad.

git bisect good v1.0

Mark a known-good commit. Git checks out the midpoint; test it, then mark good/bad. Repeat until git names the first bad commit.

git bisect run ./test.sh

Full automation: the script's exit code (0 = good, non-zero = bad) drives the whole search hands-free. The flex answer in an interview.

git bisect reset

End the session, return to where you started.

git reflog records every position HEAD has had - commits, resets, rebases, checkouts - for roughly 90 days, even for commits no branch points to anymore. This is why "I lost my work" is almost never true once something was committed: find the entry before the disaster (each shows as HEAD@{n} with the action that caused it), then git reset --hard HEAD@{n} or git branch rescue HEAD@{n}. A botched rebase, an over-eager reset --hard, a deleted branch - all recoverable. The only things reflog cannot save are changes that were never committed (a discarded working tree) and repos where the reflog was expired or never local (a fresh clone has no reflog history). Interview line that lands: "reset --hard isn't scary; uncommitted changes are."

git stash push -m 'wip: auth refactor'

Shelve tracked changes and clean the working tree. Always use -m - 'WIP on main: 4f2a...' tells you nothing a week later.

git stash -u

Include untracked files (new files are skipped by default - the classic surprise).

git stash list

Show the stack: stash@{0} is the newest.

git stash pop vs apply

pop applies + drops the entry; apply keeps it (safer when conflicts are possible - a conflicted pop does not drop, but apply is easier to reason about). Target old entries: git stash apply stash@{2}.

git stash show -p

Diff a stash before applying it.

git stash branch <name>

Create a branch from the commit the stash was made on and apply it there - the escape hatch when the stash no longer applies cleanly to a moved branch.

When NOT to stash

Long-term storage. A stash is invisible to git log and easy to forget; if the work matters, commit it to a WIP branch instead.

• ·git config --global alias.lg "log --oneline --graph --all --decorate" - the history view you actually want.
• ·git push --force-with-lease, never --force. It refuses to clobber commits someone else pushed since your last fetch.
• ·git pull --rebase as default: git config --global pull.rebase true. No more accidental merge commits from pulling.
• ·git add -p - stage hunk by hunk. The single best habit for clean, reviewable commits.
• ·git commit -v - shows the diff inside the commit-message editor, so you describe what you actually changed.
• ·git diff main...HEAD (three dots) - exactly what your branch adds since it diverged, ignoring what main did meanwhile.
• ·git blame -w -C - ignore whitespace and follow code moved between files, so blame points at the real author, not the reformatter.
• ·git config --global rerere.enabled true - git remembers conflict resolutions and replays them; a lifesaver on long rebases.
• ·git log -S 'functionName' - find the commits that added or removed a string (the pickaxe). Faster than any archaeology by hand.
• ·git switch - / git checkout - - bounce to the previous branch, like cd -.
• ·git config --global fetch.prune true - deleted remote branches disappear locally on fetch instead of accumulating forever.