Agents Directory

Reviews completed major project steps against original plans and coding standards. Assesses plan alignment, code quality, architecture, documentation, tests, security; categorizes issues by severity (critical/important/suggestions).

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.

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

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.

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.

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.

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

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.

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.

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.

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.

Generates codemaps of codebase architecture and updates READMEs/guides from code via AST analysis and dependency graphs. Use proactively for doc maintenance.

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.

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

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.

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.

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.

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.

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.

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.

Audits PRs and code changes for silent failures, inadequate error handling, broad catch blocks, and unlogged fallbacks. Delegate for systematic reviews of error handling logic.

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

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.

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.

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.

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.

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.

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

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

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.

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.

Simplifies recently modified code for clarity, consistency, and maintainability while preserving all functionality. Applies project standards like ES modules, explicit typing, React patterns, and avoids nested ternaries.

Elite code reviewer specializing in AI-powered analysis, security vulnerabilities, performance optimization, production reliability, static tools, and config reviews using 2024/2025 best practices. Delegate for PR analysis and proactive code quality assurance.

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.

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.

Builds React components, responsive layouts, and client-side state management. Masters React 19, Next.js 15, modern frontend architecture. Optimizes performance and accessibility for UI creation or fixes.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

AI test automation expert for TDD, self-healing tests, Playwright/Selenium/Appium, API/performance testing, and CI/CD strategies. Delegate for robust testing ecosystems and quality engineering.

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

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

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.

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.

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

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.

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.

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.

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.

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

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

Documentation specialist that generates codemaps from TypeScript codebase structure using AST analysis and ts-morph, maps dependencies with madge, updates READMEs and guides.

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.

Performance engineer expert in observability, app optimization, scalable systems. Masters OpenTelemetry, distributed tracing, load testing, multi-tier caching, Core Web Vitals, RUM, profiling. Delegate for end-to-end perf tuning, scalability analysis.

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.

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.

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.

Refactors legacy codebases, migrates outdated frameworks (jQuery→React, Python 2→3), reduces technical debt, and ensures backward compatibility via incremental patterns like Strangler fig, tests, and migration plans.

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.

Develops React Native, Flutter, and native iOS/Android apps with modern architecture patterns. Handles cross-platform development, native integrations, offline sync, performance optimization, and app store prep. Invoke proactively for mobile features.

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.

Implements a single assigned file by parsing the full plan for instructions, executes edits or creation using Read/Edit/Write tools, verifies code quality, fixes errors up to 3 attempts, and reports structured status.

Expert in DevSecOps, vulnerability assessment, OWASP Top 10, threat modeling, secure auth (OAuth/JWT), cloud/container security, and compliance (GDPR/SOC2). Delegate for audits, pipeline integration, and incident response.

Creates comprehensive technical documentation from codebases: analyzes architecture, design patterns, and details to produce manuals/ebooks with diagrams, overviews, and deep dives. Delegate proactively for system docs and architecture guides.

Playwright E2E testing specialist for generating, maintaining, running tests on critical user flows, quarantining flakies, and managing artifacts like screenshots, videos, traces.

Creates step-by-step tutorials from code, breaking complex concepts into progressive sections with hands-on exercises, analogies, troubleshooting, and learning objectives for onboarding guides and explanations.

Expert security auditor for DevSecOps, vulnerability assessment, threat modeling, OWASP Top 10/ASVS, secure auth (OAuth2/OIDC/JWT), cloud/container security, compliance (GDPR/SOC2). Delegate for audits, pipeline integration, incident response.

Expert GraphQL architect for enterprise schema design, federation, performance optimization (DataLoader, caching), security (RBAC, rate limiting), and real-time subscriptions.

Expert in CI/CD pipelines, GitOps (ArgoCD/Flux), container orchestration, Kubernetes deployments, zero-downtime strategies, and security scanning. Delegate for pipeline design, GitOps setups, deployment automation, and platform engineering.

Kubernetes architect for cloud-native infrastructure, GitOps (ArgoCD/Flux), managed clusters (EKS/AKS/GKE), service mesh (Istio/Linkerd), multi-tenancy, security, and platform engineering. Delegate for architecture, GitOps setups, and optimization.

Terraform/OpenTofu expert for advanced IaC automation, state management, complex modules, multi-cloud deployments, GitOps workflows, policy as code, and CI/CD. Delegate proactively for enterprise infrastructure tasks.

Linting agent for Ruby and ERB files: runs standardrb and erblint for style checks/auto-fixes, Brakeman for security scans. Delegate for pre-push code quality workflows.

AI test automation expert for TDD cycles, self-healing tests, Playwright/Selenium/Appium automation, API/performance testing, and CI/CD strategies. Delegate for scalable test suites and quality engineering.

Subagent for finding similar code implementations, usage examples, and patterns in the codebase. Provides concrete snippets with file:line refs and context. Uses Grep, Glob, Read, LS.

Deployment engineer expert in CI/CD pipelines, GitOps (ArgoCD/Flux), Docker containers, Kubernetes strategies, and zero-downtime automation. Delegate for pipeline design, GitOps implementation, security scanning, and deployment optimization.

DevOps expert for rapid incident response, log analysis, distributed tracing, Kubernetes debugging, performance optimization, and root cause analysis in production systems. Delegate for outages and complex troubleshooting.

Orchestrates TDD red-green-refactor cycles, coordinates multi-agent testing workflows (unit/integration/E2E), enforces best practices like ATDD/BDD, and uses AI for test generation/evolution across projects.

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.