git rebase

History rewriter. Powerful. Don't rebase what you've already pushed.

🎯 What & why

Replay commits onto a different base. Result: a linear history where your commits appear to have been written on top of the new base. Powerful. Rewrites SHAs. Don't rebase what you've already pushed unless you and your team are on the same page.

🧠 Mental model

Rebase finds the commits unique to your branch (base..HEAD), saves them as patches, resets your branch to the new base, and re-applies the patches one by one. New commits, new SHAs. Conflicts can interrupt; resolve and git rebase --continue.

🛠️ Synopsis

git rebase [-i | --interactive] [<options>] [--exec <cmd>]
           [--onto <newbase>] [<upstream> [<branch>]]
git rebase (--continue | --skip | --abort | --quit | --edit-todo | --show-current-patch)

🎚️ Switches & options

Flag	What it does
`-i, --interactive`	Edit the rebase plan: pick, reword, edit, squash, fixup, drop.
`--onto <newbase>`	Replay commits onto `<newbase>` instead of `<upstream>`. Lets you rebase a slice.
`--autosquash`	Auto-arrange `fixup!`/`squash!` commits.
`--autostash`	Stash dirty changes before rebasing.
`--continue`	Resume after resolving conflicts.
`--abort`	Restore pre-rebase state.
`--exec <cmd>`	Run `<cmd>` after each commit during rebase. Great for tests-per-commit.

💡 Use cases

Keeping a feature branch on top of a moving main without a flurry of merge commits.
Polishing a series of commits before review.
Splitting one big commit into several (edit + git reset + multiple commits).

🧪 Examples

Rebase current branch onto latest main.

$ git fetch origin
$ git rebase origin/main

Interactive: clean up the last 5 commits.

$ git rebase -i HEAD~5

Move a slice of commits from one base to another.

$ git rebase --onto target-branch old-base feature

Run tests after each commit.

$ git rebase --exec 'make test' origin/main

🎓 Recommendations

Adopt --autostash and --autosquash globally: git config --global rebase.autoStash true rebase.autoSquash true.
Push rebased branches with --force-with-lease. Always.
Don't rebase shared long-lived branches (main, release/*).

🪤 Common pitfalls

Rebasing a public branch and force-pushing breaks every other clone of it.
Conflicts during rebase are per-commit. You can resolve, --continue, hit another conflict, repeat. Long rebases get tedious — consider merge instead.
Mid-rebase, a git commit without --continue can leave you in a confusing state.

🔗 Related modules

📝 Quiz

Hit each option, then Check answers. Score is recorded; Next is always open.