On Building with AI

Spec-Driven Development: An Evolution, Not a Ladder to Climb

A maturity model for AI-driven development – five working levels, plus a sixth on the horizon – and why reaching the top was never the point.

June 2026 · 9 min read

A few months ago, "are you using AI?" was a reasonable question to ask a development team. It isn't anymore. Everyone is using AI. The developer pasting ChatGPT output into a file and the team running a five-agent delivery pipeline with quality gates at every handoff would both answer yes. The gap between what those two teams actually produce – in reliability, in traceability, in how well the work survives someone leaving – is enormous, and the question doesn't capture any of it.

The better question is: how are you using it, and is that the right way for what you're building?

That question pulled together a maturity model for AI-driven development: five working levels, plus a sixth on the horizon, built around the rise of spec-driven development (SDD) – the practice of treating a written spec, not a prompt or a chat transcript, as the source of truth the AI builds against. What follows is the story of how that practice evolves, and more importantly, why the destination isn't the point.


SDD MATURITY MODEL 1 Vibe Coding prompt → paste no shared context 2 Context Eng. shared AI context CLAUDE.md etc. 3 Spec-Driven spec as source of truth 4 Governed phase gates constitution 5 Orchestrated multi-agent delivery 6 Autonomous self-healing coming soon
Each level is a valid way of working – not a rung to climb through on the way to five.

Level 1

It starts with prompting, and that's not an insult

Every team starts at what the model calls exploratory AI development, known more honestly as vibe coding. You have an idea, you describe it, you judge the output, you re-prompt if it's wrong, you paste it in. There's no persistent memory between sessions, no spec, no review step. The AI doesn't know what it doesn't know, and neither does the next session.

This stage gets a bad reputation it doesn't fully deserve. For throwaway scripts, for exploring an unfamiliar API, for a solo developer figuring out whether an idea is even worth pursuing – vibe coding is fast, cheap, and exactly proportionate to the stakes. The failure mode only shows up when the stakes rise and the process doesn't rise with them: rework piles up, nobody remembers why a decision was made, and the codebase becomes a black box even to the person who "wrote" it.


Level 2

The shift nobody expects: from prompting to context engineering

The first real maturity shift has nothing to do with specs yet. It's the moment a developer gets tired of re-explaining their project to the AI every single session and writes it down once: a CLAUDE.md, an AGENTS.md, a .cursorrules file. Conventions, architecture notes, things the AI got wrong before and shouldn't repeat.

This is AI operational literacy, and the mental shift underneath it is the most important one in the whole model. You stop being a prompt writer and become a context architect. You're not crafting better requests anymore; you're engineering the environment the AI operates in. That distinction compounds. A good context file gets better every time something goes wrong, because that's exactly when you update it.

It's also where teams quietly stall. A context file that lives on one developer's laptop and never gets shared isn't a team capability – it's a personal trick. The work of this level is making the context collective, not clever.


Level 3

Specs as memory, not paperwork

Once context is shared, a new question shows up naturally: how do we agree on what we're building before anyone builds it? That's spec-driven AI development, and it's where SDD properly begins. Instead of a prompt or a chat thread, a written spec becomes the thing both the human and the AI are accountable to. The AI implements against it. When the work is done, the spec doesn't get thrown away. It gets archived and becomes part of the institutional memory of the project.

OpenSpec is the clearest expression of this idea in practice: propose a lightweight change, apply it, archive it. No heavy ceremony, no rigid gates. Just a habit of writing down intent before writing code, and keeping the record. It's deliberately suited to existing codebases and small teams who want enough structure to stop drift without taking on process they don't need yet.

The details of that workflow – the wireframes, the diagrams, the visual walk-through – are worth seeing rather than reading about secondhand. They're in the OpenSpec workflow walkthrough, and the full level-by-level breakdown is in the maturity workflows explorer.


Level 4

When trust isn't enough, you add governance

Specs solve the "what are we building" problem. They don't, by themselves, stop an AI from drifting during implementation – building something subtly different from what the spec said. That gap is what governed AI engineering closes. The workflow gets phase gates: a spec must be approved before a plan is generated, a plan before tasks are created, tasks before implementation starts. Tests get written first. A constitution document codifies the team's non-negotiables: what data the AI can touch, what standards apply, what's simply off-limits.

SpecKit is the reference tool for this level, and it comes with a useful, slightly counterintuitive metric: a healthy team rejects something at the gate 10 to 30 percent of the time. A 0 percent reject rate doesn't mean the team is excellent. It means the gates have become theater, rubber-stamped rather than reviewed.

Compliance isn't optional here

Anything touching protected health information, federal reporting, or public health guidance has a real floor to clear, and it sits at this level, not lower. The full governance and risk picture – mapped against HIPAA, NIST AI RMF, Section 508, FedRAMP, CDC standards, and HL7/FHIR – is in the governance and compliance reference. The SpecKit workflow is diagrammed in the SpecKit workflow walkthrough.


Level 5

Directing a team instead of a tool

The furthest level currently in production use reframes the relationship entirely. Instead of one AI working against one spec, AI-orchestrated delivery runs a small team of specialized agents: an analyst produces a brief, a PM turns it into a PRD, an architect writes the design, a developer implements story by story, a QA agent independently verifies each one. Each agent's output is the next agent's input, gated by a quality check at every handoff. The human's job shifts to setting direction, reviewing at the gates, and handling the exceptions nobody anticipated.

BMAD is the tool most associated with this approach, and it is genuinely powerful for team-scale, auditable delivery. It is also genuinely expensive – token costs run five to ten times higher than a single-agent workflow, the setup takes real time, and because each agent's output feeds the next, one bad artifact early in the chain poisons everything downstream. For a solo developer, this is almost always more process than the work justifies. For a team where predictability and auditability are the actual requirement, it's the strongest option available.

The full multi-agent workflow is in the BMAD workflow diagram, and a side-by-side of how OpenSpec, SpecKit, and BMAD actually compare – not as a ranking, but as three different answers to three different problems – is in the tools comparison.


The part that actually matters

This is not a ladder

It would be easy to read all of this as a ladder, with Level 5 at the top and everything below it a stop on the way up. That's not the story, and treating it that way is the most common mistake teams make with this model.

Each level is a legitimate, complete way of working – for the right job. Vibe coding is correct for a weekend prototype. A solo developer maintaining a stable codebase may get everything they need from a good context file and never touch a formal spec. A small team shipping fast on an existing product is often better served by OpenSpec's light touch than by importing SpecKit's gates, which would slow them down for risk they don't actually carry. The point isn't to reach Level 5. The point is to recognize what your work actually demands, and to match your process to that – deliberately, not by accident or by whichever tool happened to get installed.

The actual failure mode isn't being "stuck" at Level 2. It's misdiagnosing yourself.

Declaring you're at Level 4 because you installed a governance tool, while the gates quietly rubber-stamp everything and the constitution nobody reads sits in a folder – that's the failure. Tooling adoption is not maturity. Maturity is whether your process would survive someone leaving the team tomorrow.

There's a five-question self-assessment built for exactly this. No AI tools required, just an honest look at how your team actually works today. It's worth doing before deciding where to invest next: take the self-assessment.


The transitions

What it costs to move, and why moving fast isn't free

The instinct, once a team sees this model, is to want to jump straight to whichever level sounds most rigorous. Resist that. Every transition has a real cost and a real risk of skipping a step that turns out to matter.

The jump from ad-hoc prompting to a shared context file is cheap and fast – weeks, not months – but skip it and your specs at the next level will be vague, because the team never built the habit of being precise about context in the first place. The jump into governed engineering is the one program managers should slow down the most: teams reach for SpecKit's gates before they've actually learned to write a good spec, and a gate reviewing a bad spec is just a slower way to ship the same problem. And the jump into multi-agent orchestration is the most dangerous skip of all, because errors compound silently across an artifact chain instead of failing loudly in one place.

None of this is guesswork. The relative cost, the rework burden by level, and a practical playbook for each transition – trigger signals, how long it actually takes, how to know you're ready – are in the cost curve by level and the change management playbook.


What's coming

The sixth level

There's a sixth level on the horizon that isn't fully here yet: AI systems that detect a problem, plan a response from a pre-approved playbook, execute it, and hand the human a resolution report instead of an alert. Continuous compliance checking instead of periodic audits. Self-healing infrastructure. None of this is speculative science fiction – the early shapes of it are already visible in automated dependency updates and accessibility auto-fixes running today.

Teams building solid Level 4 and Level 5 discipline now are laying the foundation for this without necessarily aiming at it. And the one hard line that doesn't move regardless of how capable these systems get: any autonomous action touching protected health information needs a pre-approved, audited playbook. That's not a maturity question. It's a line. The full picture of where this is heading, and on what timeline, is at the Level 6 preview.


The takeaway

Where to start

If you take one thing from this, take the reframe: the goal was never to get everyone to Level 5. The goal is for every team to know, honestly, where they stand, and to choose the next step deliberately – because it solves a problem they actually have, not because a tool's marketing page made it sound mature.

Start with the self-assessment. Pick the one transition that addresses your real bottleneck, not the most impressive-sounding one. And if your work touches patient data, federal reporting, or public health guidance, treat governed engineering as the floor, not an aspiration.

The full interactive model

Every level, every tool, every diagram referenced above lives in the SDD Maturity Model interactive explorer. The story is here. The nitty-gritty is there.