The 27 Specialized Agents in Everything Claude Code: Complete Guide to AI-Powered Development

Everything Claude Code ships 27 dedicated agents—modular AI experts stored as Markdown files in the agents/ directory—that handle everything from implementation planning and security audits to language-specific code reviews and build error resolution.

The affaan-m/everything-claude-code repository implements an agent-based architecture where each agent encapsulates domain-specific expertise for autonomous software development. These agents are defined in individual Markdown files and orchestrated through AGENTS.md, enabling the ECC runtime to match user intent with specialized AI capabilities automatically.

Core Development Agents

These ten agents handle the fundamental software development lifecycle, from initial planning through documentation and testing.

Planning and Architecture

• planner (agents/planner.md): Generates implementation plans for complex features and refactors. Invoke this agent when designing multi-tenant onboarding flows or major architectural changes.
• architect (agents/architect.md): Makes system design and scalability decisions. Use this for architectural reviews and infrastructure planning sessions.
• tdd-guide (agents/tdd-guide.md): Orchestrates test-driven development workflows. Automatically creates failing test files that developers implement against for new features or bug fixes.

Quality Assurance and Security

• code-reviewer (agents/code-reviewer.md): Performs automated code review for quality and security standards. According to the source code, this runs automatically after any code change.
• security-reviewer (agents/security-reviewer.md): Spots security-critical problems including hard-coded secrets and SQL injection risks. Best used before committing sensitive code.
• e2e-runner (agents/e2e-runner.md): Executes Playwright end-to-end tests for critical user flows.

Maintenance and Debugging

• build-error-resolver (agents/build-error-resolver.md): Diagnoses build and type errors across the codebase. When TypeScript compilation fails, this agent analyzes output and suggests type fixes.
• refactor-cleaner (agents/refactor-cleaner.md): Removes dead code and simplifies existing implementations during code maintenance cycles.
• doc-updater (agents/doc-updater.md): Keeps documentation and codemaps current when APIs change.
• docs-lookup (agents/docs-lookup.md): Researches library and API documentation via Context7 for documentation and API questions.

Language-Specific Code Reviewers

Eight agents provide expert code review tailored to specific programming languages and frameworks.

• cpp-reviewer (agents/cpp-reviewer.md): C++ code review for memory safety and modern C++ practices.
• go-reviewer (agents/go-reviewer.md): Go code review focusing on idiomatic patterns and concurrency safety.
• kotlin-reviewer (agents/kotlin-reviewer.md): Kotlin, Android, and Kotlin Multiplatform (KMP) review.
• python-reviewer (agents/python-reviewer.md): Python code review for type safety and performance.
• java-reviewer (agents/java-reviewer.md): Java and Spring Boot review for enterprise patterns.
• rust-reviewer (agents/rust-reviewer.md): Rust code review checking for unsafe blocks, ownership issues, and adherence to linting rules.
• typescript-reviewer (agents/typescript-reviewer.md): TypeScript and JavaScript review for type correctness and modern ES standards.
• database-reviewer (agents/database-reviewer.md): PostgreSQL and Supabase optimization for schema design and query performance.

Language-Specific Build Resolvers

Six agents specialize in resolving compilation and build failures for their respective ecosystems.

• cpp-build-resolver (agents/cpp-build-resolver.md): Fixes C++ build failures including CMake and linker errors.
• go-build-resolver (agents/go-build-resolver.md): Resolves Go build failures and module resolution issues.
• kotlin-build-resolver (agents/kotlin-build-resolver.md): Fixes Kotlin and Gradle build errors.
• java-build-resolver (agents/java-build-resolver.md): Resolves Java, Maven, and Gradle build errors.
• rust-build-resolver (agents/rust-build-resolver.md): Fixes Rust build failures and Cargo configuration issues.
• pytorch-build-resolver (agents/pytorch-build-resolver.md): Resolves PyTorch runtime and CUDA issues during model training and inference.

Infrastructure and Operations Agents

Three agents handle autonomous execution, communication, and system optimization.

• chief-of-staff (agents/chief-of-staff.md): Manages multi-channel communication triage and drafting across email, Slack, Messenger, and LINE.
• loop-operator (agents/loop-operator.md): Executes autonomous loops and monitors execution, intervening on stalls to ensure safe long-running operations.
• harness-optimizer (agents/harness-optimizer.md): Tunes Harness CI/CD configuration for reliability, cost optimization, and throughput.

How Agent Orchestration Works

The central orchestration logic resides in AGENTS.md (lines 15-45), where each agent is declared with its purpose and trigger criteria. The ECC runtime continuously monitors user intent and automatically selects the most relevant agent without explicit commands.

When a user requests "Design a multi-tenant onboarding flow," the planner agent is automatically invoked from agents/planner.md. After code changes, the code-reviewer runs proactively to maintain quality gates.

Interaction Patterns

• Proactive usage: The system fires agents without explicit prompts, such as running code-reviewer automatically after a commit.
• Explicit slash-commands: Users invoke agents directly using syntax like /agent security-reviewer to audit the current workspace.
• Parallel execution: Independent agents run simultaneously using background operators (e.g., doc-updater and build-error-resolver executing concurrently).

Practical Usage Examples

Triggering the Planner Agent

Request implementation planning for complex features:

User: "Design a multi-tenant onboarding flow."

ECC automatically selects planner → returns Markdown implementation plan from agents/planner.md

Running Security Audits

Execute explicit security reviews before commits:

/agent security-reviewer

This generates a structured report highlighting hard-coded secrets and SQL-injection risks as defined in agents/security-reviewer.md.

Resolving Build Failures

Automatically diagnose TypeScript compilation errors:

/agent build-error-resolver

The resolver analyzes compiler output, suggests type fixes, and may apply edits automatically to resolve the failure.

Parallel Documentation and Testing

Execute multiple agents concurrently for efficiency:

/agent doc-updater &
/agent tdd-guide &

The doc-updater updates Markdown API specifications while tdd-guide creates failing test files for implementation.

Language-Specific Review

Request expert review for systems programming:

/agent rust-reviewer

This checks for unsafe blocks, ownership violations, and project-specific linting rules defined in agents/rust-reviewer.md.

Summary

• Everything Claude Code provides 27 specialized agents stored as Markdown files in the agents/ directory, each encapsulating expert knowledge for specific development domains.
• Agent orchestration is centralized in AGENTS.md (lines 15-45), which defines trigger criteria enabling automatic or explicit agent invocation.
• Language-specific coverage includes dedicated reviewers and build resolvers for C++, Go, Kotlin, Python, Java, Rust, TypeScript, and PyTorch.
• Core development workflows are supported by planners, architects, TDD guides, security auditors, and documentation maintainers.
• Execution modes support proactive automation, explicit slash-commands (/agent <name>), and parallel processing for maximum efficiency.

Frequently Asked Questions

How do I invoke a specific agent in Everything Claude Code?

Use the explicit slash-command syntax /agent <agent-name> to trigger any of the 27 specialized agents. For example, /agent rust-reviewer initiates a Rust-specific code review, while /agent chief-of-staff activates communication triage. The system also supports automatic invocation based on context detection in AGENTS.md.

What is the difference between code-reviewer and language-specific reviewers?

The code-reviewer agent (agents/code-reviewer.md) provides general quality and security analysis applicable across all languages, running automatically after code changes. Language-specific agents like rust-reviewer or java-reviewer offer deep expertise in idiomatic patterns, memory safety, and framework-specific standards for their respective ecosystems.

Where are the agent definitions stored in the repository?

Each agent lives as a standalone Markdown file under the agents/ directory in the root of affaan-m/everything-claude-code. The orchestration registry mapping purposes to triggers is defined in AGENTS.md at the repository root, specifically in lines 15-45 where the runtime configuration resides.

Can multiple agents run simultaneously?

Yes. Everything Claude Code supports parallel execution of independent agents. Use the background operator (&) to run agents concurrently, such as /agent doc-updater & /agent tdd-guide &, allowing documentation updates and test generation to proceed simultaneously without blocking the development workflow.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}