DOP 357: What Is Spec-Driven Development?

Episode 357

Show Notes

#357: Type a prompt, get code, fix the hallucinations, type another prompt. That is vibe coding, and it is a fine place to start. It is a terrible place to stay. So what comes next - and is spec-driven development actually it, or just waterfall wearing a new hat?

Here is the reframe that runs the whole conversation: everybody already works from a spec. Even the person who swears they are winging it has a spec in their head - which language, where it runs, what it does. The real question was never specs or no specs. It is whether you write them like waterfall, one giant document before anyone touches code, or like agile, just enough to start and the rest discovered as you go.

A design is only validated when you implement it - everything before that is an educated guess. So instead of spending a month on one detailed design, build five throwaway MVPs in a day. Fully operational. Frontend, backend, running in a cluster, connected to a database. Show them to customers. Pick the one that works. Then have the agent write the spec from the winning code, and throw the code away. The spec is the output, not the input. A PowerPoint took you a month and told the customer nothing. A working thing they can touch tells you everything.

Viktor and Darin push on where this breaks. Over-specifying gives you a false sense of security - you are lying to yourself that you know everything up front, and you do not. Legacy systems? The code is the only complete spec - any document written thirty years ago is fiction. Performance? Measure it in production and be lightning-fast to react. Greenfield, CRUD, clear API contracts - those genuinely want a spec first.

The part nobody on the org chart wants to hear: this does not delete the business analyst or the developer. It collapses the roles. The code monkey who pulls a Jira ticket, does the work, pushes it - that job is turning into tech lead, architect, product manager, all at once. Plan mode writes the spec with you, not for you. You write it to a file because you cannot review what you cannot see. And you review the tests harder than the code, because the tests are the spec made executable. Specs were always supposed to be living documents. Now there is finally no excuse.

Frequently Asked Questions

What is spec-driven development and how does it differ from vibe coding?

Viktor Farcic’s framing on DevOps Paradox episode 357 is that anyone working with AI already has a spec, because the alternative is asking for a random thing and seeing whether you like it. What actually varies is how detailed that spec is, and whether you write it all up front or discover it as you go. He argues the real question is waterfall versus agile applied to specifications.

Should you write a detailed spec before you start building?

Viktor Farcic pushes back on that on DevOps Paradox episode 357, because a design is only validated once it has been implemented. His alternative is building five throwaway MVPs, showing them to customers, picking one, and then asking Claude to generate the spec and diagrams from the winner. Teams take weeks or months to build a single MVP, he notes, and he can now build five in a day.

How much time should you spend planning before writing code?

Viktor Farcic puts the trade-off directly on DevOps Paradox episode 357: spend a week planning and finish a milestone in half a day, or spend an hour planning and finish in a day, leaving room to redo that milestone five times inside the same window. He picks redoing it five times. Over-specifying, he tells Darin Pope, mostly means lying to yourself about how much you knew up front.

Does spec-driven development work on legacy systems?

Viktor Farcic’s answer on DevOps Paradox episode 357 is that a legacy system already has a complete specification, and it is the code itself, along with the observability and networking around it. Anything written thirty years ago is neither valid nor complete by now. Darin Pope’s worry runs the other way: pointing agents at a legacy codebase runs straight into a context window nowhere near large enough to hold it.

Do you still need a spec framework now that Claude Code has plan mode?

Darin Pope raises this on DevOps Paradox episode 357, noting that the creator of Agent OS was able to strip away most of what that framework did once plan mode became good enough. Viktor Farcic’s caveat is that plan mode operates at the level of one task inside one context. You still need higher-level milestones above it, and you have to write the outcome to a file before closing a session.

Should you review the code or the tests your AI agent writes?

Viktor Farcic says on DevOps Paradox episode 357 that he now spends more time reviewing tests than code. His reasoning is that a test states the behaviour he expects, so reading the tests closely is a way of reviewing the implementation indirectly. He is careful to add that tests never capture everything, but past a certain level they tell you the code is doing what it was asked to do.

What is the DevOps Paradox podcast?

DevOps Paradox is a weekly podcast co-hosted by Darin Pope and Viktor Farcic, covering DevOps, platform engineering, and modern software delivery. Episode 357 works through spec-driven development, why building five throwaway MVPs can beat writing one detailed design, and how much planning is worth doing before an agent starts writing code. Every episode page carries audio, video, and a full transcript.

Share and Download

Hosts

Viktor Farcic

Viktor Farcic

Viktor Farcic is a member of the Google Developer Experts and Docker Captains groups, and published author.

His big passions are DevOps, Containers, Kubernetes, Microservices, Continuous Integration, Delivery and Deployment (CI/CD) and Test-Driven Development (TDD).

He often speaks at community gatherings and conferences.

He has published DevOps Paradox and Test-Driven Java Development.

His random thoughts and tutorials can be found in his blog The DevOps Toolkit.