agent-kit

Provide accessibility expertise — WCAG 2.2 compliance, ARIA patterns, keyboard navigation, focus management, screen reader support. Use when implementing WCAG compliance, ARIA roles, keyboard navigation, accessibility auditing, or inclusive design. Do NOT use for UX decisions (design).

Create, update, delete, sync, or verify project agents assembled from reusable Agent Kit profession profiles and knowledge skills. Use when setting up backend/frontend/tester or other agents for a project, changing their skill combinations, generating native Claude and Codex agent files, or maintaining the bundled profile library. Do NOT use to run agents or assemble a task workflow (use agent-orchestrator) or to create knowledge skills (use skill-creator).

Orchestrate profession agents with the host runtime's native subagent and workflow mechanisms. Use when the user asks to assemble a team, choose agents for a task, run several specialists, create an ad-hoc workflow, parallelize review or implementation, or delegate work without spelling out roles, models, effort, and task division. Do NOT use to create or change project agent definitions (use agent-creator) or for a task that should stay in the current thread.

Design APIs — protocol selection, REST, OpenAPI 3.1, RPC patterns, pagination, versioning, error contracts. Use when choosing REST/GraphQL/gRPC, designing endpoints, writing OpenAPI specs, or implementing pagination/error responses. Do NOT use for GraphQL depth (graphql) or real-time (realtime).

Design, diagram, and review software architecture: boundaries, contracts, ownership, state, behavior, evolution, and NFRs. Use when designing or redesigning a system, finding shared root causes across recurring problems, defining core or module boundaries, synthesizing scenarios, applying SOLID or design patterns, planning extensibility or migration, writing ADRs, or drawing diagrams. Do NOT use when an agreed design only needs a polished web explainer (use visualization), or for routine implementation, detailed API/schema design, or CI/CD.

Implement authentication and authorization patterns. Use when building OAuth2/OIDC flows, JWT validation, passkeys/WebAuthn, session management, MFA, RBAC/ABAC, SAML SSO, or API key auth. Do NOT use for network security or encryption primitives.

Patterns for backend services — dependency injection, middleware, error handling, service lifecycle, resilience, request pipelines. Language-agnostic. Use when building or reviewing services, structuring middleware, designing error contracts, or implementing graceful startup/shutdown. Do NOT use for API protocol choice (use api-design), auth flows (use auth), schemas (use database), or language idioms (use go/rust/kotlin/javascript).

Design background job systems — queue selection, orchestration, scheduling, retry, scaling, observability. Use when implementing job queues, task scheduling, retry strategies, dead letter handling, or workflow orchestration. Do NOT use for message brokers (use message-queues) or real-time (use realtime).

Design caching strategies — cache-aside, write-through, invalidation, multi-layer architecture. Use when choosing cache strategies, designing cache layers, configuring cache headers, implementing invalidation, or preventing stampedes. Do NOT use for database query optimization (use database skill).

CI/CD pipeline design — workflow structure, caching, matrix builds, GitHub Actions, GitLab CI, monorepo pipelines, artifact handling, secrets management in CI. Use when writing or reviewing pipelines, optimizing build times, setting up monorepo CI, handling PR checks, or auditing CI security. Do NOT use for release strategy (use release-engineering), container image building (use docker), or deployment orchestration (use kubernetes).

Navigate regulatory compliance frameworks (GDPR, EU AI Act, SOC2, HIPAA, PCI-DSS, COPPA) and operational concerns (data sovereignty, PII handling, audit trails, privacy by design, consent management, cross-border transfers, data subject requests). Use when designing data protection programs, implementing privacy controls, choosing a compliance framework, mapping data flows, or preparing for an audit. Do NOT use for application-level security (use security), authentication flows (use auth), or PCI-specific payment processing flows (use payments).

Run a question, idea, or decision through a council of 5 AI advisors who independently analyze it, peer-review each other anonymously, and synthesize a final verdict. Adapted from Karpathy's LLM Council methodology. MANDATORY TRIGGERS: 'council this', 'run the council', 'war room this', 'pressure-test this', 'stress-test this', 'debate this'. STRONG TRIGGERS (when paired with a real tradeoff): 'should I X or Y', 'which option', 'what would you do', 'is this the right move', 'validate this', 'get multiple perspectives', 'I can't decide', 'I'm torn between'. Do NOT trigger on simple yes/no questions, factual lookups, creation tasks ('write me a tweet'), or casual 'should I' without stakes. DO trigger when the user presents a genuine decision with stakes, multiple options, and context that suggests they want it pressure-tested from multiple angles.

Design modern CSS — Grid, Flexbox, custom properties, cascade layers, container queries, :has(), CSS nesting, @scope, scroll-driven animations, View Transitions, color functions, logical properties. Use when writing styles, building layout primitives, theming (light/dark), responsive design, or animation. Do NOT use for semantic markup (use html), ARIA (use accessibility), UX decisions (use design), or component architecture (use frontend).

Review and design database schemas, migrations, indexes, queries, and data access patterns. Use when auditing schemas, writing migrations, optimizing queries, or designing data models. Covers relational, document, key-value, and vector stores. Do NOT use for API design (use api-design skill).

Design UX and interaction patterns — user journeys, information architecture, cognitive load, design system governance, dashboard and data UX, onboarding flows. Use when designing or reviewing user flows, auditing IA, improving onboarding, governing a design system, or evaluating dashboards. Do NOT use for HTML/CSS implementation (use html/css), accessibility compliance (use accessibility), or frontend tooling (use frontend).

Build and secure container images. Use when writing Dockerfiles, multi-stage builds, Compose v2, buildx/bake, distroless/Chainguard, SBOM, image signing, health checks, or docker init. Do NOT use for orchestration (use kubernetes) or CI/CD pipelines (use ci-cd).

Write technical documentation — Diátaxis framework (tutorial/how-to/reference/explanation), README conventions, ADR format, runbook structure, changelog discipline, docs-as-code, API reference docs, onboarding guides, AI-readable docs (llms.txt). Use when writing docs, auditing doc completeness, structuring a docs site, or reviewing .env.example. Do NOT use for API schema design (use api-design) or release versioning (use release-engineering).

Apply Feature-Sliced Design (FSD) architecture. Use when organizing frontend structure, deciding where code belongs, auditing FSD imports, reviewing layer compliance, or migrating to FSD. Do NOT use for framework-specific patterns (use react or vue skill).

File storage expertise — upload flows, signed URLs, multipart upload, CDN integration, image processing. Use when implementing file uploads, object storage, presigned URLs, multipart uploads, CDN asset delivery, or virus scanning. Do NOT use for database storage (use database) or caching (use caching).

Apply frontend engineering patterns — bundlers, workspaces, code quality tooling, component patterns, state management choices, build configuration. Framework-agnostic. Use when configuring bundlers, structuring a monorepo frontend, auditing code-quality tooling, or picking state/data-fetching patterns. Do NOT use for framework specifics (use react/vue), HTML/CSS depth (use html/css), accessibility (use accessibility), or UX design (use design).

Write idiomatic Go — goroutines, channels, interfaces, error handling, generics, modules, testing. Use when working with .go files, go.mod, or any Go question. Triggers on goroutine, channel, context.Context, go build, golangci-lint. Do NOT use for general backend patterns (use backend) or infrastructure (use ci-cd).

Design GraphQL schemas, resolvers, DataLoader, federation, subscriptions, security, codegen. Use when designing schemas, solving N+1, setting up federation, implementing subscriptions, or codegen. Do NOT use for REST (use api-design) or real-time transport (use realtime).

Design and validate Claude Code hooks (PreToolUse, PostToolUse, Stop, SessionStart, SessionEnd, UserPromptSubmit, PreCompact, Notification, SubagentStop, TeammateIdle, TaskCompleted). Use when adding a hook, auditing existing hooks, troubleshooting a hook that did not fire or fired wrongly, designing quality gates for native Agent Teams, or reviewing hook security. Provides static command analyzer and dry-run with synthetic payloads. Do NOT use to write settings.json directly (delegate writes to update-config skill) or to spawn agents (use agent-orchestrator).

Write semantic HTML5 markup with landmark elements, accessible forms, media, and native interactive elements. Use when picking between article/section/aside, structuring page outlines, writing forms with labels and autocomplete, adding alt text, or choosing between button/a/details/dialog. Do NOT use for CSS layout or visual styling (use css), ARIA patterns beyond landmarks (use accessibility), or component logic (use frontend).

Implement internationalization — ICU MessageFormat, pluralization, RTL, Intl APIs, Temporal, translation workflows. Use when implementing i18n, localization, pluralization, RTL layout, Intl APIs, or translation pipelines. Do NOT use for accessibility (use accessibility) or CSS layout (use html/css).

Bootstrap Agent Kit for a software project by detecting its stack, selecting profession profiles and knowledge skills, and materializing native Claude and Codex project agents. Use when setting up Agent Kit in a new project, rebuilding its agent configuration, or asking "create agents for this project" without naming each role. Do NOT use for one narrow agent change (use agent-creator) or to run a task workflow (use agent-orchestrator).

Apply JavaScript language patterns — ES2025+ modules, async model, runtime selection, TypeScript type system. Use when working with JS/TS modules (ESM/CJS), async/await, event loop, runtime choice (Node/Bun/Deno), TypeScript types, generics, or tsconfig. Do NOT use for React patterns (use react) or web platform APIs (use web).

Write idiomatic Kotlin — coroutines, Flow, sealed classes, KMP, DSL builders, Gradle KTS, context parameters. Use when working with Kotlin coroutines, Flow, sealed hierarchies, data/value classes, multiplatform, DSL builders, or Gradle Kotlin DSL. Do NOT use for Android UI (use platform-specific guidance) or general JVM patterns.

Kubernetes expertise — manifests, Helm charts, Gateway API, operators, RBAC, HPA/VPA/KEDA, Karpenter, native sidecars, debugging. Use when working with K8s manifests, Helm, Gateway API, RBAC, autoscaling, network policies, or cluster debugging. Do NOT use for container building (use docker) or CI/CD (use ci-cd).

Design message broker architectures — broker selection, DLQ, idempotency, schema evolution, event-driven patterns. Use when choosing brokers, configuring topics, setting up consumer groups, or implementing idempotent processing. Do NOT use for synchronous APIs (use api-design) or job queues (use background-jobs).

Review and implement network infrastructure — DNS, CDN, TLS/mTLS, load balancing, service mesh, firewalls. Use when working with DNS, CDN, TLS/mTLS, HTTP/2-3, load balancing, service mesh, or firewalls. Do NOT use for application-level HTTP (web) or K8s networking (kubernetes).

Design observability systems — tracing, metrics (RED/USE), logging, alerting, profiling, eBPF, pipelines. Use when implementing instrumentation, metrics, logging, profiling, or alerting. Do NOT use for SLO/SLI (use reliability) or bottleneck analysis (use performance).

Configure and maintain Obsidian vault mechanics, including portable settings, excluded paths, properties, Graph view filters and groups, Bases, Canvas, templates, and repository-safe validation. Use when changing Obsidian behavior or visualization. Do NOT use to decide what knowledge means, which claims are true, or how a domain ontology should work.

Architect payment processing systems. Use when implementing payment lifecycle, webhooks, subscriptions, provider selection, PCI compliance, orchestration, or refunds. Do NOT use for general security (use security) or compliance frameworks (use compliance).

Analyze and optimize system performance across any runtime or infrastructure. Use when diagnosing bottlenecks, profiling latency, tuning throughput, investigating memory leaks, optimizing queries, reviewing caching strategies, or capacity planning. Do NOT use for SLO/SLI design or incident response (use reliability), instrumentation pipelines and metrics standards (use observability), or schema/index design (use database).

React expertise — hooks, Server Components, Suspense, RSC data flow, state management. Use when working with React hooks, Server Components, Suspense, server actions, or state management (Zustand, Jotai, TanStack Query). Do NOT use for HTML/CSS (use html/css) or web platform APIs (use web).

Design real-time communication — WebSocket, SSE, WebTransport, scaling, reconnection, presence, CRDTs. Use when implementing WebSocket, SSE, reconnection, presence, binary protocols, collaborative editing, or edge realtime. Do NOT use for message queues or HTTP polling.

Design release strategies — versioning, changesets, feature flags, progressive delivery, monorepo releases, rollback. Use when choosing semver vs calver, implementing changesets, designing feature flag lifecycle, or planning canary/blue-green rollouts. Do NOT use for CI/CD pipelines (use ci-cd) or container deployment (use docker/kubernetes).

Apply site reliability patterns — SLOs, SLIs, error budgets, health checks, graceful shutdown, circuit breakers, chaos engineering, incident response, postmortems, toil reduction, on-call practices. Use when defining SLOs, designing health probes, reviewing shutdown behavior, writing runbooks, running an incident, or reducing toil. Do NOT use for CI/CD (use ci-cd), observability instrumentation (use observability), or performance profiling (use performance).

Write, review, and architect Rust code — ownership, lifetimes, async, error handling, crate selection, API design, FFI. Use when working with .rs files, Cargo.toml, or any Rust question. Triggers on cargo, tokio, serde, axum, clippy, Edition 2024. Do NOT use for general systems-programming patterns (use backend), HTTP API design (use api-design), or other languages — pick the matching language skill (go, kotlin, javascript, zig).

Implement search systems — full-text indexing, hybrid search, autocomplete, relevance tuning, facets. Use when building search, choosing engines, tuning relevance, or adding autocomplete. Do NOT use for database queries (use database).

Apply application security patterns — OWASP Top 10, input validation, output encoding, secrets management, secure coding, supply chain, AI/LLM security. Use when auditing code for security issues, reviewing auth flows at the code level, hardening against OWASP risks, assessing supply-chain risk, or evaluating AI/LLM-specific threats. Do NOT use for compliance frameworks (use compliance), infrastructure security (use networking/kubernetes), or authentication protocols (use auth).

Implement SEO — meta tags, Open Graph, JSON-LD, robots.txt, sitemap, SSR/SSG, Core Web Vitals, GEO, IndexNow, llms.txt. Use when implementing structured data, sitemaps, hreflang, AI search optimization, or crawlability. Do NOT use for performance profiling (use performance) or accessibility (use accessibility).

Create, verify, or improve reusable skills (skills/**/SKILL.md). Use when creating a new knowledge or meta skill, scaffolding skill structure, writing SKILL.md, verifying description triggers, or improving skill effectiveness. Do NOT use for profession profiles or project agents (use agent-creator), running agent workflows (use agent-orchestrator), configuring hooks (use hook-creator), or initial project setup (use init).

Design testing strategy and patterns — test pyramid, unit/integration/e2e/contract tests, mock boundaries, fixtures, flaky test diagnosis, coverage strategy, test data management, property-based and snapshot testing. Use when writing tests, auditing test suites, planning coverage, diagnosing flakiness, reviewing mock usage, or designing a test strategy. Do NOT use for CI/CD pipelines (use ci-cd), performance profiling (use performance), or production code review (use security or language skills).

Configure the Claude Code harness by writing to settings.json — permissions allowlists, environment variables, hooks, slash-command registration. Use when the request is "allow this command", "move permission to user settings", "set DEBUG=true", "add a hook that runs on Stop", or "whenever the model does X run Y". Owns writes to Claude settings files. Do NOT use for hook design or validation (use hook-creator first), project-agent composition (use agent-creator), or creating knowledge skills (use skill-creator).

Build polished responsive HTML or Playground-style technical visualizations from an existing architecture model, document, code, diff, or dataset. Use when asked for an interactive explainer, web preview, navigable diagram set, consistent light/dark themes, code view, diff view, or mobile-friendly visualization. Owns presentation, visual grammar, responsive composition, interaction, and render QA. Do NOT use to design or validate the source architecture, assess code correctness, or design product UI.

Build Vue.js apps with Composition API, reactivity, Pinia, Vue Router, SFC patterns, Vapor mode. Use when working with Vue composables, reactivity, Pinia stores, Vue Router, SFC script setup, or Vapor mode. Do NOT use for HTML/CSS (use html/css) or web platform APIs (use web).

Apply web platform APIs — HTTP, fetch, CORS, CSP, storage, service workers, PWA, View Transitions, Navigation API, Speculation Rules, Popover API. Use when working with browser APIs, HTTP protocols, or offline patterns. Do NOT use for HTML/CSS (use html/css) or framework patterns (use react/vue).

Write idiomatic Zig — comptime, allocators, error unions, C interop, build system. Use when working with .zig files, build.zig, build.zig.zon, or any Zig question. Triggers on comptime, allocator, errdefer, @cImport, zig build. Do NOT use for general systems programming patterns (use backend) or Rust (use rust).