Claude Code Subagents · page 13

Plan-mode orchestrator for the Agent Development Life Cycle

Tests Agentforce agents and optimizes based on session trace analysis

|

Expert on creating and configuring custom Claude Code agents. Helps design specialized agents for project-specific tasks.

Expert on CLAUDE.md design patterns, best practices, and project configuration. Essential for project initialization and customization.

Decision-making agent for Self-Evolving Loop. Evaluates validation results and decides next action (continue, evolve, or ship).

Lightweight orchestrator for Self-Evolving Loop with Meta-Engineering integration. Coordinates phases, manages memory, and handles lifecycle. Only returns brief summaries.

Learning agent for Self-Evolving Loop with Meta-Engineering integration. Analyzes failures/successes, extracts patterns, and updates memory system for cross-session learning.

Expert on Claude Code hooks - automation triggers for tool calls, prompts, and notifications. Essential for autonomous workflows.

Expert on Model Context Protocol (MCP) - configuration, available servers, troubleshooting. Essential for extending Claude's capabilities.

Deep requirement analysis agent for Self-Evolving Loop. Extracts acceptance criteria, complexity assessment, and implementation strategy.

Evolution agent for Self-Evolving Loop with Meta-Engineering integration. Applies learning insights, manages lifecycle upgrades, and updates evolution metrics.

Dynamic skill generator for Self-Evolving Loop with Meta-Engineering integration. Creates tailored executor, validator, and fixer skills based on requirement analysis and pattern recommendations.

Expert on creating Claude Code skills (slash commands). Helps design reusable command-based workflows.

Use this agent when the user needs to implement a modern, professional website using frontend design system skills. This includes tasks like creating responsive layouts, implementing UI components, establishing design tokens, building component libraries, or applying modern CSS/styling techniques. Examples:\n\n<example>\nContext: User wants to create a landing page for their product\nuser: "Create a modern landing page for my SaaS product"\nassistant: "I'll use the frontend-design-system-implementer agent to create a professional landing page with modern design patterns."\n<Task tool call to frontend-design-system-implementer>\n</example>\n\n<example>\nContext: User needs to implement a design system component\nuser: "I need a reusable button component with different variants"\nassistant: "Let me launch the frontend-design-system-implementer agent to create a well-structured button component following design system best practices."\n<Task tool call to frontend-design-system-implementer>\n</example>\n\n<example>\nContext: User wants to modernize their existing website\nuser: "My website looks outdated, can you help make it look more professional?"\nassistant: "I'll use the frontend-design-system-implementer agent to apply modern design principles and create a professional look for your website."\n<Task tool call to frontend-design-system-implementer>\n</example>

Deep autonomous brand visibility analysis across all 6 AI engines — multi-pass real-query probes (5+ engines × 5–10 queries), business-DB scan, citation source enumeration, competitor disambiguation, full 30-day defense plan. Use ONLY when the user explicitly asks for "deep AI visibility analysis", "agent mode", "comprehensive AI brand audit", "autonomous AI visibility", "full multi-engine probe", or commits to a 5+ minute autonomous run. For the standard fast-path one-turn score + per-engine vulnerability map, the `ai-visibility` skill is the right tool — do NOT invoke this agent for generic "AI visibility" / "score my brand" requests, which should route to the skill.

Deep autonomous competitor research — multi-pass crawl across 5+ competitors with full backlink delta, 1000+-term keyword overlap, schema coverage scan, and review-platform delta. Use ONLY when the user explicitly asks for "deep competitor analysis", "agent mode", "autonomous competitor research", "full competitor crawl", "competitor agent", or when 5+ competitors are named. For the standard fast-path one-turn competitor scorecard, the `competitor-intel` skill is the right tool — do NOT invoke this agent for generic "analyze competitors" requests.

Deep autonomous content strategy — multi-pass site crawl, competitor content audit, full keyword + topic gap analysis, pillar + cluster topology, and 90-day publishing queue grounded in real GSC/SERP data. Use ONLY when the user explicitly asks for "deep content audit", "agent mode", "autonomous content strategy", "full site + competitor content analysis", or commits to a multi-minute autonomous run. For the standard fast-path one-turn content plan, the `content-strategy` skill is the right tool — do NOT invoke this agent for generic "plan my content" requests.

Deep autonomous schema generation across 3+ pages or the whole site — multi-file scan, JSON-LD generation, validation, and writing into source files (with user approval per file). Use ONLY when the user explicitly asks for "bulk schema", "schema across my site", "audit all schema", "fix schema everywhere", "every page", "all pages", "site-wide schema", or names a directory containing 3+ pages. For the standard fast-path one-page schema generation, the `schema-markup` skill is the right tool — do NOT invoke this agent for single-page schema requests.

Run a full SEO + AEO + GEO audit on a website or codebase. Use when user asks to "audit my site", "comprehensive SEO audit", "full site audit", "complete SEO check", or wants an end-to-end report covering technical, on-page, schema, AEO, GEO, and AI visibility. Autonomously crawls the codebase or fetches URLs and delivers a scored report.

The Accessibility Specialist ensures the software is accessible to the widest possible audience. They enforce accessibility standards, review UI for compliance, and design assistive features including remapping, text scaling, colorblind modes, and screen reader support.

The AI Programmer implements intelligent system features: recommendation engines, classification pipelines, LLM integrations, decision logic, and autonomous agent behavior. Use this agent for AI/ML feature implementation, model integration, intelligent automation, or AI system debugging.

The Analytics Engineer designs telemetry systems, user behavior tracking, A/B test frameworks, and data analysis pipelines. Use this agent for event tracking design, dashboard specification, A/B test design, or user behavior analysis methodology.

The Backend Developer builds and maintains server-side logic, APIs, databases, authentication, and integrations. Use this agent for REST/GraphQL API implementation, database operations, authentication systems, background jobs, microservices, server performance, and backend testing. Works from API design contracts and PRDs.

The Community Manager handles user-facing communications, feedback synthesis, support escalation, and community engagement. Use this agent for drafting release announcements, synthesizing user feedback into actionable insights, writing support documentation, or coordinating community-facing communication around releases and incidents.

The CTO (Chief Technical Officer) owns the high-level technical vision, architecture decisions, technology choices, and technical strategy. Use this agent for architecture-level decisions, technology evaluations, cross-system conflicts, and when a technical choice will constrain or enable product possibilities. This is the highest technical authority in the department.

The Data Engineer designs database schemas, builds data pipelines, manages migrations, and owns the data infrastructure. Use this agent for schema design, complex migrations, data modeling, ETL/ELT pipelines, database performance optimization, analytics infrastructure, and data integrity strategies.

The DevOps Engineer maintains build pipelines, CI/CD configuration, version control workflow, and deployment infrastructure. Use this agent for build script maintenance, CI configuration, branching strategy, or automated testing pipeline setup.

Unified diagnostic agent covering 3 sequential phases: Investigation (map code paths, gather evidence, find root cause), Verification (devil's advocate testing, triangulate findings), and Solution (divergent options, tradeoff analysis, surgical implementation plan). Replaces investigator + verifier + solver. Use for any complex bug diagnosis, root cause analysis, or architectural fix design.

The Frontend Developer builds and maintains all user-facing UI components, client-side logic, and browser/app rendering. Use this agent for implementing UI features, React/Vue/Angular components, CSS/styling, responsive design, accessibility, frontend performance, and client-side state management. Works from designs provided by ux-designer.

The Fullstack Developer handles end-to-end feature delivery across frontend and backend, ideal for features that span both layers or when rapid integration is needed. Use this agent for building complete features from UI to API to database, prototypes requiring full-stack wiring, or when a feature is too small to split across specialists.

The Lead Programmer owns code-level architecture, coding standards, code review, and the assignment of programming work to specialist programmers. Use this agent for code reviews, API design, refactoring strategy, or when determining how a design should be translated into code structure.

The Mobile Developer builds and maintains native and cross-platform mobile applications for iOS and Android. Use this agent for React Native, Flutter, or native Swift/Kotlin development, app architecture, offline sync, push notifications, app store deployment, and mobile-specific performance optimization. Works from designs provided by ux-designer and APIs from backend-developer.

The Network Programmer implements real-time and distributed networking: WebSocket communication, event streaming, state synchronization, and network protocol design. Use this agent for real-time feature implementation, synchronization strategy, bandwidth optimization, or distributed systems networking.

The Performance Analyst profiles application performance, identifies bottlenecks, recommends optimizations, and tracks performance metrics over time. Use this agent for performance profiling, memory analysis, response time investigation, or optimization strategy.

The Producer manages all production concerns: sprint planning, milestone tracking, risk management, scope negotiation, and cross-department coordination. This is the primary coordination agent. Use this agent when work needs to be planned, tracked, prioritized, or when multiple departments need to synchronize.

The Product Manager owns the product roadmap, user requirements, PRDs, user stories, and the bridge between business goals and technical implementation. Use this agent when defining features, prioritizing the backlog, writing acceptance criteria, analyzing user needs, or aligning stakeholders on what to build and why.

The Prototyper builds rapid proof-of-concept implementations, throwaway spikes, and time-boxed experiments to validate ideas before committing to full implementation. Use this agent for rapid POC builds, technical feasibility spikes, or when a design assumption needs a working demo to evaluate. Prototypes always live in prototypes/ and never in src/.

Unified QA agent covering both strategy and execution. Use for test plan creation, bug severity assessment, regression planning, release readiness evaluation (lead mode), AND test case writing, bug report writing, regression checklists, smoke test suites (tester mode). Replaces qa-lead + qa-tester.

Owns the release pipeline: certification checklists, store submissions, platform requirements, version numbering, and release-day coordination. Use for release planning, platform certification, store page preparation, or version management.

The Security Engineer protects software systems and user data from threats. They review code for vulnerabilities, design secure authentication and authorization, secure API and data communications, and ensure privacy compliance. Use this agent for security reviews, threat modeling, OWASP audits, auth design, and data privacy compliance.

The Technical Writer creates and maintains developer-facing and user-facing documentation: API references, README files, setup guides, changelogs, tutorials, and in-app help content. Use this agent to write documentation, improve existing docs for clarity, audit documentation coverage, generate changelogs from git history, or produce onboarding guides.

The Technical Director owns all high-level technical decisions including system architecture, technology stack choices, performance strategy, and technical risk management. Use this agent for architecture-level decisions, technology evaluations, cross-system technical conflicts, and when a technical choice will constrain or enable product capabilities.

The Tools Programmer builds internal development tools: editor extensions, content authoring tools, debug utilities, and pipeline automation. Use this agent for custom tool creation, editor workflow improvements, or development pipeline automation.

The UI Programmer implements user interface systems: menus, HUDs, inventory screens, dialogue boxes, and UI framework code. Use this agent for UI system implementation, widget development, data binding, or screen flow programming.

Tier 3 Specialist agent focused on bridging the gap between requirements (PRD) and implementation. Creates detailed UI Specifications including component decomposition, state matrices, and interaction definitions.

The UX Designer owns user experience flows, interaction design, accessibility, and information architecture for software products. Use this agent for user flow mapping, interaction pattern design, accessibility audits, onboarding flow design, and wireframe feedback.

The UX Researcher generates user insights through research methods: interviews, usability tests, surveys, and behavioral analysis. Use this agent to plan and analyze user research, synthesize findings into actionable insights, validate design assumptions, identify user pain points, and generate evidence-based design recommendations. Works with ux-designer to inform design decisions.

Anchor framework specialist for rapid Solana program development. Use for building programs with Anchor macros, IDL generation, account validation, and standardized patterns. Prioritizes developer experience while maintaining security.\\n\\nUse when: Building new programs quickly, team projects needing standardization, projects requiring IDL for client generation, or when developer experience is prioritized over maximum CU optimization.

DeFi integration specialist for composing with Solana protocols including Jupiter, Drift, Kamino, Raydium, Orca, Meteora, Marginfi, and Sanctum. Handles swap routing, lending/borrowing, staking, liquidity provision, and oracle price feeds.\n\nUse when: Integrating DeFi protocols, building swap interfaces, implementing lending/borrowing, setting up yield strategies, working with Pyth/Switchboard oracles, or composing multi-protocol transactions.

CI/CD, infrastructure, and deployment specialist for Solana projects. Handles GitHub Actions, Docker, monitoring, RPC management, and Cloudflare Workers edge deployment.\n\nUse when: Setting up CI/CD pipelines, containerizing Solana validators or programs, configuring monitoring and alerting, managing RPC infrastructure, deploying edge workers, or automating build and deploy workflows.

Senior Solana game architect for game system design, Unity/C# architecture, on-chain game state, player progression, NFT integration, and PlaySolana ecosystem. Use for high-level game design decisions, architecture reviews, and planning complex game systems.\n\nUse when: Designing new Solana games from scratch, planning game state on-chain, Unity project architecture, integrating with PlaySolana/PSG1, or deciding between implementation approaches.

React Native and Expo specialist for building Solana mobile dApps. Handles mobile wallet adapter integration, transaction signing UX, deep linking, and mobile-specific performance optimization.\n\nUse when: Building React Native or Expo mobile apps with Solana integration, implementing mobile wallet adapter flows, setting up deep links for transaction signing, or optimizing mobile dApp performance.

CU optimization specialist using Pinocchio framework. Use for performance-critical programs requiring 80-95% CU reduction vs Anchor. Specializes in zero-copy access, manual validation, and minimal binary size.\\n\\nUse when: CU limits are being hit, transaction costs are significant at scale, binary size must be minimized, or maximum throughput is required.

Rust backend specialist for building async services that interact with Solana blockchain. Builds APIs, indexing services, and off-chain processing using Axum, Tokio, and modern async patterns.\n\nUse when: Building REST/WebSocket APIs for Solana dApps, implementing transaction indexers, creating webhook services, or any Rust backend that interacts with Solana.

Senior Solana program architect for system design, account structures, PDA schemes, token economics, and cross-program composability. Use for high-level design decisions, architecture reviews, and planning complex multi-program systems.\n\nUse when: Designing new programs from scratch, planning account structures, optimizing PDA schemes, reviewing architecture for security, or deciding between implementation approaches.

Frontend specialist for Solana dApps. Builds wallet connection flows, transaction UX, token displays, and React/Next.js components with modern design (liquid glass, calm UI), WCAG 2.2 AA accessibility, and performance optimization.

Educational guide for Solana development concepts. Teaches programming patterns, explains code, creates tutorials, and designs learning paths for developers at all levels.\n\nUse when: Explaining Solana concepts, creating tutorials, designing learning paths, or helping developers understand complex blockchain code and patterns.

Testing and quality assurance specialist for Solana programs. Owns all testing frameworks (Mollusk, LiteSVM, Surfpool, Trident), CU profiling, security testing, and code quality standards.\n\nUse when: Writing comprehensive tests, setting up test infrastructure, debugging test failures, CU benchmarking, fuzz testing, or reviewing code quality.

Deep research specialist for Solana ecosystem. Performs comprehensive investigation of protocols, SDKs, APIs, and blockchain patterns with systematic methodology and evidence-based analysis.\n\nUse when: Researching Solana protocols, investigating SDK capabilities, comparing implementation approaches, or gathering information about ecosystem tools and patterns.

Technical documentation specialist for Solana blockchain projects. Creates READMEs, API docs, integration guides, architecture documentation, and deployment procedures.\n\nUse when: Writing project documentation, API references, integration guides, or any developer-facing documentation for Solana projects.

Token-2022 extensions specialist for advanced token mechanics, token economics design, launch strategies, and liquidity management on Solana. Covers transfer hooks, confidential transfers, metadata extensions, and compliance patterns.\n\nUse when: Creating tokens with Token-2022 extensions, designing token economics, implementing transfer hooks or fees, setting up token launches, configuring metadata extensions, or building compliance-ready token infrastructure.

Unity and C# specialist for Solana game development. Builds game systems using Solana.Unity-SDK, handles wallet integration, NFT display, transaction signing, and real-time gameplay. Expert in Unity patterns, async C#, and PlaySolana SDK.\n\nUse when: Implementing Unity game code, wallet connection, NFT loading, transaction building, UI systems, or any C#/Unity development for Solana games.

|

USE WHEN a test intermittently fails on unchanged code. Runs it N times sequentially, captures pass/fail + stderr, groups failures by normalized signature, returns stability report. Read-only — never modifies code or installs deps. For statistical signal across runs, not one-shot diagnosis.

USE BEFORE committing security-sensitive changes (auth, crypto, routes, templates, secrets). Audits current diff for OWASP-Top-10 patterns + deps typosquatting. Read-only. Returns Critical / Important / Nice schema with file:line. Model review — not a Semgrep/CodeQL replacement.

>

>

>

>

>

Use this agent when you need to run tests for API skills, validate skill functionalities through direct invocation, or perform end-to-end testing of API endpoints. This includes running existing test suites, exercising API skills manually to verify behavior, and validating that skill functionalities work as expected.\\n\\nExamples:\\n\\n- Example 1:\\n user: \"I just finished implementing the weather API skill\"\\n assistant: \"Let me use the api-skill-tester agent to run the tests and validate the weather API skill's functionalities.\"\\n <commentary>\\n Since a skill implementation was completed, use the Task tool to launch the api-skill-tester agent to run all tests and exercise the skill's capabilities.\\n </commentary>\\n\\n- Example 2:\\n user: \"Can you verify all the API skills are working correctly?\"\\n assistant: \"I'll use the api-skill-tester agent to run the full test suite across all API skills and validate their functionalities.\"\\n <commentary>\\n The user wants comprehensive testing of all API skills. Use the Task tool to launch the api-skill-tester agent to run all tests and manually test key functionalities.\\n </commentary>\\n\\n- Example 3:\\n user: \"I made changes to the authentication skill, make sure nothing is broken\"\\n assistant: \"Let me launch the api-skill-tester agent to run the tests for the authentication skill and verify its core functionalities still work.\"\\n <commentary>\\n Since changes were made to a skill, use the Task tool to launch the api-skill-tester agent to run relevant tests and exercise the modified skill.\\n </commentary>\\n\\n- Example 4 (proactive usage):\\n user: \"Refactor the search skill to use the new query parser\"\\n assistant: \"I've completed the refactoring of the search skill. Now let me use the api-skill-tester agent to run the tests and validate the refactored functionalities.\"\\n <commentary>\\n Since significant code changes were made to a skill, proactively use the Task tool to launch the api-skill-tester agent to ensure nothing is broken.\\n </commentary>

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, or uses the '/agents' command. When you prompt this agent, include the user's prompt VERBATIM. Remember, this agent has no context about any questions or previous conversations between you and the user. Be sure to communicate well so they can intelligently respond to the user.

Specialist for maintaining comprehensive and accurate documentation in HISTORY.md and SPECIFICATIONS.md files. Use proactively after any meaningful codebase changes (e.g. skip documentation changes, logs, formatting) IF THOSE FILES EXISTS, to ensure HISTORY.md and SPECIFICATIONS.md documentation remains complete, consistent, and well-organized. DO NOT INVOKE IF THOSE FILES DO NOT EXIST. When you prompt this agent, describe exactly what changes occurred, what was requested, what was implemented, and what was dismissed, providing as much detail as necessary. Remember, this agent has no context about any questions or previous conversations between you and the user. So be sure to communicate clearly, and provide all relevant context.

Simplifies and refines code for clarity, consistency, and maintainability while preserving all functionality. Focuses on recently modified code unless instructed otherwise.

Monitors test coverage gaps when testable code is added or modified. Does not write tests — only flags what needs testing.