coding-agent

SRE / incident responder. Diagnoses production bugs and fix-round regressions. Reproduces, isolates, traces, writes diagnosis.md (or returns inspection note). Never writes application code.

Independent code reviewer / QA. Builds, runs the project's existing test suites (never ad-hoc curl scripts), tests UI via Playwright/iOS-Simulator MCP, writes review.md with PASS/FAIL + dispatch recommendation. Independent from implementor to prevent self-evaluation bias.

Engineer. Writes code + tests for assigned tasks. Adapts to any project via the skill manifest in plan.md. Tests first (unit + integration + e2e). Returns structured update for orchestrator to apply to work.md.

Tech-lead state machine. Reads state, classifies requests, dispatches subagents, runs deterministic checks, owns coordinator state. Never writes code.

Staff engineer / designer. Converts approved intent into spec.md, then approved spec into plan.md. Researches stack and test infra via MCPs. Drafts discovery questions as a structured ask_user bundle for the orchestrator to ask (subagents have no AskUserQuestion). Owns spec.md and plan.md drafts; orchestrator signs.

Building AI agents with LangChain, LangGraph, deepagents, OpenAI Agents SDK, Claude Agent SDK, Strands, CrewAI, AutoGen, Mastra. Covers architecture, tool use, multi-agent orchestration, memory, observability, deployment.

REST API design conventions covering URL structure, HTTP methods, response formats, status codes, pagination, and versioning. Use when designing or reviewing API endpoints.

Authentication and authorization patterns covering session-based auth, JWT, OAuth 2.0, RBAC, and security best practices. Use when implementing login flows, protecting endpoints, or handling user identity.

Go expertise — patterns for building HTTP servers, CLI tools, and concurrent systems using Go standard library and popular packages. Covers Go idioms, error handling, interfaces, and goroutine patterns.

Integrating LLM providers (Anthropic, OpenAI, Google, Bedrock, Ollama) into backends. Client setup, streaming, errors, token management, compaction, caching, observability, cost, provider abstraction.

Node.js expertise — patterns for building APIs, middleware, and server-side logic using Express, Fastify, or Node.js built-ins. Covers async patterns, streams, error handling, and TypeScript on the server.

Python expertise — patterns for building APIs and server-side logic using FastAPI, Django, or Flask. Covers type hints, async Python, testing with pytest, and Python packaging.

TypeScript expertise — language-level patterns for strict typing, generics, utility types, module systems, and TypeScript configuration. Use for cross-cutting type system work that spans frontend and backend.

PostgreSQL expertise — schema design, migrations, query optimization, indexing strategy, and extension usage for production-grade relational databases.

Redis expertise — caching patterns, session management, pub/sub, data structures, TTL strategies, memory optimization, and persistence configuration.

Web accessibility patterns and requirements (WCAG 2.1 AA). Use when building any user-facing UI.

LLM-driven UI via typed JSON spec. For AI agents that produce rich output (reports, dashboards, tool results) beyond markdown. Uses @json-render with a Zod-validated catalog. Not for general product UI.

Patterns for AI assistant UIs — chat, tool rendering, rich components. Uses assistant-ui + Vercel AI SDK + json-render + shadcn + TanStack Query. For chat interfaces, agent dashboards, conversational UIs.

React component composition patterns — compound components, variant APIs, state isolation, and React 19 patterns. Use when building or reviewing React component architectures.

CSS and Tailwind specialist knowledge — utility-first styling, responsive design systems, modern layout techniques, animations, dark mode, design tokens, and accessibility-compliant theming.

Building generative UI — LLM-driven dynamic interfaces via Vercel AI SDK, JSON component rendering, streaming UI, agent-driven frontends. For chat interfaces, AI dashboards, runtime-composed UIs.

Next.js specialist knowledge — App Router architecture, Server Components, Server Actions, rendering strategies, caching, routing, API route handlers, and optimization patterns for Next.js 14+.

Frontend performance optimization patterns for Core Web Vitals. Use when building UI.

Modern React patterns and conventions for React 18+. Priority-ranked rules for performance, correctness, and maintainability. Use when building React components, reviewing React code, or diagnosing React performance issues.

React specialist knowledge — component architecture, hooks patterns, state management, TanStack libraries, shadcn/ui, React 18+ concurrent features, testing with React Testing Library, and accessibility best practices.

TanStack ecosystem — Query v5 for server state, Router v1 for type-safe routing, Table v8 for headless data grids, Form v1 for form state. Covers data fetching, caching, mutations, optimistic updates, URL state, and state management decisions.

Testing specialist knowledge — test architecture, Vitest/Jest configuration, React Testing Library, Playwright e2e tests, MSW API mocking, test factories, and CI parallelization strategies.

Visual design principles for building polished, professional UIs. Use when creating or styling frontend components to ensure they look intentional and refined, not generic or developer-default.

Polished, distinctive UIs that don't look like generic AI output. Visual hierarchy, typography, color, spacing, animation, empty/loading states, responsive, dark mode. Apply to any user-facing interface.

A structured 4-step debugging process: reproduce, understand, hypothesize, verify. Use when encountering any bug, test failure, or unexpected behavior before proposing fixes.

Documentation standards for READMEs, code comments, and API docs. Use when writing or reviewing any project documentation.

Git branching strategy, commit conventions, commit frequency, and PR practices. Use when starting feature work, writing commit messages, or preparing a pull request.

AWS expertise — configures and manages AWS services including EC2, Lambda, S3, RDS, ECS, CloudFront, IAM, and CloudFormation/CDK with security-first and cost-optimized patterns.

CI/CD pipeline structure, principles, testing strategies, and deployment patterns. Use when designing, reviewing, or debugging pipelines.

Cloud-agnostic deployment patterns — containerization, hosting selection, env management, CI/CD, zero-downtime deploys, production readiness. Applies to any cloud or self-hosted infra.

Docker containerization — multi-stage builds, security hardening, Compose orchestration, image optimization, dev workflows, production deployment. Apply to Dockerfiles, docker-compose, container configs.

Docker expertise — Dockerfiles, docker-compose configurations, multi-stage builds, image security, layer caching, and container optimization patterns.

Terraform expertise — HCL authoring, module design, state management, provider configuration, and infrastructure-as-code best practices for multi-cloud environments.

iOS and SwiftUI specialist knowledge — SwiftUI view composition, state management (@State/@Observable/@Bindable), NavigationStack, SF Symbols, Apple HIG compliance, Swift concurrency, accessibility, and testing with XCTest/Swift Testing.

iOS testing and debugging — XcodeBuildMCP for builds/tests/LLDB, ios-simulator-mcp for simulator UI interaction/screenshots, XCTest/Swift Testing for unit tests, XCUITest for UI automation.

Ship every project with a working CI pipeline (test + lint + typecheck + build). Auto-detects platform (GitHub/GitLab/Bitbucket) and stack (Node/Python/Go/Swift/Rust). Apply after the first feature ships.

Systematic code review process for domain leads reviewing specialist output. Covers correctness, security, performance, and convention compliance.

Centralized config and lightweight dependency injection — single config module, validated at startup, factory/constructor injection for wiring, composition root pattern. No heavy DI frameworks unless the app actually needs them.

Framework for evaluating and selecting npm packages, libraries, and tools. Use when choosing between alternatives (ORMs, auth libs, UI frameworks) or adding new dependencies.

End-to-end testing and visual validation using Playwright MCP and Chrome DevTools MCP. Use when verifying frontend UI, testing user flows, running Lighthouse audits, or validating application behavior in the browser.

Error handling patterns for consistent, meaningful error management across the stack. Use when implementing any feature that can fail.

Multi-perspective ideation. Architect researches the query through relevant lenses (product, architecture, security, data, cost) in its own context using Glob/Grep/Context7/Exa/DeepWiki. Only runs the perspectives the query actually needs.

Integration testing patterns using stateful API emulation, service containers, and contract testing. Use when testing code that interacts with external APIs, databases, or third-party services.

Mark and preserve non-obvious code that looks removable but isn't. Defensive patterns, workarounds for library bugs, and fixes that survived painful debugging deserve a marker so the next refactor doesn't silently regress them.

Zero-downtime database migration patterns — safe column additions, index creation, data backfills, and rollback strategies. Use when writing or reviewing database migrations for production systems.

Structured logging for any application — language-specific logger setup, log levels, what to log at each layer, request tracing. Mandatory for all implementations. Evaluator checks for it.

Generates minimal project documentation — README.md, ARCHITECTURE.md with Mermaid diagrams, and AGENTS.md. Run after first feature ships or when docs are missing. Reads the actual codebase to generate accurate docs, not boilerplate.

Prepares a project for public distribution — open source setup, package.json exports, bundling, docs, CI/CD, GitHub templates, LICENSE, CONTRIBUTING, SECURITY. Learned from Next.js, Vite, shadcn/ui, Tailwind CSS, tRPC patterns.

Automated release workflow — version bump from conventional commits, changelog generation, tagging, and optional push. Use when a project is ready to cut a release.

Security review checklist for code review and implementation. Covers OWASP top 10, authentication, data protection, and common vulnerabilities.

Patterns for apps with external clients — singleton clients, factories, connection pools, retry/timeout wrappers, graceful shutdown, service-layer organization. Apply when an app talks to DBs/APIs/caches/queues.

Patterns for sharing types, API contracts, and validation schemas between frontend and backend. Use when multiple domains consume the same data shapes to prevent contract drift.

Test-driven development process — write failing test, implement to pass, refactor. Use when implementing any feature or fixing bugs.

Decide when to use unit vs integration vs e2e tests, and when to mock vs use the real thing per dependency. Dependency injection is the enabler — without it you end up monkey-patching imports. Apply when writing tests of any kind.

2 hooks across 2 events