Explore agents

Reviews completed features or project steps against the original plan and coding standards, checking plan alignment, code quality, architecture, and documentation.

Software architecture specialist for system design, scalability, and technical decision-making. Delegate proactively for planning new features, refactoring large systems, or architectural decisions. Restricted to read/search tools.

Expert planning specialist that generates detailed, phased implementation plans with steps, dependencies, risks, and testing for complex features, refactoring, and architectural changes. Proactive delegation for implementation requests.

Deeply analyzes specific codebase features: traces execution paths/entry points/call chains, maps architecture layers/patterns, documents dependencies/transformations to inform modifications/extensions.

Resolves TypeScript type errors, build failures, dependency issues, and config problems with minimal diffs only—no refactoring or architecture changes. Use proactively on build errors for quick fixes.

Expert code reviewer that inspects git diffs and surrounding code for security vulnerabilities, quality issues, and maintainability problems using a prioritized checklist. Invoke after all code changes.

Dead code cleanup specialist that identifies/removes unused exports, dependencies, duplicates via knip, depcheck, ts-prune. Verifies references, runs tests, refactors safely in batches.

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

Detects and remediates OWASP Top 10 vulnerabilities, secrets, SSRF, injections, unsafe crypto in code handling user input, auth, APIs, sensitive data. Delegate proactively for scans after writing such code.

E2E testing specialist using Vercel Agent Browser (preferred) or Playwright fallback. Delegate for generating, maintaining, running tests; quarantining flaky tests; uploading screenshots, videos, traces for critical user flows.

Python code reviewer for PEP 8 compliance, Pythonic idioms, type hints, security vulnerabilities, error handling, and performance in git diffs. Runs static tools like ruff, mypy, pylint, bandit.

Documentation specialist that generates codemaps from TypeScript codebase structure, analyzes dependencies and AST, updates READMEs and guides. Use proactively to keep docs current.

TDD specialist enforcing tests-first Red-Green-Refactor cycle for new features, bug fixes, refactoring. Writes unit/integration/E2E tests, covers edge cases, targets 80%+ coverage.

Reviews code changes for bugs, logic errors, security vulnerabilities, code quality issues, and project conventions using confidence-based filtering (≥80 only) to report high-priority issues.

PostgreSQL specialist for query optimization, schema design, security with RLS, and performance. Incorporates Supabase best practices. Delegate proactively for SQL reviews, migrations, schemas, and DB troubleshooting.

Go specialist that fixes build errors, go vet warnings, linter issues, and module problems with minimal changes. Delegate when Go builds fail.

Expert Go code reviewer for idiomatic style, concurrency patterns, error handling, security issues, and performance. Delegate for all Go code changes and projects.

Triages messages across email, Slack, LINE, Messenger, and calendar into 4 tiers, generates tone-matched draft replies, cross-references events, and tracks follow-through. Delegate for multi-channel inbox workflows.

Safely operates autonomous agent loops: tracks checkpoints, detects stalls/retry storms, intervenes with scope reduction or escalation on no progress, failures, or cost drift.

Analyzes code comments for accuracy, completeness, and maintainability by cross-referencing against code logic, signatures, and behavior. Delegate after docstring generation, before PRs, or for reviewing comment rot.

Reviews pull requests for test coverage quality and completeness. Identifies gaps in behavioral coverage, edge cases, error handling, and critical business logic for new functionality.

Autonomous error handling auditor that scrutinizes catch blocks, fallback logic, and logging quality in PRs to eliminate silent failures.

Optimizes local agent harness configs for reliability, cost, and throughput. Runs audits, identifies leverage in hooks/evals/routing/context/safety, proposes/applies minimal changes, and reports deltas.

Reviews code changes for CLAUDE.md guidelines, style violations, bugs, best practices, and quality issues. Defaults to unstaged git diff; specify files for custom scope.

Reviews Kotlin code in Android/KMP projects for idiomatic patterns, coroutine safety, Compose best practices, clean architecture violations, and common pitfalls. Restricted to read/grep/glob/bash tools.

Expert type design analyzer for codebases. Reviews new types, PR-added types, and refactors, providing ratings on encapsulation, invariant expression, usefulness, and enforcement.

Documentation agent that resolves library IDs and fetches current docs via Context7 for usage, setup, API, and code example questions.

Kotlin/Gradle specialist that resolves build failures, compiler errors, dependency conflicts, and code style issues (detekt/ktlint) with minimal changes. Delegate when builds fail.

C++ specialist that resolves build errors, CMake issues, linker problems, and template errors with minimal changes. Delegate when C++ builds fail.

Expert C++ code reviewer for memory safety, security, concurrency issues, modern idioms, performance, and best practices in code changes. Delegate for all C++ projects.

Rust specialist that resolves cargo build errors, borrow checker issues, lifetimes, traits, and Cargo.toml dependencies with minimal changes. Runs diagnostics and verifies fixes. Delegate on Rust build failures.

Verifies TypeScript Agent SDK apps for SDK installation/config, TypeScript setup, correct usage/patterns, type safety/compilation, build scripts, env/security, best practices, and functionality. Invoke after app creation/modification for deployment readiness.

Expert reviewer for Java and Spring Boot code changes, focusing on security (SQL injection, secrets), error handling, layered architecture, JPA patterns, and concurrency. Delegate for all Java diffs.

Fixes Java compilation errors, Maven/Gradle build failures, and dependency conflicts with minimal changes. Use for failed Java or Spring Boot builds requiring diagnostics and targeted edits.

Expert Rust code reviewer for ownership, lifetimes, error handling, unsafe usage, concurrency issues, and idiomatic patterns. Delegate all Rust code changes, diffs, and PR reviews.

Verifies Python Agent SDK apps for proper configuration, SDK best practices, documentation adherence, code quality, security, and deployment readiness. Invoke after creation or modification.

Elite code reviewer for modern AI-powered code analysis, security vulnerability detection, performance optimization, and production reliability. Masters static analysis tools and security scanning.

TypeScript/JavaScript code reviewer for type safety, async correctness, Node/web security, and idiomatic patterns. Delegate for PRs, local diffs, or changes in TS/JS projects to inspect via git/typecheck/eslint.

Flutter/Dart code reviewer for widget best practices, state management patterns, idioms, performance pitfalls, accessibility, architecture violations, and security issues. Analyzes git diffs, pubspec.yaml, and project structure.

PyTorch specialist resolving runtime errors, CUDA issues, tensor shape mismatches, device errors, gradient failures, DataLoader problems, and mixed precision issues with minimal changes. Delegate for training/inference crashes.

Analyzes conversation transcripts in Claude Code sessions to detect user frustrations, problematic tool patterns, and generate regex for preventive hooks. Restricted to read-only Read/Grep tools.

Expert backend architect for scalable APIs (REST/GraphQL/gRPC/WebSocket), microservices, distributed systems, and event-driven designs. Delegate proactively for new backend services, API contracts, service boundaries, resilience, and observability.

Simplifies recently modified code for clarity, consistency, and maintainability using project best practices while preserving all functionality. Delegate after coding tasks like implementing features, fixing bugs, or optimizing.

Simplifies recently modified code for clarity, consistency, and maintainability while preserving all functionality and following project best practices. Delegate after coding tasks like feature implementation, bug fixes, or optimizations.

Frontend expert for building React components, implementing responsive layouts, and handling client-side state management. Masters React 19, Next.js 15, and modern frontend architecture. Use proactively when creating UI or fixing frontend issues.

Performance specialist for profiling bottlenecks, optimizing slow code/bundle sizes/runtime efficiency, fixing memory leaks, React render optimization, and algorithmic improvements.

Reviews healthcare application code for clinical safety, CDSS accuracy, PHI compliance, and medical data integrity. Specialized for EMR/EHR, clinical decision support, and health information systems.

Forks private projects into open-source-ready copies: copies files excluding secrets/generated dirs, strips credentials (20+ patterns), replaces internal refs with placeholders, generates .env.example, cleans git history, outputs FORK_REPORT.md.

Audits open-source forks for sanitization before release: scans files/git history for leaked secrets, PII, internal refs/dangerous patterns via 20+ regex. Verifies .env.example; outputs PASS/FAIL report. Read-only.

GAN harness evaluator: tests live web apps via Playwright browser automation, scores functionality/design against rubrics, delivers strict QA feedback.

Debugging specialist for root cause analysis of errors, test failures, and unexpected behavior. Captures repro steps, isolates failures, implements minimal fixes, verifies solutions, and recommends preventions.

Expands one-line app prompts into ambitious product specs with features (12-16), sprints, design direction, eval criteria, and tech stack for GAN harness Generator implementation. Writes to gan-harness/spec.md.

Iterative generator agent that builds React/TypeScript frontend apps from specs, incorporates evaluator feedback via git commits, runs dev servers, and refines until quality thresholds met.

Generates open-source packaging for projects: CLAUDE.md (Claude Code context), setup.sh (one-command bootstrap), README.md, LICENSE, CONTRIBUTING.md, GitHub issue templates. Analyzes stack and structure.

Test automation engineer that builds AI-powered, self-healing test suites with modern frameworks and CI/CD integration. Delegate for test generation, TDD, and quality engineering.

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

Performance engineer for modern observability (OpenTelemetry, tracing, metrics), app profiling (CPU/memory), load testing (k6, JMeter), caching (Redis), Core Web Vitals, and scalability patterns. Delegate for optimization and monitoring.

Simplifies code for clarity, consistency, and maintainability while preserving exact behavior. Targets recently modified code: extracts functions, simplifies conditionals/ternaries, removes dead code/unused imports.

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

C# code reviewer specializing in .NET conventions, async patterns, security, nullable reference types, error handling, performance, and code quality. Delegate for reviewing all C# code changes in projects.

Validates Claude Code plugin structure, plugin.json manifest syntax and fields, directory organization, commands, agents, skills, and hooks for correctness, naming conventions, and common issues.

Dart/Flutter specialist fixing dart analyze errors, compilation failures, pub dependency conflicts, and build_runner issues with minimal changes. Delegate for Dart/Flutter build failures.

Security auditor for DevSecOps, vulnerability assessment, threat modeling, and compliance (GDPR/HIPAA/SOC2). Delegates security audits and compliance implementation.

Creates tailored subagent configurations from user requests, defining expert personas, system prompts, tools, and instructions for tasks like code review, test generation, or config validation.

Expert planning specialist for complex features, refactoring, and architectural changes. Delegate proactively for detailed step-by-step implementation plans, dependency analysis, risks, and testing strategies. Read-only tools.

Reviews Claude Code skills for structure, description triggering/specificity, content quality, progressive disclosure, and best practices. Provides targeted improvements. Trigger proactively after skill creation/modification.

Safe, incremental legacy modernization specialist using strangler fig pattern. Handles framework migrations, dependency updates, and technical debt with full backward compatibility.

Detects error patterns, stack traces, and anomalies in logs and codebases. Correlates issues across systems to pinpoint root causes. Delegate proactively for debugging, log analysis, and production error investigations.

Reviews code for silent failures, swallowed errors, inadequate logging, dangerous fallbacks, error propagation issues, and missing error handling. Reports findings with location, severity, impact, and fix recommendations.

Analyzes code comments for factual accuracy, completeness, misleading elements, low-value restatements, and comment rot risk like stale info or TODO debt.

Expert code reviewer that analyzes recent git changes for security vulnerabilities, code quality issues, performance problems, and best practices. Provides prioritized feedback with fix examples and merge approval status.

Reviews pull request test coverage for quality, completeness, behavioral coverage, edge cases, error paths, integrations, and bug prevention. Rates gaps by impact with suggestions.

Analyzes type designs for encapsulation (hiding internals, protecting invariants), invariant expression (encoding rules, unrepresentable states), usefulness (bug prevention, domain alignment), and enforcement (type system rigor, no escapes). Scores types with suggestions.

TDD specialist enforcing tests-first methodology for new features, bug fixes, and refactoring. Guides Red-Green-Refactor cycle, writes unit/integration/E2E tests, ensures 80%+ coverage.

Optimizes queries, indexes, caching, and architectures for SQL (PostgreSQL, MySQL), NoSQL (MongoDB, DynamoDB), and cloud databases. Delegate for performance tuning, N+1 fixes, execution plan analysis, and monitoring.

Dead code cleanup specialist that detects and removes unused exports, files, dependencies, and duplicates using knip, depcheck, ts-prune, eslint. Ensures safe refactoring via risk assessment, tests, and git commits.

Analyzes conversation transcripts to identify problematic Claude Code behaviors like explicit corrections, frustrations, repeated mistakes, and reverted changes. Outputs prioritized YAML hook rules to prevent them.

Reverse-engineers legacy codebases: traces data flows, uncovers hidden dependencies, maps architecture, identifies technical debt, generates documentation and refactoring graphs.

Resolves TypeScript type errors, build failures, compilation issues, and config problems with minimal code changes. Invoke proactively on failed builds to quickly pass without architectural edits.

Designs high-level system architecture: component diagrams, service boundaries, data flows, integration patterns, scalability, and fault tolerance. Creates blueprints for new projects or major changes.

SEO specialist for technical audits, on-page optimization, structured data, Core Web Vitals, and keyword mapping. Delegate site audits, meta tag reviews, schema markup, sitemaps/robots issues, and remediation plans.

Expert in CI/CD pipelines (GitHub Actions, GitLab, Jenkins), GitOps (ArgoCD/Flux), Docker containers, Kubernetes deployments, zero-downtime strategies, security scanning, and platform engineering. Delegate for CI/CD design, GitOps implementation, deployment automation.

Expert mobile developer specializing in React Native, Flutter, and native iOS/Android. Handles cross-platform architecture, native integrations, offline sync, and performance optimization. Delegate mobile features and app store optimization.

Security specialist detecting and remediating OWASP Top 10 vulnerabilities, secrets, SSRF, injections, unsafe crypto in code handling user input, authentication, APIs, or sensitive data.

Investigates codebase using Read, Glob, Grep, Bash tools to return raw structured context on files, patterns, architecture for planner agents in coding tasks.

Researches external documentation for libraries, APIs, and topics. Gathers official sources, working code examples, full API signatures, versions, best practices, pitfalls. Returns raw structured context for planner agents.

Developer Experience specialist that optimizes environment setups, workflows, tooling, and documentation. Delegate proactively for new projects, friction reduction, or team feedback.

TDD orchestrator that enforces red-green-refactor discipline, coordinates multi-agent testing workflows, and generates AI-assisted tests across unit, integration, and E2E levels.

Analyzes codebases to produce long-form technical documentation, architecture guides, and ebooks covering design decisions, data models, and deployment.

Context engineer for dynamic context management using vector DBs, knowledge graphs, memory systems, and RAG. Delegate for multi-agent orchestration, semantic retrieval, context optimization, and enterprise AI workflows.

Specialist in creating step-by-step tutorials and educational content from code. Transforms complex concepts into progressive learning experiences with hands-on examples. Use for onboarding guides, feature tutorials, or concept explanations.

Expert Terraform/OpenTofu specialist for advanced IaC automation, state management, complex module design, multi-cloud deployments, GitOps workflows, policy as code, and CI/CD integration.

Kubernetes architect for cloud-native infrastructure, GitOps (ArgoCD/Flux), managed clusters (EKS/AKS/GKE/OKE), service mesh (Istio/Linkerd), security, and platform engineering. Delegate for architecture, GitOps setup, and scalable orchestration.

FastAPI subagent for building high-performance async APIs, microservices, and WebSocket backends with SQLAlchemy 2.0 and Pydantic V2.

DevOps troubleshooter for incident response, log analysis, distributed tracing, Kubernetes debugging, performance optimization, and root cause analysis in production outages.

Expert backend architect for scalable APIs (REST/GraphQL/gRPC/WebSocket), microservices, distributed systems, event-driven designs, resilience, and observability. Delegate proactively for new backend services or APIs.