By LiorCohen
Initialize spec-driven development (SDD) projects with scaffolding and settings, decompose specs into independent changes with phased plans, orchestrate full lifecycles from creation to verification, track workflow states, generate indexes and snapshots, and manage git-integrated commits via commands.
Context-aware workflow assistant — reads project state, suggests next steps, and executes via /sdd-run.
Explicit command with namespaced subcommands covering all SDD functionality.
SDD tutor — teaches concepts, methodology, and guides discovery of what's possible.
Create change specification and implementation plan with dynamic phase generation. Supports feature, bugfix, refactor, and epic types.
Guidelines for consistent, well-documented commits in SDD projects
Populate domain specs (glossary, entity definitions, use-cases) from SPEC.md content during implementation.
Process external specifications through transformation, classification, gap analysis, component discovery, and decomposition. Creates workflow items with classified context.
Orchestrates the full change lifecycle — routes actions to phase-specific sub-files.
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.
Structure for AI-assisted development
AI coding assistants are powerful but chaotic. You prompt, you get code, but then what? No documentation of decisions, no way to verify the code matches what you needed, and a codebase that's impossible to explain to teammates.
SDD brings structure to AI-assisted development. Every change starts with a spec, gets broken into a plan, and ends with verified implementation. Specialized agents handle each concern instead of one AI doing everything poorly.
claude plugin marketplace add https://github.com/LiorCohen/sdd
claude plugin install sdd
/sdd I want to initialize a new project # Initialize a new project
/sdd I want to create a new feature # Create a spec
/sdd I want to approve the spec # Review spec, create plan
/sdd I want to approve the plan # Approve plan, enable implementation
/sdd I want to start implementing # Execute the plan
/sdd I want to verify the implementation # Verify it matches the spec
Get started with the tutorial →
Every change lives in a markdown specification before it lives in code:
changes/2026/01/15/user-auth/
├── SPEC.md # What you're building (acceptance criteria)
└── PLAN.md # How to build it (phased implementation)
Specs include frontmatter metadata, acceptance criteria in Given/When/Then format, and references to domain concepts.
| Type | Purpose | Structure |
|---|---|---|
| feature | New functionality | 6 phases |
| bugfix | Fix existing behavior | 4 phases |
| refactor | Restructure without changing behavior | 4 phases |
| epic | Multiple features grouped under one goal | Child changes in changes/ subdirectory |
Instead of one general-purpose AI, SDD uses 7 specialized agents:
| Agent | Model | Purpose |
|---|---|---|
| api-designer | sonnet | Design OpenAPI contracts |
| backend-dev | sonnet | Node.js backend (CMDO architecture) |
| frontend-dev | sonnet | React components (MVVM architecture) |
| db-advisor | opus | Database performance review |
| devops | sonnet | Kubernetes, Helm, CI/CD, Testkube |
| tester | sonnet | Integration and E2E test automation |
| reviewer | opus | Code review and spec compliance |
| Command | Purpose |
|---|---|
/sdd | Context-aware hub — reads project state and guides you |
/sdd I want to create a new feature | Create new change spec |
/sdd I want to import an external spec | Import changes from external spec |
/sdd I want to approve the spec | Approve spec, create plan |
/sdd I want to approve the plan | Approve plan, enable implementation |
/sdd I want to start implementing | Execute implementation plan |
/sdd I want to verify the implementation | Verify implementation matches spec |
/sdd I want to generate config for local | Generate merged config for an environment |
/sdd set up the database | Direct system operations via natural language |
/sdd-help | Interactive tutor for SDD concepts |
SDD commands create many files. To reduce permission prompts, add this to your .claude/settings.local.json:
{
"permissions": {
"allow": [
"Write(changes/**)",
"Write(specs/**)",
"Write(components/**)",
"Edit(changes/**)",
"Edit(specs/**)",
"Edit(components/**)",
"Bash(git *)",
"Bash(npm *)"
],
"deny": [
"Write(.env*)",
"Edit(.env*)"
]
}
}
See Permissions Setup for full configuration options.
When you run /sdd I want to initialize a new project, you get:
npx claudepluginhub liorcohen/sdd --plugin sddSpec-Driven Development (SDD) plugin for Claude Code providing a comprehensive workflow for building features with requirements, design, tasks, and implementation phases.
Spec-Driven Development for Claude Code: 17 atomic, stack-agnostic skills + 9 subagents that carry a feature from idea → spec → design → data-model → API → tasks → tests → implement → review → ship, plus a TDD implementation engine and a living roadmap above the per-feature flow. Start with `survey` (maps an existing codebase or bootstraps an empty one), walk the gated backbone — each stage reads the previous artifact and hard-refuses if missing — and keep `docs/roadmap.md` (Now/Next/Later, outcome-altitude, never dates) in sync as `specify` promotes a feature to Now and `ship` moves it to Shipped. The Q&A skills are depth-tunable (easy/medium/hard — decide-for-me vs. interrogate-me-with-trade-offs); the ideation analyses run as named subagents (researcher/strategist/analyst/devil's-advocate) gated by that dial; diagrams are presented in prose and written to file (never raw Mermaid dumped to the terminal); and every acceptance criterion is covered end-to-end. design is surface-aware: it declares the feature's target surfaces at the architecture stage (backend-service / web-frontend / mobile-app / desktop-app / cli / worker / library-sdk, each a C4 container) and downstream stages gate their output by that choice — the `ui` task layer, UI-driven sequence flows, and the component / visual-regression / e2e-through-UI frontend test tiers; `ui` work reuses the repo's existing design system (components / tokens / styling) from the architecture map, never reinvents. Every stage ends with a copy-ready handoff block — what changed, the files to review, then `/clear` + the next `/sdd:…` command.
Comprehensive Spec-Driven Development toolkit with multi-language support, specialized agents, and integrated security/observability tools
Specification-driven development workflow: specify → plan → tasks → implement
GitHub Spec-Kit integration for Specification-Driven Development - define WHAT and HOW before coding
Specification-Driven Development with Process Discipline for Claude Code