Spec-Driven Development and the Vertical Agent Method

TL;DR: Microsoft published Spec-Driven Development (SDD): a spec-first approach to AI-native engineering. It argues that structured specs as shared ground truth between humans and AI beat speed without alignment. The Vertical Agent Method has been making the same bet since day one.

On June 10, 2026, Apoorv Gupta published “Spec-Driven Development: A Spec-First Approach to AI-Native Engineering” on the Microsoft DevBlogs. It’s the second entry in the Agent Experience (AX) series, and it formalizes something the Vertical Agent Method has been quietly betting on: structured specs as the contract layer between humans and AI agents.

Here’s why this matters and where these two frameworks converge.

Key takeaways:

• SDD and the Vertical Agent Method solve the same problem. Both frameworks identify the same failure mode. AI-generated code that compiles but doesn’t do what you asked. Both prescribe the same cure: structured specs as shared ground truth.
• Microsoft’s version is top-down (platform tooling). SDD ships as GitHub Spec Kit, integrating specs into Copilot and VS Code. It’s built for teams on Microsoft’s stack.
• The Vertical Agent Method is bottom-up (workflow-first). It starts with a single workflow, builds one agent, ships in 14 days. Specs emerge from the workflow, not the toolchain.
• Both reject vibe coding as a production strategy. Vibe coding works for prototypes. For systems that need to earn money or process data correctly, spec-driven beats prompt-driven.
• The convergence tells us where the industry is headed. When Microsoft and independent builders arrive at the same architectural conclusion independently, it’s a signal worth paying attention to.

What problem do SDD and VAM both identify?

Here’s the scene that plays out in every team that’s adopted AI coding tools:

The developer writes a prompt. The AI generates code that compiles and runs. The code solves the surface problem but misses the requirements. The developer writes another prompt. The AI generates code that fixes that issue but introduces two new ones. After ten rounds of prompt engineering, the code mostly works: but nobody is sure it handles the edge cases.

This is the core failure mode of prompt-driven development. The AI doesn’t know what “done” looks like because the spec exists only in the developer’s head, partially communicated through a series of conversational prompts.

SDD names this explicitly: “AI has made software delivery faster, but speed alone does not guarantee better outcomes.” The fix is to make the spec the authoritative artifact: not the prompt, not the conversation, not the code.

Where SDD and the Vertical Agent Method converge

The Vertical Agent Method is built on a single insight: scope kills agents. The way to ship working AI agents is to pick one workflow, build one agent, and ship in 14 days. Every stage of that process, from workflow definition to acceptance testing, depends on structured, machine-readable specs.

The convergence point is this: both frameworks treat the spec as a first-class artifact that both humans and AI agents operate from.

In the Vertical Agent Method, the spec takes the form of:

• Workflow definitions: structured descriptions of the process being automated, with clear start states, end states, and error paths
• Policy gates: explicit rules that constrain agent behavior, defined before the agent is built
• Tool schemas: typed interfaces between the agent and external systems, specified as YAML or JSON Schema
• Acceptance criteria: testable conditions that define success, not vague “it should work” expectations

These are the same structural elements SDD formalizes. The difference is that Microsoft ships them as platform tooling (GitHub Spec Kit, Copilot integration, VS Code planning) while the Vertical Agent Method ships them as patterns that work regardless of your toolchain.

This convergence is valuable precisely because it’s independent. Two groups approaching the problem from different starting points arrived at the same structural answer.

How does SDD work as platform and VAM as practice?

SDD is a framework backed by Microsoft’s platform investments. GitHub Spec Kit provides templates and workflows for defining specs. Copilot uses those specs to guide generation. VS Code surfaces spec validation in the editor.

The Vertical Agent Method is a practice that works with any stack. It defines the process, pick a workflow, build an agent, ship in 14 days, and adapts to whatever tools you use. The spec emerges from the workflow analysis, not the platform.

This is the key insight for solo developers and small teams: you can adopt the Vertical Agent Method today without any platform buy-in. The specs are YAML files in your repo. The validation is a CI check. The agent is whatever tool you already use. Claude Code, Cursor, Copilot, Codex.

Microsoft’s SDD validates the approach. The Vertical Agent Method makes it actionable at any scale.

What vibe coding misses

Vibe coding treats the AI as a creative collaborator. You describe what you want in loose terms, the AI generates a first pass, and you iterate. This works for:

• Prototypes and exploration
• Single-file scripts
• Personal projects where “good enough” is genuinely enough

It fails for:

• Production systems with real users
• Code that handles money, data, or access control
• Multi-file applications with complex state
• Anything that needs to be maintained by someone other than the original author

SDD and the Vertical Agent Method both recognize this boundary. The question isn’t “is vibe coding good or bad?” It’s “are you building something that needs to be right?”

What is the next step after SDD and VAM?

If you’re building production AI agents, here’s a practical starting point that works with either framework. The Vertical Agent Method framework defines the overall approach; SDD provides the spec layer that makes it work:

1. Define one workflow in structured form. Write a YAML spec with inputs, outputs, state transitions, error conditions, and acceptance criteria. Keep it under 100 lines.
2. Feed the spec to your agent. Not a prompt describing the spec: the spec itself. Claude Code and Copilot both handle structured specs well as system context.
3. Validate output against the spec. If the generated code doesn’t match the spec, it’s not done: even if it compiles.
4. Iterate on the spec, not the prompt. When something changes, update the spec first. The agent works from the spec, not a conversation history.

This is Spec-Driven Development in practice. It’s also the Vertical Agent Method in practice. Two names, same architecture, one clear direction for where AI engineering is headed.

FAQ

What is Spec-Driven Development (SDD)? Spec-Driven Development is a software engineering methodology from Microsoft that makes structured specifications the shared source of truth for both human developers and AI agents. It aims to solve the problem of AI-generated code that works syntactically but fails to meet requirements.

How does SDD relate to the Vertical Agent Method? The Vertical Agent Method, defined on Agentic Up, prescribes picking one workflow, building one agent, and shipping in 14 days : using structured specs at every stage. SDD formalizes the spec layer that the Vertical Agent Method relies on for agent guidance and human oversight.

Does SDD mean writing more documentation? Not in the traditional sense. SDD uses structured, machine-readable specs : think YAML schemas, interface contracts, and test cases : not prose-heavy design documents. The spec serves as both the AI agent’s task definition and the human’s verification checklist.

Is SDD the opposite of vibe coding? Yes. Where vibe coding treats the AI as a creative partner that generates from loose prompts, SDD treats it as an executor that works from precise, verified specifications. Both have their place, but SDD is essential for production systems where correctness matters.

Related Posts

• The Vertical Agent Method framework
• How to build your first AI agent in 2026
• AI agent state machine: structured specs for agent behavior

Microsoft’s Spec-Driven Development documentation covers the framework for aligning human and AI on shared specifications.

Microsoft’s SDD documentation covers the framework for aligning human and AI on shared specifications.

---

This article was published on Agentic Up (https://agenticup.dev): practical guides for developers and founders building with AI agents. Reach me at hello@agenticup.dev.