Git Branching, History Rewriting and Recovery

AI coding tools can produce a 400-line diff in under a minute. Git is how you review that diff, keep the parts you want, and undo the rest. Interviewers test this directly with questions like: You pushed a bad commit to main. What do you do? This section covers the workflow you will use every day and the recovery moves you need when something goes wrong.

1. The mental model: commits, refs and HEAD

A commit is an immutable snapshot plus a pointer to its parent(s). Its SHA is its identity.
A branch is a movable label pointing at one commit. Committing moves the label forward.
HEAD is the commit you are currently on, usually via a branch.
Rewriting history (amend, rebase, reset) never edits commits. It creates new commits and moves the labels. The old commits stay in the object database and are reachable through the reflog. By default they are kept for at least 30 days.

The practical rule: anything you committed is recoverable, but uncommitted work is not. Commit early and often, and clean up later.

2. The everyday branching workflow

Use short-lived feature branches cut from main, and merge them back within a day or two.

code

git switch main

git pull --rebase                      # update main without a merge bubble

git switch -c feat/health-endpoint     # create and switch to a branch

# ...edit...

git add -p                             # stage hunk by hunk and review as you go

git commit -m 'Add /health endpoint returning DB status'

git push -u origin feat/health-endpoint

To keep a branch current while main moves:

code

git fetch origin

git rebase origin/main

Merge vs rebase

	git merge	git rebase
What it does	Adds a merge commit joining the two histories	Replays your commits on top of the new base
History	True record, but noisy	Linear and easy to read and bisect
Rewrites SHAs?	No	Yes
Safe on shared branches?	Yes	Only on branches nobody else builds on

never rewrite history that other people have based work on. Your own unmerged PR branch is fair game. is not.

Situation	Command
Discard unstaged edits to a file	`git restore <path>`
Unstage a file but keep the edits	`git restore --staged <path>`
Undo the last commit and keep its changes staged	`git reset --soft HEAD~1`
Undo the last commit and keep its changes unstaged	`git reset HEAD~1` (mixed is the default)
Undo the last commit and throw its changes away	`git reset --hard HEAD~1`
Undo a commit that is already on a shared branch	`git revert <sha>`
Copy one commit onto the current branch	`git cherry-pick <sha>`
Set work aside temporarily	`git stash push -m 'wip'` then `git stash pop`

Git Branching, History Rewriting and Recovery

1. The mental model: commits, refs and HEAD

2. The everyday branching workflow

Merge vs rebase

3. Rewriting your own history

4. The undo toolkit: pick the right command

5. Recovery with the reflog

6. Finding the commit that broke things: git bisect

7. Git in an AI-assisted workflow

8. Interview-ready answers

Practice