> Analyze all React components for accessibility issues

Analyzing src/components/Button.tsx...
Analyzing src/components/Modal.tsx...
Analyzing src/components/Form.tsx...
[... 50 more files ...]

⚠️ Context limit approaching. Some files may be truncated.

> Analyze all React components for accessibility issues

Spawning sub-agents:
- Agent 1: Analyzing src/components/ui/*
- Agent 2: Analyzing src/components/forms/*
- Agent 3: Analyzing src/components/layout/*

[Agents working in parallel...]

All agents complete. Synthesizing findings:
Found 12 accessibility issues across 47 components.

> Use the Explore agent to understand the authentication system

[Explore Agent]
Analyzing authentication...

Auth System Summary:
- JWT-based authentication in src/auth/
- Session management in src/session/
- OAuth providers in src/auth/providers/
- Middleware: src/middleware/auth.ts

Key files:
- src/auth/jwt.ts (token generation)
- src/auth/verify.ts (token validation)
- src/middleware/auth.ts (route protection)

[Agent complete]

> Use the Plan agent to design a caching layer

[Plan Agent]
Designing caching solution...

Recommended Architecture:
1. Cache Layer: Redis for distributed caching
2. Cache Keys: Based on endpoint + params hash
3. TTL Strategy: 5min for listings, 1hr for static
4. Invalidation: Event-driven via message queue

Implementation Steps:
1. Set up Redis connection (src/cache/client.ts)
2. Create cache middleware (src/middleware/cache.ts)
3. Add cache decorators for services
4. Implement invalidation handlers

[Agent complete]

> Create a sub-agent to implement the user profile feature

[General Agent]
Implementing user profile...

Created:
- src/components/UserProfile.tsx
- src/api/profile.ts
- src/types/profile.ts
- tests/profile.test.ts

[Agent complete]

> /agents

Available Agents:

Built-in:
  [1] explore - Fast read-only exploration
  [2] plan - Architecture and planning
  [3] general-purpose - Full capabilities

Custom:
  [4] security-audit - Security-focused analysis
  [5] docs-generator - Documentation creation

[c] Create agent  [e] Edit agent  [d] Delete agent
[Esc] Exit

> /agents
[c] Create agent

Name: security-audit
Description: Security-focused code analysis
Allowed tools: Read, grep_search, semantic_search
System prompt: You are a security expert. Analyze code for vulnerabilities, 
exposed secrets, injection risks, and security best practices. 
Be thorough and report all findings with severity levels.

> Use sub-agents to analyze each module in parallel

Spawning agents for each module:
- Module 1: src/auth (Explore agent)
- Module 2: src/api (Explore agent)
- Module 3: src/components (Explore agent)
- Module 4: src/utils (Explore agent)

[All agents working...]

> Have the Explore agent map all database queries in the codebase

[Explore Agent]
Mapping database queries...

> Run these tasks in parallel with sub-agents:
  1. Find all TODO comments
  2. Check for deprecated API usage
  3. Identify unused exports

Spawning 3 parallel agents...

Agent 1 (TODOs): Found 23 TODO comments
Agent 2 (Deprecated): Found 5 deprecated API calls
Agent 3 (Unused): Found 12 unused exports

All agents complete.

// .claude/settings.json
{
  "agents": {
    "security-scan": {
      "description": "Security vulnerability scanner",
      "model": "claude-sonnet",
      "allowedTools": ["Read", "grep_search", "Bash(grep:*)"],
      "systemPrompt": "You are a security expert. Scan for vulnerabilities, exposed credentials, and security anti-patterns."
    },
    "docs-writer": {
      "description": "Documentation generator",
      "model": "claude-sonnet",
      "allowedTools": ["Read", "Write(docs/**)"],
      "systemPrompt": "You are a technical writer. Generate clear, comprehensive documentation."
    },
    "test-creator": {
      "description": "Test generation specialist",
      "model": "claude-sonnet",
      "allowedTools": ["Read", "Write(**/*.test.*)", "Bash(npm:test)"],
      "systemPrompt": "You are a testing expert. Create comprehensive test suites with good coverage."
    }
  }
}

Main: Analyze each microservice for API inconsistencies

Sub-agent 1 (user-service): 
  - 3 inconsistent response formats
  - Missing error codes on 2 endpoints

Sub-agent 2 (order-service):
  - Consistent patterns ✓
  - 1 deprecated endpoint in use

Sub-agent 3 (payment-service):
  - 2 inconsistent date formats
  - Non-standard status codes

Main: Synthesizing findings...

Main: I need to refactor error handling. First, have Explore 
      agents map current error patterns in each service.

Context passed to sub-agents:
- Project uses TypeScript
- Current error patterns to look for
- Reporting format expected

Sub-agents receive targeted context, not the entire conversation.

> Use Explore agents to understand this codebase structure

[Spawning Explore agents...]

Agent 1: Core architecture (src/core)
Agent 2: API layer (src/api)
Agent 3: UI components (src/components)
Agent 4: Utilities (src/utils)
Agent 5: Configuration (config, *.config.*)

[Synthesizing...]

Codebase Overview:
- Framework: Next.js 14 with App Router
- State: Zustand + React Query
- API: tRPC with Prisma ORM
- Auth: NextAuth.js with JWT
- Testing: Vitest + Playwright

Key architectural patterns:
- Feature-based folder structure
- Server/client component separation
- Centralized error handling in src/core/errors

> Refactor all API routes to use the new error handling pattern

[Creating refactoring agents...]

Agent 1: src/api/users/* (5 files)
Agent 2: src/api/products/* (8 files)
Agent 3: src/api/orders/* (6 files)
Agent 4: src/api/auth/* (4 files)

[Agents working in parallel...]

Progress:
- Agent 1: ████████░░ 80% (4/5 files)
- Agent 2: ██████░░░░ 60% (5/8 files)
- Agent 3: ████████░░ 67% (4/6 files)
- Agent 4: ██████████ 100% (4/4 files)

[All agents complete]

Summary:
- 23 files refactored
- 89 error handlers updated
- 12 type definitions added

> Create comprehensive tests for all services

[Spawning test-creator agents...]

Agent 1: UserService tests
Agent 2: OrderService tests
Agent 3: PaymentService tests
Agent 4: NotificationService tests

[Agents working...]

Created test files:
- tests/services/user.test.ts (15 tests)
- tests/services/order.test.ts (22 tests)
- tests/services/payment.test.ts (18 tests)
- tests/services/notification.test.ts (12 tests)

Total: 67 tests covering 94% of service methods

> Document all public APIs using docs-writer agents

[Spawning docs-writer agents...]

Agent 1: REST API documentation
Agent 2: GraphQL schema docs
Agent 3: SDK reference
Agent 4: Getting started guide

[Agents working...]

Generated:
- docs/api/rest.md (45 endpoints)
- docs/api/graphql.md (complete schema)
- docs/sdk/reference.md (all public methods)
- docs/getting-started.md (quickstart guide)

> Run a security audit using security-scan agents

[Spawning security-scan agents...]

Agent 1: Dependency vulnerabilities
Agent 2: Code security patterns
Agent 3: Configuration review
Agent 4: Authentication audit

[Scanning...]

Security Report:

CRITICAL (2):
- Exposed API key in src/config/legacy.ts
- SQL injection risk in src/api/search.ts

HIGH (5):
- 3 npm packages with known vulnerabilities
- Missing rate limiting on auth endpoints
- Weak password validation

MEDIUM (12):
- Various XSS prevention gaps
- Missing CSRF tokens
- Overly permissive CORS

Full report: .claude/reports/security-audit.md

# Good: Specific scope
"Analyze authentication files in src/auth"

# Bad: Too broad
"Analyze everything in src"

# Read-only task → Explore agent
# Planning task → Plan agent
# Implementation → General agent

# Good: 3-5 parallel agents
# Risky: 20 parallel agents (harder to coordinate)

"Report back with:
- List of issues found
- Severity for each
- File and line number
- Suggested fix"

Main agent should verify sub-agent results
before taking action based on them.

claude --print -p "Use Explore agents to map the codebase structure"

# .github/workflows/analysis.yml
- name: Run parallel analysis
  run: |
    claude --dangerously-skip-permissions -p \
      "Use sub-agents to analyze: 1) test coverage 2) type safety 3) lint issues"

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const response = await client.messages.create({
  model: "claude-sonnet-4-20250514",
  max_tokens: 8096,
  messages: [{
    role: "user",
    content: "Use sub-agents to analyze each module in parallel"
  }]
});

{
  "hooks": {
    "PreToolUse": [{
      "matcher": "*",
      "command": "python .claude/hooks/validate.py"
    }]
  }
}

{
  "agents": {
    "github-helper": {
      "allowedTools": ["mcp__github__*", "Read"],
      "systemPrompt": "You help with GitHub operations."
    }
  }
}

<!-- .claude/commands/audit.md -->
---
description: Full codebase audit
---

Run a comprehensive audit using sub-agents:

1. Spawn Explore agents to map the codebase
2. Spawn security-scan agents for vulnerabilities
3. Spawn a Plan agent to prioritize findings
4. Synthesize into a final report

claude --verbose

[AGENT] Spawning Explore agent for src/auth
[AGENT] Context: 2,340 tokens
[AGENT] Tools: Read, grep_search
[AGENT] Started: abc123
[AGENT] abc123: Reading src/auth/jwt.ts
[AGENT] abc123: Complete (4.2s)
[AGENT] Result: 1,200 tokens

> /export

Session exported with:
- Main agent conversation
- Sub-agent transcripts
- Tool execution history