Spec-Driven Development: The specification is back at the center of software

Sheila Cravero
9 minutes

When writing code stopped being the expensive part, the expensive part became knowing exactly what to build.

For twenty years, the software industry learned to distrust specifications. Agile was born, in large part, as a reaction against the four-hundred-page document that nobody read and that was obsolete before the first module reached production. The lesson made sense: if the cycle from idea to working software takes months, specifying everything up front is a blind bet.

AI agents changed that equation. Today, an agent can implement in an afternoon what used to take a full sprint. The cycle from idea to running software has shrunk from months to hours, and with it, something we had written off as utopian became possible again: taking the time to specify properly before building.

At the same time, agents made ambiguity expensive. A vague requirement used to cost a few days of back-and-forth. Now it costs a feature that works flawlessly and does the wrong thing, delivered at full speed. Agents amplify whatever we give them: give them ambiguity, and they hand it back at scale.

That dual pressure gave rise to what is now known as spec-driven development (SDD): writing a clear, reviewable, living specification before the agent writes any code, and treating it as the product's single source of truth.

At Darwoft, we are an AI-Native Software Engineering Company. We integrate artificial intelligence across the entire software development lifecycle, from product definition and architecture to implementation, testing, and evolution in production. All of our development is built on spec-driven development. This article shares what we have learned applying it, what it solves, what it doesn't, and how any team can get started.

What a spec is, and what it isn't

A spec is a short, precise description of what a feature must do, how we will know it works, and what constraints it must respect. It is written in plain language, with just enough structure for an agent to build from it without guessing.

It is not a PRD that gets signed off and filed away. It is not a two-line user story with a single acceptance criterion. And it is not a contract meant to freeze the project: specs change, and changing them is cheap. What should never change silently is the code.

In practice, a good spec answers six questions:

01-six-parts-of-a-spec.png

The last two rows are the ones most teams skip, and the ones that matter most when an agent is doing the building. An agent will happily build something correct that is too slow, too expensive to run, or broader than what was asked for. The spec is where we tell it no.

Three levels of commitment to the spec

The term is still taking shape, and not everyone who claims to practice SDD does the same thing. Birgitta Böckeler of Thoughtworks proposed a distinction that has become common vocabulary (martinfowler.com):

02-levels-of-commitment.png

We work spec-anchored. The spec lives in the repository, right next to the code, and every change in behavior starts with a change to the spec. It strikes the balance between the discipline an agent requires and the flexibility a real product demands.

The cycle

The spec is not a phase that ends. It is the start of a short cycle that every feature goes through, many times over. Here is how we apply it within the 8-week MVP structure we use across our projects.

04-sdd-cycle-diagram.png

When verification uncovers a gap, the spec is corrected first and the cycle runs again; the code never drifts from what was approved.

The key is the speed of the cycle. When an agent closes the loop in hours, a wrong assumption costs an afternoon, not a sprint. That is what makes rigorous specification viable: you don't have to get everything right up front, you have to be able to correct quickly and keep the correction on record.

Verification is more than passing tests. It includes code review, vulnerability scanning, and a check against the spec's non-functional constraints. A green build that ignores cost, scale, and security is only half green.

What changes for each role

SDD is not a tool you install. It is a shift in where each person spends their time. Effort moves upstream: fewer hours testing finished features only to discover they weren't what was wanted, more hours agreeing on what "done right" looks like before building.

03-what-changes-per-role.png

The deepest shift is in engineering. A great engineer's value no longer lies in typing fast, but in asking the questions the spec didn't: what happens with a three-hundred-page document, what does this cost at a million calls, what data is the agent seeing. Specification frees up time to think; it doesn't replace thinking.

For those who hire software development, the change is just as tangible. Their involvement becomes earlier and lighter, demos stop bringing surprises, and the product is documented in a way any future team can understand without reverse-engineering the code.

What spec-driven development doesn't solve

The method is sometimes sold as more than it is, and honesty matters here. A spec cannot enumerate every variable in a real-world system. Pretending otherwise is unrealistic, and it is the surest way to run into surprises in production.

In our article on the cheap code era, we walked through three cases where the spec was met, the tests passed, and acceptance was signed off, yet the system still hid a cost: twelve decimal places nobody needed in a coordinate, an algorithm benchmarked on a ten-page document instead of a three-hundred-page one, the same page sent to a model twenty-five times. Each was a line missing from the spec.

The spec is where you start, not where you finish. Three habits close the gap:

1. A representative sample inside the spec. Agree on the data profile the system will see in production and test against it, not against the small example that turns the local environment green.

2. Non-functional budgets in writing. Response time, cost per transaction, storage per document. If the number is in the spec, a test can fail because of it.

3. An audit after the green. Even implementations that succeed on the first try get reviewed for cost, scale, and security. Not out of distrust in the agent, but because that is where the costs that haven't shown symptoms yet are hiding.

How to get started tomorrow

You don't need to reorganize your company to adopt SDD. It's enough to pick a real, mid-sized feature and run it through the full cycle.

1. Pick a feature with a known risk. Something the team already knows tends to go wrong: integrations, business rules with exceptions, sensitive data.

2. Write the spec with all six parts, even if some of them are a single line. If "Out of scope" or "Non-functional constraints" end up empty, that is your first finding.

3. Have the business owner approve it, not just engineering. If nobody can approve it, the problem was never technical.

4. Generate tests from the acceptance scenarios before or alongside the code, never after.

5. Store the spec in the repository, versioned, next to the code it describes. A spec in a shared folder goes stale within weeks.

6. Measure it against reality. When the agent is done, compare the result against a representative production sample and note which line the spec was missing. That list is your improvement plan for the next cycle.

There are tools that help structure the process, such as GitHub's Spec Kit, which organizes the work into specifying, planning, breaking down into tasks, and implementing with different coding agents. But the tool matters least: the real shift is making the spec the place where decisions get made.

Why we build this way

At Darwoft, we have been building software since 2010 and have launched more than 45 MVPs. Our methods have changed many times along the way. What hasn't changed is the lesson every project leaves behind: the most expensive bug is the one implemented flawlessly from a misunderstanding.

Agents have made that lesson urgent. With a clear, living spec, we now take products to production in just 8 weeks, on time, on budget, and with quality, with every decision written down where anyone can find it. And in regulated industries, under our ISO 9001, ISO 27001, and ISO 42001 certifications, the spec is not extra paperwork: it is the first link in the chain of evidence that connects a requirement to the code, the tests, and the approval behind it.

Our evolution into an AI-native software engineering company is not simply about adding agents to write code faster. It is about rethinking how we design, build, validate, and operate software.

Today, generating code is increasingly accessible. The real differentiator is the ability to build solutions that work under real-world conditions, scale with the business, uphold high standards of security and quality, and remain cost-efficient to operate.

The speed agents deliver is real. But it only holds when someone has drawn the line they need to follow. That line is the spec.

The best solutions don't start with code. They start with a meaningful conversation.

Share it

Related Blogs

If you found this Blog insightful, you might also be interested in these related articles exploring similar topics in tech, design, and digital strategy.

Let’s Talk.

We’re excited to hear about new projects! Please fill out the details below and we’ll get back to you within one business day.

I agree to the Privacy Policy and Cookie Policy