Git Workflows

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.