Multi-Branch Development

# Working on feature A
git checkout feature-a
vim src/feature-a.js
npm test  # tests running...

# Urgent bugfix needed
git stash
git checkout main
git checkout -b bugfix
# Fix bug, commit, push

# Back to feature A
git checkout feature-a
git stash pop
# Wait, what was I doing?

# Working on feature A
cd feature-a
vim src/feature-a.js
npm test  # tests running...

# Urgent bugfix needed (in new terminal)
repo wt add bugfix
cd bugfix
# Fix bug, commit, push

# Feature A is still running tests!
# No stashing, no context loss

# Start multiple features
repo wt add feature-user-auth
repo wt add feature-dashboard
repo wt add feature-analytics

# List all worktrees
repo wt list

/path/to/repo/.bare        (bare)
/path/to/repo/main         abc123 [main]
/path/to/repo/feature-user-auth    def456 [feature-user-auth]
/path/to/repo/feature-dashboard    ghi789 [feature-dashboard]
/path/to/repo/feature-analytics    jkl012 [feature-analytics]

# Open each in your editor
code /path/to/repo/feature-user-auth
code /path/to/repo/feature-dashboard
code /path/to/repo/feature-analytics

# Or use terminal navigation
repo wt go feature-user-auth

# Terminal 1: Feature development
cd feature-user-auth
vim src/auth/login.js
npm run dev  # Dev server running

# Terminal 2: Another feature
cd feature-dashboard
vim src/dashboard/stats.js
npm test -- --watch  # Tests running

# Terminal 3: Code review
repo wt pr 123
cd pr-branch
npm test

# Terminal 4: Main branch ready for hotfixes
cd main
# Always clean and up-to-date

repo wt add feature-payment-integration
repo wt add feature-email-notifications
repo wt add feature-admin-panel

repo wt add bugfix-login-timeout
repo wt add bugfix-memory-leak
repo wt add hotfix-security-patch

repo wt add experiment-new-architecture
repo wt add prototype-ui-redesign
repo wt add spike-performance-optimization

repo wt add docs-api-reference
repo wt add docs-user-guide

repo wt add release-v2.0
repo wt add release-notes-v2.0

my-project/
├── .bare/                          # Bare repository
├── .git                            # Points to .bare
├── main/                           # Main branch
├── feature-user-auth/              # Feature worktree
├── feature-dashboard/              # Feature worktree
├── bugfix-login-timeout/           # Bugfix worktree
├── experiment-new-architecture/    # Experiment worktree
└── pr-123-add-search/              # PR review worktree

# List all worktrees
repo wt list

# Filter in shell
repo wt list | grep feature
repo wt list | grep bugfix
repo wt list | grep experiment

# Find and go to feature worktrees
ls -d feature-* | head -1 | xargs repo wt go

# Open all feature worktrees in editor
code feature-*

# See all worktrees
repo wt list

# Check status of each
for dir in feature-*; do
  echo "\n=== $dir ==="
  git -C "$dir" status -s
done

# Fetch all remotes
git --git-dir=.bare fetch --all

# Update each worktree
for dir in */; do
  if [[ -d "$dir/.git" ]]; then
    echo "Updating $dir"
    git -C "$dir" pull --rebase
  fi
done

# Check disk usage
du -sh .bare      # Git objects (shared)
du -sh feature-*  # Working trees (per-worktree)

# Total space used
du -sh .

# After sprint review, clean up finished features
repo wt clean

# Remove release preparation branches
repo wt clean

# When you have >10 worktrees and lose track
repo wt clean

# Clean slate for new work
repo wt clean
repo wt add new-feature

$ repo wt clean
Removing worktree: /path/to/repo/feature-a
Removing worktree: /path/to/repo/feature-b
Warning: Could not remove /path/to/repo/feature-c (may have uncommitted changes)
Removing worktree: /path/to/repo/experiment-x
Clean complete. Remaining worktrees:
/path/to/repo/.bare        (bare)
/path/to/repo/main         abc123 [main]
/path/to/repo/feature-c    def456 [feature-c]

# See status of all worktrees
for dir in */; do
  if [[ -d "$dir/.git" ]]; then
    echo "\n=== $dir ==="
    git -C "$dir" status -s
  fi
done

cd feature-a
git add .
git commit -m "WIP: Save progress"
git push

# Now safe to clean
cd ..
repo wt clean

# Keep main and feature-a, remove others
repo wt rm feature-b
repo wt rm experiment-x
repo wt rm bugfix-old

# Or use clean and recreate what you need
repo wt clean
repo wt add feature-a  # Recreate important work

# Good
repo wt add feature-oauth-integration
repo wt add bugfix-cart-calculation
repo wt add docs-deployment-guide

# Bad
repo wt add test
repo wt add fix
repo wt add branch1

# Good: Create worktree for new work
repo wt add feature-new-thing
cd feature-new-thing

# Bad: Work directly in main
cd main
git checkout -b feature  # Don't do this

# After PR merged
repo wt rm feature-oauth

# Delete remote branch too
git push origin --delete feature-oauth

# Weekly: Review and clean
repo wt list
# Identify stale worktrees
repo wt rm old-feature
repo wt rm abandoned-experiment

# Monthly: Full clean
repo wt clean

# In each worktree, create a TODO or NOTES file
cd feature-a
echo "Working on OAuth integration" > NOTES.md
echo "TODO: Add tests" >> NOTES.md

# In your .zshrc or .bashrc
alias wtl='repo wt list'
alias wtc='repo wt clean'
alias wta='repo wt add'
alias wtg='repo wt go'

# Usage
wtl              # List worktrees
wta feature-x    # Add worktree
wtg feature-x    # Navigate to worktree

# Backend work
repo wt add feature-api-endpoint
cd feature-api-endpoint
code .
npm run dev  # Backend server

# Frontend work (parallel)
repo wt add feature-ui-component
cd feature-ui-component
code .
npm start  # Frontend dev server

# Both running simultaneously!

# Continue your feature work
cd feature-dashboard
npm run dev  # Still running

# Review PR in separate worktree
repo wt pr 456
cd pr-branch
npm test
gh pr review 456 --approve

# Back to feature work - nothing disrupted
repo wt go feature-dashboard

# Prepare release
repo wt add release-v2.0
cd release-v2.0
# Update version, changelog

# Continue development on main
cd main
git pull
# Keep working on v2.1 features

# Hotfix for v2.0 if needed
repo wt add hotfix-v2.0.1
cd hotfix-v2.0.1
# Fix critical bug