Spec-Driven Development (SDD)
AI is only as good as the structure you give it. AI-SDD turns vague prompts into precise specs — and precise specs into working software.
The evolution of software development methodologies
"Software was expensive, slow, and limited by human capacity."
Methodologies emerged from the need to manage human capacity and complexity across coordinated teams.
Optimized for predictability and complete documentation
Optimized for iterative adaptation and continuous delivery
Specification as the shared source of truth
AI changed the bottleneck of development
Humans were the bottleneck. Every line of code cost time and money. Methodologies were born to manage that cost, minimize rework, and coordinate teams.
Execution speed is no longer the primary constraint. The new bottleneck is clarity of intent — the quality of the specification that guides the AI.
"Just Prompting" Doesn't Scale.
Code That Solves the Wrong Problem
Without structured requirements, AI generates what it thinks you want — not what you actually need. The output looks right until it hits production.
No Trace of Intent
Raw AI output has no audit trail. Six months later, no one knows why a decision was made — only that the code exists. Reviews become guesswork.
Rework Cycles That Cancel the Gains
AI acceleration without direction just gets you lost faster. Teams spend the time AI saved on fixing misaligned implementations.
The cost of fixing grows exponentially
"30 minutes of spec review = 30 days of rework avoided."
Defects caught in the requirements phase cost on average 100x less than the same defects found in production. A clear specification is the best investment a team can make.
Source: IBM System Science Institute
Spec-Driven Development: the specification as the source of truth
In SDD, the human expresses intent — the AI generates the specification. Everything else derives from it: code, tests, and documentation. The spec is the single contract between humans and AI — clear, versioned, and auditable.
Keep the specification as the single source of truth, from which code, tests, and documentation are derived — never the other way around.
Is SDD the True Parent of TDD, BDD, and DDD?
TDD, BDD, and DDD assume the specification already exists. SDD is the upstream layer that none of them have. — ai-sdd.com
Three roles, one contract
The Director
Expresses intent and business context at a high level. The AI structures the rest — the human reviews and approves each phase before proceeding.
The Contract
Formal specification in versioned text. EARS-format requirements, architecture design, and atomized tasks — with zero ambiguity.
The Executor
Transforms human intent into structured specification. Generates code, tests, and documentation aligned with the contract — without ambiguity.
"The AI generates the contract and executes it. The human defines the intent."
EARS (Easy Approach to Requirements Syntax): eliminating the ambiguity that costs dearly
"The system should send a notification when the user does something important."
5 developers = 5 different implementations
- "something important" — what exactly?
- What type of notification? Email? Push? SMS?
- Who receives it? When does it expire?
WHEN a purchase order is confirmed by the payment system AND the total amount exceeds $500.00 THEN the system SHALL send a confirmation email to the registered user WITHIN 60 seconds of payment confirmation. WHERE the user has disabled email notifications, the system SHALL send a push notification in the mobile app.
- Precise, measurable trigger
- Mandatory behavior (SHALL)
- Alternative cases covered
Steering: automatic governance for the whole team
product.md Product vision, personas, business goals, and constraints. The AI never loses strategic context.
tech.md Tech stack, code patterns, naming conventions, and security rules.
structure.md Folder organization, modules, responsibility boundaries, and architectural patterns.
Every conversation with the AI starts from scratch. Inconsistencies between features, diverging patterns, constant rework.
The AI loads project context in every session. Consistent decisions, fewer reviews, coherent code.
Steering transforms the AI from a generic assistant into a specialist member of your team, with deep knowledge of the product, stack, and project conventions.
From Steering to Shipped
Six phases, each with a human checkpoint before AI proceeds.
Steering
Establish project-wide context: product vision, tech stack, code structure. AI agents read these on every task — before generating anything.
Spec Init
Describe the feature in natural language. AI generates a structured spec shell — you refine it into the starting point for requirements.
Requirements
AI expands the description into formal EARS requirements. Human reviews and approves before moving on — this is the most critical gate.
Design
AI generates a technical design aligned to requirements. Architect validates architectural decisions. No code until design is approved.
Tasks
Design is broken into atomic, testable implementation tasks — each traceable to a specific requirement. The implementation roadmap.
Implementation
AI implements task-by-task. Developer reviews each. Validation runs against original requirements — not just "does it pass tests."
Describes the intent at a high level — the problem to solve and the business context.
Generates structured requirements in EARS format — precise, unambiguous, verifiable.
Reviews and approves requirements — or requests adjustments before proceeding.
Proposes architecture design — components, integrations, and documented technical decisions.
Reviews and approves the design — ensuring alignment with constraints and product vision.
Atomizes implementation tasks — each traceable to a requirement, with defined acceptance criteria.
Reviews and approves the backlog — validates scope, priority, and granularity before execution.
Executes spec tasks, generating tests automatically with TDD — code that adheres to the approved design and requirements.
Reviews the implementation and approves the merge — final validation before delivery.
Performs merge and deployment — original intent delivered to production, traceable end to end.
"Software fails because humans and AI misunderstand each other.
— Central Thesis of Spec-Driven Development
AI executes contracts — it doesn't guess intentions."
SDD is not about giving the AI more autonomy. It is about creating the precise contract that allows the AI to use its full execution capacity in service of human intent.
