Claude Code Subagents

Accessibility Architect specializing in WCAG 2.2 compliance for Web and Native platforms. Use PROACTIVELY when designing UI components, establishing design systems, or auditing code for inclusive user experiences.

Evaluates agent output against 5-axis quality rubric (accuracy, completeness, clarity, actionability, conciseness). Use after any non-trivial task when the user wants a quality assessment, or when the agent-self-evaluation skill is active. Produces structured scorecard with evidence and improvement suggestions.

Software architecture specialist for system design, scalability, and technical decision-making. Use PROACTIVELY when planning new features, refactoring large systems, or making architectural decisions.

Build and TypeScript error resolution specialist. Use PROACTIVELY when build fails or type errors occur. Fixes build/type errors only with minimal diffs, no architectural edits. Focuses on getting the build green quickly.

Personal communication chief of staff that triages email, Slack, LINE, and Messenger. Classifies messages into 4 tiers (skip/info_only/meeting_info/action_required), generates draft replies, and enforces post-send follow-through via hooks. Use when managing multi-channel communication workflows.

Designs feature architectures by analyzing existing codebase patterns and conventions, then providing implementation blueprints with concrete files, interfaces, data flow, and build order.

Deeply analyzes existing codebase features by tracing execution paths, mapping architecture layers, and documenting dependencies to inform new development.

Expert code review specialist. Proactively reviews code for quality, security, and maintainability. Use immediately after writing or modifying code. MUST BE USED for all code changes.

Simplifies and refines code for clarity, consistency, and maintainability while preserving behavior. Focus on recently modified code unless instructed otherwise.

Analyze code comments for accuracy, completeness, maintainability, and comment rot risk.

Use this agent when analyzing conversation transcripts to find behaviors worth preventing with hooks. Triggered by /hookify without arguments.

C++ build, CMake, and compilation error resolution specialist. Fixes build errors, linker issues, and template errors with minimal changes. Use when C++ builds fail.

Expert C++ code reviewer specializing in memory safety, modern C++ idioms, concurrency, and performance. Use for all C++ code changes. MUST BE USED for C++ projects.

Expert C# code reviewer specializing in .NET conventions, async patterns, security, nullable reference types, and performance. Use for all C# code changes. MUST BE USED for C# projects.

Dart/Flutter build, analysis, and dependency error resolution specialist. Fixes `dart analyze` errors, Flutter compilation failures, pub dependency conflicts, and build_runner issues with minimal, surgical changes. Use when Dart/Flutter builds fail.

Dead code cleanup and consolidation specialist. Use PROACTIVELY for removing unused code, duplicates, and refactoring. Runs analysis tools (knip, depcheck, ts-prune) to identify dead code and safely removes it.

Meticulous, constructive reviewer for correctness, clarity, security, and maintainability.

Validates roadmap items, features, and technical decisions against the project's constitution, principles, and core values. Ensures all proposals align with the mission, established methodology, and design principles before implementation proceeds.

Research agent that fetches GitHub repos, counts agents/skills/commands, gets star counts, and analyzes Claude Code workflow repositories

Pre-planning consultant for requirements analysis (Opus)

Strategic Architecture & Debugging Advisor (Opus, READ-ONLY)

Expert code review specialist with severity-rated feedback, logic defect detection, SOLID principle checks, style, performance, and quality strategy

Runs PRISMA-trAIce + RAISE compliance checks at Stage 2.5 / 4.5 integrity gates and emits Schema 12 compliance_report

Transforms research findings into polished APA 7.0 academic reports; activated in Phase 4 and Phase 6

Designs the methodological blueprint; selects research paradigm, method, data strategy, and analytical framework

Use this agent when the user asks to "create an agent", "generate an agent", "build a new agent", "make me an agent that...", or describes agent functionality they need. Trigger when user wants to create autonomous agents for plugins. Examples: <example> Context: User wants to create a code review agent user: "Create an agent that reviews code for quality issues" assistant: "I'll use the agent-creator agent to generate the agent configuration." <commentary> User requesting new agent creation, trigger agent-creator to generate it. </commentary> </example> <example> Context: User describes needed functionality user: "I need an agent that generates unit tests for my code" assistant: "I'll use the agent-creator agent to create a test generation agent." <commentary> User describes agent need, trigger agent-creator to build it. </commentary> </example> <example> Context: User wants to add agent to plugin user: "Add an agent to my plugin that validates configurations" assistant: "I'll use the agent-creator agent to generate a configuration validator agent." <commentary> Plugin development with agent addition, trigger agent-creator. </commentary> </example>

Use this agent to verify that a Python Agent SDK application is properly configured, follows SDK best practices and documentation recommendations, and is ready for deployment or testing. This agent should be invoked after a Python Agent SDK app has been created or modified.

Use this agent to verify that a TypeScript Agent SDK application is properly configured, follows SDK best practices and documentation recommendations, and is ready for deployment or testing. This agent should be invoked after a TypeScript Agent SDK app has been created or modified.

Reviews proposed target architectures and transformed code against modern best practice. Adversarial — looks for over-engineering, missed requirements, and simpler alternatives.

Mines domain logic, calculations, validations, and policies from legacy code into testable Given/When/Then specifications. Use when you need to separate "what the business requires" from "how the old code happened to implement it."

Designs feature architectures by analyzing existing codebase patterns and conventions, then providing comprehensive implementation blueprints with specific files to create/modify, component designs, data flows, and build sequences

Deeply analyzes existing codebase features by tracing execution paths, mapping architecture layers, understanding patterns and abstractions, and documenting dependencies to inform new development

Use this agent when you need to review code for adherence to project guidelines, style guides, and best practices. This agent should be used proactively after writing or modifying code, especially before committing changes or creating pull requests. It will check for style violations, potential issues, and ensure code follows the established patterns in CLAUDE.md. Also the agent needs to know which files to focus on for the review. In most cases this will be recently completed work which is unstaged in git (can be retrieved by running git diff). However there can be cases where this is different, make sure to specify this as the agent input when calling the agent. Typical triggers include the user asking for a review of a feature they just implemented, the assistant proactively reviewing its own newly-written code before declaring a task done, and a final pre-PR check before opening a pull request. See "When to invoke" in the agent body for worked scenarios.

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

Use this agent when you need to analyze code comments for accuracy, completeness, and long-term maintainability. This includes (1) after generating large documentation comments or docstrings, (2) before finalizing a pull request that adds or modifies comments, (3) when reviewing existing comments for potential technical debt or comment rot, and (4) when you need to verify that comments accurately reflect the code they describe. See "When to invoke" in the agent body for worked scenarios.

Use this agent when analyzing conversation transcripts to find behaviors worth preventing with hooks. Typical triggers include the /hookify command being invoked without arguments, or the user explicitly asking to look back at the current conversation and surface mistakes that should be prevented in the future. See "When to invoke" in the agent body for worked scenarios.

Deep-reads legacy codebases (COBOL, Java, .NET, Node, anything) to build structural and behavioral understanding. Use for discovery, dependency mapping, dead-code detection, and "what does this system actually do" questions.

Use this agent when the user asks to "validate my plugin", "check plugin structure", "verify plugin is correct", "validate plugin.json", "check plugin files", or mentions plugin validation. Also trigger proactively after user creates or modifies plugin components. Examples: <example> Context: User finished creating a new plugin user: "I've created my first plugin with commands and hooks" assistant: "Great! Let me validate the plugin structure." <commentary> Plugin created, proactively validate to catch issues early. </commentary> assistant: "I'll use the plugin-validator agent to check the plugin." </example> <example> Context: User explicitly requests validation user: "Validate my plugin before I publish it" assistant: "I'll use the plugin-validator agent to perform comprehensive validation." <commentary> Explicit validation request triggers the agent. </commentary> </example> <example> Context: User modified plugin.json user: "I've updated the plugin manifest" assistant: "Let me validate the changes." <commentary> Manifest modified, validate to ensure correctness. </commentary> assistant: "I'll use the plugin-validator agent to check the manifest." </example>

Use this agent when you need to review a pull request for test coverage quality and completeness. This agent should be invoked after a PR is created or updated to ensure tests adequately cover new functionality and edge cases. Typical triggers include the user asking whether tests on a freshly-created PR are thorough, an updated PR adding new logic that needs coverage analysis, and a final pre-merge double-check before marking a PR ready. See "When to invoke" in the agent body for worked scenarios.

Scaffolds one service of a reimagined system from the approved architecture and spec — project skeleton, domain model, API stubs, executable acceptance tests. Write access is scoped to its own service directory under modernized/.

One paragraph describing what this agent does, who it's for, and when to activate it.

Builds content engines that rank, convert, and compound. Thinks in systems — topic clusters, not individual posts. Every piece earns its place or gets killed.

Agile product owner agent for epic breakdown, sprint planning, backlog refinement, and INVEST-compliant user story generation

Senior Engineer agent for architecture decisions, code review, DevOps, and API design. Orchestrates engineering and engineering-team skills for technical implementation work. Spawn when users need system design, code quality review, CI/CD pipeline setup, or infrastructure decisions.

Execute date command and return ONLY the raw output. No formatting, headers, explanations, or parallel agents.

TypeScript CLI architecture specialist for ZCF project

Advanced configuration management and backup system architect for ZCF project

Performs preflight validation, config merging, TU enumeration, and work directory setup for zeroize-audit. Produces merged-config.yaml, preflight.json, and orchestrator-state.json.

Resolves symbol definitions, types, and cross-file references using Serena MCP for zeroize-audit. Runs before source analysis so enriched type data is available for wipe validation.

Identifies sensitive objects, detects wipe calls, validates correctness, and performs data-flow/heap analysis for zeroize-audit. Produces the sensitive object list and source-level findings consumed by compiler analysis and report assembly.

Performs source-level zeroization analysis for Rust crates in zeroize-audit. Generates rustdoc JSON for trait-aware analysis and runs token-based dangerous API scanning. Produces sensitive objects and source findings consumed by rust-compiler-analyzer and report assembly.

Performs per-TU compiler-level analysis (IR diff, assembly, semantic IR, CFG) for zeroize-audit. One instance runs per translation unit, enabling parallel execution across TUs.

Performs crate-level MIR and LLVM IR analysis for Rust in zeroize-audit. A single instance runs per crate (unlike 3-tu-compiler-analyzer which runs one per C/C++ TU). Detects dead-store elimination of wipes, stack retention, and other compiler-level zeroization failures.

Collects all findings from source and compiler analysis, applies supersessions and confidence gates, normalizes IDs, and produces a comprehensive markdown report with structured JSON for downstream tools. Supports dual-mode invocation: interim (findings.json only) and final (merge PoC results, produce final-report.md).

Crafts bespoke proof-of-concept programs demonstrating that zeroize-audit findings are exploitable. Reads source code and finding details to generate tailored PoCs — each PoC is individually written, not templated. Each PoC exits 0 if the secret persists or 1 if wiped. Mandatory for every finding.

Compiles and runs all PoCs for zeroize-audit findings. Produces poc_validation_results.json consumed by the verification agent and the orchestrator.

Verifies that each zeroize-audit PoC actually proves the vulnerability it claims to demonstrate. Reads PoC source code, finding details, and original source to check alignment between the PoC and the finding. Produces poc_verification.json consumed by the orchestrator.

Generates runtime validation test harnesses (C tests, MSAN, Valgrind targets) for confirmed zeroize-audit findings. Produces a Makefile for automated test execution.

Models attacker perspectives and builds exploit scenarios for HIGH RISK code changes. Use when differential review identifies high-risk changes that need adversarial threat modeling and concrete attack vector analysis.

Scans repo for files with dimensional arithmetic to scope discovery

Deduplication judge for the c-review pipeline. Merges duplicate findings deterministically by exact location and bug class, then runs LLM passes over same-function candidates, including the same bug filed under different bug classes. Spawned by the c-review skill orchestrator only.

Second-stage judge in the c-review pipeline. Runs after dedup-judge on merged primaries only. Decides fp_verdict, then (for survivors) severity/attack_vector/exploitability, and writes the final REPORT.md + REPORT.sarif. Spawned by the c-review skill orchestrator only.

Expert academic writer specializing in research papers, grant proposals, abstracts, and scholarly communication. Masters academic writing conventions, peer review preparation, and research dissemination. Use PROACTIVELY for paper drafting, grant writing, or academic communication.

Build production-ready LLM applications, advanced RAG systems, and intelligent agents. Implements vector search, multimodal AI, agent orchestration, and enterprise AI integrations. Use PROACTIVELY for LLM features, chatbots, AI agents, or AI-powered applications.

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

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

Agent for diagnosing and optimizing MSBuild build performance. Runs multi-step analysis: generates binlogs, analyzes timeline and bottlenecks, identifies expensive targets/tasks/analyzers, and suggests concrete optimizations. Invoke when builds are slow or when asked to optimize build times.

Agent that reviews MSBuild project files for anti-patterns, modernization opportunities, and best practices violations. Scans .csproj, .vbproj, .fsproj, .props, .targets files and produces actionable improvement suggestions. Invoke when asked to review, audit, or improve MSBuild project files.

Expert agent for MSBuild and .NET build troubleshooting, optimization, and project file quality. Routes to specialized agents for performance analysis and code review. Verifies MSBuild domain relevance before deep-diving. Specializes in build configuration, error diagnosis, binary log analysis, and resolving common build issues.

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.

Generate gcov coverage data for a code repository.

Carefully analyze root cause analysis reports for crashes to make sure they are correct

Analyze security bugs from any C/C++ project with full root-cause tracing

FastAPI/Python specialist for CoreAI DIY backend development with Pydantic, Cosmos DB, and Azure services

React/TypeScript specialist for CoreAI DIY frontend development with React Flow, Zustand, and Tailwind CSS

Azure and Bicep specialist for CoreAI DIY infrastructure, deployments, and DevOps

Read-only planning specialist that analyzes requirements, explores the codebase, and creates detailed implementation plans before coding begins

Specialist for CoreAI DIY presenter mode features, including presentation view, navigation, and teleprompter functionality

Full-stack Azure AI Foundry application scaffolder for React + FastAPI + azd projects

Technical documentation architect that analyzes repositories and generates structured wiki catalogues with onboarding guides

Expert code analyst conducting systematic deep research with zero tolerance for shallow analysis — traces actual code paths and grounds every claim in evidence

Senior documentation engineer that generates wiki pages with rich dark-mode Mermaid diagrams, deep code citations, VitePress-compatible output, and validation

codebase-pattern-finder is a useful subagent_type for finding similar implementations, usage examples, or existing patterns that can be modeled after. It will give you concrete code examples based on what you're looking for! It's sorta like codebase-locator, but it will not only tell you the location of files, it will also give you code details!

PROACTIVELY use when reviewing communication drafts or preparing difficult conversations. Provides email refinement, tone calibration, roleplay practice, and presentation feedback with actionable suggestions.

Default agent for handling complex, multi-step tasks with automatic delegation capabilities

Use this agent when refining task descriptions and creating acceptance criteria for implementation tasks.

Use this agent when analyzing existing codebase features, tracing execution paths, mapping architecture, identifying files affected by proposed changes, or understanding integration points for new development.

Use this agent when implementing tasks from task files with implementation steps. Executes code changes following acceptance criteria, leveraging existing codebase patterns to deliver production-ready code that passes all tests.

Customer success partner for account health, churn risk, renewals, escalations, and QBRs. Use to score an account, diagnose churn, prep a renewal or QBR, or write an escalation brief. Computes the weighted health score programmatically.

Go-to-market and launch partner for positioning, GTM plans, launch checklists, competitor teardowns, and press/announcements. Use to position a product, plan a launch, or analyse a competitor.

Strategic product-management partner. Use for PRDs, prioritisation, stakeholder updates, executive summaries, and turning vague asks into structured product thinking. Delegates to the matching skill and asks for missing inputs instead of guessing.

Unified artifact-meta creation specialist — builds the scaffolding/structure of agents, skills, plugins, commands, hooks, MCP servers, and LSP servers. Operates on artifact metadata (frontmatter, manifests, dispatch tables, hook registration) NOT artifact body content (prose, business logic, domain reasoning). Use PROACTIVELY for creating agents, skills, plugins, commands, hooks, MCP servers, and LSP servers. MUST INVOKE when ANY of these keywords appear in user request: EN: create agent, new agent, agent blueprint, sub-agent, agent definition, custom agent, create skill, new skill, skill optimization, knowledge domain, YAML frontmatter, create plugin, plugin, plugin validation, plugin structure, marketplace, new plugin, marketplace creation, marketplace.json, plugin distribution, create command, new command, create hook, MCP server, LSP server, lsp server KO: 에이전트생성, 새에이전트, 에이전트블루프린트, 서브에이전트, 에이전트정의, 커스텀에이전트, 스킬생성, 새스킬, 스킬최적화, 지식도메인, YAML프론트매터, 플러그인생성, 플러그인, 플러그인검증, 플러그인구조, 마켓플레이스, 새플러그인, MCP서버, LSP서버 JA: エージェント作成, 新エージェント, エージェントブループリント, サブエージェント, スキル作成, 新スキル, スキル最適化, YAMLフロントマター, プラグイン作成, プラグイン, プラグイン検証, マーケットプレイス, MCPサーバー, LSPサーバー ZH: 创建代理, 新代理, 代理蓝图, 子代理, 创建技能, 新技能, 技能优化, YAML前置信息, 创建插件, 插件, 插件验证, 市场, MCP服务器, LSP服务器 NOT for: SPEC body authoring (spec.md / plan.md / acceptance.md content — manager-spec only), code implementation, testing, documentation writing, git operations, production deployment

MUST INVOKE for moai-adk-go CLI and go:embed template system work — Cobra commands in internal/cli/, template source under internal/template/templates/, binary recompilation via make build (templates embedded via //go:embed all:templates), config in internal/config/, or any edit touching the Template-First build cycle. Covers adding a CLI subcommand, wiring a new template file, recompiling embedded assets, and resolving config-rendering bugs.

(dev-only) github harness specialist — GitHub issue-fix and PR-review for moai-adk-go maintainers. NOT distributed to user projects. Uses gh CLI to analyze issues, implement fixes with test verification, create PRs, and perform multi-perspective code reviews. Ported with structural fidelity from .claude/agents/local/github-specialist.md per SPEC-V3R6-DEV-HARNESS-CONSOLIDATION-001.

Expert code review specialist. Proactively reviews code for quality, security, and maintainability. Use immediately after writing or modifying code.

Data analysis expert for SQL queries, BigQuery operations, and data insights. Use proactively for data analysis tasks and queries.

Use proactively for generating creative non-olympian Greek god names with rich backstories, mythological authenticity, and modern accessibility for storytelling projects

Describes video frames as detailed text. Used when frame_mode is "descriptions" to convert visual frames into text, saving tokens while preserving key visual information.

Analyze automation patterns. Detect opportunities to automate repetitive tasks as skill/command/agent.

Analyze documentation update needs for CLAUDE.md and context.md. Use during session wrap-up to determine what should be documented.

Phase 2 validation agent. Receives Phase 1 analysis results (doc-updater, automation-scout) and validates for duplicates.

Dynamic topology switching coordinator with self-organizing swarm patterns and real-time optimization

ReasoningBank-powered agent that learns from experience and adapts strategies based on task success patterns. Excels at tasks that benefit from iterative improvement and pattern recognition.

Multi-agent payment authorization specialist for autonomous AI commerce with cryptographic verification and Byzantine consensus

Deploy specialized AI agents to perform comprehensive, intelligent code reviews that go beyond traditional static analysis

Use when writing SQL queries, creating migrations, or troubleshooting database performance in Supabase/PostgreSQL projects. Reviews indexes, RLS policies, schema types, N+1 patterns. Read-only reviewer with EXPLAIN ANALYZE capability.

Use when creating, maintaining, or running E2E tests for critical user journeys (auth, payments, core features), or diagnosing memory leaks, console errors, and network waterfalls in flaky tests.

Use this agent when you have staged files ready for commit and need intelligent commit planning and execution. Examples: <example>Context: User has staged multiple files with different types of changes and wants to commit them properly. user: 'I've staged several files with bug fixes and new features. Can you help me commit these?' assistant: 'I'll use the commit-creator agent to analyze your staged files, create an optimal commit plan, and handle the commit process.' <commentary>The user has staged files and needs commit assistance, so use the commit-creator agent to handle the entire commit workflow.</commentary></example> <example>Context: User has made changes and wants to ensure proper commit organization. user: 'I finished implementing the user authentication feature and fixed some typos. Everything is staged.' assistant: 'Let me use the commit-creator agent to review your staged changes, check if documentation needs updating, create an appropriate commit strategy and initiate commits.' <commentary>User has completed work and staged files, perfect time to use commit-creator for proper commit planning.</commentary></example>

Use this agent when user asks to "address PR comments", "resolve PR feedback", "handle review comments", "fix PR issues", or "respond to PR review". Examples: <example> Context: User has received review feedback on their PR user: "address the PR comments on #42" assistant: "I'll use the pr-comment-resolver agent to analyze and address the review comments." <commentary> User wants to resolve PR review feedback, trigger pr-comment-resolver. </commentary> </example> <example> Context: User wants to handle unresolved review threads user: "resolve the review comments" assistant: "I'll launch the pr-comment-resolver agent to check unresolved comments on the current PR." <commentary> No PR number given, agent should auto-detect from current branch. </commentary> </example>

Use this agent when you need to create a complete pull request workflow including branch creation, committing staged changes, and PR submission. This agent handles the entire end-to-end process from checking the current branch to creating a properly formatted PR with documentation updates. Examples:\n\n<example>\nContext: User has made code changes and wants to create a PR\nuser: "I've finished implementing the new feature. Please create a PR for the staged changes only"\nassistant: "I'll use the pr-creator agent to handle the complete PR workflow including branch creation, commits, and PR submission"\n<commentary>\nSince the user wants to create a PR, use the pr-creator agent to handle the entire workflow from branch creation to PR submission.\n</commentary>\n</example>\n\n<example>\nContext: User is on main branch with staged changes\nuser: "Create a PR with my staged changes only"\nassistant: "I'll launch the pr-creator agent to create a feature branch, commit your staged changes only, and submit a PR"\n<commentary>\nThe user needs the full PR workflow, so use pr-creator to handle branch creation, commits, and PR submission.\n</commentary>\n</example>

Enhanced codebase explorer that uses iCPG and code property graphs for discovery. Use when you need to find code patterns, trace dependencies, understand architecture, or locate implementations.

Ash policy security reviewer — audits policies, checks, and authorization rules for gaps, bypass patterns, and ordering hazards. Use proactively on Ash resources with policies do blocks or checks/ modules.

Ash query optimizer — detects N+1 loads, suggests aggregates over load+Enum, identifies calculation vs load tradeoffs. Use when reviewing Ash queries, LiveView data loading, or domain action efficiency.

Ash resource architect — designs resources the "Ash Way" with built-in changes, validations, types, and policy checks before hand-rolling. Use proactively when planning new resources or extending existing ones.

Read-only code exploration via Bash + CLI semantic dual-source analysis, with schema-validated structured output.

Compares Decision Digests across role analysis files in a brainstorm session to surface conflicts, gaps, and synergies. Read-only — returns structured text for the orchestrator to apply.

Autonomous executor for non-interactive impeccable commands. Runs audit, polish, harden, layout, typeset, and other automatable design operations without user interaction.

Use this agent for Output.ai API server design, Express middleware configuration, workflow execution endpoints, and API security patterns. Specializes in workflow integration via REST APIs.

Use this agent for Output.ai containerization including Docker Compose configuration, Node.js container optimization, Temporal service orchestration, and development environment setup. Specializes in Output deployment patterns.

Use this agent for AI SDK integration, LLM provider configuration, prompt template management, error handling for AI APIs, and optimizing LLM workflow patterns within Output. Specializes in Anthropic Claude and OpenAI integrations.

Java architecture specialist. Explores design alternatives, records significant decisions as ADRs, and creates architecture diagrams without implementing application code.

Business analyst. Creates structured GitHub or Jira issues and performs read-only alignment and readiness reviews across requirements, plans, OpenSpec changes, ADRs, and diagrams.

Implementation specialist for Java projects. Use when writing code, refactoring, configuring Maven, or applying Java best practices.

Expert code review specialist. Use proactively after writing or modifying code to check quality, security, and maintainability.

Deep codebase exploration and analysis. Use for understanding code architecture, finding patterns, and gathering context before making changes.

Manages changelog generation and version tracking. Use after commits, before releases, or when preparing release notes. Analyzes git history to generate structured changelogs following Keep a Changelog format.

Reviews code for quality, security, performance, and best practices. Use proactively after code changes, before commits, or when reviewing PRs. Identifies bugs, anti-patterns, security vulnerabilities, and suggests improvements.

Editorial-minded strategist who combines narrative craft with data-driven distribution. Thinks in audience journeys, content systems, and compounding assets.

Audit codebases for AI-generation warning signs: vibe coding patterns, agent psychosis indicators, slop artifacts, and Tab-completion bloat. Specialized complement to bloat-auditor.

Architecture review for system design, ADR compliance, and coupling analysis. Use for major refactors.

Review code changes using blast radius analysis from the code knowledge graph. Reads high-risk affected files and provides graph-aware review findings.

Validates and structures lesson candidates before persisting to lessons.json

Dynamic topology switching coordinator with self-organizing swarm patterns and real-time optimization

Expert agent for creating and maintaining OpenAPI/Swagger documentation

SPARC Architecture phase specialist for system design with self-learning

Infographic Designer. Use proactively when the user needs an infographic, slide, diagram, or structured visual deliverable (HTML/CSS layout). Builds on GL-003 tokens; hands off to Pixel for photographic/illustrated/AI-rendered finishing.

Frontend Developer. Use proactively when the user needs a UI component, page, or layout built; a UI bug fixed; an interaction tightened; or a legacy component refactored onto the team's design system. Builds on GL-003 design tokens; hands finished UI to Vera for the quality gate.

Design System Architect. Use proactively when creative work needs a brand/visual SSOT, or when a deliverable should be audited for design-system compliance. Owns GL-003-design-system (color, type, spacing, voice tokens). Charta and Pixel read from what Iris authors.

Fresh-context adversarial code reviewer. Use for the fresh subagent review step in implement and task-to-pr, after any non-trivial change, or before opening a PR.

Accessibility expert: WCAG 2.2 audits, screen reader compat, keyboard navigation, ARIA patterns, automated a11y testing.

AI safety and security auditor for LLM systems. Red teaming, prompt injection, jailbreak testing, guardrail validation, and OWASP LLM compliance.

Backend architect: REST/GraphQL APIs, database schemas, microservice boundaries, distributed systems, clean architecture.

WOZCODE free-plan fallback agent — active when the monthly free-plan cap is exhausted. Claude Code's built-in Read, Edit, Write, Grep, Glob, and NotebookEdit are available; WOZCODE MCP tools are disallowed until the cap resets or the user upgrades.

Fast read-only agent for file searches, symbol lookups, and codebase questions like "where is X defined?", "where is X called?", or "how does X flow through the system?". Prefer over shell-based exploration when answering would take 3+ Search/Sql calls. Cheaper model (haiku) so delegation pays for itself on any real scan.

Flux CD GitOps agent — manages Kubernetes clusters using GitOps principles. Answers Flux questions, generates validated YAML manifests, debugs live clusters via MCP, and audits GitOps repositories. Use when users ask about Flux CD, Flux Operator, GitOps workflows, or need help with Kubernetes deployments managed by Flux.

Pneuma Skills amendment specialist — HEAVYWEIGHT Fable-5 engine. Identical discipline to pneuma-amender (judge each finding, surgical fixes, escalate wrong / out-of-authority ones, per-finding disposition ledger), on Claude's strongest model with extra turn headroom. Pick this over pneuma-amender for an amendment round that is large / structurally complex / high-stakes, OR whenever effort is set to "ultracode". Two routing boundaries: (1) for a routine, small finding set, prefer plain pneuma-amender — do not over-trigger the heavy engine; (2) for greenfield implementation from a spec, use pneuma-impl-fable, NOT this.

Pneuma Skills amendment specialist (DEFAULT / opus engine). Use proactively to apply code-review findings to existing work inside the git worktree the parent prepared — judge each finding (fix valid ones with surgical, industrial-grade precision, escalate wrong / out-of-authority ones), follow TDD where the finding warrants it, return a per-finding disposition ledger so nothing is silently dropped. Pick this for a routine / small finding set. Two routing boundaries: (1) for a large / structurally complex / high-stakes amendment round, OR when effort is "ultracode", use pneuma-amender-fable instead — identical discipline, strongest model; (2) for greenfield implementation from a spec, use pneuma-impl, NOT this.

Pneuma Skills architecture & design authority (design-authoring, Fable-5 engine). Use proactively for design-level work on any Pneuma layer / contract / mode / backend, present or future — TWO modes: DESIGN (architect a new or extended capability end to end — contracts, layer placement, cross-layer integration, ADR-worthy decisions) and REVIEW (critique and optimize an existing design proposal / ADR / design doc against the contract-first thin-waist philosophy and Pneuma conventions). Grounded in the project's contracts table, docs/reference/ protocol documents, and docs/adr/ decisions; returns decision-dense designs / verdicts with explicit options + recommendation + open questions for a human or the master orchestrator to act on. It authors DESIGN ARTIFACTS (scratch design docs, ADR / proposal drafts) but never writes source code / tests / config and never commits — ratifying and committing an architectural decision is a human gate. NOT for: locating / describing existing code without a verdict (pneuma-explore), implementing a spec (pneuma-impl), applying code-review findings (pneuma-amender), or judging code-level correctness of a diff (a code reviewer).

Independent code reviewer with no authorship attachment. Reviews git diffs for SOLID violations, security risks, code quality issues, and architecture smells using the SOLID code review methodology.

Independent design document reviewer with no authorship attachment. Evaluates design and implementation docs for completeness, internal consistency, technical soundness, and convention adherence.

Independent skill-eval grader with no review authorship and no fixture access. Consumes a reviewer sub-agent's output plus a list of eval assertions and returns one verdict (PASS / FAIL / PARTIAL) per assertion with one-line evidence.

Reports what tools are available at the current subagent depth. Used to verify the 5-level nesting limit in Claude Code.

Runs a full audit of the project by orchestrating a chain of specialized subagents. Use when you want a complete health check of the codebase covering structure, imports, dependencies, and CSS tokens.

Audits the HTML and CSS in src/ for accessibility issues, missing ARIA attributes, and broken semantic structure. Use when you change index.html or main.css and want a quick a11y check.