Git Workflows

Advanced git operations for real-world development. Covers interactive rebase, bisect, worktree, reflog recovery, subtrees, submodules, sparse checkout, conflict resolution, and monorepo patterns.

When to Use

Cleaning up commit history before merging (interactive rebase)
Finding which commit introduced a bug (bisect)
Working on multiple branches simultaneously (worktree)
Recovering lost commits or undoing mistakes (reflog)
Managing shared code across repos (subtree/submodule)
Resolving complex merge conflicts
Cherry-picking commits across branches or forks
Working with large monorepos (sparse checkout)

Interactive Rebase

Squash, reorder, edit commits

# Rebase last 5 commits interactively
git rebase -i HEAD~5
Rebase onto main (all commits since diverging)

git rebase -i main

The editor opens with a pick list:

pick a1b2c3d Add user model
pick e4f5g6h Fix typo in user model
pick i7j8k9l Add user controller
pick m0n1o2p Add user routes
pick q3r4s5t Fix import in controller

Commands available:

pick   = use commit as-is
reword = use commit but edit the message
edit   = stop after this commit to amend it
squash = merge into previous commit (keep both messages)
fixup  = merge into previous commit (discard this message)
drop   = remove the commit entirely

Common patterns

# Squash fix commits into their parent
# Change "pick" to "fixup" for the fix commits:
pick a1b2c3d Add user model
fixup e4f5g6h Fix typo in user model
pick i7j8k9l Add user controller
fixup q3r4s5t Fix import in controller
pick m0n1o2p Add user routes
Reorder commits (just move lines)
pick i7j8k9l Add user controller
pick m0n1o2p Add user routes
pick a1b2c3d Add user model
Split a commit into two
Mark as "edit", then when it stops:
git reset HEAD~
git add src/model.ts
git commit -m "Add user model"
git add src/controller.ts
git commit -m "Add user controller"
git rebase --continue

Autosquash (commit messages that auto-arrange)

# When committing a fix, reference the commit to squash into
git commit --fixup=a1b2c3d -m "Fix typo"
# or
git commit --squash=a1b2c3d -m "Additional changes"
Later, rebase with autosquash
git rebase -i --autosquash main
fixup/squash commits are automatically placed after their targets

Abort or continue

git rebase --abort      # Cancel and restore original state
git rebase --continue   # Continue after resolving conflicts or editing
git rebase --skip       # Skip the current commit and continue

Bisect (Find the Bug)

Binary search through commits

# Start bisect
git bisect start
Mark current commit as bad (has the bug)
git bisect bad
Mark a known-good commit (before the bug existed)
git bisect good v1.2.0
or: git bisect good abc123
Git checks out a middle commit. Test it, then:
git bisect good   # if this commit doesn't have the bug
git bisect bad    # if this commit has the bug
Repeat until git identifies the exact commit
"abc123 is the first bad commit"
Done — return to original branch
git bisect reset

Automated bisect (with a test script)

# Fully automatic: git runs the script on each commit
# Script must exit 0 for good, 1 for bad
git bisect start HEAD v1.2.0
git bisect run ./test-for-bug.sh
Example test script
cat > /tmp/test-for-bug.sh << 'EOF'
#!/bin/bash
Return 0 if bug is NOT present, 1 if it IS

npm test -- --grep "login should redirect" 2>/dev/null
EOF
chmod +x /tmp/test-for-bug.sh
git bisect run /tmp/test-for-bug.sh

Bisect with build failures

# If a commit doesn't compile, skip it
git bisect skip
Skip a range of known-broken commits

git bisect skip v1.3.0..v1.3.5

Worktree (Parallel Branches)

Work on multiple branches simultaneously

# Add a worktree for a different branch
git worktree add ../myproject-hotfix hotfix/urgent-fix
# Creates a new directory with that branch checked out
Add a worktree with a new branch
git worktree add ../myproject-feature -b feature/new-thing
List worktrees
git worktree list
Remove a worktree when done
git worktree remove ../myproject-hotfix
Prune stale worktree references

git worktree prune

Use cases

# Review a PR while keeping your current work untouched
git worktree add ../review-pr-123 origin/pr-123
Run tests on main while developing on feature branch
git worktree add ../main-tests main
cd ../main-tests && npm test
Compare behavior between branches side by side

git worktree add ../compare-old release/v1.0
git worktree add ../compare-new release/v2.0

Reflog (Recovery)

See everything git remembers

# Show reflog (all HEAD movements)
git reflog
# Output:
# abc123 HEAD@{0}: commit: Add feature
# def456 HEAD@{1}: rebase: moving to main
# ghi789 HEAD@{2}: checkout: moving from feature to main
Show reflog for a specific branch
git reflog show feature/my-branch
Show with timestamps
git reflog --date=relative

Recover from mistakes

# Undo a bad rebase (find the commit before rebase in reflog)
git reflog
# Find: "ghi789 HEAD@{5}: checkout: moving from feature to main" (pre-rebase)
git reset --hard ghi789
Recover a deleted branch
git reflog
Find the last commit on that branch
git branch recovered-branch abc123
Recover after reset --hard
git reflog
git reset --hard HEAD@{2}   # Go back 2 reflog entries
Recover a dropped stash
git fsck --unreachable | grep commit
or

git stash list  # if it's still there
git log --walk-reflogs --all -- stash  # find dropped stash commits

Cherry-Pick

Copy specific commits to another branch

# Pick a single commit
git cherry-pick abc123
Pick multiple commits
git cherry-pick abc123 def456 ghi789
Pick a range (exclusive start, inclusive end)
git cherry-pick abc123..ghi789
Pick without committing (stage changes only)
git cherry-pick --no-commit abc123
Cherry-pick from another remote/fork

git remote add upstream https://github.com/other/repo.git
git fetch upstream
git cherry-pick upstream/main~3   # 3rd commit from upstream's main

Handle conflicts during cherry-pick

# If conflicts arise:
# 1. Resolve conflicts in the files
# 2. Stage resolved files
git add resolved-file.ts
# 3. Continue
git cherry-pick --continue
Or abort

git cherry-pick --abort

Subtree and Submodule

Subtree (simpler — copies code into your repo)

# Add a subtree
git subtree add --prefix=lib/shared https://github.com/org/shared-lib.git main --squash
Pull updates from upstream
git subtree pull --prefix=lib/shared https://github.com/org/shared-lib.git main --squash
Push local changes back to upstream
git subtree push --prefix=lib/shared https://github.com/org/shared-lib.git main
Split subtree into its own branch (for extraction)

git subtree split --prefix=lib/shared -b shared-lib-standalone

Submodule (pointer to another repo at a specific commit)

# Add a submodule
git submodule add https://github.com/org/shared-lib.git lib/shared
Clone a repo with submodules
git clone --recurse-submodules https://github.com/org/main-repo.git
Initialize submodules after clone (if forgot --recurse)
git submodule update --init --recursive
Update submodules to latest
git submodule update --remote
Remove a submodule
git rm lib/shared
rm -rf .git/modules/lib/shared
Remove entry from .gitmodules if it persists

When to use which

Subtree: Simpler, no special commands for cloners, code lives in your repo.
         Use when: shared library, vendor code, infrequent upstream changes.

Submodule: Pointer to exact commit, smaller repo, clear separation.
Use when: large dependency, independent release cycle, many contributors.

Sparse Checkout (Monorepo)

Check out only the directories you need

# Enable sparse checkout
git sparse-checkout init --cone
Select directories
git sparse-checkout set packages/my-app packages/shared-lib
Add another directory
git sparse-checkout add packages/another-lib
List what's checked out
git sparse-checkout list
Disable (check out everything again)

git sparse-checkout disable

Clone with sparse checkout (large monorepos)

# Partial clone + sparse checkout (fastest for huge repos)
git clone --filter=blob:none --sparse https://github.com/org/monorepo.git
cd monorepo
git sparse-checkout set packages/my-service
No-checkout clone (just metadata)

git clone --no-checkout https://github.com/org/monorepo.git
cd monorepo
git sparse-checkout set packages/my-service
git checkout main

Conflict Resolution

Understand the conflict markers

<<<<<<< HEAD (or "ours")
Your changes on the current branch
=======
Their changes from the incoming branch
>>>>>>> feature-branch (or "theirs")

Resolution strategies

# Accept all of ours (current branch wins)
git checkout --ours path/to/file.ts
git add path/to/file.ts
Accept all of theirs (incoming branch wins)
git checkout --theirs path/to/file.ts
git add path/to/file.ts
Accept ours for ALL files
git checkout --ours .
git add .
Use a merge tool
git mergetool
See the three-way diff (base, ours, theirs)
git diff --cc path/to/file.ts
Show common ancestor version

git show :1:path/to/file.ts   # base (common ancestor)
git show :2:path/to/file.ts   # ours
git show :3:path/to/file.ts   # theirs

Rebase conflict workflow

# During rebase, conflicts appear one commit at a time
# 1. Fix the conflict in the file
# 2. Stage the fix
git add fixed-file.ts
# 3. Continue to next commit
git rebase --continue
# 4. Repeat until done
If a commit is now empty after resolution

git rebase --skip

Rerere (reuse recorded resolutions)

# Enable rerere globally
git config --global rerere.enabled true
Git remembers how you resolved conflicts
Next time the same conflict appears, it auto-resolves
See recorded resolutions
ls .git/rr-cache/
Forget a bad resolution

git rerere forget path/to/file.ts

Stash Patterns

# Stash with a message
git stash push -m "WIP: refactoring auth flow"
Stash specific files
git stash push -m "partial stash" -- src/auth.ts src/login.ts
Stash including untracked files
git stash push -u -m "with untracked"
List stashes
git stash list
Apply most recent stash (keep in stash list)
git stash apply
Apply and remove from stash list
git stash pop
Apply a specific stash
git stash apply stash@{2}
Show what's in a stash
git stash show -p stash@{0}
Create a branch from a stash
git stash branch new-feature stash@{0}
Drop a specific stash
git stash drop stash@{1}
Clear all stashes

git stash clear

Blame and Log Archaeology

# Who changed each line (with date)
git blame src/auth.ts
Blame a specific line range
git blame -L 50,70 src/auth.ts
Ignore whitespace changes in blame
git blame -w src/auth.ts
Find when a line was deleted (search all history)
git log -S "function oldName" --oneline
Find when a regex pattern was added/removed
git log -G "TODO.*hack" --oneline
Follow a file through renames
git log --follow --oneline -- src/new-name.ts
Show the commit that last touched each line, ignoring moves
git blame -M src/auth.ts
Show log with file changes
git log --stat --oneline -20
Show all commits affecting a specific file
git log --oneline -- src/auth.ts
Show diff of a specific commit
git show abc123

Tags and Releases

# Create annotated tag (preferred for releases)
git tag -a v1.2.0 -m "Release 1.2.0: Added auth module"
Create lightweight tag
git tag v1.2.0
Tag a past commit
git tag -a v1.1.0 abc123 -m "Retroactive tag for release 1.1.0"
List tags
git tag -l
git tag -l "v1.*"
Push tags
git push origin v1.2.0      # Single tag
git push origin --tags       # All tags
Delete a tag

git tag -d v1.2.0            # Local
git push origin --delete v1.2.0  # Remote

Tips

```
git rebase -i
```
is the single most useful advanced git command. Learn it first.
Never rebase commits that have been pushed to a shared branch. Rebase your local/feature work only.
```
git reflog
```
is your safety net. If you lose commits, they're almost always recoverable within 90 days.
```
git bisect run
```
with an automated test is faster than manual binary search and eliminates human error.
Worktrees are cheaper than multiple clones — they share
```
.git
```
storage.
Prefer
```
git subtree
```
over
```
git submodule
```
unless you have a specific reason. Subtrees are simpler for collaborators.
Enable
```
rerere
```
globally. It remembers conflict resolutions so you never solve the same conflict twice.
```
git stash push -m "description"
```
is much better than bare
```
git stash
```
. You'll thank yourself when you have 5 stashes.
```
git log -S "string"
```
(pickaxe) is the fastest way to find when a function or variable was added or removed.

Git Workflows

AI Skill Market Insights

Be Part of the 0+ Developer Community

Git Workflows

When to Use

Interactive Rebase

Squash, reorder, edit commits

Rebase onto main (all commits since diverging)

Common patterns

Reorder commits (just move lines)

Split a commit into two

Mark as "edit", then when it stops:

Autosquash (commit messages that auto-arrange)

Later, rebase with autosquash

fixup/squash commits are automatically placed after their targets

Abort or continue

Bisect (Find the Bug)

Binary search through commits

Mark current commit as bad (has the bug)

Mark a known-good commit (before the bug existed)

or: git bisect good abc123

Git checks out a middle commit. Test it, then:

Repeat until git identifies the exact commit

"abc123 is the first bad commit"

Done — return to original branch

Automated bisect (with a test script)

Example test script

Return 0 if bug is NOT present, 1 if it IS

Bisect with build failures

Skip a range of known-broken commits

Worktree (Parallel Branches)

Work on multiple branches simultaneously

Add a worktree with a new branch

List worktrees

Remove a worktree when done

Prune stale worktree references

Use cases

Run tests on main while developing on feature branch

Compare behavior between branches side by side

Reflog (Recovery)

See everything git remembers

Show reflog for a specific branch

Show with timestamps

Recover from mistakes

Recover a deleted branch

Find the last commit on that branch

Recover after reset --hard

Recover a dropped stash

or

Cherry-Pick

Copy specific commits to another branch

Pick multiple commits

Pick a range (exclusive start, inclusive end)

Pick without committing (stage changes only)

Cherry-pick from another remote/fork

Handle conflicts during cherry-pick

Or abort

Subtree and Submodule

Subtree (simpler — copies code into your repo)

Pull updates from upstream

Push local changes back to upstream

Split subtree into its own branch (for extraction)

Submodule (pointer to another repo at a specific commit)

Clone a repo with submodules

Initialize submodules after clone (if forgot --recurse)

Update submodules to latest

Remove a submodule

Remove entry from .gitmodules if it persists

When to use which

Sparse Checkout (Monorepo)

Check out only the directories you need

Select directories

Add another directory

List what's checked out

Disable (check out everything again)

Clone with sparse checkout (large monorepos)

No-checkout clone (just metadata)

Conflict Resolution

Understand the conflict markers

Resolution strategies