tasq/node_modules/agentic-flow/.claude/commands/pair/examples.md

# Pair Programming Examples

Real-world examples and scenarios for pair programming sessions.

## Example 1: Feature Implementation

### Scenario
Implementing a user authentication feature with JWT tokens.

### Session Setup
```bash
claude-flow pair --start \
  --mode switch \
  --agent senior-dev \
  --focus implement \
  --verify \
  --test
```

### Session Flow
```
👥 Starting pair programming for authentication feature...

[DRIVER: You - 10 minutes]
/explain JWT authentication flow
> AI explains JWT concepts and best practices

/suggest implementation approach
> AI suggests using middleware pattern with refresh tokens

# You write the basic auth middleware structure

[SWITCH TO NAVIGATOR]

[NAVIGATOR: AI - 10 minutes]
/implement JWT token generation with refresh tokens
> AI generates secure token implementation

/test-gen
> AI creates comprehensive test suite

[SWITCH TO DRIVER]

[DRIVER: You - 10 minutes]
# You refine the implementation
/review --security
> AI performs security review, suggests improvements

/commit --message "feat: JWT authentication with refresh tokens"
✅ Truth Score: 0.98 - Committed successfully
```

## Example 2: Bug Fixing Session

### Scenario
Debugging a memory leak in a Node.js application.

### Session Setup
```bash
claude-flow pair --start \
  --mode navigator \
  --agent debugger-expert \
  --focus debug \
  --trace
```

### Session Flow
```
👥 Starting debugging session...

/status
> Analyzing application for memory issues...

/perf --profile
> Memory usage growing: 150MB → 450MB over 10 minutes

/find "new EventEmitter" --regex
> Found 3 instances of EventEmitter creation

/inspect eventEmitters --deep
> Discovering listeners not being removed

/suggest fix for memory leak
> AI suggests: "Add removeListener in cleanup functions"

/implement cleanup functions for all event emitters
> AI generates proper cleanup code

/test
> Memory stable at 150MB ✅

/commit --message "fix: memory leak in event emitters"
```

## Example 3: Test-Driven Development

### Scenario
Building a shopping cart feature using TDD.

### Session Setup
```bash
claude-flow pair --start \
  --mode tdd \
  --agent tdd-specialist \
  --test-first
```

### Session Flow
```
👥 TDD Session: Shopping Cart Feature

[RED PHASE]
/test-gen "add item to cart"
> AI writes failing test:
  ✗ should add item to cart
  ✗ should update quantity for existing item
  ✗ should calculate total price

[GREEN PHASE]
/implement minimal cart functionality
> You write just enough code to pass tests

/test
> Tests passing: 3/3 ✅

[REFACTOR PHASE]
/refactor --pattern repository
> AI refactors to repository pattern

/test
> Tests still passing: 3/3 ✅

[NEXT CYCLE]
/test-gen "remove item from cart"
> AI writes new failing tests...
```

## Example 4: Code Refactoring

### Scenario
Refactoring legacy code to modern patterns.

### Session Setup
```bash
claude-flow pair --start \
  --mode driver \
  --focus refactor \
  --verify \
  --threshold 0.98
```

### Session Flow
```
👥 Refactoring Session: Modernizing UserService

/analyze UserService.js
> AI identifies:
  - Callback hell (5 levels deep)
  - No error handling
  - Tight coupling
  - No tests

/suggest refactoring plan
> AI suggests:
  1. Convert callbacks to async/await
  2. Add error boundaries
  3. Extract dependencies
  4. Add unit tests

/test-gen --before-refactor
> AI generates tests for current behavior

/refactor callbacks to async/await
# You refactor with AI guidance

/test
> All tests passing ✅

/review --compare
> AI shows before/after comparison
> Code complexity: 35 → 12
> Truth score: 0.99 ✅

/commit --message "refactor: modernize UserService with async/await"
```

## Example 5: Learning Session

### Scenario
Learning React hooks with AI mentorship.

### Session Setup
```bash
claude-flow pair --start \
  --mode mentor \
  --agent react-expert \
  --pace slow \
  --examples
```

### Session Flow
```
👥 Learning Session: React Hooks

/learn useState hook
> AI explains with interactive examples

/example custom hook for API calls
> AI shows best practice implementation:
```javascript
function useApi(url) {
  const [data, setData] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);
  
  useEffect(() => {
    // Implementation explained step by step
  }, [url]);
  
  return { data, loading, error };
}
```

/implement my own custom hook
# You write with AI guidance

/review --educational
> AI provides detailed feedback with learning points

/quiz react hooks
> AI tests your understanding
> Score: 8/10 - Good progress!
```

## Example 6: Performance Optimization

### Scenario
Optimizing a slow React application.

### Session Setup
```bash
claude-flow pair --start \
  --mode switch \
  --agent performance-expert \
  --focus optimize \
  --profile
```

### Session Flow
```
👥 Performance Optimization Session

/perf --profile
> React DevTools Profiler Results:
  - ProductList: 450ms render
  - CartSummary: 200ms render
  - Unnecessary re-renders: 15

/suggest optimizations for ProductList
> AI suggests:
  1. Add React.memo
  2. Use useMemo for expensive calculations
  3. Implement virtualization for long lists

/implement React.memo and useMemo
# You implement with AI guidance

/perf --profile
> ProductList: 45ms render (90% improvement!) ✅

/implement virtualization with react-window
> AI implements virtual scrolling

/perf --profile
> ProductList: 12ms render (97% improvement!) ✅
> FPS: 60 stable ✅

/commit --message "perf: optimize ProductList with memoization and virtualization"
```

## Example 7: API Development

### Scenario
Building a RESTful API with Express.

### Session Setup
```bash
claude-flow pair --start \
  --mode navigator \
  --agent backend-expert \
  --focus implement \
  --test
```

### Session Flow
```
👥 API Development Session

/design REST API for blog platform
> AI designs endpoints:
  POST   /api/posts
  GET    /api/posts
  GET    /api/posts/:id
  PUT    /api/posts/:id
  DELETE /api/posts/:id

/implement CRUD endpoints with validation
> AI implements with Express + Joi validation

/test-gen --integration
> AI generates integration tests

/security --api
> AI adds:
  - Rate limiting
  - Input sanitization
  - JWT authentication
  - CORS configuration

/document --openapi
> AI generates OpenAPI documentation

/test --integration
> All endpoints tested: 15/15 ✅

/deploy --staging
> API deployed to staging environment
```

## Example 8: Database Migration

### Scenario
Migrating from MongoDB to PostgreSQL.

### Session Setup
```bash
claude-flow pair --start \
  --mode switch \
  --agent database-expert \
  --verify \
  --test
```

### Session Flow
```
👥 Database Migration Session

/analyze MongoDB schema
> AI maps current structure:
  - users collection → users table
  - posts collection → posts table
  - Embedded comments → comments table with FK

/design PostgreSQL schema
> AI creates normalized schema with relations

/implement migration script
# You write migration with AI assistance

/test --migration --sample-data
> Migration successful for 10,000 records ✅

/implement data access layer
> AI creates repository pattern implementation

/test --integration
> All queries working correctly ✅

/verify data integrity
> Truth score: 0.995 ✅
> No data loss detected
```

## Example 9: CI/CD Pipeline

### Scenario
Setting up GitHub Actions CI/CD pipeline.

### Session Setup
```bash
claude-flow pair --start \
  --mode navigator \
  --agent devops-expert \
  --focus implement
```

### Session Flow
```
👥 CI/CD Pipeline Setup

/implement GitHub Actions workflow
> AI creates .github/workflows/ci.yml:
  - Build on push/PR
  - Run tests
  - Check coverage
  - Deploy to staging

/test --ci --dry-run
> Pipeline simulation successful ✅

/implement deployment to production
> AI adds:
  - Manual approval step
  - Rollback capability
  - Health checks
  - Notifications

/security --scan-pipeline
> AI adds security scanning:
  - Dependency scanning
  - Container scanning
  - Secret scanning

/commit --message "ci: complete CI/CD pipeline with security scanning"
```

## Example 10: Mobile App Development

### Scenario
Building a React Native mobile feature.

### Session Setup
```bash
claude-flow pair --start \
  --mode switch \
  --agent mobile-expert \
  --language react-native \
  --test
```

### Session Flow
```
👥 Mobile Development Session

/implement offline-first data sync
> AI implements:
  - Local SQLite storage
  - Queue for pending changes
  - Sync on connection restore
  - Conflict resolution

/test --device ios simulator
> Feature working on iOS ✅

/test --device android emulator
> Feature working on Android ✅

/optimize --mobile
> AI optimizes:
  - Reduces bundle size by 30%
  - Implements lazy loading
  - Adds image caching

/review --accessibility
> AI ensures:
  - Screen reader support
  - Proper contrast ratios
  - Touch target sizes

/commit --message "feat: offline-first sync with optimizations"
```

## Common Patterns

### Starting Patterns
```bash
# Quick start for common scenarios
claude-flow pair --template <template>
```

Available templates:
- `feature` - New feature development
- `bugfix` - Bug fixing session
- `refactor` - Code refactoring
- `optimize` - Performance optimization
- `test` - Test writing
- `review` - Code review
- `learn` - Learning session

### Session Commands Flow

#### Typical Feature Development
```
/start → /explain → /design → /implement → /test → /review → /commit → /end
```

#### Typical Bug Fix
```
/start → /reproduce → /debug → /trace → /fix → /test → /verify → /commit → /end
```

#### Typical Refactoring
```
/start → /analyze → /plan → /test-gen → /refactor → /test → /review → /commit → /end
```

## Best Practices from Examples

1. **Always Start with Context** - Use `/explain` or `/analyze`
2. **Test Early and Often** - Run tests after each change
3. **Verify Before Commit** - Check truth scores
4. **Document Decisions** - Use `/note` for important choices
5. **Review Security** - Always run `/security` for sensitive code
6. **Profile Performance** - Use `/perf` for optimization
7. **Save Sessions** - Use `/save` for complex work

## Related Documentation

- [Getting Started](./README.md)
- [Session Management](./session.md)
- [Commands Reference](./commands.md)
- [Configuration](./config.md)