Spec-Driven Development: The Approaches Behind AI Software Factories (2026)
AI & Automation

Spec-Driven Development: The Approaches Behind AI Software Factories (2026)

Share

TL;DR: Spec-driven development means agreeing a written specification before an AI agent writes any code, then building and reviewing against that document. It is the part of an "AI software factory" that decides whether the output is any good. As of November 2026 there are five main approaches: spec-first toolkits (GitHub Spec Kit, Kiro, OpenSpec), fresh-context review (the Elephant-Goldfish Model), agent teams with roles (BMAD Method), plan-then-execute with context engineering (Claude Code's plan mode and CLAUDE.md), and test-first, where failing tests are the spec. Vibe coding is fine for prototypes; production work needs a reviewed spec, a check the agent can run and a human sign-off.

Spec-driven development has become a crowded tool category in little more than a year. GitHub, AWS and many open-source projects ship their own version, and "AI software factory" has become the phrase for chaining these steps together. This guide is organised by approach rather than by tool, because the tools change every few weeks and the approaches don't. Tool details are correct as of 17 November 2026.

Vibe coding vs spec-driven development: where vibe coding breaks down

Andrej Karpathy coined "vibe coding" in February 2025 for a style where you "forget that the code even exists", and he called it "not too bad for throwaway weekend projects". That still holds. For a prototype, an internal script or a clickable demo, talking to an agent until something works is a sensible use of an afternoon.

Real projects differ in four ways:

  • The requirements live in chat history. The next session, the next developer and the client can't see them.
  • The agent fills gaps with plausible guesses. The BMAD Method README puts it well: coding assistants "often turn unstated assumptions into code".
  • Nobody can review intent. A reviewer sees a diff, not what the diff was supposed to achieve.
  • The agent marks its own homework. Anthropic's Claude Code guide notes that the agent "stops when the work looks done", which is not the same as done.

None of this is new. It is the expectation gap from our requirement elicitation masterclass. Agents just let a team fall into it faster.

What is spec-driven development?

Spec-driven development (SDD) is a way of working with AI coding agents where a written specification, agreed before implementation starts, is the source of truth. The agent builds against it, reviewers check the work against it, and when code and spec disagree, a person decides which one changes.

Birgitta Böckeler of Thoughtworks describes three levels:

  1. Spec-first: a spec is written for the task at hand, then usually set aside once the code exists.
  2. Spec-anchored: the spec is kept and updated as the feature evolves.
  3. Spec-as-source: humans edit only the spec and the code is regenerated from it.

When she wrote in October 2025, almost every tool was spec-first. Several now aim for spec-anchored, with living specs and drift checks, while spec-as-source has proved hardest to deliver. The underlying idea is old: test-driven development, behaviour-driven development and a good product requirements document all put the "what" before the "how". What has changed is the reader. A spec now has to work for an agent that wasn't in any of your meetings.

Where the AI software factory fits

"AI software factory" is used loosely, mostly in vendor marketing. Most definitions converge on an operating model where agents handle discrete steps of delivery (triage, coding, review, testing) while people define intent and verify results. A buyer's guide from Unblocked says the bottleneck "moves upstream to specification and verification", and BCG Platinion calls the change a "relocation of human effort" rather than its removal. Tessl, the spec-as-source tool Böckeler tested, has since repositioned itself under the line "Build your software factory, one skill at a time".

Whatever you call the pipeline, the spec is its intake. A factory fed a vague prompt produces vague software, faster.

Five approaches to spec-driven development (as of November 2026)

1. Spec-first: requirements, design and tasks before code

How it works. You describe the feature in plain language. The agent turns it into requirements, then a technical plan, then a task list, and you review each before the next is generated. Only then does the agent implement the tasks.

Tools.

  • GitHub Spec Kit is an MIT-licensed toolkit from GitHub (about 150,000 stars). Its core flow is a one-off project "constitution" of principles, then specify, plan, tasks, implement and converge for each feature, where converge checks the code against the spec and adds missed work back to the task list. It integrates with more than 40 coding agents, including Claude Code, GitHub Copilot, Codex CLI, Gemini CLI and Cursor.
  • Kiro is an agentic engineering system, with an IDE, a CLI and a web app, that its site says is "built and run by AWS". Its specs move through requirements (user stories with acceptance criteria), design and tasks, saved as requirements.md, design.md and tasks.md. It also offers bug-fix specs and a "Quick Spec" that generates all three files without approval gates.
  • OpenSpec, from Fission-AI (MIT, about 75,000 stars, version 2.0 released on 11 November 2026), keeps each change in its own folder with a proposal, specs, a design and tasks, then archives it into the living specs once built. It positions itself as lighter than Spec Kit and built for existing codebases as well as new ones.

When it fits. Medium or large features, especially when a client needs to sign off scope before money is spent.

Weak spots. Ceremony. In Böckeler's test, Kiro turned a small bug into four user stories with 16 acceptance criteria, and she found Spec Kit's many Markdown files tedious to review. Agents also don't always follow the spec they were given, so you still need review and tests.

2. Fresh-context review: the Elephant-Goldfish Model

How it works. The Elephant-Goldfish Model (EGM) splits the work between agents with very different memories. The "elephant" is a long session that holds the project's context and drafts the spec with you. The "goldfish" reviewers are fresh agents that see only the document and the code it references, none of the conversation. If the spec only makes sense to someone who was in the chat, a goldfish trips over it, and the unstated assumption surfaces. You decide which findings matter and approve the design before an agent implements it.

Diagram of the Elephant-Goldfish review loop: an elephant agent with full project context drafts a spec, three goldfish reviewer agents read only the spec and the referenced code, their findings go to a human who resolves trade-offs and approves or sends the spec back for revision, and only then does an agent implement the code

Tools. EGM is an Apache 2.0 plugin open-sourced on Google's GitHub in September 2026, with about 20,000 stars. Its README states that it is not an officially supported Google product. It grew out of Dave Rensin's April 2026 essay, which argues that the design document should become the main artefact humans own: "Documents that pass the Goldfish test become important protections against slop." The plugin runs in Claude Code, Codex CLI, the ChatGPT and Codex desktop apps, Antigravity and Claude Cowork. Its skills cover brainstorming, drafting section by section, a five-stage review (simplicity, comprehension, design critique, a second simplicity pass and implementation readiness) and resolving findings. Two are useful on their own: bootstrap writes README files bottom-up for an existing codebase, and drift report compares design documents with the current code, ideally weekly.

When it fits. Expensive design decisions, specs that people outside the conversation must rely on, and existing codebases whose documentation has rotted.

Weak spots. It needs an agent that can spawn fresh subagents, and reviews cost tokens and time and produce a lot of feedback by design, which you have to triage. Its rule that design phases don't touch production code is a convention that, as the architecture notes admit, nothing enforces.

3. Agent teams with roles: BMAD Method

How it works. Instead of one general agent, you work with named personas that mirror a delivery team. In the BMAD Method these are an analyst, a product manager, a product owner, a UX designer, an architect and a developer, each with its own artefacts, from a brief and PRD to epics, stories and an architecture document. A "party mode" lets several personas discuss a draft. Work is sized to the change, so a trivial edit skips planning while a project-sized effort gets the full path.

Tools. BMAD Method is free and MIT-licensed (about 55,000 stars). Version 6.12 is the stable line and version 7 is in preview alpha as of November 2026, so expect changes.

When it fits. New products with no brief or PRD yet, and solo founders who want to be pushed through product questions before code. It is the same instinct behind the AI agents we gave roles in our own studio.

Weak spots. Roles are prompts, not separate expertise. Anthropic's Claude Code guide points out that a subagent is by default the same model on the same task, giving you "a fresh pair of eyes" but "not a smarter answer". The documents still need a person who knows the business to read them critically.

4. Plan-then-execute and context engineering

How it works. This is the lightest approach, and many developers already use it without naming it. The agent explores the codebase and writes a plan, you correct the plan, and only then does it edit files. Around that loop sits context engineering, which Anthropic defines as curating "the optimal set of tokens" the model sees: project memory files, focused sessions and notes the agent can reload later.

Tools. In Claude Code, plan mode lets the agent read files and run commands but blocks edits until you approve the plan. Anthropic's best practices suggest letting the agent interview you until it could write a spec, saving it to a file and building from it in a fresh session. The guide also says to keep CLAUDE.md short, holding only what the agent can't work out from the code, and to move rules with zero exceptions into hooks and permission rules. For review, its /code-review command checks the diff in a fresh subagent that never saw your conversation, which is the goldfish idea built into the tool.

When it fits. Day-to-day features and fixes on a familiar codebase, by developers who review the result.

Weak spots. It depends on discipline. The plan usually lives in the session, so unless you save it, it is spec-first at best and gone next week.

5. Test-first: failing tests as the spec

How it works. You write, or have the agent write, tests that describe the behaviour you want. You confirm they fail, then the agent writes only enough code to make them pass. A test suite is a spec that a machine can check, which closes the "looks done" gap.

Tools. No special tooling. Kent Beck's essay Augmented Coding: Beyond the Vibes describes building a B+ tree library with an agent that followed strict red-green-refactor rules, one test at a time, while he watched for loops, unrequested features and disabled or deleted tests. Anthropic's guide makes the same point for unattended runs: give the agent "a failing test it has to turn green".

When it fits. Business rules, calculations, libraries, data transformations and bug fixes, where right and wrong are easy to state.

Weak spots. Tests capture behaviour, not intent or architecture, and user experience is hard to express as a test. An agent can also weaken or disable a test instead of fixing the code, which is exactly what Beck watched for, so tests need human review too. Our post on non-functional testing covers what functional tests miss.

Which spec-driven development approach fits your project?

Matrix comparing six ways of working with AI coding agents across six situations: vibe coding, spec-first, fresh-context review, agent teams with roles, plan-then-execute and test-first, rated as good fit, workable or poor fit for prototypes, production products, solo developers, teams, existing codebases and regulated work

These approaches combine rather than compete. You might write a spec-first document, give it a fresh-context review, implement it in plan mode and use tests as the definition of done. Our rough guide:

  • Prototype or demo: vibe coding or plain plan mode. If the idea survives, write the spec before rebuilding it, as in our MVP guide.
  • Product heading to production: a spec-first document per feature, reviewed by a person, with tests as acceptance criteria.
  • Solo developer: plan-then-execute plus tests. Add a spec-first tool only once features span several sessions.
  • Team: spec-first or fresh-context review, with specs in the repository so humans and agents read the same document.
  • Existing codebase: document what is there first (EGM's bootstrap, BMAD's existing-codebase path, OpenSpec's change folders), then run drift checks. Our legacy modernisation post explains why that discovery step matters.
  • Regulated or high-risk work: spec-first with approval gates, fresh-context review and named human sign-off at each stage. Spec Kit presets can, for example, require regulatory traceability in plans.

How we work at Netling

Our team uses Claude Code. On client projects, a written spec is drafted and approved by a person before AI writes any code. You can see where that sits in our development process and our Build service.

Some work is never left to AI alone:

  • Security-sensitive code, including authentication, payments and permissions.
  • Merging, which always waits for human code review.
  • Database migrations and anything that touches production data.
  • Architecture decisions: the stack, the data model and where service boundaries sit.

We also provide dedicated developers who join your team: React and Next.js developers, NestJS developers or Nuxt developers.

Frequently asked questions

Is spec-driven development the opposite of vibe coding?

Not quite. Vibe coding skips the written spec and judges results by whether they seem to work, while spec-driven development agrees the spec first and checks the code against it. You can vibe code a prototype, then switch once the idea is worth building properly.

What is an AI software factory?

An informal term for a delivery pipeline where AI agents handle steps such as coding, review and testing, while people define what to build and verify the result. Spec-driven development is its intake: without a clear spec, the factory builds the wrong thing faster.

Do I need a tool like Spec Kit or Kiro?

No. A Markdown spec in your repository, a coding agent in plan mode and a set of failing tests cover the core idea. Dedicated tools add structure and repeatability, which helps most for teams and larger features.

What is the Elephant-Goldfish Model?

An open-source plugin, published on Google's GitHub but not an officially supported Google product, in which a context-rich "elephant" agent drafts a spec and fresh "goldfish" agents review it without seeing the conversation. A human approves the spec before any code is written.

Is spec-driven development just waterfall again?

It can be, if you specify a whole product up front. Used well, it works per feature: a short spec, a review, an implementation and a spec update, repeated every few days inside normal agile delivery.

Final thoughts

Spec-driven development is less about any tool than about where the thinking happens. Agents can now write code faster than people can read it, so the human work moves to deciding what to build, writing it down clearly and checking the result. Pick the lightest approach that gives you a reviewed spec, a check the agent can run and a person who signs off, and add structure as the project and team grow.

If you are planning a product and want a team that writes the spec before the code, send us a project brief or get in touch.

Share this article

Found it useful? Help others discover it.

Start Your Project

Ship your next product with confidence

Trusted by 500+ clients worldwide. From MVP to enterprise scale — we've delivered 3,000+ production products across 20+ industries.

18+

Years of
Experience

3,000+

Projects
Delivered

20+

Countries
Served

4.9/5

Avg. Client
Rating

Start Your Project Today

Free consultation • No commitment required

Engineering Quality

Clean architecture. Maintainable code. Thoughtful execution.

NDA & Data Security

Full confidentiality from first conversation.

Responsive Collaboration

Clear updates and direct access to the team.

Predictable Timelines

Milestone-driven delivery with realistic planning.

Flexible Engagement

Project-based, dedicated teams, or long-term support.

Long-Term Partnership

Support beyond launch as your product evolves.