Rebase last 5 commits

git rebase -i HEAD~5

Rebase all commits on current branch

git rebase -i $(git merge-base HEAD main)

Rebase onto specific commit

git rebase -i abc123

2. Cherry-Picking

Apply specific commits from one branch to another without merging entire branches.

Cherry-pick single commit

git cherry-pick abc123

Cherry-pick range of commits (exclusive start)

git cherry-pick abc123..def456

Cherry-pick without committing (stage changes only)

git cherry-pick -n abc123

Cherry-pick and edit commit message

git cherry-pick -e abc123

3. Git Bisect

Binary search through commit history to find the commit that introduced a bug.

Start bisect

git bisect start

Mark current commit as bad

git bisect bad

Mark known good commit

git bisect good v1.0.0

Git will checkout middle commit - test it

Then mark as good or bad

git bisect good # or: git bisect bad

Continue until bug found

When done

git bisect reset

Automated Bisect:

Use script to test automatically

git bisect start HEAD v1.0.0

git bisect run ./test.sh

test.sh should exit 0 for good, 1-127 (except 125) for bad

4. Worktrees

Work on multiple branches simultaneously without stashing or switching.

List existing worktrees

git worktree list

Add new worktree for feature branch

git worktree add ../project-feature feature/new-feature

Add worktree and create new branch

git worktree add -b bugfix/urgent ../project-hotfix main

Remove worktree

git worktree remove ../project-feature

Prune stale worktrees

git worktree prune

5. Reflog

Your safety net - tracks all ref movements, even deleted commits.

View reflog

git reflog

View reflog for specific branch

git reflog show feature/branch

Restore deleted commit

git reflog

Find commit hash

git checkout abc123

git branch recovered-branch

Restore deleted branch

git reflog

git branch deleted-branch abc123

Practical Workflows

Workflow 1: Clean Up Feature Branch Before PR

Start with feature branch

git checkout feature/user-auth

Interactive rebase to clean history

git rebase -i main

Example rebase operations:

- Squash "fix typo" commits

- Reword commit messages for clarity

- Reorder commits logically

- Drop unnecessary commits

Force push cleaned branch (safe if no one else is using it)

git push --force-with-lease origin feature/user-auth

Workflow 2: Apply Hotfix to Multiple Releases

Create fix on main

git checkout main

git commit -m "fix: critical security patch"

Apply to release branches

git checkout release/2.0

git cherry-pick abc123

git checkout release/1.9

git cherry-pick abc123

Handle conflicts if they arise

git cherry-pick --continue

or

git cherry-pick --abort

Workflow 3: Find Bug Introduction

Start bisect

git bisect start

git bisect bad HEAD

git bisect good v2.1.0

Git checks out middle commit - run tests

npm test

If tests fail

git bisect bad

If tests pass

git bisect good

Git will automatically checkout next commit to test

Repeat until bug found

Automated version

git bisect start HEAD v2.1.0

git bisect run npm test

Workflow 4: Multi-Branch Development

Main project directory

cd ~/projects/myapp

Create worktree for urgent bugfix

git worktree add ../myapp-hotfix hotfix/critical-bug

Work on hotfix in separate directory

cd ../myapp-hotfix

Make changes, commit

git commit -m "fix: resolve critical bug"

git push origin hotfix/critical-bug

Return to main work without interruption

cd ~/projects/myapp

git fetch origin

git cherry-pick hotfix/critical-bug

Clean up when done

git worktree remove ../myapp-hotfix

Workflow 5: Recover from Mistakes

Accidentally reset to wrong commit

git reset --hard HEAD~5 # Oh no!

Use reflog to find lost commits

git reflog

Output shows:

abc123 HEAD@{0}: reset: moving to HEAD~5

def456 HEAD@{1}: commit: my important changes

Recover lost commits

git reset --hard def456

Or create branch from lost commit

git branch recovery def456

Advanced Techniques

Rebase vs Merge Strategy

When to Rebase:

• Cleaning up local commits before pushing
• Keeping feature branch up-to-date with main
• Creating linear history for easier review

When to Merge:

• Integrating completed features into main
• Preserving exact history of collaboration
• Public branches used by others

Update feature branch with main changes (rebase)

git checkout feature/my-feature

git fetch origin

git rebase origin/main

Handle conflicts

git status

Fix conflicts in files

git add .

git rebase --continue

Or merge instead

git merge origin/main

Autosquash Workflow

Automatically squash fixup commits during rebase.

Make initial commit

git commit -m "feat: add user authentication"

Later, fix something in that commit

Stage changes

git commit --fixup HEAD # or specify commit hash

Make more changes

git commit --fixup abc123

Rebase with autosquash

git rebase -i --autosquash main

Git automatically marks fixup commits

Split Commit

Break one commit into multiple logical commits.

Start interactive rebase

git rebase -i HEAD~3

Mark commit to split with 'edit'

Git will stop at that commit

Reset commit but keep changes

git reset HEAD^

Stage and commit in logical chunks

git add file1.py

git commit -m "feat: add validation"

git add file2.py

git commit -m "feat: add error handling"

Continue rebase

git rebase --continue

Partial Cherry-Pick

Cherry-pick only specific files from a commit.

Show files in commit

git show --name-only abc123

Checkout specific files from commit

git checkout abc123 -- path/to/file1.py path/to/file2.py

Stage and commit

git commit -m "cherry-pick: apply specific changes from abc123"

Best Practices

1. Always Use --force-with-lease: Safer than --force, prevents overwriting others' work

2. Rebase Only Local Commits: Don't rebase commits that have been pushed and shared

3. Descriptive Commit Messages: Future you will thank present you

4. Atomic Commits: Each commit should be a single logical change

5. Test Before Force Push: Ensure history rewrite didn't break anything

6. Keep Reflog Aware: Remember reflog is your safety net for 90 days

7. Branch Before Risky Operations: Create backup branch before complex rebases

Safe force push

git push --force-with-lease origin feature/branch

Create backup before risky operation

git branch backup-branch

git rebase -i main

If something goes wrong

git reset --hard backup-branch

Common Pitfalls

• Rebasing Public Branches: Causes history conflicts for collaborators
• Force Pushing Without Lease: Can overwrite teammate's work
• Losing Work in Rebase: Resolve conflicts carefully, test after rebase
• Forgetting Worktree Cleanup: Orphaned worktrees consume disk space
• Not Backing Up Before Experiment: Always create safety branch
• Bisect on Dirty Working Directory: Commit or stash before bisecting

Recovery Commands

Abort operations in progress

git rebase --abort

git merge --abort

git cherry-pick --abort

git bisect reset

Restore file to version from specific commit

git restore --source=abc123 path/to/file

Undo last commit but keep changes

git reset --soft HEAD^

Undo last commit and discard changes

git reset --hard HEAD^

Recover deleted branch (within 90 days)

git reflog

git branch recovered-branch abc123