By genkovich
SDD implements a complete spec-driven development pipeline for Claude Code: survey a codebase or bootstrap greenfield, walk gated stages from idea capture → spec → architecture → data model → OpenAPI contract → task breakdown → TDD implementation → review → ship, while maintaining a living roadmap (Now/Next/Later). Every stage hard-refuses to proceed if the previous artifact is missing, and the depth of Q&A and ideation is tunable.
Clean-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 — or when fix needs a reported symptom localized to its code path. Returns a concise structured map (or file:line root-cause candidates); 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 — the source of truth; the feature_size: frontmatter mirrors in spec.md and sad.md are re-synced to it on every (re)classification.
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 §5 building blocks + the §6 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).
Admin access level
Server config contains admin-level keywords
Uses power tools
Uses Bash, Write, or Edit tools
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
A self-contained Claude Code plugin that carries a feature from a one-line idea to reviewed, verified, shipped code through 17 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,
or --prefix DIR to install under an arbitrary directory (useful for trying it out in a sandbox):
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 — they register different names for the same skills, so running both shows every
skill twice. To undo the script install: re-run install.sh codex --uninstall from the same
directory (or with the same --global / --prefix). To undo the marketplace install: /plugins
→ the sdd tab → uninstall (or remove the [plugins."sdd@…"] entry from ~/.codex/config.toml).
The script warns when it detects a marketplace install already registered.
Windows note. The installer is a bash script — run it from Git Bash or WSL. The directories it writes (
.agents/,.codex/,.cursor/) start with a dot, which Explorer hides by default — enable «Hidden items» (ordir /a) to see them.
Cursor (2.4+) — the same script; cd into your project first (installs into
.cursor/skills/ + .cursor/agents/ of the current directory; --global for ~,
--prefix DIR for an arbitrary directory):
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.
npx claudepluginhub genkovich/sdd --plugin sddLLM 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.
Spec-driven development methodology for full-stack teams
Spec-Driven Development (SDD) plugin for Claude Code providing a comprehensive workflow for building features with requirements, design, tasks, and implementation phases.
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 pipeline for Claude Code: interview-to-spec, spec-approach, tdd, verify, diagnose, and a feature orchestrator.
Specification-Driven Development with Process Discipline for Claude Code
Spec-driven development using GitHub spec-kit methodology. Constitution-first approach with specify, plan, tasks, and implement phases.