Has anyone actually combined TDD + Specification-Driven Development (SDD) in a real project?
retained text
I've been digging into **Specification-Driven Development (SDD)** lately, especially the newer AI-assisted version of it, and I'm trying to figure out how much of this is actually useful engineering vs. new terminology/hype.
The idea I'm exploring is roughly:
**Spec → acceptance criteria → TDD → implementation → verification**
So SDD would operate at the feature/system level: define what the system should do, constraints, edge cases, etc.
Then TDD operates underneath that: take those requirements and drive the implementation with the usual **Red → Green → Refactor** loop.
On paper, this seems pretty reasonable. They're solving different problems:
* **SDD:** Are we building the right thing?
* **TDD:** Did we implement this behavior correctly?
* **BDD/acceptance tests:** Does the system behave as the user expects?
There are actually some older ideas around this. For example, there's a 2004 paper called *Agile Specification-Driven Development* that explicitly discusses combining tests with formal contracts. More recently, SDD has come back into the conversation because of AI coding agents and tools like Spec Kit, Kiro, etc.
But here's what I'm really interested in:
**Has anyone actually done this in production?**
Not just "I wrote a blog post about how it could work."
I'm looking for people who have actually tried something like:
Feature specification
↓
Acceptance / contract tests
↓
TDD implementation
↓
Integration / E2E verification
↓
Spec ↔ code ↔ tests kept in sync
A few questions I'd love to hear experiences about:
1. **Have you used SDD + TDD together on a real project?**
2. What did your actual workflow look like?
3. What did you use for the "spec"? Markdown? OpenAPI? Gherkin? Design-by-contract? Something else?
4. Did the spec actually remain useful after implementation started, or did it become documentation nobody looked at?
5. Did it reduce bugs/rework, or did it mostly create more artifacts to maintain?
6. If you used AI coding agents, did having a strong spec actually improve the generated code?
7. Where did the approach break down?
8. Would you recommend this approach to a team today?
And perhaps the bigger question:
**Is modern SDD genuinely a useful layer on top of TDD, or are we mostly putting a new name around requirements engineering + acceptance testing + TDD?**
I'm particularly interested in **negative experiences** too. If you tried it and thought "this is over-engineered nonsense," I'd genuinely like to hear why.
I'm trying to determine whether there's a practical engineering pattern here worth experimenting with, rather than just following the latest AI-development buzzword.
If you've actually built something this way, I'd love to hear what happened.document fetched 2026-10-07 00:39 · canonical https://reddit.com/r/ClaudeCode/comments/1wza2ur/has_anyone_actually_combined_tdd