Welcome to the Age Of Spec-Driven Development

Vibe coding is dead. Long live agentic coding. If you’re a lead developer still stuck in the “prompt, code, pray, repeat” pipeline, it’s time to move past the Lovable / Replit honeymoon phase. Prompting your way to a deliverable is just a fancy way of generating technical debt at scale. To actually ship, you need Spec-Driven Development (SDD).

I’ve always been a rapid prototyping fan. Usually, the bottleneck is upstream: business teams don’t get why we need “requirements.” Vibe coding let everyone build a prototype, but now we’re drowning in massive, unmaintainable prompt libraries.

Entering the VIBE

With coding agents however, we aren’t just prompting; we’re architecting.

However, much like the kid’s frustration getting their dad to follow instructions, building out agents requires you to be just as specific in what you’re asking for.

https://www.youtube.com/watch?v=FN2RM-CHkuI

The SDD Agent Workflow

1. Establish the Ground Truth: Create your AGENTS.md and ROADMAP.md. This is your system’s “brain.” Define your DB schema, data dictionary, and high-level project goals before the first line of code is even a thought. Also it’s good to pick a programming language and LLM that has a half-way decent training set.

2. The Requirement Breakdown: Don’t just say “build a login.” Create a 1.0_ITEM_REQUIREMENT.md. Use an agent to grill you for details until the requirement is airtight.

3. The Design Specification: Turn that requirement into 1.0.1_ITEM_DESIGN.md. Describe every input, output, and test condition. If the agent doesn’t know how to fail, it won’t know how to succeed.

4. The Coding Plan: Force the agent to write a step-by-step execution plan. It must include test case generation and a mandate to update the documentation as it goes. If it doesn’t plan to document, it’s not allowed to code. This also becomes your TODO guide for the module, keeping track of status, and ability to restart when you need to kill the agent and start the last step over again.

5. Execution & Review: Set the agents loose, but keep your hand on the tether.

6. After finishing your coffee, your jog around the office, you come back, and check the results to ensure they’re making sense.

The Secret Sauce of Vibing with SDD

Now, here’s the part that’s going to separate out successful spec driven development.

Not picking the most advanced LLM model; it’s Context Engineering.

Too much documentation or a bloated codebase makes agents “circle the drain”—spending half their context window compacting memory and the other half hallucinating. Keep your agents micro-focused. If a task isn’t modular, it’s a failure of your design, not the AI.

One way to solve the “too many files” and content in too many documents problem, spin up an MCP server (like ContextStream) to handle indexing and scanning. But even then, you have to watch the memory. Knowing when to kill a “looping” agent flock and spawn a fresh one is the new “turning it off and on again.”

One of the nice things about Anthropic and their Claude Code is you can view extended thinking and interrupt it as it’s going along if it’s starting to go sideways and pinging some random NSA server over in the middle of the Pacific.

Are developers dead?

Will this replace us? Not any time soon.

Crafting legitimate technical specs and triaging the inevitable agentic “toddler logic” still requires an engineer. We haven’t reached the 1-dev-to-1,000-agent ratio. One dev can manage a single stream of agents effectively, but there’s still a non-trivial amount of babysitting involved.

And now that you’re managing a dozen spoiled agents, don’t even think about trying to task switch. Getting your train of thought interrupted when you’re juggling 10 flaming hockey sticks, can set the whole office on fire now.

Not to mention there’s a good amount of technical expertise needed in order to tell good code from bad, architecture that works, vs architecture that’ll wake you up at 2AM because of a missing semicolon.

With SDD we’ve seen increases in developer productivity of almost 30%. Is it perfect? Nope. Can it handle those huge multi-Tennant Haskell legacy systems? Also nope. But it does really good with greenfield, and hyper specific brownfield work.

We’ve basically come full circle: we’ve traded waiting for the compiler to finish for waiting for agents to return the next batch of results.

#SoftwareEngineering #AIAgents #SpecDrivenDevelopment #SoftwareDevelopment #TechLeadership