Help us improve
Share bugs, ideas, or general feedback.
Share bugs, ideas, or general feedback.
Share bugs, ideas, or general feedback.
By genkovich
Drive a feature from idea to shipped code through a gated backbone of spec, design, data model, API, tasks, tests, implementation, review, and release, with each stage reading previous artifacts and enforcing completeness. Includes a TDD engine, living roadmap, Q&A with depth control, and surface-aware design for multi-platform apps.
npx claudepluginhub genkovich/sdd --plugin sddClean-context multi-perspective reviewer of an SDD feature's candidate approaches. Use during specify's ideation pass (hard depth) to pressure-test the three strategic approaches from three lenses — Engineer, Executive, UX — so the recommendation isn't blind to cost, feasibility, or the user. Read-only; returns one 3×3 synthesis matrix (lens × approach) scored +/0/− with ≤6-word justifications. The Engineer lens stays abstract (latency/complexity/integration surface), never product or library names.
Clean-context coherence critic for SDD artifacts (a spec or a SAD). Use after a Socratic pass to detect cross-section drift, coherence damage from user edits, structural gaps, and constraint/ quality leaks the per-section walk could not see. Read-only; reads the upstream artifacts itself; emits cited findings only. It judges coherence, it does not propose new design.
Clean-context adversary for SDD. Two modes, named by the dispatch prompt. (A) Ambiguity hunt over a written spec — used by clarify to find where two competent engineers would reasonably build different things (vague terms, unmeasured NFRs, under-specified ACs, conflicts). (B) Failure-mode hunt over a raw idea + candidate approaches — used by specify's ideation pass (medium/hard) to find how it fails in production (attack vectors with monitoring/churn/incident signals). Read-only; reads its inputs itself; emits cited findings. It surfaces problems, it does not resolve them.
Read-only brownfield scout for SDD. Use when a skill (design, data-model) needs the existing codebase mapped before it designs against it — module boundaries, the patterns already in use, where similar features live, the migration/test conventions. Returns a concise structured map; it locates and summarizes, it does not edit, review, or design.
Makes a failing SDD test pass — the GREEN + REFACTOR + GATE steps of test-driven development. Use after test-author has produced a red test for a task. Given the task and its quoted failing line, it writes the minimal production code to pass, refactors while staying green, and runs the per-task gate (unit + integration-if-available + lint + vet). It never weakens or edits the test to force a pass.
Use to derive the API contract for a feature — an OpenAPI 3.1 document at docs/features/{slug}/contracts/openapi.yaml plus a drift/sync report (and an events doc when the feature has async flows). Triggers on "api for {slug}", "openapi for {slug}", "API contract for {slug}", "lock the interface for {slug}", "events for {slug}", "/sdd:api {slug}", "контракт API для {slug}", "OpenAPI для {slug}", "опиши ендпоінти". The contract is never hand-written: it is a derived function of data-model.md (typed fields + constraints), the sad.md §6 sequence diagrams (error branches, async actors), and spec.md acceptance criteria. Runs an inline drift check (does the contract match the model and the sequences?) and a reconcile mode. Hard-refuse if data-model.md is missing → run `data-model {slug}` first.
Use to run an ambiguity sweep over a written spec.md and close every under-specified point before planning or design proceeds — so two engineers can't reasonably build different things from the same spec. Triggers on "clarify {slug}", "find ambiguities in {slug}", "is the spec ready", "sharpen the spec", "/sdd:clarify {slug}", "прояснити специфікацію", "знайди неоднозначності {slug}", "чи готова специфікація". Re-reads the spec, dispatches a clean-context devil's-advocate subagent to list where the spec forks, then for each ambiguity runs AskUserQuestion to RESOLVE it (tighten §1/§5/§6 in place) or DEFER it (→ §8 Open questions with owner+due). Output: an updated docs/features/{slug}/spec.md with every ambiguity resolved or deferred — none dangling. Hard-refuse if spec.md is missing.
Use to classify a feature into XS/S/M/L/XL and write docs/features/{slug}/.size so later skills know how much of each artifact to produce. Triggers on "classify size", "feature size", "is this XS or M for {slug}", "size {slug}", "/sdd:classify-size {slug}", "класифікуй розмір {slug}", "який розмір фічі", "XS чи M". Asks four AskUserQuestion (PR count / time / new module-API-migration / breaking changes), maps to a size class via the shared size matrix, confirms with the user, and writes the one-line .size file. Syncs with spec.md frontmatter feature_size: if present (warns on conflict).
Use to design the data model AND generate the actual forward + rollback migrations in one pass — shippable SQL, not a plan. Triggers on "data model for {slug}", "schema for {slug}", "generate migrations for {slug}", "DB design + migration", "/sdd:data-model {slug}", "модель даних для {slug}", "схема для {slug}", "згенеруй міграції". Reads spec.md §5 + sad.md §6.4 ER + the sequence diagrams, then writes docs/features/{slug}/data-model.md plus paired *.up.sql / *.down.sql migrations STAGED under docs/features/{slug}/migrations/ (NOT the live migrations/ tree — implement promotes them when the feature is actually built) and an audit report. Greenfield-first; brownfield delta via --mode brownfield; drift-only via --drift-only. Hard-refuses if spec.md or sad.md is missing. Stack-agnostic: detects and FOLLOWS the repo's DB + migration conventions and domain layer — it imposes no DB philosophy and writes no rules file.
Use to record a post-hoc or asynchronous architecture decision as a MADR ADR when it was NOT captured during the synchronous design pass — a choice made in code, in a chat, on a whiteboard, or one a tasks/review gate flagged as missing. Triggers on "ADR for {decision}", "adr for {slug}", "document the decision on {topic}", "lock in the decision about {X}", "MADR for {topic}", "/sdd:decide-adr {slug} {title}", "створи ADR для рішення", "задокументуй рішення", "ADR на {тему}". Confirms the decision is ADR-worthy via the blast-radius gate, picks the next 4-digit number, copies design's MADR template, and fills context / drivers / considered options / outcome / honest consequences. Supports a Proposed → Accepted review flow. Output: docs/features/{slug}/adr/NNNN-{title}.md. For decisions made live with the user, use `design` — it spawns ADRs inline (Accepted).
Uses power tools
Uses Bash, Write, or Edit tools
Share bugs, ideas, or general feedback.
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge.
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge.
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
Spec-driven development methodology for full-stack teams
Spec-Driven Development Workflow for Claude Code. A 6-step pipeline: Requirements → Code Analysis → Design → Implement → Verify → Self-Improve. Specifications are the source of truth, code is a verified artifact.
Spec-Driven Development (SDD) plugin for Claude Code providing a comprehensive workflow for building features with requirements, design, tasks, and implementation phases.
Specification-Driven Development with Process Discipline for Claude Code
Spec-driven development pipeline for Claude Code: interview-to-spec, spec-approach, tdd, verify, diagnose, and a feature orchestrator.
Comprehensive AI-assisted development workflow system with specialized agents, orchestrated commands, and file-based state management
LLM Wiki workflows — ingest, query, lint, inbox. Operates on any wiki whose CLAUDE.md has frontmatter type: schema, scope: wiki.
Enforce team PR review conventions: changelog entry, no console.log, test coverage, no formatting churn, security checklist.
Pre-deploy checklist enforcer: env diff, migrations dry-run, smoke endpoints, rollback plan, oncall heads-up.
Pre-deploy checklist enforcer: env diff, migrations dry-run, smoke endpoints, rollback plan, oncall heads-up.
Enforce team PR review conventions: changelog entry, no console.log, test coverage, no formatting churn, security checklist.
A self-contained Claude Code plugin that carries a feature from a one-line idea to reviewed, verified, shipped code through 16 atomic, stack-agnostic skills and a TDD implementation engine — with a living roadmap above the per-feature flow.
Every skill is Socratic (it walks decisions with you, it doesn't dump a wall of output),
gated (a stage hard-refuses when its prerequisite artifact is missing), and stack-agnostic
(no language, tracker, or test tool is hard-coded — the skills detect what your repo uses).
The Q&A skills (specify / clarify / design) are also depth-tunable — an easy / medium / hard
dial decides how much the skill decides for you vs. interrogates you with trade-offs.
Claude Code — native plugin:
/plugin marketplace add genkovich/sdd
/plugin install sdd@sdd
After updating to a new release: re-run /plugin install sdd@sdd, then /reload-plugins.
Codex CLI — cd into your project first: the script installs into the current directory
(.agents/skills/ + .codex/agents/). Add --global after codex to install under ~ instead:
cd your-project
curl -fsSL https://raw.githubusercontent.com/genkovich/sdd/main/install.sh | bash -s -- codex
Then restart codex (skills are discovered at session start) and type $sdd-specify.
Alternative — the plugin marketplace. Note that add only registers the marketplace, it
installs nothing by itself:
codex plugin marketplace add genkovich/sdd
then inside codex run /plugins, switch to the sdd marketplace tab and pick
Install plugin. One naming nuance: the marketplace install registers the original skill
names ($specify), while the installer script prefixes them — $sdd-specify — because bare
names like review / design / api collide with generic skills. Pick one of the two paths,
not both, or the skill list shows each skill twice.
Cursor (2.4+) — the same script; cd into your project first (installs into
.cursor/skills/ + .cursor/agents/ of the current directory; --global for ~):
cd your-project
curl -fsSL https://raw.githubusercontent.com/genkovich/sdd/main/install.sh | bash -s -- cursor
Then restart Cursor (or run Developer: Reload Window) and invoke a stage by typing / in
the chat and picking sdd-specify. (Cursor also reads .agents/skills/, so a Codex install is
already visible to Cursor.) Once the plugin is listed on the Cursor marketplace, installing from
the in-app marketplace panel works too — project- or user-scoped.
How every Claude-specific mechanism — AskUserQuestion, subagents, /clear, the implement
engine modes — maps to Codex / Cursor is one table:
skills/_shared/tool-adapters.md.
The flow is a straight line: each stage writes a file the next one reads. Run them in order (the diagram + table are just below).
/sdd:survey ← once per repo: map an existing codebase, OR bootstrap an empty one
/sdd:specify checkout-discounts ← interviews you, writes the spec (you don't bring one)
/sdd:design … → /sdd:implement … → /sdd:review … → /sdd:ship
Two things to know up front: survey runs once per repo — on an existing codebase it maps the
current architecture to docs/architecture-map.md (every later stage reads it); on an empty repo it
runs a short foundation session and scaffolds the skeleton (detail below).
And specify creates the spec from a short interview — you bring the idea, not the document.
From there you walk the backbone in order. Each step reads the previous step's file and refuses if it's missing, so you can't skip ahead by accident.
Every stage ends with a copy-ready handoff block (skills/_shared/handoff.md):
What I did + Review before continuing (links to the files it wrote, so you can eyeball them at the
gate) + Run next — /clear, then the next /sdd:… command in a fenced block you copy in one
click. The /clear matters because each stage is gated and re-reads its inputs from disk, so it
needs no carryover — clearing keeps the context small and stops one stage's chatter from drifting into
the next. (Loop-backs are the exception — when review bounces back to implement, you stay in
context to iterate; utilities make /clear optional.)
There are three kinds of skill. Most of your time is the backbone — a straight line you walk in order. A few are utilities you call whenever you need them. Two close the loop after the code is written.