Git Workflow Strategies

The core workflow (Spec → Plan → Work → Compound) runs the same regardless of how you manage branches. This guide covers the two git strategies for isolating that work, and when to pick each one.

Strategy 1: Branch-based (serial)

The default for most tasks. You create a feature branch, run the full workflow, ship, and return to main.

git switch -c feature/add-persistence
# Spec → Plan → Work → Compound
/act:git:push-make-pr
# Merge PR on GitHub
/act:git:switch-main-pull
git branch -d feature/add-persistence

Best for	One feature at a time
Setup	None — standard git
Context switches	Stash or commit before switching
CLI sessions	One

Strategy 2: Worktree-based (parallel)

Each feature gets its own directory, branch, and Claude session. No stashing, no context switching — just open another terminal.

# Create worktrees/add-persistence/ — a sibling directory with its own branch
/git-worktree create add-persistence
# Open a new terminal at the worktree directory
cd worktrees/add-persistence
claude
# Spec → Plan → Work → Compound
/act:git:push-make-pr
# Merge PR on GitHub, then clean up
/git-worktree delete add-persistence

Best for	Parallel features or comparing approaches
Setup	ACT Pro (/git-worktree)
Context switches	Switch terminals — no stashing needed
CLI sessions	One per worktree

Worktrees share git history

All worktrees point to the same .git directory. Commits, branches, and tags are visible everywhere — only the working directory and checked-out branch differ. See the Git Worktrees playbook for detailed setup steps.

When to choose which

Factor	Branch	Worktree
One feature at a time	Yes	Overkill
Multiple features in parallel	Painful (stash/switch)	Yes
Comparing two models on the same feature	No	Yes — one worktree per model
Quick hotfix while mid-feature	Stash + switch	Create a second worktree
Disk space constrained	Lighter	Each worktree is a full checkout

Model comparison workflow

When you want to evaluate two different models (e.g., Opus vs Sonnet) on the same feature:

1. Create two worktrees from the same starting point
2. Open a Claude session in each, configured with a different model
3. Run the same spec and plan through /act:workflow:work in both
4. Compare the results — code quality, test coverage, approach
5. Keep the better result, delete the other worktree

This is the main scenario where worktrees clearly outperform branches, since you need two independent working directories at the same time.

The full cycle

Whichever strategy you choose, the end-to-end cycle looks the same:

1. Isolate — create a branch or worktree
2. Build — run the core workflow (Spec → Plan → Work)
3. Ship — /act:git:push-make-pr to create a PR
4. Merge — review and merge on GitHub
5. Capture — /act:workflow:compound to save insights
6. Clean up — delete the branch or worktree, return to main

Related

• Workflow Overview — the Spec → Plan → Work → Compound pipeline
• Git Commands — commit, push, and PR commands
• Git Worktrees — step-by-step worktree setup and usage