Claude Cowork in Action

> This document is a practical guide to leveraging Claude in collaborative team environments and multi-agent workflows. Learn how to orchestrate multiple Claude instances, coordinate AI-assisted development across teams, and implement effective collaboration patterns that enhance productivity while maintaining code quality and consistency.

What is Claude Cowork?

Claude Cowork refers to collaborative AI workflows where multiple Claude instances or team members work together using Claude to solve complex problems, develop features, and maintain codebases at scale.

Key Capabilities:

Multi-agent orchestration and coordination

Parallel task execution across different areas

Team-based AI-assisted development

Consistent context sharing across sessions

Collaborative code review and quality control

Distributed problem-solving workflows

Use Cases:

Large-scale feature development

Coordinated refactoring across multiple modules

Parallel bug fixing and testing

Team onboarding and knowledge transfer

Distributed system debugging

Multi-repository project management

Core Concepts

1. Agent Orchestration

Single Orchestrator Pattern: One Claude instance coordinates multiple specialized agents, each focusing on specific tasks.

Orchestrator Agent (Main)
├── Frontend Agent → UI/UX development
├── Backend Agent → API and business logic
├── Database Agent → Schema and migrations
├── Testing Agent → Test coverage
└── DevOps Agent → CI/CD and deployment

Benefits:

Centralized coordination

Clear task delegation

Reduced context conflicts

Easier progress tracking

2. Parallel Execution

Independent Task Streams: Multiple Claude sessions work simultaneously on non-overlapping areas of the codebase.

Session A: User Authentication Module
Session B: Payment Processing Module
Session C: Notification System
Session D: Analytics Dashboard

Requirements:

Clear module boundaries

Minimal cross-dependencies

Shared coding standards

Regular synchronization points

3. Context Sharing

Shared Knowledge Base:

Project documentation (CLAUDE.md)

Architecture decisions (ADR)

Coding standards and conventions

Test requirements and coverage goals

Deployment procedures

Session Continuity:

Save session transcripts for knowledge transfer

Document decisions and rationale

Maintain shared task lists

Cross-reference related work

Setup and Configuration

Project Structure

Create Shared Configuration:

.claude/
├── settings.json          # Global settings
├── settings.local.json    # Developer-specific overrides
├── commands/              # Custom slash commands
│   ├── review-pr.md
│   ├── deploy.md
│   └── sync-agents.md
├── skills/                # Reusable workflows
│   ├── frontend-dev/
│   ├── backend-dev/
│   ├── testing/
│   └── deployment/
└── templates/             # Code templates
    ├── component.tsx
    ├── api-route.ts
    └── test-suite.spec.ts

CLAUDE.md Configuration

Team Collaboration Section:

# Project: E-Commerce Platform

## Team Structure

### Agent Assignments

**Frontend Team**
- Agent A: Component library and design system
- Agent B: Page layouts and routing
- Agent C: State management and data fetching

**Backend Team**
- Agent D: API endpoints and controllers
- Agent E: Business logic and services
- Agent F: Database models and migrations

**QA Team**
- Agent G: Unit and integration tests
- Agent H: E2E tests and automation

## Coordination Rules

### Communication
- Document all decisions in session notes
- Tag related sessions: `[frontend]`, `[backend]`, `[testing]`
- Update shared task list after each session
- Notify dependencies before major changes

### Code Integration
- Create feature branches: `feat/agent-a/feature-name`
- Run full test suite before merging
- Require approval from orchestrator
- Squash commits per agent

### Conflict Resolution
- Orchestrator has final decision authority
- Defer to domain expert agents
- Document conflicts and resolutions
- Update guidelines to prevent recurrence

Settings Configuration

.claude/settings.json:

{
  "model": "claude-sonnet-4.5",
  "team": {
    "enabled": true,
    "orchestrator": "main",
    "agents": [
      {
        "id": "frontend-a",
        "role": "Frontend Developer",
        "scope": "src/components/",
        "specialization": "React components and UI"
      },
      {
        "id": "backend-a",
        "role": "Backend Developer",
        "scope": "src/api/",
        "specialization": "API development"
      },
      {
        "id": "testing-a",
        "role": "QA Engineer",
        "scope": "tests/",
        "specialization": "Test automation"
      }
    ]
  },
  "collaboration": {
    "sharedContext": true,
    "sessionLinking": true,
    "taskSynchronization": true
  },
  "mcpServers": {
    "gitnexus": {
      "command": "npx",
      "args": ["-y", "@gitnexus/mcp-server"]
    }
  }
}

Collaboration Patterns

Pattern 1: Orchestrated Development

Scenario: Building a complete feature with multiple components

Setup:

Orchestrator Session: Feature Coordinator
├── Creates feature branch
├── Breaks down requirements
├── Assigns tasks to specialist agents
├── Reviews and integrates work
└── Coordinates testing and deployment

Workflow:

Step 1: Planning (Orchestrator)
─────────────────────────────────────────
You: We need to add user profile editing functionality

Orchestrator: I'll coordinate this feature across teams:

Tasks Created:
1. [frontend-a] Create ProfileEdit component
2. [backend-a] Add PUT /api/users/:id endpoint
3. [backend-a] Add validation and authorization
4. [testing-a] Write component tests
5. [testing-a] Write API integration tests
6. [devops-a] Update deployment config

I'll assign these to specialist agents now.

Step 2: Parallel Execution
─────────────────────────────────────────
Frontend Agent Session:
You: [frontend-a] Create ProfileEdit component per task #1

Frontend Agent: Creating ProfileEdit component...
✓ Created src/components/ProfileEdit.tsx
✓ Added form validation
✓ Integrated with API client
✓ Added loading and error states

Backend Agent Session:
You: [backend-a] Add PUT /api/users/:id endpoint per task #2

Backend Agent: Creating user update endpoint...
✓ Added route handler in src/api/users.ts
✓ Implemented validation middleware
✓ Added authorization checks
✓ Updated API documentation

Step 3: Integration (Orchestrator)
─────────────────────────────────────────
You: Review and integrate completed tasks

Orchestrator: Reviewing agent work...

Frontend (Agent A):
✓ Code quality: Good
✓ Follows conventions: Yes
✓ Tests needed: Yes (flagged for testing agent)

Backend (Agent B):
✓ Code quality: Good
✓ Security: Validated
✓ Tests needed: Yes (flagged for testing agent)

Integration check:
✓ Frontend-Backend contract matches
✓ No merge conflicts
✓ All dependencies resolved

Proceeding with testing phase...

Pattern 2: Domain Expert Collaboration

Scenario: Complex problem requiring multiple specializations

Problem: Optimize slow database queries

Involved Agents:
├── Backend Agent → Identifies slow queries
├── Database Agent → Analyzes query plans
├── Performance Agent → Profiling and metrics
└── Testing Agent → Load testing and validation

Workflow:

Backend Agent:
─────────────────────────────────────────
Identified slow queries:
1. getUserPosts() - 2.3s average
2. getPostComments() - 1.8s average
3. getUserFollowers() - 3.1s average

Database Agent:
─────────────────────────────────────────
Query plan analysis:

getUserPosts():
- Missing index on posts.user_id
- Sequential scan on 1M rows
Recommendation: CREATE INDEX idx_posts_user_id

getPostComments():
- N+1 query pattern
Recommendation: Use JOIN instead of multiple queries

Performance Agent:
─────────────────────────────────────────
Profiling results:
- 80% time spent in database queries
- High memory usage from large result sets
- 200+ queries per page load

Recommendations:
1. Implement query result caching (Redis)
2. Add pagination (limit 50 per page)
3. Use database connection pooling

Testing Agent:
─────────────────────────────────────────
Load test results after optimizations:

Before:
- Avg response time: 2.3s
- 95th percentile: 4.5s
- Throughput: 45 req/s

After:
- Avg response time: 0.3s (↓87%)
- 95th percentile: 0.6s (↓87%)
- Throughput: 380 req/s (↑744%)

All tests passing ✓

Pattern 3: Continuous Integration

Scenario: Multiple agents working on the same codebase

Synchronization Points:

# Agent completes work
Agent: Completed task, ready for integration

# Run integration check
/sync-check

Orchestrator: Running integration check...

Checking:
✓ No merge conflicts
✓ All tests pass
✓ Code style consistent
✓ Documentation updated
⚠ Circular dependency detected in imports

Conflict Resolution Required:
- backend-agent modified UserService
- frontend-agent also modified UserService
- Changes overlap in validateUser() method

Resolution: Coordinating with agents...

# Merge and proceed
/integrate-changes

Orchestrator: Integrating changes...
✓ Merged backend-agent changes
✓ Merged frontend-agent changes
✓ Resolved method signature conflict
✓ Tests still passing
✓ Ready for next iteration

Advanced Workflows

Multi-Repository Coordination

Managing Microservices:

Project Structure:
├── user-service/          (Agent A)
├── order-service/         (Agent B)
├── payment-service/       (Agent C)
├── notification-service/  (Agent D)
└── api-gateway/           (Orchestrator)

Cross-Service Changes:

Orchestrator:
─────────────────────────────────────────
Task: Add order status notifications

Impact Analysis:
- order-service: Add status change events
- notification-service: Listen to events
- user-service: Get user preferences
- api-gateway: Update API contracts

Coordinating across 4 services...

Agent A (order-service):
✓ Added OrderStatusChanged event
✓ Event published to message broker
✓ Updated service API docs

Agent D (notification-service):
✓ Added event listener
✓ Implemented notification templates
✓ Integrated with email service

Agent B (user-service):
✓ Added getNotificationPreferences() API
✓ Returns user notification settings

Orchestrator (api-gateway):
✓ Updated API contracts
✓ Added new endpoints
✓ Updated OpenAPI spec

Integration:
✓ All services compatible
✓ Event flow verified
✓ E2E test passing

Knowledge Transfer Sessions

Onboarding New Team Members:

Senior Agent (Teaching Mode):
─────────────────────────────────────────
You: Explain the authentication flow to Junior Agent

Senior: I'll explain our authentication system:

Architecture Overview:
1. Client sends credentials to /api/auth/login
2. AuthController validates via AuthService
3. JWT token generated with user claims
4. Token stored in HTTP-only cookie
5. Subsequent requests validated by AuthMiddleware

Let me show you the code...

[Walks through each file]

Key Files:
• src/api/auth.ts - Entry point
• src/services/AuthService.ts - Business logic
• src/middleware/AuthMiddleware.ts - Protection
• src/utils/JwtUtils.ts - Token handling

Junior Agent Session:
─────────────────────────────────────────
You: I need to add password reset functionality

Junior: Based on what I learned, I should:

1. Add POST /api/auth/reset-password endpoint
2. Generate reset token in AuthService
3. Send email with reset link
4. Validate token on reset form submission

Senior, does this approach align with our architecture?

Senior: Correct approach! A few additions:
- Set token expiry (15 minutes)
- Rate limit reset requests
- Invalidate old tokens on success
- Log all reset attempts for security

Would you like me to review your implementation?

Parallel Testing Strategy

Distributed Test Execution:

Test Orchestrator:
─────────────────────────────────────────
Test Suite Distribution:

Agent A: Unit tests (frontend)
├── Component tests (120 tests)
├── Hook tests (45 tests)
└── Utility tests (30 tests)
Estimated: 2 minutes

Agent B: Unit tests (backend)
├── Service tests (80 tests)
├── Controller tests (55 tests)
└── Middleware tests (25 tests)
Estimated: 3 minutes

Agent C: Integration tests
├── API endpoint tests (90 tests)
├── Database tests (40 tests)
└── Auth flow tests (20 tests)
Estimated: 5 minutes

Agent D: E2E tests
├── User journeys (15 scenarios)
├── Critical paths (8 scenarios)
└── Edge cases (12 scenarios)
Estimated: 8 minutes

Running in parallel...

Results:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Agent A: ✓ 195/195 passed (1m 54s)
Agent B: ✓ 160/160 passed (2m 48s)
Agent C: ✓ 150/150 passed (4m 32s)
Agent D: ⚠ 34/35 passed (7m 21s)

Overall: 539/540 tests passed (99.8%)
Total time: 7m 21s (vs 18m sequential)
Speedup: 2.5x

Failed Test:
- E2E: User checkout with expired coupon
  Agent D investigating...

Best Practices

1. Clear Task Boundaries

✅ Good Separation:

Agent A: Implement user authentication UI
  - Login form component
  - Signup form component
  - Password reset flow
  - Client-side validation

Agent B: Implement authentication API
  - Login endpoint
  - Signup endpoint
  - Password reset endpoint
  - JWT token management

❌ Poor Separation:

Agent A: Work on authentication
Agent B: Also work on authentication
(Unclear boundaries, potential conflicts)

2. Regular Synchronization

Sync Points:

# After completing each major task
/checkpoint

Orchestrator: Checkpoint reached
- 3 agents completed tasks
- Running integration check...
- All clear, proceeding

# Before major changes
/pre-flight-check

Orchestrator: Pre-flight check
- No conflicting work in progress
- All dependencies available
- Safe to proceed

# End of work session
/session-summary

Orchestrator: Session Summary
- Tasks completed: 7
- Code changes: 15 files
- Tests added: 34
- Issues found: 2 (documented)
- Next session: Focus on issues

3. Documentation Standards

Session Documentation Template:

# Session: [Agent ID] - [Date]

## Objective
[What you're trying to accomplish]

## Context
- Related to: [Link to orchestrator session]
- Dependencies: [Other agents' work]
- Scope: [Files/modules affected]

## Work Completed
- [x] Task 1
- [x] Task 2
- [ ] Task 3 (deferred)

## Changes Made
- File 1: Added feature X
- File 2: Refactored function Y
- File 3: Fixed bug Z

## Decisions
1. Chose approach A over B because...
2. Deferred optimization for later because...

## Next Steps
- Complete remaining task
- Coordinate with Agent B on integration
- Update tests

## Notes for Team
- Breaking change: API signature updated
- New dependency: library-x v2.0
- Consider refactoring: Module Y is getting large

4. Conflict Prevention

Pre-Work Checklist:

Before starting work:
□ Check what other agents are working on
□ Verify no overlapping file modifications
□ Communicate if boundaries might overlap
□ Lock shared resources if needed
□ Update task status to "in progress"

During work:
□ Commit frequently to feature branch
□ Push changes regularly
□ Document significant decisions
□ Alert others of API changes
□ Run tests before integration

After completion:
□ Run full test suite
□ Update documentation
□ Request integration review
□ Verify no conflicts with main branch
□ Update task status to "complete"

5. Quality Gates

Multi-Agent Code Review:

Author Agent: Completed feature implementation

Review Process:
─────────────────────────────────────────
Stage 1: Automated Checks
✓ Linting passed
✓ Type checking passed
✓ Unit tests passed
✓ Code coverage: 87% (target: 80%)

Stage 2: Peer Agent Review
Frontend Agent: Reviewing backend code...
✓ API contract matches expectations
✓ Error handling appropriate
✓ Performance considerations addressed
Approval: ✓

Stage 3: Security Agent Review
Security Agent: Running security analysis...
✓ No SQL injection vectors
✓ Input validation present
✓ Authentication checks in place
⚠ Recommendation: Add rate limiting
Approval: ✓ (with recommendation)

Stage 4: Orchestrator Review
Orchestrator: Final review...
✓ Meets requirements
✓ Follows conventions
✓ Well documented
✓ Integration verified
Decision: Approved for merge

Note: Address rate limiting in next iteration

Monitoring and Analytics

Session Metrics

Track Collaboration Effectiveness:

Weekly Report:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Team Productivity:
- Total sessions: 47
- Avg session length: 34 minutes
- Tasks completed: 156
- Code commits: 203

Collaboration Metrics:
- Integration conflicts: 3 (↓40% from last week)
- Cross-agent reviews: 28
- Knowledge transfers: 12
- Pair programming sessions: 8

Code Quality:
- Test coverage: 89% (↑2%)
- Bug reports: 5 (↓3)
- Code review approval rate: 94%
- Time to merge: 2.3 hours (↓25%)

Top Performing Patterns:
1. Frontend-Backend paired development
2. Test-first parallel execution
3. Expert consultation model

Areas for Improvement:
1. Reduce frontend-devops integration time
2. Increase test automation coverage
3. Better documentation of architectural decisions

Performance Optimization

Agent Utilization:

Agent Workload Distribution:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Frontend-A:  ████████░░ 80% utilized
Backend-A:   ██████████ 100% utilized (overloaded)
Backend-B:   ████░░░░░░ 40% utilized
Testing-A:   ███████░░░ 70% utilized
DevOps-A:    █████░░░░░ 50% utilized

Recommendations:
- Redistribute backend tasks to Backend-B
- Frontend-A can assist with component testing
- DevOps-A can handle infrastructure documentation

Optimized Distribution:
Frontend-A:  ████████░░ 80% → Feature development
Backend-A:   ████████░░ 80% → Complex logic
Backend-B:   ████████░░ 80% → CRUD endpoints
Testing-A:   ████████░░ 80% → Test automation
DevOps-A:    ███████░░░ 70% → CI/CD + docs

Troubleshooting

Common Issues

Issue 1: Merge Conflicts

Problem: Two agents modified the same file

Solution:
─────────────────────────────────────────
Orchestrator: Detecting conflict...

Conflict in: src/services/UserService.ts
- Agent A: Added email verification
- Agent B: Added password strength check
- Both modified same method: createUser()

Resolution Strategy:
1. Review both implementations
2. Merge logic from both agents
3. Ensure both features work together
4. Update tests for combined functionality

Executing resolution...
✓ Merged email verification from Agent A
✓ Merged password validation from Agent B
✓ Combined in unified createUser() method
✓ Tests updated and passing

Conflict resolved!

Issue 2: Dependency Deadlock

Problem: Circular dependency between agents

Detected:
─────────────────────────────────────────
Agent A: Waiting for Agent B's API endpoint
Agent B: Waiting for Agent A's data model

Resolution:
─────────────────────────────────────────
Orchestrator: Breaking deadlock...

Solution:
1. Agent A: Create temporary data model stub
2. Agent B: Implement API with stub
3. Agent A: Complete data model
4. Agent B: Update API with real model

Executing:
✓ Agent A: Created UserModel stub
✓ Agent B: Implemented API endpoints
✓ Agent A: Completed full UserModel
✓ Agent B: Updated API integration
✓ Both agents unblocked

Issue 3: Context Divergence

Problem: Agents have inconsistent understanding

Symptoms:
─────────────────────────────────────────
- Agent A using old API conventions
- Agent B following new standards
- Integration failing due to mismatches

Solution:
─────────────────────────────────────────
Orchestrator: Synchronizing context...

Actions:
1. Update shared CLAUDE.md with latest standards
2. Broadcast update to all agents
3. Audit existing code for inconsistencies
4. Create migration plan

Synchronization:
✓ Updated documentation
✓ All agents notified
✓ Found 12 files needing updates
✓ Migration plan created
✓ Context aligned across team

Real-World Case Studies

Case Study 1: E-Commerce Platform Rebuild

Objective: Rebuild monolithic app as microservices

Team Structure:

Orchestrator (Solution Architect)
├── Frontend Team
│   ├── Agent A: Product catalog UI
│   └── Agent B: Checkout flow UI
├── Backend Team
│   ├── Agent C: Product service
│   ├── Agent D: Order service
│   └── Agent E: Payment service
└── Platform Team
    ├── Agent F: API gateway
    └── Agent G: DevOps and infrastructure

Timeline:

Week 1: Architecture and planning
  - Orchestrator: Design system architecture
  - All agents: Review and provide input
  - Result: Architecture approved

Week 2-3: Parallel development
  - Frontend agents: Build UI components
  - Backend agents: Build microservices
  - Platform agents: Setup infrastructure
  - Result: 80% core functionality complete

Week 4: Integration
  - Orchestrator: Coordinate integration
  - All agents: Fix integration issues
  - Result: Full system working end-to-end

Week 5: Testing and deployment
  - Testing agents: Comprehensive testing
  - DevOps agent: Production deployment
  - Result: Successfully deployed to production

Results:

5-week rebuild (estimated 12 weeks with traditional approach)

Zero production bugs in first month

95% test coverage across all services

Clean architecture with clear boundaries

Case Study 2: Legacy Code Refactoring

Objective: Refactor 50k-line legacy monolith

Challenges:

No documentation

Complex interdependencies

Active development during refactor

No comprehensive tests

Approach:

Phase 1: Understanding (Week 1)
─────────────────────────────────────────
Orchestrator + All agents:
- Analyze codebase structure
- Map dependencies
- Identify patterns and anti-patterns
- Document current architecture

Tools used:
- GitNexus for dependency analysis
- Multiple agents for parallel exploration
- Generated comprehensive documentation

Phase 2: Test Coverage (Week 2-3)
─────────────────────────────────────────
Testing agents:
- Write missing unit tests
- Add integration tests
- Create E2E test suite

Result: 0% → 78% coverage

Phase 3: Incremental Refactoring (Week 4-8)
─────────────────────────────────────────
Strategy: Strangler Fig pattern

Week 4: Extract authentication module
  - Agent A: New auth service
  - Agent B: Migration logic
  - Tests passing ✓

Week 5: Extract user management
  - Agent C: New user service
  - Agent D: Data migration
  - Tests passing ✓

Week 6: Extract business logic
  - Agent E: New core services
  - Agent F: API updates
  - Tests passing ✓

Week 7-8: Final migration and cleanup
  - All agents: Complete migration
  - Remove legacy code
  - Performance optimization

Results:

50k lines → 35k lines (30% reduction)

Test coverage: 0% → 85%

Performance: 2x faster

Maintainability: Significantly improved

Zero downtime during migration

Tips and Tricks

Maximize Parallel Efficiency

1. Independent Work Streams:

Plan tasks with minimal dependencies:

✅ Good:
- Agent A: Build login UI
- Agent B: Build signup UI
- Agent C: Build dashboard UI
(All can work independently)

❌ Bad:
- Agent A: Design database schema
- Agent B: Write ORM models (needs schema)
- Agent C: Write API (needs models)
(Sequential dependency chain)

2. Early Interface Definition:

Define interfaces first, implement in parallel:

Step 1: Orchestrator defines API contracts
{
  "POST /api/users": {...},
  "GET /api/users/:id": {...}
}

Step 2: Parallel implementation
- Frontend agent: Builds UI using contract
- Backend agent: Implements API per contract
- Both can work simultaneously

Effective Communication

Status Updates:

# Quick status check
/status

All Agents Status:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Frontend-A: ✓ Task complete, ready for review
Backend-A:  ⏳ In progress (70% done)
Testing-A:  ⏸️ Blocked (waiting for Backend-A)
DevOps-A:   ✓ Idle, available for new tasks

Blockers:
- Testing-A waiting on Backend-A completion
  ETA: 30 minutes

# Notify on completion
/notify testing-a

Orchestrator → Testing-A:
Backend-A has completed their work.
You can proceed with integration testing.

Resource Management

Optimize Agent Allocation:

Task: Build new feature (estimated 8 hours)

Option 1: Single Agent
- Duration: 8 hours
- Risk: Single point of failure
- Knowledge: Concentrated

Option 2: Two Agents (Parallel)
- Duration: 4-5 hours
- Risk: Coordination overhead
- Knowledge: Shared
- Efficiency: 1.6-2x

Option 3: Four Agents (Highly Parallel)
- Duration: 3-4 hours
- Risk: High coordination cost
- Knowledge: Distributed
- Efficiency: 2-2.7x (diminishing returns)

Best choice: 2 agents (optimal balance)

Resources

Claude API Docs: https://docs.anthropic.com

Multi-Agent Patterns: https://github.com/patterns/multi-agent

Best Practices: https://www.anthropic.com/best-practices

Community Examples: https://github.com/anthropics/claude-examples

Quick Reference

# ========== Team Coordination ==========
/status                  # Check all agent status
/sync-check             # Verify integration readiness
/assign <task>          # Assign task to agent
/checkpoint             # Create sync point

# ========== Session Management ==========
/link-session <id>      # Link related sessions
/session-summary        # Generate summary
/handoff <agent>        # Transfer context

# ========== Quality Control ==========
/integration-test       # Run integration tests
/conflict-check         # Check for merge conflicts
/review-request         # Request peer review

# ========== Documentation ==========
/document-session       # Document current session
/update-adr             # Update architecture decisions
/knowledge-transfer     # Create transfer document

Next Steps

Set up multi-agent configuration in .claude/settings.json

Create orchestrator session for complex projects

Define clear task boundaries and responsibilities

Establish synchronization points and checkpoints

Implement quality gates and review processes

Monitor collaboration metrics for continuous improvement

---

Last Updated: 2026-08-20 Difficulty: Intermediate Prerequisites: Familiarity with Claude Code