r/SpecDrivenDevelopment • • Aug 21 '26 Bravo

We tried spec-driven development for months. We couldn't prove it improved the code.

60 Upvotes

When our team adopted OpenSpec, the argument seemed obvious: agree on the requirements, review the plan, then let the agent implement it. That should produce better code than throwing a prompt at a coding agent and hoping for the best.

After a few months of using the full propose → review → apply → archive workflow, we are no longer sure it does.

Our work is mostly data engineering and legacy-to-Python migration. We use both frontier and open models through Claude Code, Codex CLI, OpenCode, and similar tools. This is not a vendor comparison. The question is whether the method itself changes the result.

For tasks that fit into one context window and have clear acceptance criteria, we see little reliable difference between a reviewed spec and a well-scoped first prompt. The spec-driven runs typically consume two to three times as many tokens and take about twice as long. The resulting code is not consistently better. Sometimes it is worse: more files, more indirection, and abstractions that the task never needed.

The little evidence we have points the same way

The best comparison I have found is an OpenSpec bake-off from June 2026. The same PRD was implemented once with OpenSpec and once with Claude Code alone. OpenSpec made the design process more pleasant and surfaced three additional gaps. It also produced 50% more code with 50% higher cyclomatic complexity, took twice as long, and cost three times as much.

That is one experiment, not a benchmark. But it matches our experience.

Marmelab made a similar criticism in “Spec-Driven Development: The Waterfall Strikes Back”: a trivial “show the current date” feature produced eight files and roughly 1,300 lines of specification text. The problem is not writing things down. It is paying a large coordination cost for changes that did not need coordination.

Maybe the model changes the value of the spec

My current hypothesis is that explicit specs may help weaker planning models more than frontier models.

A strong model already reconstructs a plan during a normal coding run. A formal SDD workflow externalizes that plan, makes it reviewable, and preserves it across sessions—but may add little new information. A smaller local model with weaker multi-step reasoning or a shorter effective context may benefit much more from a pre-digested task list.

There is an uncomfortable counter-hypothesis: the weaker model may also write the weaker spec. If the same model turns a vague request into a flawed specification and then faithfully implements it, SDD has not removed the error. It has formalized it.

This should be testable: same repository, task, acceptance suite, and model; spec-first versus direct implementation; then compare correctness, regressions, review time, token cost, wall-clock time, changed lines, and complexity. I have found plenty of testimonials, but very little controlled data—especially for Qwen, GLM, DeepSeek, Kimi, or Mistral.

The real value may not be code quality

OpenSpec did give us something useful: a reviewable record of intent. It forced design questions into the open and left an artifact for teammates, clients, audits, and future maintainers.

That suggests a different decision rule. Do not ask whether a spec will make the agent write better code. Ask whether this change needs a reviewed and durable agreement before code exists.

My tentative threshold is:

  • Direct prompt for a bounded change with one owner, objective tests, and no architectural decision.

  • Lightweight goal, constraints, non-goals, and acceptance checklist for a multi-file change within one subsystem.

  • Versioned specification for work crossing services or team boundaries, changing public contracts, migrating important data, or spanning several agents and sessions.

Project-level context matters too. If AGENTS.md, CLAUDE.md, architecture notes, skills, and commands already encode the conventions and constraints, a change spec must add a real decision—not merely repeat the repository context in another format.

The failure mode I worry about most

An LLM writes a SHALL requirement. The same or another LLM implements it. The requirement now appears justified because it exists in the spec, and the code appears justified because it satisfies the requirement. Nothing in that loop proves the feature is needed or integrated.

The safeguard may be simple: every normative requirement must trace to a stakeholder need, an existing contract, or an executable acceptance test. The implementation should be free to reject or revise a proposed design when repository evidence contradicts it.

That leads to the variant I want to try next: use the spec as an acceptance artifact, not an implementation recipe. Review the goal, constraints, non-goals, and examples up front. Let the agent choose the implementation. Then verify the result against the spec and tests, ideally in a separate review pass.

I would be interested in three kinds of counter-evidence:

  1. Controlled comparisons of the same task and model with and without SDD.

  2. Evidence that smaller or local models benefit more—or less—than frontier models.

  3. Concrete thresholds teams use to decide when a full spec earns its cost.

Maybe we are using SDD on the wrong class of tasks. Or maybe its strongest benefit was never better code. Maybe it is better alignment, traceability, and review—and we should evaluate it on those terms.


r/SpecDrivenDevelopment • • Aug 20 '26

The SDD Rabbit Hole

Post image
53 Upvotes

My view of the SDD rabbit hole so far :)

Eventually, it seems like nobody is really satisfied with using someone else's tool for making their specs, and this sub has dozens of projects from people showing off their own unique SDD tools and workflows. I sorta think this is natural--spec design is kinda the new craft of software engineering, and I think we're all going to come up with our own style of doing things.

But, I was really inspired seeing all of the unique stuff everyone was building in this sub. I really like this community, so I figured I would try to make something that helps you guys out.

Rudder (https://github.com/RudderCode/Rudder) is a skill that shows you how comprehensive your specs are by comparing it to the code your agent generates. Rudder generates unit tests based on your spec and reports back coverage. If you ask it to hit a coverage percentage, Rudder will iteratively ask you questions, refine your spec, and run a red-green TDD workflow until your spec sufficiently covers your code. Since everyone has their own workflows for creating specs, I thought I'd make a tool that can sit alongside your tools and help out on the side.

Curious about how you guys are dealing with the problem of trying to make your specs comprehensive enough to stop the AI from making mistakes? Also, curious about where on the iceberg you guys are :)


r/SpecDrivenDevelopment • • Mar 27 '26

Why Software Engineering Will Never Die Revisited In The Age Of Spec Driven Development

Thumbnail i-programmer.info
47 Upvotes

The rise of Spec Driven Development begs for a reassessment of the original thesis; are the principles of "why software engineering will never die" still valid or have they been overridden by spec-driven development and thus completely automated, just like coding is?


r/SpecDrivenDevelopment • • Apr 06 '26

Spec-driven development made my AI workflows actually usable

35 Upvotes

I used to treat specs as something optional like nice to have documentation. But once I started working more with AI-assisted coding, that approach completely broke down.

The moment I switched to spec-driven development, everything changed.

Instead of vague prompts and inconsistent outputs, I now define:

  • clear requirements

  • expected behavior

  • edge cases upfront

Then I let AI work within that structure.

The biggest difference?
Less back-and-forth, fewer hallucinations, and way more predictable results.

It also made debugging easier if something’s wrong, it’s either:

  1. the spec

  2. or the implementation

No more guessing.

Lately I’ve been pairing this approach with tools that help enforce and track specs across workflows , and it feels like the missing layer between prompting and actual engineering.

Curious how others here are using specs with AI are you writing full formal specs, or keeping them lightweight?


r/SpecDrivenDevelopment • • Aug 05 '26

Test-Driven Development vs Spec-Driven Development

32 Upvotes

For a little background, I’m an engineer who went from a FAANG corporate environment to a startup and consequently started heavily abusing coding agents. Like a lot of others here, I started to realize that the code I was creating just simply was not “up to spec”—the LLM is designed to one-shot, even if that means guessing what you want for 90% of the implementation.

My solution was to make a tool for myself that writes unit tests based on my prompts and then runs a test-driven development flow. This way, when I hit coverage I know that X% of the code my AI generated comes directly from decisions I made in chat with my coding agent. (If you’re curious, I’m linking it here, but this isn’t intended to be a promotional post: https://github.com/RudderCode/Rudder )

Lately I’ve been curious about SDD since it seems adjacent to that, but I’m new to it so I have my qualms with having to change my coding flow. Writing specs has always been out there as an option, but for me it just felt like it slows down development a lot to work on making a spec, and then I lack the guarantee that there isn’t any guesswork by the LLM if the spec I write isn’t thorough enough. Do you guys feel the same or am I missing something with SDD?


r/SpecDrivenDevelopment • • May 11 '26

Spec-Driven Development with OpenSpec and OpenCode

Thumbnail
youtu.be
32 Upvotes

My OpenCode + OpenSpec setup for Spec-Driven Development with skills for git commit discipline, interviewing during proposal creation using grill-me, C4 Diagrams during design, Architectural Decision Records for durable technical choices and Custom OpenSpec Schema to bring this all together. Thanks.


r/SpecDrivenDevelopment • • Aug 31 '26

My book “Spec-Driven Development: Engineering with Intent” is now live on Manning MEAP

Thumbnail hubs.la
31 Upvotes

Many of you who are regulars here probably know me from the discussions we have had around Spec-Driven Development and also a maintainer (technical direction advisor) of OpenSpec. I am excited to share something I have been working on for a while.

My book, “Spec-Driven Development: Engineering with Intent,” is now live on u/ManningBooks MEAP.

https://hubs.la/Q04vMvjf0

The first three chapters are live, and get 50% off from Sept 14 to Sept 28 with my discount code MLKrishnan, valid for all formats..

The book covers how we can close the gap between our ideas and AI agent-generated implementations by articulating our intent clearly, using approaches including Spec-Driven Development, Ralph Loops, and more. While seeing a coding agent generate a prototype from a single-line prompt may be impressive, getting a coding agent to deliver production-ready software is a completely different ball game. In the book, we look at what it takes to engineer context effectively for coding agents so that they are not constantly bottlenecked on us, yet deliver software that is aligned with what we want. Software engineering is ultimately about how we collaborate as a team, and this book looks at coding agents as members of the team at our table rather than just tools on the desk.

One of the advantages of MEAP is that you get to read the book as I write it. Since many of you here are actively exploring and practicing SDD, I would really value your thoughts and feedback. It can help shape the book as it evolves.


r/SpecDrivenDevelopment • • 22d ago

We’ve come full circle

30 Upvotes

I’ve been working in aerospace as a systems and software engineer for nearly two decades. Requirements are the bedrock of everything in the aerospace industry. I’ve seen so many people dismiss requirements as holding them back, slowing them down, waste of time, yet they are always the thing at delivery that is the core of the conversation. They are always at the core of the conversation when we get something wrong. They are what we complain about when writing tests.

Thus, the irony and delight to find spec driven development beginning to gain significant traction in the agent assisted coding workflow. Once again, requirements are at the center of things.

I’ve been working on my own side project using spec driven development, I have about 60% coverage from my specs to my codebase (I currently have around 450 requirements). I decompose them in a very similar way we do in aerospace. And I have to say… it is crazy effective. I look forward to what the community comes up with.


r/SpecDrivenDevelopment • • Apr 30 '26

Spec-Driven Development across multiple teams and repos. How do you ship vertical slices?

30 Upvotes

I'm a tech lead planning to roll out coding agents (Claude Code, Codex, Copilot CLI) with Spec-Driven Development as the methodology around them. The challenge is that almost every SDD example I've found with spec-kit, Kiro and the usual blog posts assumes a single team working in a single repo. My reality is quite different:

  • A platform built from many components like UI, HTTP services, event-driven consumers, warehouse and cache, all of them spread across multiple repos.

  • Ownership split across several teams. My team owns some backend components but not all.

  • Most interesting features are vertical slices: they touch the UI, a couple of services we own, an event consumed by another team, and sometimes a data contract owned by data platform.

The naive SDD flow assumes the agent can see the whole slice and one team can ship it. Neither is true here. What I'm trying to figure out is how SDD actually works when a single feature is spread across repos and teams that can't be coordinated by an agent alone.

If you've done this for real, I'd love to hear how you handle:

  1. Where the spec lives. One spec for the whole slice, or one per component with a coordinating doc on top? Who owns it, who signs off on it?

  2. Cross-repo context. How does the agent reason about a slice when half the relevant code lives in a repo it can't see, owned by a team it can't talk to?

  3. Coordinating contract changes. When the slice requires a new event or API owned by another team, how does that negotiation flow? Does it block the work, run in parallel, get stubbed?

  4. Sequencing. Who builds first, who deploys first, how do you avoid "we shipped, they aren't ready"?

  5. What didn't work. Approaches you tried and abandoned, frameworks that demoed well and fell over, anti-patterns worth warning me away from.

Not looking for theory; looking for real examples and experiences


r/SpecDrivenDevelopment • • May 20 '26

I built the same app with GitHub Spec Kit and then OpenSpec: Tutorial & Comparison

28 Upvotes

Been using spec-driven development for a few months and kept seeing Spec Kit vs. OpenSpec comparisons that felt like they were written by people who hadn't actually used both. So I just built the same app twice.

Same stack (Next.js, Drizzle, PostgreSQL), same feature set, different SDD framework each time. Tracked token costs, session times, where I got stuck, where the AI went sideways.

A few things surprised me, particularly around token economics and how differently each tool handles context.

Curious if others have done similar experiments or landed somewhere different. I've compiled 2 tutorials + my findings and opiniated conclusions in a blog post and a few associated repos - will post them in a comment below.

What's your take on Spec Kit vs. OpenSpec?


r/SpecDrivenDevelopment • • May 16 '26

I stopped organizing AI agents like an Agile team and built a Mafia instead

28 Upvotes

Gangsta Agents (GitHub), a skills framework for spec-driven AI development. I wanted to share it here because the community actually cares about the problem it solves.


Why a Mafia family, not an Agile team

A lot of SDD frameworks organize agents to mimic Agile teams — standups, sprints, backlogs, story points. I think that's the wrong metaphor. Agile was designed around human coordination costs. AI agents don't need standups. They need hierarchy, discipline, and enforced pipelines.

Gangsta Agents is inspired by the structure of a Mafia family. There's a Don (you) at the top who approves every phase gate. An Underboss decomposes work. Crew Leads orchestrate. Workers execute in parallel. No one freelances outside their role. No one skips a step.

A well-run Mob moves faster than a committee — and so do agents when you stop pretending they need Agile rituals.


The core idea

Every feature goes through a 6-phase pipeline called The Heist:

  1. Reconnaissance — gather intel before any design decisions

  2. The Grilling — adversarial debate (more on this below)

  3. The Sit-Down — produce a signed Contract spec; no code without one

  4. Resource Development — execution planning

  5. Execution (The Hit) — code runs against the spec, never the other way around

  6. The Delivery — wrap up and update institutional memory

Each phase is gated. The Don (you) approves before anything moves forward.


What makes it different — The Grilling

Most spec-driven frameworks get you to write a spec before coding. Gangsta Agents adds a step most frameworks skip: adversarial validation before the spec is finalized.

The Grilling runs two agents in structured debate — a Proposer argues for the best approach from the Dossier, a Devil's Advocate attacks every assumption, identifies edge cases, and proposes alternatives. Multiple rounds run until positions stabilize, then the Grilling Conclusions are documented and approved before you ever write a Contract.

The result: weak assumptions get caught through debate, not production failures. I've found this is where single-perspective design silently goes wrong — no one challenges the obvious approach until it's too late.


What makes it different — The Ledger

AI sessions are stateless. Every session starts from zero unless you do something about it. Most frameworks don't.

The Ledger is persistent institutional memory stored in docs/gangsta/ in your project. It tracks:

  • Insights — successful patterns worth reusing

  • Fails — documented mistakes and why they happened

  • Constitution — project-specific rules that accumulate over time

The Ledger is updated at the end of every Heist. Any new session can read it and pick up where the last one left off — the agent knows the codebase's quirks, the gotchas, and the agreed-upon rules without you re-explaining them.

Without this, every session re-discovers the same things. Insights don't compound. Fails repeat.


Who it supports

Native integrations for Claude Code, GitHub Copilot, Gemini CLI, OpenCode, and Codex. Cursor supported via npx skills add. Skills are pure markdown files — no vendor lock-in, any agent can read them.


Happy to answer questions about the design decisions. The spec-is-law principle (Omerta rule #5: code contradicts spec → revise the spec first, never the reverse) was the hardest constraint to enforce in practice, and The Grilling emerged directly from watching LLMs confidently pick the wrong approach with no one to push back.

🔗 https://gangsta.page 🐙 https://github.com/kucherenko/gangsta


r/SpecDrivenDevelopment • • Oct 05 '26

Free eBook Spec-Driven AI Development

Thumbnail
blog.manning.com
27 Upvotes

I am glad to share that an excerpt from my book, Spec-Driven Development: Engineering with Intent, is featured in u/ManningBooks’s new free ebook, Spec-Driven AI Development.

And it is completely free. If you are exploring Spec-Driven Development or looking to adopt AI-native software engineering, this is a great place to start.

A bit of a back-to-back post from me today. However, I wanted to share it anyway, as it may be most relevant to this community. Thanks again for all the support so far.


r/SpecDrivenDevelopment • • Sep 09 '26

OpenSpec workflow right in your VS Code

Post image
27 Upvotes

Hi! My name is Alex, I've been developing DevTools for more then 8 years.

I want to show you my product, that I use everyday – SpecBuddy. It's an extension for VS Code (also for JetBrains IDEs actually), that makes working with OpenSpec workflow much easier and pleasure.

SpecBuddy shifts working with agents from plain chat (but it also chat-capable) to specs-centric manner. You can launch new propose from plain Markdown document:

After the propose is generated you can review it, leave comments right in the specification files and than send the back to the agent. You can see the whole history of spec changes. Actually, you can leave comments everywhere in any project files.

After you think your Change Spec is ready, you can start subtasks execution, using special Cockpit panel.

You can run step-by-step, or you can run a bunch of them, or all steps together. After each you can make a code review and send feedback to the agent. After that it could fix the code, or maybe fix the whole specification and make complete code regeneration. The choise is up to you.

The most important, that you can see the changes those were generated by the agent at the exact step.

SpecBuddy is a process superviser, your are an actor. At any moment you can ask it make a commit, Sync or/and Archive.

In the next release it will capable to work with several specifications at the same time via worktrees (it is already done for IntelliJ). SpecBuddy will also help you merge the branches and fix conflicts.

What agents it supports? Actually, most of them. Claude, Codex, OpenCode, Cursor and any agent that supports ACP ( agentclientprotocol.com ).

I started to use SSD at the very beginning of my development with coding agents. I believe coding must be pleasent and SpecBuddy gives me that.

I will be happy if you try and give me back a feedback. You can find more details on specbuddy.dev .

How I build it?

From the very begining I used SDD. Firstly it was my own simplified workflow (SpecBuddy also supports it) – spec -> plan -> implementation. All specs and plans had been archiving after implementation, no durable main specs. As I am a fun of IntelliJ IDEA, plugin for it was the first. And at the very begining I used SpecBuddy to develop SpecBuddy. This gives my unique opportunity of aggresive dogfooding:) At some moment I migrated to OpenSpec and main specs started to emerge. When IntelliJ plugin has seemed ready to me, I took its main specs and asked Claude Code to make VS Code Extension by them. Of course, I had to dive deep into a code, though building VS Code Extension was much much faster.

Thank you for reading!


r/SpecDrivenDevelopment • • Sep 10 '26

Spec Driven is Great With Agents

25 Upvotes

This is how our team works for months. Spec Driven solves building structural memory problem. Makes project management easier. I think this way just fits new paradigm perfectly. It really makes us super efficient. And this is how it looks :


r/SpecDrivenDevelopment • • Mar 29 '26

Github Spec Kit vs Claude Superpowers?

24 Upvotes

What is your take on which of these is the best for complex projects?
I've been using Spec Kit + Beads + Ralph Loop + Agent Teams and it has been working great and I just recently started playing with Claude Super Powers.


r/SpecDrivenDevelopment • • 26d ago Hooray Bravo

Markdown specs are advice, not checks: I built a compiler that makes the agent's spec fail when it's wrong

23 Upvotes

Spec-driven development fixed a real problem: agents now start from a spec instead of a vibe. But in most setups (spec-kit, Kiro, a PRD in docs/), the spec is still Markdown. That means:

  • nothing checks that the spec is complete or consistent

  • a typo in a reference is invisible

  • a rule can exist with nothing enforcing it, and no test proving it

  • the agent can misread or skip a section, silently

I kept hitting the same failure: the rule was written down ("a refund never exceeds the captured amount"), the agent built the feature, tests passed, and the rule was never applied. Nothing failed, so nobody noticed.

So I built SpecForge, an open-source compiler for specs (Rust). The spec is written in small structured .spec files, usually drafted by the agent (simplified example):

invariant refund_within_capture "Refunds never exceed the captured amount" {
  guarantee "A refund larger than the capture is rejected"
  risk high
  verify unit "rejects a refund larger than the captured amount"
}

behavior issue_refund "Refund a captured payment" {
  invariants [refund_within_capture]
  produces   [refund_isued]
}

event refund_issued "A refund was issued"

Then specforge check (output trimmed):

[E003] Error: unresolved reference 'refund_isued' in entity 'issue_refund'
  Help: did you mean 'refund_issued'?
[W007] Warning: event 'refund_issued' is not produced by any behavior

What it checks: every reference resolves, every invariant is enforced by some behavior, every promise names the test that proves it (and specforge collect records which tests actually ran and passed). There's no AI in the checker, so it gives the same verdict every time.

The loop becomes: AI drafts the spec → SpecForge checks it → the agent builds against the checked spec (queried over MCP) → you review what's promised vs. proven.

Domain rules (for example, pharma/GxP requirements) can be added as extensions that run in a wasm sandbox.

Repo: https://github.com/leaderiop/SpecForge

It's pre-release, and I'd really value this sub's take:

  1. Is the "Markdown spec is advice, not a check" problem something you hit in practice, or does a good spec-kit/Kiro workflow already cover it?

  2. Would you accept a structured spec language, given the agent writes most of it?

  3. Where should the check run: before the agent starts, in a hook before it calls the task done, or in CI?


r/SpecDrivenDevelopment • • Oct 16 '26

OpenSpec: A task tracker with a spec attached?

Thumbnail
askloft.ai
23 Upvotes

I work on Loft, a spec tool for coding agents, so take this with whatever grain of salt you like. My team and I wanted to know how good real-world OpenSpec specs are, so we went and measured.

What we did: we scored the main specs of 40 public OpenSpec projects (some random + some showcased examples + a few big ones and OpenSpec's own repo). Then we did the same for the most-starred OpenSpec projects and for teams that only write proposals. We scored them against OpenSpec's own writing guide and the usual tests of a good requirement. Two blind passes by an LLM graded a sample of requirements against a rubric, with project names stripped. And we also counted the task-list state of almost 2K open changes.

What we found:

  • The format is basically solved (yeah, no sh.t). In almost all projects, essentially every requirement has a SHALL and a scenario. But specs that follow the format aren't any better written because of it. The format and the writing are separate problems.

  • Specs get worse as they grow. In a typical project, only 55% of requirements state one obligation, and only 35% have a scenario for when something goes wrong. Bigger projects score lower, mostly because requirements bundle several obligations and start naming files and function signatures.

  • Specs lag the code. In projects with main specs, 39% of open changes have every task ticked but were never archived, so the specs don't include that work. A third of spec files still have the placeholder Purpose that archiving writes. OpenSpec's own repo has 23 of 30 open changes in that state. It still ranks 3rd of 40, for what it's worth.

  • Stars don't predict anything. The 25 most-starred projects score about the same as the random draw. Two popular repos translated OpenSpec's headings into Chinese, so OpenSpec can't read any of their requirements.

In most projects, the change folder is where the work happens: a proposal, some tasks with checkboxes. Teams are lazy and don't archive, so the tasks stay current and the specs don't. As a result, what people actually have is a prose disguised as a task tracker, with a spec attached.

Obviously, these are correlations across public repos. And the judges are LLMs (though the two passes agreed within one point on 99.9% of grades).

The detailed report is linked.


r/SpecDrivenDevelopment • • May 17 '26

Tried GitHub's spec-kit with Claude Code for 2 months — notes on what works and what doesn't

23 Upvotes

Been experimenting with Spec-Driven Development for a couple of months now, specifically GitHub's spec-kit toolkit with Claude Code as the agent. Wanted to share notes because I think this sub will have strong opinions on it, and frankly I'm still figuring parts of it out.

Quick definition for anyone who hasn't seen spec-kit: it's GitHub's official toolkit for what they call Spec-Driven Development. The philosophy is that the spec, not the prompt, becomes the source of truth. You write a versioned, reviewable spec; the agent generates code from it; any substantial change goes back to the spec first. Five phases: Constitution, Specify, Plan, Tasks, Implement. Repo: github.com/github/spec-kit

What's actually good:

- Agent-agnostic. Same spec works with Claude Code, Cursor, Codex, Gemini CLI, Copilot. I've literally generated initial code with Claude Code, then handed the spec to Cursor for test refactoring, and it picked up cleanly. The spec is the portable asset.

- Hard checkpoints between phases. You see the full proposed architecture (Plan phase) before a single line of code gets written. Catches bad arch decisions when they cost 5 minutes to fix instead of 5 hours.

- The Constitution file as quality gate. You define inviolable principles up front (test coverage minimums, dependency allowlists, perf budgets, typing strictness). Agent fails its own validation if it tries to violate them.

- Determinism improves a lot vs. raw prompting. The agent isn't filling in 30 implicit decisions on its own — they're in the spec. Re-running the implement phase produces much more consistent output across runs.

What annoys me:

- Drift is real. If you tweak code manually without updating the spec, things desync fast. spec-kit has some tooling for this but it's young.

- Heavy overhead for small changes. Bug fixes <50 LOC or trivial features make the 5-phase flow feel ceremonial. My current rule: only do full SDD for new modules or features touching 200+ LOC. Below that, just do it manually.

- Legacy migration is painful. Retrofitting SDD onto an existing 30k-LOC codebase without prior specs is months of work, not days. Haven't found a clean approach yet.

- Quality depends heavily on the agent. Claude Code (Sonnet/Opus 4.6+) handles it well. Smaller models struggle with the Plan phase — they generate plans that compile but don't reflect good architectural reasoning.

Practical setup I'm using now:

- spec-kit installed via: uv tool install --from git+https://github.com/github/spec-kit.git specify-cli (PSA: PyPI has typosquatters with similar names. Only the github/spec-kit repo is official.)

- Claude Code as primary agent. Have also tested with Cursor and Gemini CLI for cross-validation.

- SQLite for any local persistence needs in the project. Easy to spec, easy to validate, no cloud dependency to mock.

- A reusable constitution template I've extracted: strict typing, pytest coverage >80%, explicit dependency allowlist, no cloud services unless requirement explicitly demands it.

Two questions for the sub:

  1. Has anyone gotten local models (Qwen, DeepSeek-Coder, GLM, Llama) to handle the Plan and Implement phases competently? My local-only experiments have been mixed — small models follow the format but architectural reasoning falls apart. Curious if anyone's found specific local models or prompt engineering tricks that fit spec-kit's phase structure.

  2. Anyone running SDD multi-agent (one model writes spec, another implements, a third audits)? Theoretically should improve quality through specialization but I haven't gotten it to be measurably better than single-agent in practice.

Curious if anyone has a setup that actually works.


r/SpecDrivenDevelopment • • Jun 24 '26

Understanding OpenSpec & Spec-Driven Development

Thumbnail
fadamakis.com
22 Upvotes

r/SpecDrivenDevelopment • • Apr 08 '26

How are you maintaining spec document as it evolves?

22 Upvotes

Considering SDD is the plausible way forward for enterprise software development, spec documents become source of truth. Spec Kit like tools provide convenient ways to create spec documents. As features evolve and various team members work on related features, spec document bound to change. Structuring and versioning the document becomes really important. In ideal cases, there used to be single SRS document for an application. Now, should we be creating and updating a single spec document or feature specific spec documents. Should spec document be living with the code?
Please let me know your thoughts on maintaining spec document as software evolves.


r/SpecDrivenDevelopment • • 10d ago

Advanced software specification and SDD with Agentic Software Engineering (ASE) and Specification Book (SpecBook)

Post image
21 Upvotes

We released version 2.0 of Agentic Software Engineering ( ASE, https://ase.tools ), the Apache-2.0-licensed Open-Source toolkit that fuses the concepts of modern Agentic AI and traditional Software Engineering. ASE 2.0 ( https://ase.tools/news/#ase-2.0 ) delivers an agentic software specification and development approach. For this, ASE 2.0 integrates a new AI-driven task grilling mechanism and the brand new Specification Book ( SpecBook, https://specbook.tools ) companion toolkit. This way, ASE 2.0 supports Spec-Driven Development (SDD) based on both User Stories and Spec-as-Source. Additionally, ASE 2.0 now allows to realize SDD through agentic development pipelines where humans and agents closely cooperate on tasks.

ASE ships as a plugin for the agent harness Anthropic Claude Code CLI -- and with reduced functionality also for Github Copilot CLI and OpenAI Codex CLI. It comprises deeply integrated agent hooks and "mods", highly parameterisable agent skills, an underlying Model-Context-Protocol (MCP) backing service, a companion Command-Line Interface (CLI), and companion Terminal and Web User Interfaces.


r/SpecDrivenDevelopment • • Jul 23 '26

Which “Harness Engineering” are you using?

20 Upvotes

I’ve been using spec driven development for a while and it’s amazing.

But I want to know which approach are you using for software development with AI and how’s it working for your. Feels like SDD is getting outdated


r/SpecDrivenDevelopment • • Oct 11 '26

Breadcrumbs for SDD is out

Thumbnail
breadcrumb-sdd.org
19 Upvotes

Finally, the first working version of Breadcrumbs for SDD is out!

It was 3 weeks of intense work (and token consumption, I confess) to get this result, and I am truly happy with the result.

So, what is Breadcrumbs for SDD? What problem does it solve? And why did I take so much time if I was getting help from AI?

With the advent of SDD (spec-driven development) and ASLDC (agentic software development lifecycle), specifications, intents, and ADRs are shipped with code and are now treated as the primary source of knowledge.

However, because we write them in natural language, detecting the drift between the intent of these documents and the code remains costly and challenging in software development, especially for brownfield projects.

With Breadcrumbs, my idea is to provide a lightweight metadata layer over these artifacts so that human developers and agents can easily track relationships among artifacts in an SDD repository and make drift detection more feasible.

Interested? If so, I invite you to check the project website.


r/SpecDrivenDevelopment • • Jul 18 '26

Behavior-Driven Development and Spec-Driven Development with OpenSpec

Thumbnail
youtube.com
19 Upvotes

Experimenting with Behavior-Driven Development (BDD) and SDD in OpenSpec to achieve a strict Spec-as-Source workflow.

In this walkthrough, I capture the spec in Gherkin format, which the agent first translates into acceptance tests, driving the coding agent to generate the implementation. The harness prevents direct modifications to the code without going through the spec and encourages starting with the spec, using techniques such as Claude Code hooks. Would love to hear your thoughts and feedback.


r/SpecDrivenDevelopment • • Jun 28 '26

Spec-Driven Development Multi-Model Adversarial Authoring and Glossary with OpenCode and OpenSpec

Thumbnail
youtube.com
19 Upvotes

This is a follow-up to my earlier post about "Spec-Driven Development with OpenSpec and OpenCode": https://www.reddit.com/r/SpecDrivenDevelopment/s/jLn7MWYwcj. In this video I cover multi-model adversarial authoring of Specifications with one sub-agent authoring, another reviewing to reduce bias before human review. Also glossary skills where terminology defined once, reused everywhere to improve consistency and quality of specifications. Thanks.