Git & GitHub Bible

6.1I committed to the wrong branch

You meant to be on feat/x but you were on main when you committed.

Run this (commit not yet pushed)

git log -1                            # note the SHA of the commit to move
git log --oneline origin/main..HEAD   # ⚠ MUST show exactly one commit
git switch feat/x                     # or: git switch -c feat/x
git cherry-pick <sha>                 # use the SHA, not the branch name
git switch main
git reset --hard HEAD~1               # ⚠ destructive; previous --oneline check is the precondition

Verify

git log --oneline -3 main             # bad commit gone
git log --oneline -3 feat/x           # bad commit landed here as new SHA

6.2Undo my last commit (keep my changes)

Last commit was wrong, but the file edits are fine — you want to redo the commit.

git reset --soft HEAD~1     # commit gone, changes still staged
# edit, restage as needed
git commit -m "better message"

Verify

git status                  # should show staged changes
git log --oneline -3

6.3Undo my last commit (discard my changes)

Last commit was wrong AND the changes are bad — throw it all away.

git status                  # confirm nothing else uncommitted you'd lose
git reset --hard HEAD~1     # ⚠ destructive

6.4Undo a commit that's already pushed

Bad commit is on a shared branch (or main). Rewriting history is unsafe.

git revert <sha>            # creates a new commit that inverts the bad one
git push

For merge commits, plain git revert errors. You must pick a parent:

git revert -m 1 <merge-sha>   # -m 1 = keep first-parent line (branch that received the merge)

6.5Fix the last commit message

Not yet pushed

git commit --amend          # opens editor for new message

Already pushed (your own feature branch)

git commit --amend
git push --force-with-lease   # ⚠ never on main/shared

Already pushed to main / shared branch: leave it. Don't rewrite history others may have pulled.

6.6I accidentally committed a secret or wrong file

Not yet pushed (last commit only)

git rm --cached <file>             # untrack but keep on disk
echo "<file>" >> .gitignore
git commit --amend --no-edit

Already pushed — the secret is already exposed

1. Rotate the secret immediately (regenerate token, change password). History rewrites alone do not protect a leaked credential.
2. Then scrub history with git-filter-repo:

   brew install git-filter-repo                   # or: pip install git-filter-repo
   git filter-repo --path <file> --invert-paths   # ⚠ rewrites entire history
   git push --force                               # ⚠ see note

   Note: this is the one place the bible uses bare --force instead of --force-with-lease (§1). filter-repo deliberately rewrites every ref; lease checks fight that intent and can leave dangling refs holding the secret.
3. Tell collaborators to re-clone. Their local clones still have the secret.

6.7My PR needs the latest changes from main

git switch main
git pull
git switch feat/x
git rebase main             # replay your commits on top of new main
# resolve any conflicts (see §6.11)
git push --force-with-lease # ⚠ rebase rewrote your SHAs

Alternative (if branch is shared)

git switch feat/x
git merge main              # creates a merge commit; no force-push needed
git push

6.8Combine my last 3 commits into 1

git rebase -i HEAD~3
# In the editor: leave first as `pick`, change others to `squash` (or `s`)
# Save, then edit the combined message in the next editor view

If already pushed (your own branch only): git push --force-with-lease ⚠

6.9Split one big commit into smaller commits

git rebase -i HEAD~N        # N puts the big commit in range
# Mark the commit `edit` (or `e`) and save. Rebase pauses there:
git reset HEAD~              # un-commit but keep changes in working dir
git add -p                   # stage one logical chunk
git commit -m "first piece"
git add -p
git commit -m "second piece"
# repeat until clean
git rebase --continue

6.10I'm mid-rebase and want out

git rebase --abort

6.11Merge conflict, and I don't know what to do

Git can't auto-merge two changes to the same lines.

git status                  # lists files "both modified"
# Open each conflicted file. Find conflict markers:
#   <<<<<<< HEAD
#   your version
#   =======
#   their version
#   >>>>>>> branch-name
# Edit to the final version. Remove all markers.
git add <resolved-file>
# When all conflicts resolved:
git merge --continue        # if mid-merge
git rebase --continue       # if mid-rebase
git cherry-pick --continue  # if mid-cherry-pick

Tools that help

git mergetool               # 3-way merge tool (configurable)
git diff                    # shows conflict hunks before resolving
git checkout --ours <file>  # take your version wholesale
git checkout --theirs <file> # take their version wholesale

6.12I deleted a branch I needed

git reflog                  # find the last commit on that branch
# Look for "checkout: moving from <branch>" or its tip
git switch -c <branch> <sha>

6.13Commit from another branch without merging the whole branch

git log --oneline other-branch    # find the SHA
git switch feat/x
git cherry-pick <sha>

Multiple commits

git cherry-pick <sha1> <sha2> <sha3>
git cherry-pick <sha1>..<sha2>     # range, exclusive of sha1

6.14I pushed to main by mistake

Haven't yet been overwritten

git revert <sha>            # creates an undo commit
git push

Broke production: revert immediately as above. Root-cause separately. Do not force-push main.

6.15Two machines have diverged on the same branch

You committed on Mac, then committed on Windows without pulling first. Both have local commits the other doesn't.

git fetch
git status                  # will say "diverged"
git pull --rebase           # replays your local commits on top of remote's
# resolve conflicts if any (§6.11)
git push

Or, to merge instead

git pull                    # creates a merge commit
git push

Prevention: push at end of every session; pull at start. See Multi-Instance Protocol.

6.16My worktree is in a weird state

worktree path is gone but git worktree list still lists it; or you can't switch branches because Git says it's checked out elsewhere.

git worktree list           # see what Git thinks exists
git worktree prune          # remove records for worktrees whose dirs are gone
git worktree remove <path>  # remove a specific one
git worktree remove --force <path>   # ⚠ if dirty

Claude Code worktrees live at ~/Documents/Development/<repo>/.claude/worktrees/<adjective-name> with branches claude/<adjective-name>. They persist after the task ends. Prune periodically with git worktree prune.

6.17Remove a file from all of git history

Giant file accidentally committed, blowing up clone size. Or a leaked secret (but rotate first — §6.6).

brew install git-filter-repo                         # or: pip install git-filter-repo
git filter-repo --path path/to/file --invert-paths   # ⚠ rewrites all history
git push --force --all                               # ⚠ bare --force intentional — see §6.6
git push --force --tags                              # ⚠ rewrites tags

Preconditions

• All collaborators warned and ready to re-clone.
• Backup of the repo exists (cp -r repo repo.bak first).
• Not on main/master of a high-traffic repo without team coordination.

6.18gh pr create failed because branch isn't pushed

git push -u origin <current-branch>
gh pr create --title "..." --body "..."

-u only needed the first time per branch.

6.19PR has conflicts and I'm scared to resolve them

Option A — locally (recommended)

gh pr checkout <pr-number>      # switches to PR's branch
git fetch origin main
git rebase origin/main          # or: git merge origin/main
# resolve conflicts (§6.11)
git push --force-with-lease     # ⚠ rebase only; plain push if you merged

Option B — in GitHub UI: click "Resolve conflicts" on the PR. Only works for simple cases.

6.20What changed between two refs?

6.21Find when a bug was introduced (git bisect)

Manual

git bisect start
git bisect bad                  # current commit is broken
git bisect good <known-good-sha>
# Git checks out a midpoint. Test it.
git bisect good                 # or: git bisect bad
# Repeat until Git names the first bad commit.
git bisect reset                # return to original HEAD

Automated

git bisect start HEAD <good-sha>
git bisect run ./test.sh        # exit 0 = good, non-zero = bad
git bisect reset