SDD Framework

What Is Spec-Driven Development

Understand SDD, the methodology that makes AI coding tools build exactly what you specified — and meet cc-sdd, its open-source implementation.

What Is Spec-Driven Development?

Spec-Driven Development (SDD) is a methodology where specifications — not code — are the primary development artifact. The spec drives AI implementation. Where traditional development writes code first and documents later (if at all), SDD writes the spec first, reviews it with humans, then lets AI implement it.

SDD exists at three levels:

Spec-first: Write the spec before coding begins. The spec is the plan; code is the execution.

Spec-anchored: The spec is maintained alongside the code throughout the lifecycle. When requirements change, the spec is updated first, then code follows.

Spec-as-source: The spec is the living source of truth. Code is derived from the spec, and any divergence between them is treated as a bug.

The Problem SDD Solves

When developers use AI coding tools without structured input, they encounter a predictable set of problems:

  • Inconsistency: The same feature described differently each session produces different implementations. No conventions are preserved.
  • Context loss: AI tools have no memory between sessions. You re-explain your architecture every time.
  • Drift: Over multiple AI-assisted sessions, the codebase accumulates conflicting patterns because the AI was not aware of decisions made in previous sessions.
  • Untraceability: You cannot answer "why was this built this way?" because there is no documented specification.
  • Review blindness: It is hard to review AI-generated code against requirements when requirements only exist as vague descriptions in someone's head.

SDD solves all of these by formalizing the input into structured, reviewable specifications with human approval gates before any code is written.

Core Principles

  1. Specifications are the single source of truth — Requirements, design decisions, and architectural choices are documented before implementation begins.
  1. Human validates at every stage — AI proposes; human approves. Requirements, design, and implementation all have explicit human review gates.
  1. Project memory persists — Steering files capture architecture, conventions, and domain rules so the AI is aware of every previous decision in every future session.
  1. Implementation traces back to requirements — Every piece of code links to a specific requirement. Nothing is implemented without a requirement. No requirement is unimplemented.

cc-sdd: The Open-Source SDD Implementation

cc-sdd (from gotalab) is an open-source implementation of SDD that brings Kiro-style slash commands to the tools developers already use. It works with Claude Code, Cursor, GitHub Copilot, Codex, Gemini CLI, Windsurf, OpenCode, and Qwen Code.

Install in any project:

text
npx cc-sdd@latest

cc-sdd creates a .kiro/ directory in your project with three subdirectories:

  • .kiro/steering/ — project memory files (architecture, conventions, rules)
  • .kiro/specs/ — feature specifications (requirements, design, tasks)
  • .kiro/settings/ — templates and custom rules

The AI-DLC Methodology

The AI-Driven Development Lifecycle (AI-DLC) is the process framework that SDD operates within:

  • AI executes tasks at machine speed
  • Human validates at human judgment speed
  • Short cycles (hours to days, not weeks) replace long sprints
  • "Bolts" (intensive focused sessions) replace traditional sprints with administrative overhead
  • The spec is the sprint plan — no grooming ceremonies needed when requirements are already structured

Why This Matters

"Vibe coding" — the practice of describing features conversationally and accepting whatever the AI produces — works for demos and throwaway code. It fails for production software because:

  • There is no shared understanding of what was built
  • There is no way to verify correctness against requirements
  • There is no project memory across sessions
  • There is no traceability for debugging or change management

SDD is the antidote to vibe coding for production software.

Key Takeaways

  • SDD makes specifications the primary artifact — AI implements the spec, not an ad-hoc description
  • The three levels of SDD: spec-first, spec-anchored, spec-as-source
  • SDD solves context loss, inconsistency, drift, and untraceability in AI-assisted development
  • cc-sdd is the open-source implementation that brings SDD slash commands to existing AI coding tools
  • The AI-DLC replaces sprints with "Bolts" — intensive cycles of AI execution + human validation

Example

markdown
# Installing cc-sdd

# Default (Claude Code)
npx cc-sdd@latest

# For specific AI tools
npx cc-sdd@latest --cursor
npx cc-sdd@latest --copilot
npx cc-sdd@latest --codex
npx cc-sdd@latest --gemini
npx cc-sdd@latest --windsurf

# Creates this structure in your project:
.kiro/
├── steering/
│   ├── architecture.md
│   ├── tech-stack.md
│   └── naming-conventions.md
├── specs/
│   └── (feature specs go here)
└── settings/
    ├── templates/
    └── rules/
Try it yourself — MARKDOWN