--- title: "SDD Is Eating Software Engineering: The Methodology That Went From Blog Post to Industry Movement" date: 2026-04-07 tags: ["Spec-Driven Development","Agentic Workflows","AWS Kiro","Frameworks","Industry"] categories: ["Spec-Driven Development","Industry"] summary: "Spec-Driven Development has crossed from niche methodology to recognized category — with 30+ competing frameworks, a conference track at Agentic Conf Hamburg, AWS Kiro as the first commercial SDD IDE, and enterprise backing from McKinsey and Anthropic's own trend reports. Here's what's happening and what it means." --- Sometime in early 2026, Spec-Driven Development stopped being a thing that a certain kind of developer did and became a thing that the industry named, argued about, and built products around. That transition matters. When a methodology acquires competing frameworks, a conference track, a McKinsey citation, and a dedicated commercial IDE, it has crossed from pattern to paradigm. This is that moment for SDD. And if you've been doing this already — writing specs instead of code, letting Claude or another agent handle implementation — you're not ahead of the curve anymore. The curve just arrived. ## What Happened This Week The convergence of signals was striking even by 2026's standards. Vishal Mysore published a Medium piece mapping 30+ SDD and agentic-coding frameworks — SpecKit, OpenSpec, GSD, Devika, Tessl, and many more. The headline: "SDD is eating software engineering." It's a Marc Andreessen riff, which means it's aspirational, but the underlying map is real. These are not vaporware: several have production users, GitHub stars in the tens of thousands, and teams building on top of them. Agentic Conf Hamburg 2026 accepted a session titled "Beyond the Vibes: Lessons from Using Spec-Driven Development Frameworks for Agentic Coding" — a talk that explicitly addresses the transition from informal vibe coding to structured SDD discipline. When a methodology gets a conference slot with the word "lessons" in the title, it means practitioners have accumulated enough production experience to have learned things worth sharing. Rick's Cafe AI published a piece titled "The 2nd Phase of Agentic Development," framing the current moment as the end of the experiment and the beginning of the infrastructure. The first phase was about proving AI could write code. The second phase is about making that reliable, repeatable, and governable — which is exactly where SDD lives. And Anthropic's own 2026 Agentic Coding Trends Report frames the shift from AI-as-assistant to AI-as-engineer as the central trend of the year, with SDD as the methodology that makes that shift tractable. ## AWS Kiro: The First Commercial SDD IDE The most concrete signal is hardware — or rather, software with a price tag. AWS Kiro launched as the first commercial IDE built explicitly around the SDD model, with Agent Hooks and MCP integration as first-class citizens rather than afterthoughts. The core Kiro workflow should feel familiar if you've been doing SDD with Claude Code: you write a spec, the agent reads it, implements it, runs tests, and iterates. What Kiro adds is a structured spec format (`.spec.md` files with explicit sections for requirements, acceptance criteria, and implementation notes), an Agent Hooks system that fires on spec changes (rerun tests, regenerate types, update documentation), and deep AWS integration so that Kiro agents can provision infrastructure as part of implementation, not as a separate step. The Agent Hooks piece deserves attention. One persistent challenge with SDD is keeping the agent in sync with the spec as requirements evolve. If you update the spec, does the agent automatically re-run the affected tests? Does it regenerate the API contracts? Kiro automates these triggers, reducing the cognitive overhead of maintaining spec-to-implementation coherence over time. The MCP integration is less novel — Claude Code, Cursor, Windsurf, and VS Code all support MCP at this point — but Kiro's implementation is tighter than most. Tool calls are scoped to the current spec, so an agent working on a database schema spec doesn't accidentally invoke file-system tools outside the schema directory. This kind of per-spec sandboxing is good security hygiene, and it's worth noting that it's architecturally similar to what Claude Code's permission system enables manually. AWS backing Kiro is significant for enterprise adoption. The McKinsey/QuantumBlack agentic workflows piece from February 2026 — which is now heavily cited across the industry — concluded that the biggest barrier to agentic adoption in enterprises isn't AI capability, it's governance. "How do we audit what the agent did?" is the question that stops enterprise SDD deployments. A Kiro spec is, by design, an audit trail: requirements, acceptance criteria, and the gap between what was specified and what was implemented are all explicit and version-controlled. ## 30+ Frameworks: What They Get Right and Wrong Mysore's framework map is a Cambrian explosion, and like most Cambrian explosions, a lot of these creatures won't survive. A few observations: **The spec format wars have started.** Every framework has its own opinion about what a spec should look like. SpecKit uses a structured YAML front matter with a natural language body. OpenSpec goes full JSON Schema. GSD (Goal-Spec-Done) keeps it intentionally informal. Tessl invented its own DSL. None of them are wrong exactly, but the fragmentation means that skills and tooling built for one spec format don't transfer cleanly to another. This is where Claude Code's format-agnostic approach has an advantage. Claude Code doesn't enforce a spec format — it reads whatever you write and infers structure from context. That's less elegant than a rigid schema, but it's more durable. Developers who have been writing `SPEC.md` files in their own ad-hoc style for the past year don't need to migrate anything. **The best frameworks separate concerns cleanly.** The frameworks that seem most durable are the ones that treat the spec as the source of truth for *what* the system should do, and leave *how* entirely to the agent. The worst frameworks bleed implementation details into the spec — database column names, specific library choices, performance targets tied to current hardware. Over-specified specs age badly and fight the agent instead of guiding it. **None of them has solved multi-agent spec coordination.** The hard problem in SDD isn't single-agent workflows — it's keeping multiple agents in sync when they're working from the same spec simultaneously. If two agents are implementing different sections of a spec and both touch the same interface, who wins? Most frameworks either ignore this problem or handle it with brute-force locking that serializes work anyway. Claude Code's mailbox architecture (covered here in March) is probably the most production-ready solution to this, but it requires explicit design, not something frameworks handle automatically yet. ## The Enterprise Imprimatur The McKinsey/QuantumBlack paper matters because McKinsey papers are how methodologies get approved in enterprises. If your CTO read "agentic workflows reduce time-to-delivery by 40% in the teams we studied" in a McKinsey PDF, the conversation about whether to invest in SDD tooling just got much easier. The data in that paper is real: TELUS, Zapier, and organizations in the McKinsey/QuantumBlack portfolio all show meaningful productivity gains from structured agentic workflows. The caveat — which McKinsey buries but is important — is that the gains come from *structured* agentic workflows. Teams that handed agents unstructured tasks and hoped for the best saw minimal gains. Teams that wrote specs, defined acceptance criteria, and built feedback loops between spec and implementation saw the 40% numbers. That's the SDD thesis in a single data point. ## What This Means for Practitioners If you've been doing SDD informally with Claude Code — writing SPEC.md files, using CLAUDE.md to enforce conventions, running agents against well-defined tasks — you're in a stronger position than you might realize. The methodology is being validated externally, which means the organizational politics of advocating for it are getting easier. A few things to watch: **The spec file as source of truth is becoming conventional wisdom.** Which means you'll start seeing spec-aware tooling in places that aren't SDD-specific. Expect CI/CD pipelines that validate implementation against spec, code review tools that surface spec-to-code divergence, and monitoring systems that alert when runtime behavior drifts from specified behavior. **Framework convergence is coming.** The current fragmentation in SDD frameworks mirrors the early JavaScript framework wars — too many options, incompatible formats, duplicated effort. Consolidation will happen, probably around the formats that major tool vendors (AWS, Anthropic, Microsoft) choose to support natively. **The role of the spec writer is becoming a real job title.** Anthropic's trends report notes that a new role is emerging: developers who spend most of their time writing and refining specs rather than writing code. This is the SDD practitioner's endgame. The spec is the leverage point; everything else is execution. The methodology that Marc Andreessen would say is eating software engineering didn't start as a methodology. It started as a practice: write down what you want, let the AI build it, review the result. That practice is now a movement. The question isn't whether SDD will shape how software is built — it already is. The question is which tools, formats, and frameworks survive the consolidation. --- *Sources: [Vishal Mysore — Medium](https://medium.com/@visrow/spec-driven-development-is-eating-software-engineering-a-map-of-30-agentic-coding-frameworks-6ac0b5e2b484), [Agentic Conf Hamburg 2026](https://agentic.hamburg/conf-2026/sessions/beyond-the-vibes/), [Rick's Cafe AI](https://cafeai.home.blog/2026/04/06/the-2nd-phase-of-agentic-development/), [Anthropic 2026 Agentic Coding Trends Report](https://resources.anthropic.com/hubfs/2026%20Agentic%20Coding%20Trends%20Report.pdf), [JetBrains Blog](https://blog.jetbrains.com/blog/2026/03/24/introducing-jetbrains-central-an-open-system-for-agentic-software-development/), [The New Stack](https://thenewstack.io/5-key-trends-shaping-agentic-development-in-2026/).*