Agent Fleet

General code quality, patterns, and best practices. Meant to run right after any code change.

OWASP Top 10, hardcoded secrets, SSRF, injection, and unsafe crypto.

Type safety, async correctness, and Node/web security.

PEP 8 compliance, Pythonic idioms, type hints, and security.

Hook correctness, render performance, and server/client component boundaries.

Composition API correctness, reactivity pitfalls, and template security.

Idiomatic Go, concurrency patterns, and error handling.

Ownership, lifetimes, unsafe usage, and error handling.

Protocol-oriented design, ARC memory management, and Swift Concurrency.

Coroutine safety, Compose practices, and Android/KMP pitfalls.

Spring Boot and Quarkus, detected automatically. JPA, security, concurrency.

Memory safety, modern C++ idioms, concurrency, and performance.

.NET conventions, async patterns, and nullable reference types.

Functional idioms, pattern matching, and computation expressions.

PSR-12 compliance, PHP type system, and Eloquent ORM patterns.

Widget practices, state management, and Dart idioms. Library-agnostic.

ORM correctness, DRF patterns, and migration safety.

Async correctness, dependency injection, and Pydantic schemas.

PostgreSQL query optimization, schema design, and Supabase practices.

Feature pipelines, training reproducibility, model serving, and rollback.

Clinical safety, CDSS accuracy, and PHI compliance for EMR/EHR systems.

Router and switch configs: stale references, risky commands, guardrails.

Comment accuracy, completeness, and the risk of comment rot.

Encapsulation, invariant expression, and whether types are actually enforced.

Swallowed errors, bad fallbacks, and missing error propagation.

PR test coverage quality, weighted toward behavioral coverage.

Scores agent output on a 5-axis rubric and returns a scorecard.

Build and TypeScript errors. Minimal diffs, no architectural edits.

Vite, webpack, Next.js, CRA, Parcel, esbuild, and Bun failures.

Build errors, go vet issues, and linter warnings.

cargo build errors, borrow checker issues, and Cargo.toml problems.

swift build, Xcode failures, SPM dependencies, and code signing.

Kotlin compiler errors and Gradle configuration issues.

Maven and Gradle. Detects Spring Boot or Quarkus and adapts.

CMake, linker errors, and template instantiation failures.

dart analyze errors, Flutter compilation, and pub conflicts.

pip/Poetry errors, migration conflicts, and collectstatic failures.

Tensor shape mismatches, device errors, DataLoader, mixed precision.

ArkTS and ArkUI: V2 state management, Navigation routing, API usage.

System design, scalability, and technical decision-making.

Feature blueprints derived from your existing codebase conventions.

Traces execution paths and maps architecture layers and dependencies.

Implementation plans for complex features and refactors.

WCAG 2.2 compliance for web and native, plus design system audits.

Enterprise and multi-site network architecture from requirements.

Home and small-lab network plans with staged changes and rollback.

Extracts behavioral specs from brownfield codebases into OpenSpec.

Enforces write-tests-first and pushes for 80%+ coverage.

E2E tests via Vercel Agent Browser, falling back to Playwright.

Simplifies recently changed code without altering behavior.

Dead code removal driven by knip, depcheck, and ts-prune.

Bottlenecks, bundle size, memory leaks, and render cost.

Codemaps, READMEs, and guides. Runs the update-docs workflow.

Current library and API docs pulled through Context7.

Tunes this agent harness for reliability, cost, and throughput.

Runs autonomous agent loops and intervenes when they stall.

Reads transcripts for behaviors worth preventing with a hook.

Read-only OSI-layer diagnosis with an evidence-backed root cause.

Strips secrets and internal references ahead of a public release.

Verifies a fork is clean. Produces a PASS/FAIL report.

Generates README, LICENSE, CONTRIBUTING, and setup.sh.

Triages email, Slack, LINE, and Messenger into four action tiers.

Campaign planning, positioning, copy, and content calendars.

Expands a one-line prompt into a full product specification.

Implements to spec, then iterates on evaluator feedback.

Drives the running app with Playwright and scores it against a rubric.

Executable phase plans with task breakdown and dependency analysis.

Executes plans with atomic commits, deviation handling, and checkpoints.

Goal-backward check that a phase actually delivered what it promised.

Project roadmaps with phase breakdown and coverage validation.

Verifies a plan will reach the phase goal before execution starts.

Maps each new file to its closest existing analog in the codebase.

Researches how to implement a phase before it gets planned.

Domain ecosystem research feeding roadmap creation.

Merges parallel researcher output into one summary.

Severity-classified findings written to REVIEW.md.

Applies REVIEW.md findings, committing each fix atomically.

Scientific-method bug investigation with session management.

Runs the multi-cycle debug loop in an isolated context.

Verifies threat-model mitigations exist in the implemented code.

Cross-phase integration and end-to-end flow verification.

Fills validation gaps by generating the missing tests.

Explores the codebase and writes structured analysis documents.

Writes structured intel files to .planning/intel/.

Writes and updates project documentation from a doc assignment.

Checks factual claims in generated docs against the live codebase.

Classifies planning docs as ADR, PRD, SPEC, DOC, or UNKNOWN.

Consolidates classified docs and surfaces conflicts and blockers.

Produces the UI-SPEC design contract for frontend phases.

Validates UI-SPEC against 6 quality dimensions. BLOCK/FLAG/PASS.

Retroactive 6-pillar visual audit of implemented frontend code.

Distills a framework's official docs into implementation guidance.

Business domain context, failure modes, and regulatory landscape.

Designs the evaluation strategy and rubrics for an AI phase.

Scores implemented eval coverage against the spec's plan.

Interactive decision matrix for choosing an AI/LLM framework.

Researches one gray-area decision and returns a comparison table.

Surfaces a phase's hidden assumptions with codebase evidence.

Scores a developer profile across 8 behavioral dimensions.

Technical audits, on-page work, structured data, and remediation plans.

Crawlability, indexability, URL structure, and JavaScript rendering.

E-E-A-T signals, readability, depth, and thin content detection.

Detects, validates, and generates Schema.org JSON-LD.

Validates and generates XML sitemaps with quality gates.

Core Web Vitals and page load measurement.

Screenshots, mobile rendering, and above-the-fold analysis.

GBP signals, NAP consistency, citations, and local schema.

Geo-grid rank tracking, GBP audits, and competitor radius mapping.

AI crawler access and citability for AI Overviews, ChatGPT, Perplexity.

Semantic topic clustering via SERP overlap and hub-and-spoke design.

Backlink profile from Moz, Bing WMT, and Common Crawl web graphs.

Captures baselines of SEO-critical elements and detects regressions.

Product schema, Shopping and Amazon visibility, pricing gaps.

SERP backwards analysis for page-type mismatch and persona scoring.

CrUX field data, GSC indexation, and GA4 organic traffic.

Live SERP, keyword, backlink, and AI visibility data.

Audits OG and social preview images, plans what's missing.

Applies FLOW framework stage prompts to a target URL.

AI SDK patterns, providers, agents, durable workflows, MCP servers.

CI/CD, preview URLs, promotions, rollbacks, env vars, domains.

Core Web Vitals, rendering strategy, caching, edge, bundle size.

Multi-step research and search when you're unsure where to look.

Read-only fan-out search across many files. Locates code, doesn't audit it.

Designs implementation plans and weighs architectural trade-offs.

Catch-all when nothing more specific fits.

Answers questions about Claude Code, the Agent SDK, and the API.

Configures your status line setting.