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