A comprehensive collection of specialized AI subagents for Claude Code, designed to enhance development workflows with domain-specific expertise.
This repository contains 28 specialized subagents that extend Claude Code's capabilities. Each subagent is an expert in a specific domain, automatically invoked based on context or explicitly called when needed.
- backend-architect - Design RESTful APIs, microservice boundaries, and database schemas
- frontend-developer - Build React components, implement responsive layouts, and handle client-side state management
- mobile-developer - Develop React Native or Flutter apps with native integrations
- graphql-architect - Design GraphQL schemas, resolvers, and federation
- architect-reviewer - Reviews code changes for architectural consistency and patterns
- python-pro - Write idiomatic Python code with advanced features and optimizations
- golang-pro - Write idiomatic Go code with goroutines, channels, and interfaces
- devops-troubleshooter - Debug production issues, analyze logs, and fix deployment failures
- deployment-engineer - Configure CI/CD pipelines, Docker containers, and cloud deployments
- cloud-architect - Design AWS/Azure/GCP infrastructure and optimize cloud costs
- database-optimizer - Optimize SQL queries, design efficient indexes, and handle database migrations
- incident-responder - Handles production incidents with urgency and precision
- dx-optimizer - Developer Experience specialist that improves tooling, setup, and workflows
- code-reviewer - Expert code review for quality, security, and maintainability
- security-auditor - Review code for vulnerabilities and ensure OWASP compliance
- test-automator - Create comprehensive test suites with unit, integration, and e2e tests
- performance-engineer - Profile applications, optimize bottlenecks, and implement caching strategies
- debugger - Debugging specialist for errors, test failures, and unexpected behavior
- data-scientist - Data analysis expert for SQL queries, BigQuery operations, and data insights
- data-engineer - Build ETL pipelines, data warehouses, and streaming architectures
- ai-engineer - Build LLM applications, RAG systems, and prompt pipelines
- ml-engineer - Implement ML pipelines, model serving, and feature engineering
- prompt-engineer - Optimizes prompts for LLMs and AI systems
- api-documenter - Create OpenAPI/Swagger specs and write developer documentation
- payment-integration - Integrate Stripe, PayPal, and payment processors
- quant-analyst - Build financial models, backtest trading strategies, and analyze market data
- legacy-modernizer - Refactor legacy codebases and implement gradual modernization
- context-manager - Manages context across multiple agents and long-running tasks
These subagents are automatically available when placed in ~/.claude/agents/ directory.
cd ~/.claude
git clone https://github.com/wshobson/agents.gitClaude Code will automatically delegate to the appropriate subagent based on the task context and the subagent's description.
Mention the subagent by name in your request:
"Use the code-reviewer to check my recent changes"
"Have the security-auditor scan for vulnerabilities"
"Get the performance-engineer to optimize this bottleneck"
# Code quality and review
"Use code-reviewer to analyze this component for best practices"
"Have security-auditor check for OWASP compliance issues"
# Development tasks
"Get backend-architect to design a user authentication API"
"Use frontend-developer to create a responsive dashboard layout"
# Infrastructure and operations
"Have devops-troubleshooter analyze these production logs"
"Use cloud-architect to design a scalable AWS architecture"
# Data and AI
"Get data-scientist to analyze this customer behavior dataset"
"Use ai-engineer to build a RAG system for document search"# Feature development workflow
"Implement user authentication feature"
# Automatically uses: backend-architect → frontend-developer → test-automator → security-auditor
# Performance optimization workflow
"Optimize the checkout process performance"
# Automatically uses: performance-engineer → database-optimizer → frontend-developer
# Production incident workflow
"Debug high memory usage in production"
# Automatically uses: incident-responder → devops-troubleshooter → performance-engineerEach subagent follows this structure:
---
name: subagent-name
description: When this subagent should be invoked
tools: tool1, tool2 # Optional - defaults to all tools
---
System prompt defining the subagent's role and capabilitiesClaude Code automatically coordinates agents using these common patterns:
User Request → Agent A → Agent B → Agent C → Result
Example: "Build a new API feature"
backend-architect → frontend-developer → test-automator → security-auditor
User Request → Agent A + Agent B (simultaneously) → Merge Results
Example: "Optimize application performance"
performance-engineer + database-optimizer → Combined recommendations
User Request → Analysis → Route to appropriate specialist
Example: "Fix this bug"
debugger (analyzes) → Routes to: backend-architect OR frontend-developer OR devops-troubleshooter
Primary Agent → Review Agent → Final Result
Example: "Implement payment processing"
payment-integration → security-auditor → Validated implementation
- backend-architect: API design, database schemas, system architecture
- frontend-developer: UI/UX planning, component architecture
- cloud-architect: Infrastructure design, scalability planning
- python-pro: Python-specific development tasks
- golang-pro: Go-specific development tasks
- mobile-developer: React Native/Flutter development
- devops-troubleshooter: Production issues, deployment problems
- incident-responder: Critical outages requiring immediate response
- database-optimizer: Query performance, indexing strategies
- performance-engineer: Application bottlenecks, optimization
- security-auditor: Vulnerability scanning, compliance checks
- data-scientist: Data analysis, insights, reporting
- code-reviewer: Code quality, maintainability review
- test-automator: Test strategy, test suite creation
- debugger: Bug investigation, error resolution
- Let Claude Code delegate automatically - The main agent analyzes context and selects optimal agents
- Be specific about requirements - Include constraints, tech stack, and quality requirements
- Trust agent expertise - Each agent is optimized for their domain
- Start with high-level requests - Let agents coordinate complex multi-step tasks
- Provide context between agents - Ensure agents have necessary background information
- Review integration points - Check how different agents' outputs work together
- Use explicit invocation for specific needs - When you want a particular expert's perspective
- Combine multiple agents strategically - Different specialists can validate each other's work
- Request specific review patterns - "Have security-auditor review backend-architect's API design"
- Monitor agent effectiveness - Learn which agents work best for your use cases
- Iterate on complex tasks - Use agent feedback to refine requirements
- Leverage agent strengths - Match task complexity to agent capabilities
To add a new subagent:
- Create a new
.mdfile following the format above - Use lowercase, hyphen-separated names
- Write clear descriptions for when the subagent should be used
- Include specific instructions in the system prompt
Agent not being invoked automatically:
- Ensure your request clearly indicates the domain (e.g., "performance issue" → performance-engineer)
- Be specific about the task type (e.g., "review code" → code-reviewer)
Unexpected agent selection:
- Provide more context about your tech stack and requirements
- Use explicit invocation if you need a specific agent
Multiple agents producing conflicting advice:
- This is normal - different specialists may have different priorities
- Ask for clarification: "Reconcile the recommendations from security-auditor and performance-engineer"
Agent seems to lack context:
- Provide background information in your request
- Reference previous conversations or established patterns
If agents aren't working as expected:
- Check agent descriptions in their individual files
- Try more specific language in your requests
- Use explicit invocation to test specific agents
- Provide more context about your project and goals