Subagents de Claude Code · página 3

Use when working on cloud and hybrid network architectures, security, and performance optimization, including network design, troubleshooting, and automation, with emphasis on reliability, scalability, and zero-trust principles.

Use when building, reviewing, or debugging Next.js 14+ apps, App Router, server components, server actions, routing, performance, SEO, and production deployment.

Use when working on natural language processing, understanding, and generation, including transformer models, text processing pipelines, and production NLP systems, with emphasis on multilingual support and real-time performance.

Use when building, reviewing, or debugging Node.js backend services, Express, Fastify, NestJS, APIs, workers, queues, streams, and server runtime behavior.

Use when working on payment gateway integration, PCI compliance, and financial transaction processing, including secure payment flows, multi-currency support, and fraud prevention, with emphasis on reliability, compliance, and seamless user experience.

Use when working on system optimization, bottleneck identification, and scalability engineering, including performance testing, profiling, and tuning across applications, databases, and infrastructure, with emphasis on achieving optimal response times and resource efficiency.

Use when working on modern PHP 8.3+ with strong typing, async programming, and enterprise frameworks, including Laravel, Symfony, and modern PHP patterns with emphasis on performance and clean architecture.

Use when working on internal developer platforms, self-service infrastructure, and developer experience, including platform APIs, GitOps workflows, and golden path templates, with emphasis on empowering developers and accelerating delivery.

Use when working on database administration, performance optimization, and high availability. Deep expertise in PostgreSQL internals, advanced features, and enterprise deployment, with emphasis on reliability and peak performance.

Use when working on legacy .NET Framework, RSAT modules, and enterprise IT operations across AD, DNS, DHCP, GPO, and Windows servers.

Use when working on modern .NET, cloud automation, CI/CD tooling, Azure integration, and high-performance scripting across Windows, Linux, and macOS environments.

Use when working on module design, function structure, reusable libraries, profile optimization, and cross-version compatibility across PowerShell 5.1 and PowerShell 7+.

Use when working on desktop and terminal interfaces using WinForms, WPF, TUIs, and Metro-style frameworks like MahApps.Metro and Elysium. Focuses on building maintainable, testable, and user-friendly frontends on top of PowerShell and .NET automation.

Use when analyzing an unfamiliar project, identifying stack, architecture, entry points, build/test commands, risks, and a practical implementation path.

Use when working on project planning, execution, and delivery, including resource management, risk mitigation, and stakeholder communication, with emphasis on delivering projects on time, within budget, and exceeding expectations.

Use when designing, optimizing, and managing prompts for large language models, including prompt architecture, evaluation frameworks, and production prompt systems, with emphasis on reliability, efficiency, and measurable outcomes.

Use when working on modern Python 3.11+ development with deep expertise in type safety, async programming, data science, and web frameworks, including Pythonic patterns while ensuring production-ready code quality.

Use when working on comprehensive quality assurance, test strategy, and quality metrics, including manual and automated testing, test planning, and quality processes, with emphasis on delivering high-quality software through systematic testing.

Security vulnerability analysis and testing

Build Python agents using Agentica SDK - spawn agents, implement agentic functions, multi-agent orchestration

Unit and integration test execution and validation

Feature planning, design documentation, AND integration planning

End-to-end and acceptance test execution

Analyze Claude Code sessions using Braintrust logs

Session analysis, precedent lookup, and learning extraction

Query the artifact index for precedent and guidance

Feature and implementation code review

Investigate issues using codebase exploration, logs, and code search

Release prep, version bumps, changelog generation

Refactoring and code transformation review

Implementation and refactoring agent using TDD workflow

Integration and API review

Multi-agent coordination for complex patterns

Extract perception changes from session thinking blocks and store as learnings

Analyze brownfield codebase and create initial continuity ledger

External research - web, docs, APIs with optional LLM

External repository research and analysis

Refactoring planning AND migration planning

Create implementation plans using research, best practices, and codebase analysis

Reviews feature plans (from architect) and change plans (from phoenix)

Performance profiling, race conditions, memory issues

Document the codebase comprehensively

Review implementation by comparing plan (intent) vs Braintrust session (reality) vs git diff (changes)

Codebase exploration and pattern finding

Documentation, handoffs, session summaries, and ledger management

Analyze Claude Code sessions using Braintrust logs

General bug investigation and root cause analysis

Lightweight fixes and quick tweaks

Migration and upgrade review

Validate plan tech choices against current best practices and past precedent

Researches a single gray area decision and returns a structured comparison table with rationale. Spawned by discuss-phase advisor mode.

Researches a chosen AI framework's official docs to produce implementation-ready guidance — best practices, syntax, core patterns, and pitfalls distilled for the specific use case. Writes the Framework Quick Reference and Implementation Guidance sections of AI-SPEC.md. Spawned by /gsd:ai-integration-phase orchestrator.

Deeply analyzes codebase for a phase and returns structured assumptions with evidence. Spawned by discuss-phase assumptions mode.

Applies fixes to code review findings from REVIEW.md. Reads source files, applies intelligent fixes, and commits each fix atomically. Spawned by /gsd:code-review --fix.

Reviews source files for bugs, security issues, and code quality problems. Produces structured REVIEW.md with severity-classified findings. Spawned by /gsd:code-review.

Explores codebase and writes structured analysis documents. Spawned by map-codebase with a focus area (tech, arch, quality, concerns). Writes documents directly to reduce orchestrator context load.

Manages multi-cycle /gsd:debug checkpoint and continuation loop in isolated context. Spawns gsd-debugger agents, handles checkpoints via AskUserQuestion, dispatches specialist skills, applies fixes. Returns compact summary to main context. Spawned by /gsd:debug command.

Investigates bugs using scientific method, manages debug sessions, handles checkpoints. Spawned by /gsd:debug orchestrator.

Classifies a single planning document as ADR, PRD, SPEC, DOC, or UNKNOWN. Extracts title, scope summary, and cross-references. Spawned in parallel by /gsd:ingest-docs. Writes a JSON classification file and returns a one-line confirmation.

Synthesizes classified planning docs into a single consolidated context. Applies precedence rules, detects cross-ref cycles, enforces LOCKED-vs-LOCKED hard-blocks, and writes INGEST-CONFLICTS.md with three buckets (auto-resolved, competing-variants, unresolved-blockers). Spawned by /gsd:ingest-docs.

Verifies factual claims in generated docs against the live codebase. Returns structured JSON per doc.

Writes and updates project documentation. Spawned with a doc_assignment block specifying doc type, mode (create/update/supplement), and project context.

Researches the business domain and real-world application context of the AI system being built. Surfaces domain expert evaluation criteria, industry-specific failure modes, regulatory context, and what "good" looks like for practitioners in this field — before the eval-planner turns it into measurable rubrics. Spawned by /gsd:ai-integration-phase orchestrator.

Retroactive audit of an implemented AI phase's evaluation coverage. Checks implementation against the AI-SPEC.md evaluation plan. Scores each eval dimension as COVERED/PARTIAL/MISSING. Produces a scored EVAL-REVIEW.md with findings, gaps, and remediation guidance. Spawned by /gsd:eval-review orchestrator.

Designs a structured evaluation strategy for an AI phase. Identifies critical failure modes, selects eval dimensions with rubrics, recommends tooling, and specifies the reference dataset. Writes the Evaluation Strategy, Guardrails, and Production Monitoring sections of AI-SPEC.md. Spawned by /gsd:ai-integration-phase orchestrator.

Executes GSD plans with atomic commits, deviation handling, checkpoint protocols, and state management. Spawned by execute-phase orchestrator or execute-plan command.

Presents an interactive decision matrix to surface the right AI/LLM framework for the user's specific use case. Produces a scored recommendation with rationale. Spawned by /gsd:ai-integration-phase and /gsd-select-framework orchestrators.

Verifies cross-phase integration and E2E flows. Checks that phases connect properly and user workflows complete end-to-end.

Analyzes codebase and writes structured intel files to .planning/intel/.

Fills Nyquist validation gaps by generating tests and verifying coverage for phase requirements

Analyzes codebase for existing patterns and produces PATTERNS.md mapping new files to closest analogs. Read-only codebase analysis spawned by /gsd:plan-phase orchestrator before planning.

Researches how to implement a phase before planning. Produces RESEARCH.md consumed by gsd-planner. Spawned by /gsd:plan-phase orchestrator.

Verifies plans will achieve phase goal before execution. Goal-backward analysis of plan quality. Spawned by /gsd:plan-phase orchestrator.

Creates executable phase plans with task breakdown, dependency analysis, and goal-backward verification. Spawned by /gsd:plan-phase orchestrator.

Researches domain ecosystem before roadmap creation. Produces files in .planning/research/ consumed during roadmap creation. Spawned by /gsd:new-project or /gsd:new-milestone orchestrators.

Synthesizes research outputs from parallel researcher agents into SUMMARY.md. Spawned by /gsd:new-project after 4 researcher agents complete.

Creates project roadmaps with phase breakdown, requirement mapping, success criteria derivation, and coverage validation. Spawned by /gsd:new-project orchestrator.

Verifies threat mitigations from PLAN.md threat model exist in implemented code. Produces SECURITY.md. Spawned by /gsd:secure-phase.

Retroactive 6-pillar visual audit of implemented frontend code. Produces scored UI-REVIEW.md. Spawned by /gsd:ui-review orchestrator.

Validates UI-SPEC.md design contracts against 6 quality dimensions. Produces BLOCK/FLAG/PASS verdicts. Spawned by /gsd:ui-phase orchestrator.

Produces UI-SPEC.md design contract for frontend phases. Reads upstream artifacts, detects design system state, asks only unanswered questions. Spawned by /gsd:ui-phase orchestrator.

Analyzes extracted session messages across 8 behavioral dimensions to produce a scored developer profile with confidence levels and evidence. Spawned by profile orchestration workflows.

Verifies phase goal achievement through goal-backward analysis. Checks codebase delivers what phase promised, not just that tasks completed. Creates VERIFICATION.md report.

Simple greeting agent, use proactively when greeting the user. If they say 'hi claude' or 'hi cc' or 'hi claude code' use this agent.

AI research specialist that proactively gathers latest news and developments in LLMs, AI agents, and engineering. Use for staying current with AI/ML innovations, finding actionable insights, and discovering new tools and techniques.

Generates a new, complete Claude Code sub-agent configuration file from a user's description. Use this to create new agents. Use this Proactively when the user asks you to create a new sub agent.

Proactively triggered when work is completed to provide concise audio summaries and suggest next steps. If they say 'tts' or 'tts summary' or 'audio summary' use this agent. When you prompt this agent, describe exactly what you want them to communicate to the user. Remember, this agent has no context about any questions or previous conversations between you and the user. So be sure to communicate well so they can respond to the user. Be concise, and to the point - aim for 2 sentences max.

Backend architect for scalable API design, microservices, and distributed systems

Cloud architect for AWS/Azure/GCP infrastructure, IaC, FinOps, and multi-cloud strategies

Code review expert for quality analysis, security vulnerabilities, and production reliability

Database architect for data modeling, technology selection, schema design, and migration planning

Debugging specialist for errors, test failures, and unexpected behavior

Technical documentation architect for comprehensive system docs and architecture guides

Frontend developer for React, Next.js, responsive layouts, and accessible UI components

Performance engineer for optimization, observability, and scalable system performance

Security auditor for DevSecOps, OWASP compliance, vulnerability assessment, and threat modeling

TDD orchestrator enforcing red-green-refactor discipline and test-driven development

Use this agent when CLAUDE.md files or .claude/rules/ files may have drifted from the actual codebase state. This includes after significant refactors, feature additions, file renames, directory restructuring, or when you suspect documentation no longer matches reality. Use proactively after any large code change.\\n\\nExamples:\\n\\n- Example 1:\\n user: \"Refactor the services directory to split analysis into separate modules\"\\n assistant: \"I've completed the refactoring of the services directory. Let me now launch the claude-md-auditor agent to ensure all CLAUDE.md files reflect these structural changes.\"\\n <commentary>\\n Since a significant refactor was performed that likely changed file paths, exports, and directory structure documented in CLAUDE.md files, use the Task tool to launch the claude-md-auditor agent.\\n </commentary>\\n\\n- Example 2:\\n user: \"Add a new notifications feature with hooks, components, and a store slice\"\\n assistant: \"The notifications feature is now implemented. I'll use the claude-md-auditor agent to update the documentation to include the new files and patterns.\"\\n <commentary>\\n A new feature was added with multiple new files across components, hooks, and store slices. The CLAUDE.md files likely need updating to document these additions. Use the Task tool to launch the claude-md-auditor agent.\\n </commentary>\\n\\n- Example 3:\\n user: \"Rename isRealUserMessage to isParsedRealUserMessage across the codebase\"\\n assistant: \"The rename is complete across all source and test files. Now I'll launch the claude-md-auditor agent to update any documentation references to the old function name.\"\\n <commentary>\\n A function was renamed which is likely documented in CLAUDE.md type guard tables and conventions sections. Use the Task tool to launch the claude-md-auditor agent to fix stale references.\\n </commentary>\\n\\n- Example 4:\\n user: \"Can you audit the CLAUDE.md files to make sure they're up to date?\"\\n assistant: \"I'll launch the claude-md-auditor agent to systematically verify all documentation against the actual codebase.\"\\n <commentary>\\n The user explicitly requested a documentation audit. Use the Task tool to launch the claude-md-auditor agent.\\n </commentary>

Use this agent when the user wants to fix all code quality issues in the project, including linting, formatting, and unused code detection. This agent runs `pnpm fix` followed by `pnpm quality` in a loop, delegating each iteration to a subagent, until all issues are resolved.\\n\\nExamples:\\n\\n- User: \"Fix all the quality issues\"\\n Assistant: \"I'll launch the quality-fixer agent to iteratively fix all linting, formatting, and quality issues.\"\\n (Uses Task tool to launch quality-fixer agent)\\n\\n- User: \"Run quality checks and fix everything\"\\n Assistant: \"Let me use the quality-fixer agent to handle that.\"\\n (Uses Task tool to launch quality-fixer agent)\\n\\n- User: \"Make sure the code passes all checks\"\\n Assistant: \"I'll use the quality-fixer agent to ensure all quality checks pass.\"\\n (Uses Task tool to launch quality-fixer agent)\\n\\n- After completing a large refactor or feature implementation:\\n Assistant: \"Now that the changes are complete, let me launch the quality-fixer agent to ensure everything passes quality checks.\"\\n (Uses Task tool to launch quality-fixer agent)

Proactive methodology guidance agent. Monitors note creation and provides real-time quality advice. Suggests connections, flags quality issues, recommends MOC updates. Activates when the user creates notes, asks about methodology, or needs architectural advice.