Initial commit

2025-11-29 18:16:40 +08:00
commit f125e90b9f
370 changed files with 67769 additions and 0 deletions
--- a/skills/devops/git-worktree-setup/examples/sample-workflows.md
+++ b/skills/devops/git-worktree-setup/examples/sample-workflows.md
@@ -0,0 +1,753 @@
+# Git Worktree Sample Workflows
+
+Real-world examples of using git worktrees with Claude Code for parallel development.
+
+## Table of Contents
+
+1. [Daily Development Workflows](#daily-development-workflows)
+2. [Code Review Workflows](#code-review-workflows)
+3. [Emergency Hotfix Workflows](#emergency-hotfix-workflows)
+4. [Experimentation Workflows](#experimentation-workflows)
+5. [Team Collaboration Workflows](#team-collaboration-workflows)
+6. [Testing and QA Workflows](#testing-and-qa-workflows)
+7. [Advanced Workflows](#advanced-workflows)
+
+---
+
+## Daily Development Workflows
+
+### Workflow 1: Parallel Feature Development
+
+**Scenario:** You're working on feature A when a new urgent feature B request comes in.
+
+**Steps:**
+
+```bash
+# Currently working on feature-authentication
+cd ~/projects/myapp
+git branch  # Shows: * feature-authentication
+
+# New request: add dashboard feature
+# Create worktree instead of switching branches
+
+User: "Create a worktree for feature-dashboard"
+
+Claude:
+✓ Creating worktree...
+  Location: ~/projects/myapp-feature-dashboard
+  Branch: feature-dashboard (new)
+  Dependencies: Installing...
+  ✓ Ready!
+
+# Open new Claude Code session
+cd ~/projects/myapp-feature-dashboard
+claude
+
+# Now have two parallel sessions:
+# Terminal 1: Working on authentication
+# Terminal 2: Working on dashboard
+```
+
+**Benefits:**
+- No context switching
+- No stashing required
+- Independent testing
+- Parallel Claude Code sessions
+
+---
+
+### Workflow 2: Bug Investigation During Feature Work
+
+**Scenario:** Mid-feature development, you need to investigate a production bug.
+
+**Steps:**
+
+```bash
+# Current state: Working on feature-redesign with uncommitted changes
+
+User: "Create a worktree from main for bugfix-login-error"
+
+Claude:
+Checking prerequisites...
+⚠️  You have uncommitted changes in current worktree
+Continue? (Current work won't be affected)
+
+User: "yes"
+
+Claude:
+✓ Creating worktree from main...
+  Location: ~/projects/myapp-bugfix-login-error
+  Branch: bugfix-login-error (from main)
+  ✓ Clean state (no redesign changes)
+  ✓ Ready!
+
+# Investigate bug in clean environment
+cd ~/projects/myapp-bugfix-login-error
+claude
+
+# After fix:
+git add .
+git commit -m "fix: resolve login redirect issue"
+git push
+
+# Create PR for bugfix
+gh pr create --title "Fix: Login redirect error"
+
+# Return to feature work
+cd ~/projects/myapp-feature-redesign
+
+# Feature work still intact with all uncommitted changes
+```
+
+**Key Points:**
+- Bug investigated in clean environment
+- Feature work undisturbed
+- Easy context switching
+- Independent commits and PRs
+
+---
+
+## Code Review Workflows
+
+### Workflow 3: PR Review Without Interruption
+
+**Scenario:** Teammate requests review while you're coding.
+
+**Steps:**
+
+```bash
+# Current: Working on feature-payments
+
+# Teammate: "Can you review PR #456?"
+
+User: "Create a worktree for PR 456 review"
+
+Claude:
+Fetching PR #456...
+PR Branch: feature-user-settings
+Author: @teammate
+
+Creating review worktree...
+✓ Location: ~/projects/myapp-review-456
+✓ Checked out: feature-user-settings
+✓ Installing dependencies...
+✓ Ready for review!
+
+# Review in fresh environment
+cd ~/projects/myapp-review-456
+claude
+
+# In Claude Code, review changes:
+# - Read code
+# - Run tests: npm test
+# - Check build: npm run build
+# - Test locally: npm run dev
+
+# Leave feedback on GitHub
+gh pr review 456 --comment --body "LGTM! Tests pass, code looks good."
+
+# Clean up review worktree
+cd ~/projects/myapp
+User: "Remove the review-456 worktree"
+
+Claude:
+✓ No uncommitted changes
+✓ Removed worktree
+✓ Disk space freed: ~850MB
+
+# Back to feature work
+cd ~/projects/myapp-feature-payments
+# Continue where you left off
+```
+
+**Benefits:**
+- Review in pristine environment
+- Your work stays untouched
+- Run tests without affecting your code
+- Quick cleanup after review
+
+---
+
+### Workflow 4: Compare Multiple PR Approaches
+
+**Scenario:** Two PRs propose different solutions to the same problem.
+
+**Steps:**
+
+```bash
+User: "Create worktrees for PR 123 and PR 124 to compare"
+
+Claude:
+Creating comparison worktrees...
+
+✓ PR #123 (approach-a): ~/projects/myapp-pr-123
+✓ PR #124 (approach-b): ~/projects/myapp-pr-124
+
+Installing dependencies in parallel...
+✓ Both environments ready!
+
+# Test approach A
+cd ~/projects/myapp-pr-123
+npm test
+npm run benchmark
+
+# Test approach B
+cd ~/projects/myapp-pr-124
+npm test
+npm run benchmark
+
+# Compare results:
+# Approach A: 250ms, cleaner code
+# Approach B: 180ms, more complex
+
+# Decision: Approve approach B, suggest code cleanup
+
+# Clean up both
+User: "Clean up PR worktrees"
+
+Claude:
+✓ Removed: myapp-pr-123
+✓ Removed: myapp-pr-124
+```
+
+**Use Case:**
+- A/B testing different implementations
+- Performance comparison
+- Side-by-side code review
+- Data-driven decisions
+
+---
+
+## Emergency Hotfix Workflows
+
+### Workflow 5: Production Hotfix During Feature Development
+
+**Scenario:** Critical production bug needs immediate fix.
+
+**Steps:**
+
+```bash
+# Current: Deep in feature development with many uncommitted changes
+
+# Alert: Production is down!
+
+User: "Create emergency hotfix worktree from production branch"
+
+Claude:
+🚨 Creating emergency hotfix...
+
+✓ Source: production branch
+✓ Location: ~/projects/myapp-hotfix-critical
+✓ Branch: hotfix-api-timeout (from production)
+✓ Clean slate (production code)
+✓ Dependencies: Installing...
+✓ Ready in 15 seconds!
+
+Next: cd ~/projects/myapp-hotfix-critical && claude
+
+# Fix in isolated environment
+cd ~/projects/myapp-hotfix-critical
+claude
+
+# In Claude Code:
+# 1. Identify issue
+# 2. Write fix
+# 3. Test thoroughly
+# 4. Deploy
+
+git add .
+git commit -m "hotfix: increase API timeout to 30s"
+git push origin hotfix-api-timeout
+
+# Deploy to production
+./deploy-hotfix.sh
+
+# Merge to main
+git checkout main
+git merge hotfix-api-timeout
+git push
+
+# Merge to feature branch too (avoid conflicts later)
+cd ~/projects/myapp-feature-redesign
+git merge main
+
+# Clean up hotfix worktree
+User: "Remove hotfix worktree"
+
+Claude:
+✓ Hotfix merged to main and feature branch
+✓ Production fixed
+✓ Removed worktree
+✓ Back to feature development
+```
+
+**Critical Benefits:**
+- Instant context switch
+- Production code isolated
+- No stashing complex changes
+- Merge back to all branches easily
+
+---
+
+### Workflow 6: Multiple Simultaneous Hotfixes
+
+**Scenario:** Multiple production issues at once.
+
+**Steps:**
+
+```bash
+User: "Create hotfix worktrees for login-bug, payment-error, and api-timeout"
+
+Claude:
+Creating 3 hotfix worktrees from production...
+
+✓ hotfix-login-bug → ~/projects/myapp-hotfix-login
+✓ hotfix-payment-error → ~/projects/myapp-hotfix-payment
+✓ hotfix-api-timeout → ~/projects/myapp-hotfix-api
+
+Installing dependencies in parallel...
+All ready!
+
+Assign to team:
+  Developer 1: cd ~/projects/myapp-hotfix-login
+  Developer 2: cd ~/projects/myapp-hotfix-payment
+  Developer 3: cd ~/projects/myapp-hotfix-api
+
+# Each developer works in isolation
+# Fixes don't conflict
+# Deploy independently
+# Merge back when done
+```
+
+**Team Benefits:**
+- Parallel hotfix development
+- No branch conflicts
+- Independent testing
+- Fast resolution
+
+---
+
+## Experimentation Workflows
+
+### Workflow 7: Test Radical Architecture Change
+
+**Scenario:** Want to try a major refactor without risking main work.
+
+**Steps:**
+
+```bash
+User: "Create an experiment worktree for testing GraphQL migration"
+
+Claude:
+Creating experiment worktree...
+✓ Location: ~/projects/myapp-experiment-graphql
+✓ Branch: experiment-graphql-migration
+✓ Based on: main
+✓ Ready for experimentation!
+
+cd ~/projects/myapp-experiment-graphql
+claude
+
+# Implement radical changes:
+# - Replace REST with GraphQL
+# - New schema design
+# - Different data layer
+
+# Test the experiment
+npm test
+npm run benchmark
+
+# Results look promising!
+# Migrate learnings to feature branch
+
+# Or if experiment fails:
+User: "Remove experiment worktree"
+
+Claude:
+✓ No harm done to main codebase
+✓ Learnings documented
+✓ Removed worktree
+```
+
+**Experimentation Benefits:**
+- Safe to fail
+- No polluting main branch
+- Easy to abandon
+- Document learnings
+
+---
+
+### Workflow 8: Performance Comparison
+
+**Scenario:** Test if optimization actually improves performance.
+
+**Steps:**
+
+```bash
+User: "Create worktrees for baseline and optimization comparison"
+
+Claude:
+Creating comparison environment...
+
+✓ Baseline: ~/projects/myapp-baseline (current main)
+✓ Optimization: ~/projects/myapp-optimized (new branch)
+
+# Test baseline
+cd ~/projects/myapp-baseline
+npm run benchmark > baseline-results.txt
+
+# Implement optimization
+cd ~/projects/myapp-optimized
+claude
+# (Make optimization changes)
+
+npm run benchmark > optimized-results.txt
+
+# Compare results
+diff baseline-results.txt optimized-results.txt
+
+# Baseline: 450ms avg
+# Optimized: 220ms avg
+# Improvement: 51% faster ✓
+
+# Optimization validated - merge it!
+git checkout main
+git merge experiment-optimized
+
+# Clean up
+User: "Remove comparison worktrees"
+```
+
+---
+
+## Team Collaboration Workflows
+
+### Workflow 9: Pair Programming Setup
+
+**Scenario:** Pair programming with screen sharing.
+
+**Steps:**
+
+```bash
+# Developer 1 (driver)
+User: "Create pairing worktree for feature-checkout"
+
+Claude:
+✓ Created: ~/projects/myapp-pairing-checkout
+✓ Fresh environment
+✓ Ready for pairing session
+
+cd ~/projects/myapp-pairing-checkout
+claude
+
+# Share screen, develop together
+# Commit frequently
+
+git add .
+git commit -m "WIP: checkout flow"
+git push
+
+# Developer 2 (navigator) checks out same worktree later
+git worktree add ~/projects/myapp-pairing-checkout pairing-checkout
+cd ~/projects/myapp-pairing-checkout
+# Continue from where Dev 1 left off
+
+# After pairing session
+User: "Merge pairing work to main feature branch"
+
+Claude:
+✓ Merged pairing-checkout → feature-checkout
+✓ Removed pairing worktree
+✓ Clean state
+```
+
+---
+
+### Workflow 10: Integration Testing Multiple Features
+
+**Scenario:** Test how three features work together before merging.
+
+**Steps:**
+
+```bash
+# Current state:
+# - feature-auth (ready)
+# - feature-dashboard (ready)
+# - feature-reports (ready)
+
+User: "Create integration worktree combining auth, dashboard, and reports"
+
+Claude:
+Creating integration environment...
+
+✓ Base: main branch
+✓ Location: ~/projects/myapp-integration-test
+✓ Branch: integration-test
+
+Merging features...
+✓ Merged: feature-auth
+✓ Merged: feature-dashboard
+✓ Merged: feature-reports
+
+Running tests...
+⚠️  2 integration test failures detected
+
+# Fix integration issues in integration worktree
+cd ~/projects/myapp-integration-test
+claude
+
+# Fix conflicts and integration issues
+git add .
+git commit -m "fix: resolve feature integration conflicts"
+
+# All tests pass!
+npm test
+# ✓ All 156 tests passing
+
+# Now safe to merge features to main
+git checkout main
+git merge feature-auth
+git merge feature-dashboard
+git merge feature-reports
+
+# Clean up
+User: "Remove integration test worktree"
+```
+
+---
+
+## Testing and QA Workflows
+
+### Workflow 11: Test Across Multiple Node Versions
+
+**Scenario:** Ensure compatibility with Node 16, 18, and 20.
+
+**Steps:**
+
+```bash
+User: "Create worktrees for testing Node 16, 18, and 20"
+
+Claude:
+Creating test environments...
+
+✓ node16: ~/projects/myapp-test-node16
+✓ node18: ~/projects/myapp-test-node18
+✓ node20: ~/projects/myapp-test-node20
+
+# Terminal 1: Node 16
+cd ~/projects/myapp-test-node16
+nvm use 16
+npm install
+npm test
+# Result: 3 failures (deprecated API)
+
+# Terminal 2: Node 18
+cd ~/projects/myapp-test-node18
+nvm use 18
+npm install
+npm test
+# Result: All pass ✓
+
+# Terminal 3: Node 20
+cd ~/projects/myapp-test-node20
+nvm use 20
+npm install
+npm test
+# Result: All pass ✓
+
+# Fix Node 16 compatibility in separate worktree
+cd ~/projects/myapp-test-node16
+claude
+# Fix deprecated API usage
+
+# All versions pass!
+```
+
+---
+
+### Workflow 12: Regression Testing
+
+**Scenario:** Test new feature doesn't break existing functionality.
+
+**Steps:**
+
+```bash
+# Have feature branch with changes
+
+User: "Create worktrees for regression testing: baseline and feature"
+
+Claude:
+Setting up regression test...
+
+✓ Baseline: ~/projects/myapp-baseline (main branch)
+✓ Feature: ~/projects/myapp-feature-new-ui
+
+# Run tests in baseline
+cd ~/projects/myapp-baseline
+npm test -- --coverage > baseline-coverage.txt
+
+# Run tests in feature
+cd ~/projects/myapp-feature-new-ui
+npm test -- --coverage > feature-coverage.txt
+
+# Compare
+diff baseline-coverage.txt feature-coverage.txt
+
+# Baseline: 142/142 tests pass, 87% coverage
+# Feature: 156/156 tests pass, 89% coverage
+# Added: 14 new tests ✓
+# Coverage improved ✓
+# No regressions ✓
+
+# Safe to merge!
+```
+
+---
+
+## Advanced Workflows
+
+### Workflow 13: Dependency Update Testing
+
+**Scenario:** Test major dependency update before applying to all branches.
+
+**Steps:**
+
+```bash
+User: "Create worktree to test React 19 upgrade"
+
+Claude:
+✓ Created: ~/projects/myapp-react19-test
+✓ Branch: test-react19-upgrade
+
+cd ~/projects/myapp-react19-test
+claude
+
+# Upgrade React
+npm install react@19 react-dom@19
+
+# Update code for breaking changes
+# Run tests
+npm test
+
+# Some failures - fix them
+# Document migration steps
+
+# Once stable, apply to feature branches
+cd ~/projects/myapp-feature-auth
+npm install react@19 react-dom@19
+# Apply same fixes
+
+# Repeat for other worktrees
+```
+
+---
+
+### Workflow 14: Database Migration Testing
+
+**Scenario:** Test database schema changes safely.
+
+**Steps:**
+
+```bash
+User: "Create worktree for testing database migration"
+
+Claude:
+✓ Created: ~/projects/myapp-db-migration-test
+✓ Using test database
+
+cd ~/projects/myapp-db-migration-test
+
+# Point to test database
+echo "DATABASE_URL=postgresql://localhost/myapp_test" > .env
+
+# Run migration
+npm run migrate:up
+
+# Test application with new schema
+npm test
+npm run dev
+
+# Migration successful!
+
+# Apply to staging/production
+# Clean up test worktree
+```
+
+---
+
+## Complete Real-World Example
+
+### Full Development Day with Worktrees
+
+```bash
+# 9:00 AM - Start day, check tasks
+git worktree list
+# Just main worktree
+
+# 9:15 AM - Start planned feature
+User: "Create worktree for feature-notifications"
+# Work on notifications...
+
+# 11:30 AM - Urgent: Review teammate's PR
+User: "Create worktree for reviewing PR 234"
+# Review, approve, remove worktree
+
+# 1:00 PM - Production bug reported
+User: "Create hotfix worktree from production"
+# Fix bug, deploy, merge back
+
+# 2:30 PM - Back to notifications feature
+cd ~/projects/myapp-feature-notifications
+# Continue where I left off
+
+# 3:00 PM - PM requests quick prototype
+User: "Create experiment worktree for dashboard prototype"
+# Build prototype, demo to PM
+# Not approved - remove worktree
+
+# 4:00 PM - Finish notifications feature
+git add .
+git commit -m "feat: add push notifications"
+git push
+
+# Create PR
+gh pr create --title "Feature: Push Notifications"
+
+# 4:30 PM - Clean up
+User: "Show my worktrees"
+
+Claude:
+Current worktrees:
+  main (clean)
+  feature-notifications (PR created)
+  hotfix-production (merged and deployed)
+
+User: "Clean up merged worktrees"
+
+Claude:
+✓ Removed: hotfix-production
+✓ Kept: feature-notifications (PR pending)
+
+# End of day - organized workspace
+```
+
+---
+
+## Summary
+
+Git worktrees enable:
+- **Parallel development** without context switching
+- **Safe experimentation** without risk
+- **Fast emergency responses** without disruption
+- **Efficient code reviews** in isolation
+- **Comprehensive testing** across environments
+- **Team collaboration** with shared workflows
+
+**Key Principles:**
+1. Create worktrees liberally - they're cheap
+2. Clean up regularly - avoid clutter
+3. Use descriptive names - future you will thank you
+4. Document team conventions - consistency matters
+5. Automate common patterns - save time
+
+**Remember:** Worktrees are a tool. Use them when they add value. Don't overcomplicate simple tasks.