Built-in Agent Types
Claude Code comes with several specialized agent types, each optimized for specific tasks.
1. The Explore Agent
Purpose: Fast codebase exploration and understanding
When to Use:
- Understanding new codebases
- Finding where specific functionality lives
- Answering questions about code structure
- Searching for patterns or implementations
Triggering the Explore Agent:
Search the codebase for all places where we handle user authentication.
Show me the authentication flow from login to session creation.
Or more explicitly:
Use the explore agent to find all API routes that require authentication
and map out the middleware chain.
What Makes It Special:
- Optimized for reading, not writing
- Uses Glob and Grep efficiently
- Maintains a mental map of the codebase
- Can specify thoroughness: "quick", "medium", "very thorough"
Power User Tip:
Use a "very thorough" explore agent to create a complete
architecture document for this codebase. Include:
- All major modules and their responsibilities
- Data flow diagrams
- External dependencies
- Potential circular dependencies
2. The Plan Agent
Purpose: Software architecture and implementation planning
When to Use:
- Designing new features
- Planning refactoring efforts
- Architectural decisions
- Complex multi-step implementations
Triggering the Plan Agent:
Enter planning mode for implementing a real-time notification system.
Consider scalability, existing patterns, and mobile support.
Output Structure:
The Plan agent produces structured implementation plans:
# Implementation Plan: Real-time Notifications
## Overview
[High-level description]
## Phase 1: Infrastructure
- [ ] Set up WebSocket server
- [ ] Create notification database schema
- [ ] Implement pub/sub system
## Phase 2: Backend
- [ ] Create notification service
- [ ] Add API endpoints
- [ ] Implement rate limiting
## Phase 3: Frontend
- [ ] Create notification context
- [ ] Build notification components
- [ ] Add sound and visual alerts
## Files to Create/Modify
- src/services/notification.ts (create)
- src/lib/websocket.ts (create)
- src/components/NotificationBell.tsx (create)
- src/app/api/notifications/route.ts (create)
## Risks and Mitigations
[Identified risks and how to handle them]
3. The Code Reviewer Agent
Purpose: Deep code review for quality, bugs, and security
When to Use:
- Before merging PRs
- After implementing features
- Security audits
- Performance reviews
Triggering the Code Reviewer:
Review the authentication module for:
- Security vulnerabilities
- Logic errors
- Performance issues
- Best practice violations
Be harsh. I want production-ready code.
Review Output Structure:
4. The Code Explorer Agent
Purpose: Deep analysis of existing features and patterns
When to Use:
- Understanding complex features
- Tracing execution paths
- Mapping dependencies
- Learning from existing implementations
Example Usage:
Use the code explorer agent to trace the complete checkout flow.
Start from the "Add to Cart" button and follow through to payment
confirmation. Document every function call, state change, and
API request.
5. The Code Architect Agent
Purpose: Designing feature architectures and structures
When to Use:
- New feature design
- System design decisions
- Component architecture
- API design
Example Usage:
Use the code architect agent to design a multi-tenant
architecture for our SaaS platform. Consider:
- Database isolation strategies
- Authentication scoping
- Resource quotas
- Billing integration
Agent Comparison Table
Skills System
Skills are pre-packaged workflows triggered by slash commands. Think of them as "macros" that execute complex multi-step processes.
Built-in Skills
The /commit Skill
What happens:
- Runs
git status to see changes
- Runs
git diff to analyze modifications
- Reads recent commit history for style matching
- Generates a conventional commit message
- Stages appropriate files
- Creates the commit
Pro Tip: Claude follows your project's commit style automatically!
The /review-pr Skill
What happens:
- Fetches PR #123 details from GitHub
- Analyzes all changed files
- Runs multiple review agents in parallel
- Consolidates findings
- Provides comprehensive review
The /init Skill
Initializes Claude Code in a new project:
- Scans project structure
- Identifies tech stack
- Creates/updates CLAUDE.md
- Sets up appropriate configurations
Creating Custom Skills
You can create your own skills by adding them to your plugin configuration.
Example: Custom Deploy Skill
# .claude/plugins/deploy/skills/deploy.yaml
name: deploy
description: Deploy to production with safety checks
content: |
## Pre-deployment Checklist
Before deploying, verify:
1. All tests pass
2. No TypeScript errors
3. Lint checks pass
4. Build succeeds
Then execute:
1. Run test suite
2. Build production bundle
3. Run deployment script
4. Verify deployment health
5. Notify team
Usage:
Skill Chaining
Skills can trigger other skills:
This might internally trigger:
/plan – Design the feature- Implementation phase
/review – Review the code/test – Run tests/commit – Commit changes
Coworks Integration
Coworks enables multi-session collaboration—multiple Claude instances working together on different aspects of your project.
The Concept
┌─────────────────────────────────────────────────┐
│ YOUR PROJECT │
└─────────────────────────────────────────────────┘
│ │ │
▼ ▼ ▼
┌───────────┐ ┌───────────┐ ┌───────────┐
│ Session 1 │ │ Session 2 │ │ Session 3 │
│ │ │ │ │ │
│ Frontend │ │ Backend │ │ Tests │
│ Work │ │ Work │ │ Work │
└─────┬─────┘ └─────┬─────┘ └─────┬─────┘
│ │ │
└──────────────┼──────────────┘
│
▼
┌─────────────────┐
│ Shared Context │
│ & File System │
└─────────────────┘
Setting Up Coworks
Terminal 1 – Frontend Work:
cd my-project
claude --session frontend
Terminal 2 – Backend Work:
cd my-project
claude --session backend
Terminal 3 – Test Writing:
cd my-project
claude --session tests
Communication Between Sessions
Sessions can communicate through:
- Shared Files – Write to coordination files
- Git Branches – Each session on different branch
- Task Files – Shared TODO files
Example Workflow:
# .claude/cowork-tasks.md
## Frontend (Session: frontend)
- [x] Create Dashboard component
- [ ] Implement data fetching
- [ ] Waiting for: Backend API endpoints
## Backend (Session: backend)
- [x] Set up database schema
- [ ] Create API endpoints (IN PROGRESS)
- [ ] Notify frontend when ready
## Tests (Session: tests)
- [ ] Waiting for: Components to be created
- [ ] Write integration tests
Real-World Coworks Pattern
Scenario: Building a complete feature with frontend, backend, and tests simultaneously.
Session 1 (Backend):
You're working on the backend for a user profile feature.
Create the API endpoints and database schema.
Update .claude/cowork-tasks.md when endpoints are ready.
Session 2 (Frontend):
You're working on the frontend for a user profile feature.
Watch .claude/cowork-tasks.md for backend API availability.
Create components with mock data first, then integrate.
Session 3 (Tests):
You're writing tests for the user profile feature.
Watch for completed components and endpoints.
Write tests as features become available.
Building Custom Agents
The real power comes from creating your own specialized agents.
Agent Definition Structure
// .claude/plugins/my-plugin/agents/security-auditor.ts
export const securityAuditor = {
name: "security-auditor",
description: "Performs comprehensive security audits",
// When this agent should be suggested
triggerPatterns: [
"security audit",
"check for vulnerabilities",
"pen test",
"security review"
],
// Tools this agent can use
tools: ["Read", "Grep", "Glob", "WebSearch"],
// System prompt for the agent
systemPrompt: `
You are a senior security engineer performing a code audit.
Your checklist:
1. OWASP Top 10 vulnerabilities
2. Authentication/Authorization flaws
3. Input validation issues
4. Sensitive data exposure
5. Security misconfiguration
6. Injection vulnerabilities
7. Cryptographic failures
For each finding:
- Severity (Critical/High/Medium/Low)
- Location (file:line)
- Description
- Proof of concept (if applicable)
- Remediation steps
Be thorough. Assume an attacker mindset.
`
};
Example Custom Agents
1. The Documentation Agent
name: documentation-generator
description: Generates comprehensive documentation
tools: [Read, Glob, Write]
systemPrompt: |
You are a technical writer creating documentation.
For each module:
- Purpose and responsibility
- Public API reference
- Usage examples
- Common patterns
- Troubleshooting guide
Use clear, concise language. Include code examples.
Follow the existing documentation style.
2. The Performance Analyzer
name: performance-analyzer
description: Analyzes code for performance issues
tools: [Read, Grep, Glob, Bash]
systemPrompt: |
You are a performance engineer analyzing code.
Look for:
- N+1 query patterns
- Unnecessary re-renders
- Memory leaks
- Blocking operations
- Missing caching opportunities
- Inefficient algorithms
Provide:
- Issue description
- Performance impact (estimated)
- Before/after code
- Benchmarking suggestions
3. The Migration Agent
name: migration-assistant
description: Helps with framework/library migrations
tools: [Read, Write, Edit, Glob, Grep, WebSearch]
systemPrompt: |
You are a migration specialist.
Your process:
1. Analyze current implementation
2. Research target patterns
3. Create migration plan
4. Execute incrementally
5. Verify functionality
Rules:
- Never break existing functionality
- Create backups before changes
- Test after each step
- Document breaking changes
Real-World Orchestration
Let's put it all together with production-ready patterns.
Pattern 1: The Full-Stack Feature
I need to build a complete "Team Management" feature.
Use this orchestration:
1. PLAN AGENT: Design the feature architecture
2. Wait for my approval
3. BACKEND SESSION: Create API and database (parallel)
4. FRONTEND SESSION: Create components with mocks (parallel)
5. Integration: Connect frontend to backend
6. CODE REVIEWER: Review all code
7. TEST SESSION: Write comprehensive tests
8. COMMIT: Create feature commit
Coordinate through .claude/tasks/team-management.md
Pattern 2: The Refactoring Pipeline
Refactor the payment module with this pipeline:
STAGE 1 - Analysis:
- EXPLORE AGENT: Map all payment-related code
- CODE EXPLORER: Document current implementation
STAGE 2 - Design:
- CODE ARCHITECT: Design new structure
- Present plan for approval
STAGE 3 - Execution:
- Incremental refactoring
- CODE REVIEWER after each change
- Tests passing at each step
STAGE 4 - Verification:
- Full test suite
- Manual testing checklist
- Documentation update
Pattern 3: The Bug Investigation
Bug: Users intermittently see "undefined" in their profile name.
Investigation pipeline:
1. EXPLORE: Find all code touching user profile name
2. CODE EXPLORER: Trace data flow from DB to UI
3. GREP: Search for potential null/undefined sources
4. ANALYSIS: Present hypotheses ranked by likelihood
5. FIX: After I confirm the cause
6. TEST: Add regression tests
7. REVIEW: Security and edge case review
Pattern 4: The Parallel Development
We have 3 days to build an MVP. Let's parallelize:
DAY 1:
- Session A: Database schema + seed data
- Session B: Authentication system
- Session C: UI component library
DAY 2:
- Session A: Core API endpoints
- Session B: Business logic services
- Session C: Main pages and routing
DAY 3:
- All sessions: Integration
- Code review
- Bug fixes
- Documentation
Coordinate through shared task board.
Orchestration Best Practices
1. Clear Boundaries
Each agent/session should have clear responsibilities:
## Session Boundaries
### API Session
- Owns: /src/app/api/**, /src/services/**
- Does NOT touch: Components, pages, styles
### UI Session
- Owns: /src/components/**, /src/app/(routes)/**
- Does NOT touch: API routes, services
### Test Session
- Owns: /__tests__/**, *.test.ts
- Can READ any file, but only writes tests
2. Checkpoint Gates
Never let agents run too long without verification:
After completing each phase:
1. Summarize what was done
2. List files changed
3. Run tests
4. WAIT for my approval before next phase
3. Conflict Resolution
When multiple sessions touch shared code:
Before modifying shared files:
1. Check .claude/locks/ for active locks
2. Create lock file: .claude/locks/shared-utils.lock
3. Make changes
4. Remove lock file
5. Update .claude/changelog.md
4. Progress Tracking
# .claude/progress.md
## Feature: Team Management
### Phase 1: Planning ✅
- [x] Architecture design
- [x] API specification
- [x] Component breakdown
### Phase 2: Backend (IN PROGRESS)
- [x] Database schema
- [ ] API endpoints (3/7 done)
- [ ] Validation layer
### Phase 3: Frontend (WAITING)
- [ ] Components
- [ ] Pages
- [ ] Integration
### Phase 4: Testing (BLOCKED)
- Waiting for Phase 2 & 3
Quick Reference
Agent Trigger Phrases
Session Management Commands
# List active sessions
claude --list-sessions
# Join existing session
claude --session <name>
# Kill a session
claude --kill-session <name>
# Session with isolated context
claude --session <name> --fresh
Coordination Files
.claude/
├── tasks/ # Shared task lists
├── locks/ # File locks for conflicts
├── progress.md # Overall progress
├── decisions.md # Architecture decisions
└── changelog.md # What changed and why
Conclusion
You now have the knowledge to orchestrate an entire AI development team.
Remember the key principles:
- Specialize – Use the right agent for each task
- Parallelize – Run independent work simultaneously
- Coordinate – Clear boundaries and communication
- Verify – Checkpoint gates and reviews
The developers who master multi-agent orchestration don't just write code faster—they build better software through diverse AI perspectives.
Your next step: Set up a simple two-session workflow and experience the power of parallel AI development.
The future of software development isn't a single AI assistant. It's an AI team, orchestrated by you.
Tags: #ClaudeCode #Subagents #AIOrchestration #DevTools #Productivity #SoftwareEngineering #AITeam #CodingWorkflow
Comments · 0
Beta: comments are stored locally on your device and not visible to other readers.
No comments yet. Be the first to share your thoughts.