Every agent, listed.

Design docs and tradeoff analysis for changes spanning 3+ modules — data model shifts, new subsystems, cross-cutting concerns. Use BEFORE implementation when scope crosses three or more modules or reverses a prior design decision. Explicitly NOT for small changes — it declines those in three sentences and hands back.

Diff-focused review — correctness first, then simplification; severity-tagged findings with file:line. Use PROACTIVELY after completing a logical chunk of work, and when asked to review a diff, branch, or PR before commit or merge. Reports only — never edits; fixing bugs is the debugger's job, restructuring is the refactorer's.

Root-cause analysis for failures with unknown cause — reproduces first, bisects hypotheses with experiments, proves the cause before proposing any fix. Use when a test fails, an error appears, or behavior is wrong and nobody knows why yet. Not for known-cause fixes, cleanup (refactorer), or review (code-reviewer).

Commit messages and PR descriptions written from the actual diff — imperative mood, no adjectives, why over what, repo conventions matched. Use when asked for a commit message, PR title/body, or branch summary. Reads the diff and git history only; never edits code.

Behavior-preserving restructuring with a test gate before and after every step — extract, rename, move, dedupe. Use when tests are green and code needs structural change without changing what it does. Not for failing tests (debugger), behavior changes, or adding coverage (test-writer).

Creates new modules, components, endpoints, or file sets matching existing project conventions, sampled first from 2-3 sibling examples. Use when adding a file or module whose pattern already exists elsewhere in the repo. Not for first-of-its-kind structures (architect) and not for implementing business logic.

Characterization and edge-case tests for existing code — arrange/act/assert, real behavior over mock theater, house style matched. Use when working code lacks coverage, before a risky refactor, or when asked to add tests for a path. Not for fixing failing tests (debugger) or designing new features test-first (tdd-loop skill).

Finds the riskiest UNtested code paths, ranked by blast radius, mutation exposure, and churn — never by chasing a percentage. Use when deciding what to test next, before a risky refactor or dependency upgrade, or when coverage numbers exist but confidence doesn't. Reports a ranked gap list with the concrete bug each gap could let through; the coverage-raise skill is the follow-on that writes the tests.

Finds unreferenced exports, files, and dependencies, each backed by the exact search commands proving zero references. Use when asked to find dead code, unused files, unused exports, or unused dependencies. Only flags what nothing references — restructuring bloated-but-live code is simplifier's job, not this agent's.

Audits failure behavior at IO boundaries — swallowed exceptions, catch-and-log-only, missing timeouts/retries/cancellation on network, DB, filesystem, and subprocess calls — and reports what actually happens today when each dependency fails. Use when reliability bugs recur, before integrating a new external service, or on any request to review error handling, timeouts, or retries. Attacker-controlled input reaching a sink is security-auditor's territory, not this agent's.

Maps places where one concept carries multiple names across a codebase (user/account/member, delete/remove/destroy, id/uuid/key) and produces rename plans with collision and serialization-boundary checks. Use when asked to unify naming, audit terminology, or prepare a rename refactor. Produces a plan with evidence counts; it does not execute renames and does not judge code structure.

OWASP-style audit of changed surfaces — injection, broken authz, secrets, unsafe deserialization, path traversal, SSRF — where every finding must include a concrete exploit path from an untrusted input to a sink, never vibes. Use PROACTIVELY when a diff touches auth, session handling, input parsing, SQL/shell/HTML construction, file paths, URL fetching, or crypto; or on any request for a security review. Reliability-only error handling belongs to error-handling-auditor.

Reduces working code without changing behavior — dead branches inside live paths, needless abstraction, duplication — and proves it with a green test run plus before/after line and nesting counts. Use when code works but has grown bloated, after a feature lands, or on any request to simplify, shrink, flatten, or deduplicate code that is still referenced. Unreferenced exports/files/deps go to dead-code-finder instead.

Diagnoses and fixes failing CI pipelines (GitHub Actions, GitLab CI). Use when a workflow or job is red, tests pass locally but fail in CI, or a pipeline broke with no code change — classifies flake vs real failure vs CI-config rot before changing anything. Not for authoring new pipelines (that is /setup-ci).

Produces zero-downtime rollout plans — migration ordering, backward-compatibility windows, numeric rollback triggers. Use when a deploy involves schema migrations, breaking API or message-format changes, or infra swaps where old and new code will run concurrently. Plans only; never executes a deploy.

Writes and optimizes container builds — multi-stage Dockerfiles, layer-cache ordering, non-root users, .dockerignore — and measures image size before/after. Use when containerizing an app, shrinking a bloated image, speeding up slow docker builds, or fixing a container that runs as root. Not for deploy orchestration or CI wiring.

Audits environment variables — compares .env.example and deploy configs against variables the code actually reads, flags undocumented, unused, and secret-looking entries. Use when env config drifts, onboarding hits missing-var errors, or before adding a new deploy environment. Reports by name; never prints secret values.

Reviews infrastructure-as-code — Terraform, wrangler.toml, serverless.yml, CloudFormation — for least-privilege violations, cost surprises, and destroy/recreate traps. Use when IaC files appear in a diff or before an apply/deploy of cloud config. Not for Dockerfiles (dockerizer) or CI workflow failures (ci-doctor).

Cuts releases mechanically — semver bump, changelog from commits since the last tag, annotated tags. Use when asked to bump a version, generate or update a changelog, or tag a release. Stops and asks instead of guessing when commit history and the requested bump disagree.

Accessibility test automation — axe scans wired into Playwright per UI state, keyboard-navigation and focus-order specs, with honest limits stated up front — automated checks catch a minority of real accessibility issues, so every report ends with what still needs a manual pass. Use when a page or component needs a11y coverage or regressions must be blocked in CI. Not for general E2E user flows (playwright-engineer) or audits that produce a document instead of running tests.

Integration tests for HTTP APIs — a per-endpoint matrix of happy path, every documented error, and authz denial, with schema + status + header assertions plus idempotency and pagination checks; adapts to the stack (supertest, pytest, or plain fetch with node:test). Use when an endpoint or handler needs tests above the unit layer, or an API contract must be pinned before a change. Not for unit-testing internal functions (eng-core test-writer), browser flows (playwright-engineer), or performance under load (load-tester).

Mobile E2E with Appium — per-platform capability sets, accessibility-id-first locators, explicit-wait discipline, and deliberate Android/iOS divergence handling inside one suite. Use when a native or hybrid mobile flow needs automated coverage or an Appium test fails on one platform but not the other. Not for browser E2E (playwright-engineer), first-time driver/emulator install (appium-setup skill), or intermittent pass/fail forensics (flake-hunter).

Flaky-test forensics at any layer — reproduces the flake with repeat, stress, and order-shuffle runs, classifies the cause (race, shared state, time/timezone, network, ordering), proves it with a deterministic repro, and fixes at cause; retries and quarantine are last resorts and any quarantine gets an expiry. Use when a test passes sometimes and fails sometimes, locally or in CI. Not for tests that fail every time (eng-core debugger) or suite-wide stabilization campaigns (e2e-stabilize skill).

SLO-first load testing — turns a latency/error budget into k6 or artillery scripts with ramp, soak, and spike profiles, reads p95/p99 honestly, and does capacity math with stated assumptions; hard safety rule — never targets any environment without explicit human confirmation it is safe to load. Use when someone asks "can this handle X rps" or needs load scripts and an interpretation of results. Not for functional API testing (api-test-engineer) or browser-side performance profiling.

Browser E2E specs in Playwright that assert user-visible behavior, not implementation — role-based locators over CSS, auto-wait discipline with zero hard sleeps, deliberate stub-vs-real network decisions, fixtures over page-object bloat; writes new specs and repairs failing ones. Use when a user flow needs browser coverage or a Playwright spec fails and the fix is more than a locator swap. Not for unit tests (eng-core test-writer), pure locator repair after a DOM change (selector-fixer), or intermittent pass/fail forensics (flake-hunter).

Mechanical locator repair for E2E tests broken by DOM changes — maps each element-not-found failure to the minimal locator update, prefers role and test-id targets, flags brittle patterns it touched. Use when specs fail with locator/element-not-found timeouts after a UI change and the intended behavior is unchanged. Never changes assertions, waits, or test logic — anything beyond a locator swap escalates to playwright-engineer; intermittent failures go to flake-hunter.

Designs a repo's test portfolio — which behaviors get unit vs integration vs E2E coverage, gap analysis ranked by risk × churn, tooling recommendations with tradeoffs, all inside a CI-minutes budget. Use when a repo's testing approach needs direction — new project, suite that is slow or untrusted, or before investing weeks in tests. Explicitly NOT for writing any individual test — it hands ranked rosters to playwright-engineer, api-test-engineer, appium-engineer, and eng-core test-writer. Not for line-level coverage gap hunting either (eng-quality coverage-analyst).

Builds factual competitive teardowns from public pages — positioning claims, features, pricing, and omissions — with every statement labeled VERIFIED (source URL + date) or INFERENCE. Use when asked what a competitor offers, charges, claims, or how they position. Never invents numbers, never audits your own pages (seo-auditor), never recommends your positioning (positioning-strategist).

Writes and rewrites landing page copy — headlines, subheads, section copy, CTAs — strictly from an existing positioning doc, always delivering 3 variants with reasoning. Use when a page or section needs copy and positioning exists; if no positioning doc is found, it stops and requests positioning-strategist first. Not for strategy, audits, or blog posts.

Establishes product positioning — competitive alternatives, unique attributes, value, and who cares most — and writes it to a positioning doc. Use PROACTIVELY when marketing work is requested but no positioning doc exists, when "who is this for" or "what do we say we are" is unresolved, or before copy, pricing, or campaign decisions. Refuses to write copy; that is landing-copywriter's job.

Analyzes packaging and price points — value metric, tier fences, anchoring, decoy detection — and models revenue scenarios with every assumption explicit and adjustable. Use when deciding what to charge, how to structure tiers, or whether a pricing change pays. Consumes competitor facts (from competitor-analyst) but does not collect them, and does not write pricing-page copy (landing-copywriter).

Audits your own pages for technical and content SEO — titles, meta, heading structure, internal links, crawlability, structured data, and query-intent match — with every finding ranked by effort vs impact. Use when asked to audit, improve, or debug the search performance of a site or page you own. Not for competitor research (competitor-analyst) or writing copy (landing-copywriter).

Turns a git range into a user-facing changelog — what changed for the reader, grouped by impact, zero commit-speak. Use when asked for a changelog, a release-notes draft, or "what shipped since <ref>"; use PROACTIVELY when a version bump or release tag has just landed. NOT for launch announcements (launch-writer) or version-decision procedure (release-notes skill).

Writes task-oriented documentation from source code — quickstart before reference, examples proven by running them, drift against code flagged. Use when asked to document a module, API, CLI, or feature ("write docs for X", "add API docs", "update the docs"); NOT for linear walkthroughs with checkpoints (tutorial-writer) or README restructuring (readme-polish skill).

Drafts launch posts for HN, Reddit, and X from a shipped feature or diff — leads with the problem, shows the artifact, obeys each channel's norms, bans superlatives. Use when announcing a release, feature, or project ("launch post", "Show HN", "announce this"); NOT for compressing an existing writeup into short posts (social-drafter) or the logistics around the launch (launch-checklist skill).

Compresses one finished artifact (blog post, changelog, launch post, README) into 3 platform-fitted short posts — X, LinkedIn, Bluesky/Mastodon — under hard character budgets, no hashtag spam. Use when asked to "turn this into posts/tweets" or make "socials" from an existing writeup; NOT for authoring the primary launch narrative from a diff (launch-writer) or multi-post threads (/tweet-thread).

Writes step-by-step tutorials from a working example it verifies by running first — every step ends in a checkpoint the reader can observe. Use when asked for a tutorial, walkthrough, or "getting started" guide a reader follows linearly from zero to a working result; NOT for reference/API documentation of a surface (docs-writer).