
Adversarial review of non-trivial decisions using fresh-context scrutiny. Use when correctness matters more than speed, when stakes are high (production, security-sensitive logic, irreversible operations), or before committing significant architectural or implementation choices.
DDD and hexagonal architecture with functional core pattern. Use when designing features, modeling domains, breaking down tasks, or understanding component responsibilities.
Disciplined diagnosis loop for hard bugs and performance regressions. Reproduce → minimise → hypothesise → instrument → fix → regression-test. Use when user says "diagnose this" / "debug this", reports a bug, says something is broken/throwing/failing, or describes a performance regression.
Security architecture and threat modeling knowledge. Auto-invokes when designing features that handle untrusted data, authentication, authorization, external integrations, file uploads, or sensitive data. Provides risk assessment frameworks, trust boundary analysis, and security design principles — not implementation code.
Compact the current conversation into a handoff document for another agent to pick up.
Documentation generation for code projects. Use when updating docs, writing README, generating API docs, creating changelog, or when the user mentions documentation, docs, readme, api docs, or any documentation task.
Generate and validate conventional commit messages following the conventionalcommits.org spec. Use whenever the user wants to commit code, mentions commit messages, git commit, or asks to create a commit. Triggers on "commit", "git commit", "conventional", or when reviewing commit message format.
Execute implementation tasks from an approved plan.json. Use when spec-plan has produced approved tasks and the human is ready to start coding. Tracks progress via beads (preferred) or harness-native todos, enforces TDD, reports between batches. Trigger when the user says "implement", "go", "start", "do it", or after spec-plan completes task creation. Do NOT use without an approved plan — invoke spec-plan first.
Post-implementation completion workflow. Use after spec-implement completes to validate, review, create stacked commits, and prepare for PR. Triggers when implementation is done, when the user says "finish", "done", "complete", or after implementation tasks are finished.
Socratic interrogation of plans against the project's domain model and documented decisions. Use when the user wants to stress-test a plan, clarify terminology, or validate assumptions against existing domain language. Updates CONTEXT.md and ADRs inline as decisions crystallise.
Write implementation plans, iterate with human annotations, create structured tasks. Use when there's an approved spec (design.md) and the next step is breaking it into implementable work. Trigger when the user says "write a plan", "plan this out", "break this down", "I added notes" (annotation cycle), or after spec-brainstorm completes. Also trigger for "create tasks" or "add to beads". Do NOT use for research (use spec-brainstorm) or execution (use spec-implement).
Multi-agent code review with parallel specialized reviewers, architecture validation, and challenge validation. Use `rq` to request a review of diffs (defaults to main branch), `rs` to respond to review findings. Triggers on "review this", "review my code", "code review", "check for bugs", "audit this", when examining PRs, pull requests, branches, or diffs. Always asks user before applying fixes.
Conversational design workshop for new features. Interviews the human one question at a time, explores 2-3 approaches with trade-offs, then produces a focused spec. Combines requirements discovery with codebase research and architecture design. Use when the user says "create a spec", "design this feature", "let's brainstorm", "what should we build", or at the start of any feature/refactor/complex-bug workflow.
Skill routing and workflow orchestration. Routes to correct spec skill based on task type. Establishes discipline and manages transitions between workflow phases. Use when starting any conversation or task to determine which spec skill applies.
Subagent dispatch patterns for implementation tasks. Use when spec-implement has multiple tasks to execute and subagents are available. Covers parallel dispatch for independent work, the two-stage review cycle (spec compliance then code quality), focused prompt construction, and integration of results. Trigger when executing plan tasks with subagent support, when facing 2+ independent problems, or when the user asks to use subagents for implementation.
REST API design patterns. Use when designing endpoints, error responses, pagination, versioning, or API structure. Framework-agnostic principles for building consistent, maintainable APIs.
TypeScript project tooling with Bun, tsgo, Vitest, Biome, and Turborepo. Use when setting up package.json scripts, running builds, typechecking, configuring tests, linting, formatting, or orchestrating monorepo development.
Type-safe functional effects with Effect-TS. Use when building applications with Effect, using Effect.gen generators, handling typed errors, managing services with Layer and Context.Tag, validating data with Schema, or managing resources with acquireRelease.
Building REST APIs with Fastify in TypeScript. Use when creating routes, handling requests, implementing validation with TypeBox, structuring applications, or working with HTTP handlers and plugins.
Functional programming patterns for reliable TypeScript. Use when modeling state machines, discriminated unions, Result/Option types, branded types, or building type-safe domain models.
TypeScript testing patterns with Vitest and MSW. Use when writing unit tests, mocking APIs, creating typed mocks for dependency injection, or using snapshot testing.
Python monorepo architecture with uv workspaces, mise, and apps/packages pattern. Use when setting up project structure, configuring workspaces, managing dependencies across packages, or designing multi-app Python repositories.
Python application architecture with functional core, effectful shell, DDD, and data modeling. Use when designing application layers, separating pure business logic from IO, defining domain models, implementing validation, or structuring bounded contexts.
Manage stacked commits using Graphite. Use when the user wants to create multiple stacked commits, manage a commit stack, sync with remote, or submit PRs from a stack. Triggers on "stacked", "stack", "gt ", "graphite", or when working with multiple related commits.
SQLAlchemy ORM patterns for Python database access. Use when defining models, writing queries, implementing upserts, working with JSON columns, or managing database sessions.
DynamoDB single-table design using dynamodb-toolbox v2. Use when creating entities, defining key patterns, designing GSIs, writing queries, implementing pagination, or working with any DynamoDB data layer in TypeScript projects.
Performance profiling and optimization. Use when code is slow, has memory issues, or needs optimization. Triggers on "slow", "performance", "optimize", "memory leak", "profiling", "bottleneck", or any performance-related concern.
Modern Python language features and typing patterns. Use when writing type hints, using generics, implementing pattern matching, working with async/await, or leveraging Python 3.10+ features.
Type-safe SQL with Drizzle ORM in TypeScript. Use when defining database schemas, writing queries, setting up relations, running migrations, or working with PostgreSQL/MySQL/SQLite/Cloudflare D1/Durable Objects data layers.
Temporal workflow orchestration in Python. Use when designing workflows, implementing activities, handling retries, managing workflow state, or building durable distributed systems.
Use when starting feature work that needs isolation from current workspace - creates isolated git worktrees with smart directory selection and safety verification. Triggers on worktree, git worktree, isolated workspace, or creating a new branch for feature work.
Generate and validate conventional commit messages following the conventionalcommits.org spec. Use whenever the user wants to commit code, mentions commit messages, git commit, or asks to create a commit. Triggers on "commit", "git commit", "conventional", or when reviewing commit message format.
Stub-Driven TDD and layer boundary testing. Use when writing tests, deciding what to test, or testing at component boundaries.
Security audit and vulnerability detection. Use when reviewing code for security issues, scanning dependencies, or addressing security concerns. Triggers on "security", "vulnerability", "audit", "CVE", "injection", "XSS", "SQL injection", "auth", or when the user asks to check for security issues.
Challenge an approach with critical thinking. Use when questioning assumptions, validating decisions, testing approach validity, or preventing automatic agreement.
Extended reasoning analysis using sequential thinking. Use for deep exploration, comprehensive analysis, complex decisions, or when you need fresh perspectives on difficult problems.
Python project tooling with uv, mise, ruff, basedpyright, and pytest. Use when setting up pyproject.toml, running builds, typechecking, configuring tests, linting, formatting, or managing Python environments.
Building REST APIs with FastAPI, Pydantic validation, and OpenAPI. Use when creating routes, handling requests, designing endpoints, implementing validation, error responses, pagination, or generating API documentation.
Stub-Driven TDD and layer boundary testing with pytest. Use when writing tests, deciding what to test, testing at component boundaries, or implementing test-driven development.
Install this Claude Code plugin into another AI coding tool (opencode, Claude Code, Gemini CLI, Codex CLI, Windsurf, etc.). Use when the user asks to install, port, migrate, or sync this plugin to another tool, or asks "how do I use this in X". Triggered by phrases like "install atelier", "port to opencode", "sync to Claude", "how do I use this in cursor", or "add to Codex".
Discovery, research, and architecture for new features. Produces spec.md — a living specification that covers what exists, what we're building, and how it fits together. Combines requirements discovery with codebase research and design. Use when the user says "create a spec", "what should we build", "design this feature", or at the start of any feature/refactor/complex-bug workflow.