Claude Code Subagents · page 4

Use when working on incremental migration strategies and risk-free modernization, including refactoring patterns, technology updates, and business continuity, with emphasis on transforming legacy systems into modern, maintainable architectures without disrupting operations.

Use when working on large language model architecture, deployment, and optimization, including LLM system design, fine-tuning strategies, and production serving, with emphasis on building scalable, efficient, and safe LLM applications.

Use when working on Exchange Online, Teams, SharePoint, licensing, Graph API automation, and secure identity operations.

Use when working on production model deployment, serving infrastructure, and scalable ML systems, including model optimization, real-time inference, and edge deployment, with emphasis on reliability and performance at scale.

Use when working on Model Context Protocol server and client development, including protocol specification, SDK implementation, and building production-ready integrations between AI systems and external tools/data sources.

Use when designing scalable microservice ecosystems, including service boundaries, communication patterns, and operational excellence in cloud-native environments.

Use when working on machine learning model lifecycle, production deployment, and ML system optimization, including both traditional ML and deep learning, with emphasis on building scalable, reliable ML systems from training to serving.

Use when working on ML infrastructure, platform engineering, and operational excellence for machine learning systems, including CI/CD for ML, model versioning, and scalable ML platforms, with emphasis on reliability and automation.

Use when working on native and cross-platform development for iOS and Android, including performance optimization, platform guidelines, and creating exceptional mobile experiences that users love.

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.

Backend architect. Delegate only when the user explicitly starts an Octopus workflow.

Cloud architect. Delegate only when the user explicitly starts an Octopus workflow.

Code reviewer. Delegate only when the user explicitly starts an Octopus workflow.

Database architect. Delegate only when the user explicitly starts an Octopus workflow.

Debugger. Delegate only when the user explicitly starts an Octopus workflow.

Documentation architect. Delegate only when the user explicitly starts an Octopus workflow.

Frontend developer. Delegate only when the user explicitly starts an Octopus workflow.

Performance engineer. Delegate only when the user explicitly starts an Octopus workflow.

Security auditor. Delegate only when the user explicitly starts an Octopus workflow.

TDD orchestrator. Delegate only when the user explicitly starts an Octopus workflow.

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)

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.

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

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.

Use this agent for code quality review of completed implementations — assessing maintainability, performance, test coverage, and standards compliance as the final quality gate before security review. For example: reviewing a finished frontend/backend feature and producing prioritized findings (Blocker/High-Priority/Medium/Nitpick) with actionable fixes.

Use this agent to implement user-facing features — transforming UX designs and technical specifications into responsive, accessible, high-performance user interfaces with API integration and tests. Delegate frontend build work such as UI components, styling, client-side state and data handling, or web performance optimization.

Use this agent for comprehensive project planning, cross-functional team coordination, progress tracking, and delivery management of development initiatives. For example: planning a 6-week user authentication project across a UX designer, backend developer, and QA tester, or regaining control of a project facing delays and scope creep.

Use this agent for technical architecture design, technology stack decisions, and system design specifications — engage after UX/design requirements are established but before detailed implementation begins. For example: planning the architecture for an event management dashboard from completed UX designs, choosing the stack and patterns for a new microservices project, or recommending scaling strategies for performance issues under load.

Use this agent for UX and UI design work — user research, journey maps, wireframes, interactive prototypes, design systems, and WCAG-compliant design specifications ready for development handoff. Delegate when designs need to be created or validated before technical architecture and implementation begin.

Use this agent when you need to run the Ralph orchestrator end-to-end test suite, analyze diagnostic outputs, and generate comprehensive reports of findings. This includes validating backend connectivity, orchestration loop behavior, event parsing, hat collections, memory systems, and error handling. Invoke this agent after making changes to core orchestration logic, before releases, or when debugging integration issues.\\n\\nExamples:\\n\\n<example>\\nContext: User has made changes to the event parsing logic and wants to verify nothing is broken.\\nuser: \"I just modified the event parsing in ralph-core, can you verify everything still works?\"\\nassistant: \"I'll use the ralph-e2e-verifier agent to run the full E2E test suite and analyze the results.\"\\n<Task tool invocation to launch ralph-e2e-verifier>\\n</example>\\n\\n<example>\\nContext: User is preparing a release and needs validation.\\nuser: \"We're preparing to release v0.5.0, please run the E2E tests\"\\nassistant: \"I'll launch the ralph-e2e-verifier agent to run comprehensive E2E tests across all backends and generate a release readiness report.\"\\n<Task tool invocation to launch ralph-e2e-verifier>\\n</example>\\n\\n<example>\\nContext: User notices orchestration issues and wants diagnostics analyzed.\\nuser: \"Ralph seems to be selecting the wrong hats, can you investigate?\"\\nassistant: \"I'll use the ralph-e2e-verifier agent to run E2E tests with diagnostics enabled and analyze the hat selection decisions.\"\\n<Task tool invocation to launch ralph-e2e-verifier>\\n</example>

Use this agent when you need to execute a Ralph orchestration loop end-to-end and verify its completion. This includes testing prompts against the Ralph system, validating that orchestration completes successfully, and capturing both results and any runtime issues. Examples:\\n\\n<example>\\nContext: User wants to test if a prompt works correctly with Ralph orchestration.\\nuser: \"Test if Ralph can handle the prompt 'create a hello world function'\"\\nassistant: \"I'll use the ralph-loop-runner agent to execute this prompt through Ralph and verify completion.\"\\n<Task tool call to ralph-loop-runner agent>\\n</example>\\n\\n<example>\\nContext: User is debugging why a Ralph run failed.\\nuser: \"Run this spec through Ralph and tell me what went wrong\"\\nassistant: \"Let me use the ralph-loop-runner agent to execute this and capture any runtime problems.\"\\n<Task tool call to ralph-loop-runner agent>\\n</example>\\n\\n<example>\\nContext: User wants to validate Ralph behavior after code changes.\\nuser: \"I just modified the event parser, can you run a test loop?\"\\nassistant: \"I'll use the ralph-loop-runner agent to run a complete orchestration loop and verify the changes work correctly.\"\\n<Task tool call to ralph-loop-runner agent>\\n</example>

executor が返した advisor-request.v1 に対して方針だけ返す非実行 advisor

sprint-contract と review artifact を基準に verdict を返す read-only reviewer

実装、preflight 自己点検、検証、commit 準備を 1 タスク単位で進める統合ワーカー

Reviews diffs for bugs, regressions, missing tests, and safety issues

Read-only researcher for docs, source, schemas, and implementation context

Runs project verification commands and summarizes failures

Analyzes and optimizes context window usage across sessions. Use when context feels bloated, sessions run slow, or approaching compaction limits.

Analyze session token usage and cost patterns. Identify expensive operations and recommend optimizations. Use to understand and reduce session costs.

Specialized debugging agent. Use when facing hard bugs, test failures, or runtime errors that need systematic investigation.

Multi-phase development agent. Research > Plan > Implement with validation gates. Use PROACTIVELY when building features that touch >5 files or require architecture decisions.

Analyze permission denial patterns and generate optimized alwaysAllow/alwaysDeny rules. Use when permission prompts slow down workflow.

Break down complex tasks into implementation plans before writing code. Use when task touches >5 files, requires architecture decisions, or has unclear requirements.

Code review specialist that verifies every finding against actual code before reporting. Use before committing, for PR reviews, or after major changes.

Confidence-gated exploration that assesses readiness before implementation. Scores 0-100 across five dimensions and gives GO/HOLD verdict.

Adversarial senior design critic. Renders the work, looks at it, and argues for rejection. Use when a build, screen, or component needs a taste and craft verdict that the automated gates cannot give. Runs after the gates are green, never instead of them.

Guard the beads execution record: enforce the write-flush-verify discipline that defeats the bd rapid-write race, audit epic dependency graphs for cycles and orphans, catch closures whose title overstates what shipped, flag open beads carrying no disposition or a disproven premise, and reconcile bd against its GitHub and Plane projections. Owns RECORD INTEGRITY; delegates graph analysis to bead-dependency-mapper and epic-closure drift to bead-epic-auditor rather than duplicating them. Use before closing an epic, after any batch of bd writes, when a bead premise looks stale, or when auditing whether the record matches reality. Trigger with "audit beads", "check the bead DAG", "did that close actually land", "bead hygiene".

Verify every factual assertion in a diff, PR body, commit message, bead note, or governing doc against the actual repository, and fail anything that cannot be substantiated by a command. Use before merging any PR that makes claims about counts, coverage, consumers, enforcement, provenance, or certification, and when auditing standing docs for rot. Trigger with "verify claims", "check this PR body", "is this claim true", "claim audit".