A comprehensive collection of 83 specialized AI subagents for Claude Code, providing domain-specific expertise across software development, infrastructure, and business operations.

This repository provides production-ready subagents that extend Claude Code's capabilities with specialized knowledge. Each subagent incorporates:

• Current industry best practices and standards (2024/2025)
• Production-ready patterns and enterprise architectures
• Deep domain expertise with 8-12 capability areas per agent
• Modern technology stacks and frameworks
• Optimized model selection based on task complexity

Agents are assigned to specific Claude models based on task complexity and computational requirements. The system uses three model tiers:

Clone the repository to the Claude agents directory:

cd ~/.claude
git clone https://github.com/wshobson/agents.git

The subagents will be automatically available to Claude Code once placed in the ~/.claude/agents/ directory.

Claude Code automatically selects the appropriate subagent based on task context and requirements. The system analyzes your request and delegates to the most suitable specialist.

Specify a subagent by name to use a particular specialist:

"Use code-reviewer to analyze the recent changes"
"Have security-auditor scan for vulnerabilities"
"Get performance-engineer to optimize this bottleneck"

code-reviewer: Analyze component for best practices
security-auditor: Check for OWASP compliance
tdd-orchestrator: Implement feature with test-first approach
performance-engineer: Profile and optimize bottlenecks

backend-architect: Design authentication API
frontend-developer: Create responsive dashboard
graphql-architect: Design federated GraphQL schema
mobile-developer: Build cross-platform mobile app

devops-troubleshooter: Analyze production logs
cloud-architect: Design scalable AWS architecture
network-engineer: Debug SSL certificate issues
database-admin: Configure backup and replication
terraform-specialist: Write infrastructure modules

data-scientist: Analyze customer behavior dataset
ai-engineer: Build RAG system for document search
mlops-engineer: Set up experiment tracking
ml-engineer: Deploy model to production

business-analyst: Create metrics dashboard
docs-architect: Generate technical documentation
api-documenter: Write OpenAPI specifications
content-marketer: Create SEO-optimized content

Subagents coordinate automatically for complex tasks. The system intelligently sequences multiple specialists based on task requirements.

Feature Development

"Implement user authentication"
→ backend-architect → frontend-developer → test-automator → security-auditor

Performance Optimization

"Optimize checkout process"
→ performance-engineer → database-optimizer → frontend-developer

Production Incidents

"Debug high memory usage"
→ incident-responder → devops-troubleshooter → error-detective → performance-engineer

Infrastructure Setup

"Set up disaster recovery"
→ database-admin → database-optimizer → terraform-specialist

ML Pipeline Development

"Build ML pipeline with monitoring"
→ mlops-engineer → ml-engineer → data-engineer → performance-engineer

For sophisticated multi-agent orchestration, use the Claude Code Commands collection which provides 52 pre-built slash commands:

/full-stack-feature   # Coordinates 8+ agents for complete feature development
/incident-response    # Activates incident management workflow
/ml-pipeline         # Sets up end-to-end ML infrastructure
/security-hardening  # Implements security best practices across stack

Each subagent is defined as a Markdown file with frontmatter:

---
name: subagent-name
description: Activation criteria for this subagent
model: haiku|sonnet|opus  # Optional: Model selection
tools: tool1, tool2       # Optional: Tool restrictions
---

System prompt defining the subagent's expertise and behavior

• haiku: Simple, deterministic tasks with minimal reasoning
• sonnet: Standard development and engineering tasks
• opus: Complex analysis, architecture, and critical operations

Agents execute in sequence, passing context forward:

backend-architect → frontend-developer → test-automator → security-auditor

Multiple agents work simultaneously on different aspects:

performance-engineer + database-optimizer → Merged analysis

Dynamic agent selection based on analysis:

debugger → [backend-architect | frontend-developer | devops-troubleshooter]

Primary work followed by specialized review:

payment-integration → security-auditor → Validated implementation

1. Automatic selection - Let Claude Code analyze context and select optimal agents
2. Clear requirements - Specify constraints, tech stack, and quality standards
3. Trust specialization - Each agent is optimized for their specific domain

1. High-level requests - Allow agents to coordinate complex multi-step tasks
2. Context preservation - Ensure agents have necessary background information
3. Integration review - Verify how different agents' outputs work together

1. Direct invocation - Specify agents when you need particular expertise
2. Strategic combination - Use multiple specialists for validation
3. Review patterns - Request specific review workflows (e.g., "security-auditor reviews API design")

1. Monitor effectiveness - Track which agents work best for your use cases
2. Iterative refinement - Use agent feedback to improve requirements
3. Complexity matching - Align task complexity with agent capabilities

To add a new subagent:

1. Create a new .md file with appropriate frontmatter
2. Use lowercase, hyphen-separated naming convention
3. Write clear activation criteria in the description
4. Define comprehensive system prompt with expertise areas

• Ensure request clearly indicates the domain
• Be specific about task type and requirements
• Use explicit invocation if automatic selection fails

• Provide more context about tech stack
• Include specific requirements in request
• Use direct agent naming for precise control

• Normal behavior - specialists have different priorities
• Request reconciliation between specific agents
• Consider trade-offs based on project requirements

• Include background information in requests
• Reference previous work or patterns
• Provide project-specific constraints

MIT License - see LICENSE file for details.

• Claude Code Documentation
• Subagents Documentation
• Claude Code GitHub
• Claude Code Commands