r/SpecDrivenDevelopment • • 1d ago

I can't be the only one concerned that we're becoming so focused on how quickly AI can produce code that we're forgetting all these learnings we've had from decades of SWE...

7 Upvotes

I've been following the growing popularity of SDD, doing it myself, I can't help feeling we're overlooking engineering practices we've spent decades developing and shouting about.

It's very common to see workflows where an AI agent writes a markdown spec, implements code, then writes tests to validate the same implementation. Huge PRs and reduced human review.

I know some SDD kits support test-first development, but doesn't seem to be the default approach.

A Markdown specification can't go RED or GREEN on its own. And tests passing doesn't necessarily mean you've built the right thing.

I've seen discussions around removing humans from PR reviews entirely, which I find a bit mad. Why not instead automatically flag changes to agreed business behaviour, contracts or fitness functions as requiring particular human attention, but then again not many teams are in a position where they have these...

Is anyone making use of SDD in such a way, following the classic workflows of TDD, BDD, FFDD and ATDD?

I've been working on this tool to help combat this and having good results, so this is also a shameless plug, alongside wanting to hear from proponents of SDD.

The main principle is:

AI may propose and implement changes, but it must not independently redefine the conditions by which those changes are judged successful.

It's still very much an early alpha, built by just me. Currently Windows x64, .NET 10, ASP.NET Core APIs and Reqnroll/MSTest. The packaged release supports Codex, with Claude Code and Cursor support being developed.

I've started benchmarking against Spec Kit too, with some promising early results, although there's a lot more work needed there.

Repo: https://github.com/tayzer/TADA

I'm not against SDD at all. Quite the opposite, I think there's a lot of potential here. I just worry we're so focused on the speed of AI-generated code that we're overlooking some of the lessons we've learned from decades of software engineering.

I'd genuinely love some criticism from people using SDD regularly. Are you already incorporating executable acceptance tests into your workflows? How are you stopping agents from modifying their own success criteria? And is requiring human approval of those criteria too much friction?


r/SpecDrivenDevelopment • • 1d ago

Spec driven development: Vermilion Editor

Thumbnail
github.com
11 Upvotes

Hi. I had no idea there was a community for this. I've been doing the spec driven development for a while and am in the process of making an IDE specifically for this use case... by using this method.

I guess I'll just leave a link here and let you guys take a look at it.

I didn't want to post in the vibe coding subs because I'll be honest they seem kinda... lazy.

Anyways... This is the basics, my github page and the project page explain more:

The gate protocol

Every non-trivial task proceeds through gates, and every gate follows the same loop:

 Orchestrator writes a self-contained prompt
        │
        ▼
 Fresh Qwen session ── reads AGENTS.md ── does ONE step ── writes evidence files ── "STOPPING AND WAITING"
        │
        ▼
 Orchestrator audits the tree and the evidence ──► PASS | PASS WITH NOTES | FAIL
        │                                                │            │
        │                                     fix loop (same session) │ corrective prompt
        ▼                                                             │
 I commit the gate, commit the updated docs, push  ◄──────────────────┘

Several properties of this loop are deliberate:

  • One step per prompt, and every prompt is self-contained. I open a fresh agent session for each step, which keeps the local model's context small and its behaviour predictable. Prompts are kept short enough to stay well inside what the agent handles reliably (an oversized one once hung it). Each carries its own context, rails, steps and evidence requirements, and begins with a mandatory instruction to read AGENTS.md first.

  • Evidence is produced by the machine, not narrated by the model. Long outputs (configuration, build, test runs, proofs) are written by the commands themselves into time-stamped files that record the commit they ran against. The Orchestrator reads those files directly and checks their timestamps against the edited sources.

  • Nothing is carried forward as debt. A note raised in an audit is fixed before the gate is committed, through short continuation prompts in the same agent session. A remark that depends on code not yet written is attached to the gate that will write it, never left as a loose to-do.

  • The agent cannot commit, push or discard work. OpenCode's permission configuration denies every git command that creates, rewrites or throws away history; only I perform those operations, and only at the end of a gate.

  • The agent must say when the prompt looks wrong. Every report has a "Prompt doubts" section. Qwen follows the prompt anyway, unless that would break a rule, and the Orchestrator judges the doubt afterwards.

  • Every milestone ends in a review. Before the next milestone begins, the Orchestrator and I discuss what was promised against what was delivered, what we learned about the process and the technology, and whether the plan should change.The gate protocol Every non-trivial task proceeds through gates, and every gate follows the same loop: Orchestrator writes a self-contained prompt │ ▼ Fresh Qwen session ── reads AGENTS.md ── does ONE step ── writes evidence files ── "STOPPING AND WAITING" │ ▼ Orchestrator audits the tree and the evidence ──► PASS | PASS WITH NOTES | FAIL │ │ │ │ fix loop (same session) │ corrective prompt ▼ │ I commit the gate, commit the updated docs, push ◄──────────────────┘ Several properties of this loop are deliberate: One step per prompt, and every prompt is self-contained. I open a fresh agent session for each step, which keeps the local model's context small and its behaviour predictable. Prompts are kept short enough to stay well inside what the agent handles reliably (an oversized one once hung it). Each carries its own context, rails, steps and evidence requirements, and begins with a mandatory instruction to read AGENTS.md first. Evidence is produced by the machine, not narrated by the model. Long outputs (configuration, build, test runs, proofs) are written by the commands themselves into time-stamped files that record the commit they ran against. The Orchestrator reads those files directly and checks their timestamps against the edited sources. Nothing is carried forward as debt. A note raised in an audit is fixed before the gate is committed, through short continuation prompts in the same agent session. A remark that depends on code not yet written is attached to the gate that will write it, never left as a loose to-do. The agent cannot commit, push or discard work. OpenCode's permission configuration denies every git command that creates, rewrites or throws away history; only I perform those operations, and only at the end of a gate. The agent must say when the prompt looks wrong. Every report has a "Prompt doubts" section. Qwen follows the prompt anyway, unless that would break a rule, and the Orchestrator judges the doubt afterwards. Every milestone ends in a review. Before the next milestone begins, the Orchestrator and I discuss what was promised against what was delivered, what we learned about the process and the technology, and whether the plan should change.


r/SpecDrivenDevelopment • • 1d ago

Built an open-source test management tool with AI agents as first-class citizens — TestPulse 1.0.0

Thumbnail
reddit.com
1 Upvotes

r/SpecDrivenDevelopment • • 3d ago

We need lawyers, not developers.

Thumbnail reddit.com
2 Upvotes

r/SpecDrivenDevelopment • • 3d ago

Enterprise Applications

2 Upvotes

Who here is actually building business applications for companies?
I have the impression that most posts are from solo developers.


r/SpecDrivenDevelopment • • 4d ago

Finally introduced coding subagents to my harness

Post image
2 Upvotes

I was running several primary agents in parallel across multiple projects and the notifications were burying me. Every agent stopped to ask me something: "X or Y?", "found a side issue, fix now or later?" etc. I had become the bottleneck. my AGENTS.md cover many conventions/rules/standards but its still wasn't enough to cover so many of these questions.

So I restructured my workflow like a team:

  • Me: the manager

  • One chat per project: the team lead

  • The other agents: team members, each working in its own "lane"

How lanes work

  • A lane is a git worktree plus a chat working inside it. Each one gets its own branch and folder, so agents don't trample each other's files.

  • The lead asks to open a lane with a title, a plan, and the files it expects to touch. Nothing starts until I approve it on a Lanes board. Before I approve, the harness checks for overlap with files other open lanes are touching, my plan usage, machine load, and whether a spec exists for the work.

  • When a team member stops (it's done, blocked, or has a question), it rings the lead, not me. The lead works through its inbox and replies.

  • The lead can only answer from written rules: a lead.md file in the project plus the project's docs, and it has to cite the rule it used. If no rule covers the question, or it's a taste/preference call, it escalates to me.

  • Escalations land on the board and on my phone as numbered questions, each with a recommended answer. I can answer straight away or ask the lead a follow-up first.

  • The lead can also send me FYI notes that don't need an answer.

I still have full control

Every lane is a normal chat. I can open any of them, read the whole transcript, and type into it directly if I want to step in. The harness never merges a branch, deletes a branch, or removes a worktree on its own.

My notifications are now mostly things that actually need me. It's still early, and I keep refining what goes into lead.md, since that file decides how much the lead can handle without me.

So far I have noticed I am getting a lot more done with less headaches. (literally!)


r/SpecDrivenDevelopment • • 5d ago

Do retries hide real bugs?

Thumbnail
reddit.com
2 Upvotes

r/SpecDrivenDevelopment • • 6d ago

Sharing pi-spec-mode, an extension for drafting, validating and maintaining specifications

Post image
3 Upvotes

r/SpecDrivenDevelopment • • 5d ago

How we write the Ant docs

Thumbnail reddit.com
1 Upvotes

r/SpecDrivenDevelopment • • 6d ago

I just released SPEC-SS: my workflow for coding agents. Looking for feedback

Thumbnail
reddit.com
2 Upvotes

r/SpecDrivenDevelopment • • 7d ago

How do you write automated tests and how do your tests connect to requirements?

Thumbnail reddit.com
2 Upvotes

r/SpecDrivenDevelopment • • 8d ago

Declarative vs imperative in SDD

13 Upvotes

Hey guys,

I was talking to a friend the other day regarding how you should approach spec work and realized that I am thinking about it in a declarative way while the rest of the world seems to be thinking imperatively.

In a nutshell, chances are that if you want to, say, "add the email function to the product", you would think about this as a sequence of tasks: your flavor of of spec, dev, qa, deploy. From my perspective, tasks are secondary, a derivative, of a diff between two product states.

The current state is whatever is in production now, and its spec. The target state is the product with the email sending functions live. The diff is added/changed/removed spec items. The tasks are derived, because you can always reconstruct the tasks from the spec diff, but not vice versa.

There's more on this in an article on our website (link in comments).

LMK your thoughts, happy to discuss.


r/SpecDrivenDevelopment • • 8d ago

From spec-driven to behaviour-driven development

Thumbnail
reddit.com
2 Upvotes

r/SpecDrivenDevelopment • • 10d ago

I'm building a new kind of harness that tests code against formal specs

8 Upvotes

I'm developing a tool to check whether code satisfies formal specifications written in FizzBee. While TLA+ or FizzBee are good tools for checking whether a system can reach invalid states, they don't provide a way to verify implementations conform to the specifications. Unlike unit testing, there is no widely acceppted way to check implemented code follows a formal specification.

So, I built Spec Guardian:
https://github.com/mrasu/spec-guardian

It generates tests from the execution results of specifications written in FizzBee. The tests compare FizzBee's abstract states with concrete states stored in RDB tables or KVS. AI can also generate tests for the same purpose, but it tends to writes tests that follows implementations rather than specifications. That's why Spec Guarding generates tests primarily from FizzBee's results and yaml configuration.

Using Spec Guardian, I tested iceberg-go against a specification written by Jack Vanlightly.
As a result, I found that iceberg-go doesn't support Merge-On-Read mode and creates a single bundled file instead of multiple files as an optimization. While the goal of Spec Guardian is to find bugs, I think finding differences between implementations and specifications is a good sign that I'm on the right track.

It's still under development.
What do you think of this approach to comparing specifications and implementations? Could it become a new kind of AI harness? What features would you like to see added?


r/SpecDrivenDevelopment • • 10d ago

Writing PRDs with ChatGPT/Claude kept giving me generic garbage, so I built a tool that learns the product first

Thumbnail reddit.com
2 Upvotes

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 • • 11d ago

Pi-Maestro: a spec driven multiagent development workflow

12 Upvotes

Hi everyone! I've been building pi-maestro, a Pi extension for a spec-driven multiagent workflow, inspired by GitHub Spec Kit and OpenSpec. It helps you define a change, clarify requirements, and approve a spec with concrete acceptance criteria. You can use it in two ways:

  • Spec only: prepare and approve a spec for implementation elsewhere.

  • Spec + implementation: approve the spec, then let Maestro run the implementation workflow.

By default, three agents run in sequence:

  • Builder implements the spec.

  • Verifier independently checks each acceptance criterion.

  • Simplifier refactors the code for clarity without changing behavior.

You can disable the verifier and simplifier independently, using just the builder or pairing it with either agent. See phase configuration for details.

You make the scope decisions and review the final code.

I'd love some feedback, especially on whether the separation of roles is useful and where the workflow adds unnecessary friction.

If you've built something similar in Pi, I'd be interested in comparing approaches.

https://github.com/emilioSp/pi-maestro

If you find it useful, consider giving it a star on GitHub!

Cheers!


r/SpecDrivenDevelopment • • 12d ago

I built a design system in Svelte 5 that compiles to web components, with an MCP server so AI agents stop inventing props

2 Upvotes

Most of the UI in our codebases is now written with an agent in the loop, and agents don't read Storybook. I wrote up what I changed in how I build a design system because of that: one contract per component feeding docs, types, a linter and an MCP server; events that follow platform rules; validation before review.

Article: https://medium.com/@mohamed.mokhtari/your-design-system-has-a-new-user-it-doesnt-read-the-docs-6eefc4bfb583

How are your teams handling this? Docs written for agents, codegen context, nothing yet?


r/SpecDrivenDevelopment • • 12d ago

The shift toward AI-driven "vibe coding" and spec-driven development in modern tech agencies.

0 Upvotes

​Most dev teams are finding that pure prompt-and-pray coding leads to messy, unmaintainable codebases.

The real shift in 2026? Spec-driven development.

​When we build web automation tools at Enreach Enterprises, we don't just chat with an AI and hope for the best. We write clean structural specs first, let the AI handle the boilerplate, and use human judgment for architecture and security.

​Speed is great, but code integrity wins enterprise trust. How is your team balancing AI velocity with quality control?

#VibeCoding #SoftwareDevelopment #TechTrends #AIAutomation


r/SpecDrivenDevelopment • • 15d ago

Test tools for APIs.. curious what/why you use what you use

Thumbnail reddit.com
5 Upvotes

r/SpecDrivenDevelopment • • 15d ago

Created a claude code plugin/skill to create researched and validated specs

2 Upvotes

I've always believed in that specs should be detailed and validated. So I created ideavalidator as a mod and skill. It's here: https://github.com/alinaqi/ideavalidator

Here's how it works:

It's a grounded idea-validation pipeline..

The target isn't "a good idea": it's a business that's profitable from day one. Two principles rule everything:
- Desk research is never validation. Grounded research can at most justify GO → real-world tests (interviews, pre-sales, paid pilots), never GO → build.
- Behaviour beats stated intent. Money paid, workarounds built, tools switched > "I'd use this." Every evidence item is labelled so you can see which kind it is.

How you start it
- From a URL: ingest --url <site> [--idea "<angle>"] reads the site + search and writes ideas/<slug>.md.
- From an interview: the skill asks only for the missing brief fields (actor, job, workaround + cost, why-us, candidate verticals, money, business model, day-one constraints).
- Then: run --idea ideas/<slug>.md executes the pipeline into runs/<slug>/.

Here is what makes it more than a prompt chain:

  1. Demand signals (signals, auto in run).. search volume + social validation (Reddit API, X via Grok).

  2. Category + Business Model Canvas (classify) .. identifies the real category so stages compare to the right incumbents, and surfaces business-model-innovation options + USP; rendered as a BMC grid + value-positioning map

  3. Anti-over-qualification ... score the idea as stated for its ICP; adjacent/bigger businesses are parked in adjacent_opportunities, never scored, and stages may not invent an unstated compliance regime or silently re-scope the founder's thesis.

  4. Self-validation audit (selfcheck, auto at end of run) .. flags over-qualification, score inconsistencies, weak/single-source KILLs, and unreachable citations (catches fabricated sources).

  5. Council (council) ... optional multi-model sounding board: framework personas debate, a Red Team attacks, a Chair synthesises. Opinion, never a gate.

The output can be used with any coding agent to convert into todos and actual implementation or the idea can be killed.

Hope it helps.

PS: it was part of my agentic superharness palgu.ai and I decided to opensource it.


r/SpecDrivenDevelopment • • 16d ago

Spec driven and UI layout design?

4 Upvotes

Under spec driven development,how does a developer design the UI layout, elements as well as their on screen ordering the way he wants, when he doesn't touch the code? is the design specified somewhere and then referenced from the specs?
I know that something like that is being done with Figma, but what about when using templates like HTML+Thymleaf?
To sum it up, does the Agent do as it thinks when desiging layouts or do you instruct it, and how? Some practical references or examples would be useful. Thanks


r/SpecDrivenDevelopment • • 16d ago

Would you pay for a software modelling tool similar to AutoCAD?

2 Upvotes

I've been building for the last few months a tool for modelling software visually. A sort of mix between Figma and AutoCAD aimed at creating a single diagram for the whole project at different layers, with stories, specifications, etc. It integrates with AI providing validation in real-time.

Is this a tool you would be willing to pay for? What would make or break your decision?

Note this started inspired by SDD but actually ended up closer to a mix of MDD, FDD and other patterns.


r/SpecDrivenDevelopment • • 18d ago

The Convergence on Deterministic AST Invariants: Why Frontier AI Had to Abandon Probabilistic Code Editing

Thumbnail
reddit.com
3 Upvotes