Software engineering has a habit of rediscovering old ideas.
The latest example is Spec-Driven Development.
If you’ve spent time experimenting with AI coding assistants, Cursor, Claude Code, BMAD, Spec Kit, or agentic development workflows, you’ll have noticed a growing trend:
The quality of the specification increasingly determines the quality of the software.
What feels like a new movement is actually rooted in ideas that have existed for decades.
As David Anderson noted:
“In old money we used to call this executable specification.”
The difference today is that AI has dramatically reduced the cost of turning specifications into working software.
That changes everything.
What Is Spec-Driven Development?
At its simplest, Spec-Driven Development means describing what you want before generating how it should be built.
Instead of jumping straight into code, teams focus on:
- user needs
- business outcomes
- constraints
- architecture
- quality requirements
- security requirements
- operational expectations
The specification becomes the foundation from which implementation is generated.
AI agents can then use those specifications to:
- generate code
- create tests
- build documentation
- propose architectures
- automate implementation tasks
The specification becomes the starting point for delivery rather than an afterthought.
Why Spec-Driven Development Is Working Now
The software industry has tried similar ideas before.
Model-driven development.
Executable specifications.
Code generation frameworks.
Many promised significant productivity improvements but struggled with adoption.
The difference today is AI.
Mark McCann highlighted one of the key shifts:
“You can pair up with an AI assistant and help clarify your thinking.”
Instead of spending days documenting requirements, AI can:
- ask clarifying questions
- identify missing information
- challenge assumptions
- suggest improvements
- structure requirements
This dramatically reduces the effort involved in producing useful specifications.
Better Specifications Start With Better Thinking
One of the most interesting observations from the discussion was that AI exposes weaknesses in organisational thinking.
Many teams discover they cannot write effective specifications because they have never clearly defined:
- their vision
- their North Star
- their KPIs
- their principles
- their architectural standards
- their operating model
As Mark explained:
“The more sorted your organisation is, the easier it will be to do spec-driven development.”
AI forces teams to clarify intent.
If your strategy is unclear, your specifications will be unclear.
And unclear specifications produce poor outcomes.
Small Batches Still Win
One of the strongest themes from the discussion was that AI does not remove the need for incremental delivery.
Many teams make the mistake of writing enormous specifications and expecting AI agents to build entire systems in one pass.
That rarely works.
As Michael O’Reilly observed, trying to do too much too quickly becomes overwhelming.
The lesson is familiar:
- small batches
- fast feedback
- iterative delivery
- continuous refinement
still outperform large-scale upfront design.
The specification evolves alongside the product.
Just as software evolves.
The Return of Engineering Fundamentals
Spec-Driven Development is also causing many established engineering practices to resurface.
During the discussion the team highlighted the renewed relevance of:
- Behaviour Driven Development (BDD)
- Test Driven Development (TDD)
- Domain Driven Design (DDD)
- Architecture Decision Records (ADRs)
- Incremental delivery
- Fast feedback loops
These approaches never disappeared.
AI simply makes them more valuable.
The better your engineering discipline, the better your AI-assisted outcomes become.
Who Owns the Specification?
One of the most debated topics was ownership.
Is the specification owned by:
- Product Management?
- Engineering?
- Architecture?
- QA?
- Everyone?
David Anderson offered a strong perspective:
“The spec is owned by the tech lead and the team.”
While product managers contribute requirements and business outcomes, engineering leaders remain accountable for ensuring specifications are:
- technically sound
- implementable
- aligned to standards
- operationally viable
The specification should be a collaborative artefact.
But someone must ultimately own its quality.
Context Is Becoming the New Source Code
A recurring theme throughout the conversation was the importance of context.
Modern AI development isn’t simply about writing requirements.
Teams increasingly need to provide:
- architecture standards
- security requirements
- testing strategies
- release processes
- operational constraints
- coding standards
The specification becomes far richer than a traditional requirements document.
In many cases, context becomes just as important as code.
This is why concepts such as:
- Context Engineering
- Context-Driven Development
- Harness Engineering
are emerging alongside Spec-Driven Development.
Verification Becomes More Important Than Generation
Generating software is becoming easier.
Verifying software remains difficult.
The conversation highlighted how organisations must invest heavily in:
- testing
- validation
- verification
- quality controls
Mark McCann summarised this well:
“You need to invest heavily in both the clarity of intent and the verification and validation of what comes out the other end.”
AI may accelerate delivery.
But confidence still comes from engineering discipline.
Four Models of Spec-Driven Development
The discussion also referenced work from Patrick Debois, outlining four emerging approaches:
Spec-First
Create a detailed specification before implementation begins.
Spec-Driven
Use collaborative workflows where AI continuously helps refine the specification.
Spec-Source
Treat the specification as the primary source of truth for the system.
Spec-Aligned
Continuously evolve specifications alongside implementation to keep both aligned.
Each approach has strengths and trade-offs.
Most organisations will likely adopt a hybrid model.
The Future of Software Engineering
Spec-Driven Development is not just about writing better documents.
It represents a broader shift in software engineering.
The bottleneck is moving away from implementation and towards:
- clarity
- intent
- context
- validation
- organisational knowledge
The teams that thrive in the AI era will not necessarily be those generating the most code.
They will be the teams that create the clearest specifications, provide the richest context, and build the strongest feedback loops.
Because increasingly:
The quality of the software depends on the quality of the thinking behind it.
Key Takeaways
- AI is making Spec-Driven Development practical at scale.
- Better specifications produce better software outcomes.
- Small batch sizes remain critical.
- BDD, TDD and DDD are becoming more relevant again.
- Context is becoming a first-class engineering artefact.
- Verification and validation matter more than code generation.
- The future of software engineering is increasingly specification-led.