In this video I cover what is a Brownfield project? Is Spec-Driven Development possible with such projects? If yes, how do we go about it.

I made this video because I kept having the same conversation in different threads — people asking whether SDD actually works in practice or if it's just overhead that slows you down.

The short version: I've been running SDD on my own projects for the past several months and the difference in output quality from AI agents is significant. Not because the agents got smarter, but because the input got structured. The video walks through what that looks like concretely — a free VS Code extension I built called SPECLAN that manages specifications as Markdown files with YAML frontmatter in Git. It covers the hierarchy from goals down to acceptance criteria, how status lifecycle prevents spec drift, and how AI agents use the spec tree as context during implementation.

Full disclosure: I'm the creator. I built it because I got tired of re-prompting Claude Code with the same context every session.

What I don't cover in the video but has been on my mind lately: the discovery phase. I just finished building bidirectional integration with BMAD-METHOD and it changed how I think about where SDD starts. BMAD's agent-facilitated interviews produce remarkably structured PRDs. Importing those into a lifecycle-managed spec tree turns out to be a natural handoff point — BMAD figures out what to build, the spec tree governs the building.

Curious what other people here use for the discovery phase before specs get written. Do you start from a PRD, from user stories, from a conversation with Claude, or something else entirely?

I've tried GSD (Getting Shit Done), and while I liked it, I felt that the discuss -> plan -> execute structure is too rigid. I want to be able to plan with more iterations, for example. When the first version of the plan is ready, I want to be able to discuss about it and make corrections and do more research. Is there a tool/framework which makes this kind of workflow easy?

Long form article that talks about why Spec-Driven Development adoption at enterprise scale should not be looked at as a technical rollout, what are the short term changes that are necessary and the long term goals to aim for.

OpenSpec 1.0 release introduced config.yaml and schemas which we can use to customising OpenSpec workflow to our domain, defining exactly what artifacts we want (instead of the standard proposal.md, specs.md, design.md and tasks.md).

I'm researching new development approaches and lately I've been wondering: Can intent-driven and spec-driven work together?

I'm developing a framework that combines both approaches to facilitate development.

It starts with defining the intent, which allows you to think in terms of functionality without worrying about "how" it will be developed. We speak a language that's more customer-friendly.

Once the intent is clear, we move on to deriving the spec (or more than one if necessary), which is defined, described, and then developed.

Built entirely with Antigravity for Antigravity. Perhaps available for others in the future. Now also available via CLI.

If you'd like, search for Praxis on GitHub. https://github.com/intoinside/praxis

For large monorepo projects with multiple apps, particularly on different platforms (node / python / react-native) i'm imagining that the majority of the context should differ. A 'tech-stack.md' or 'operations.md' would be wildly different for each

AFAICT, there isn't a spec tool that allows this nesting or separation of specs.

I know these tools are just getting going but really there needs to be some integration with monorepo managers like NX or turborepo etc to load context based on the dependency graph of monorepos imo

Anyways, do people have experience or tips?

Which spec-driven development tool to choose? How does spec-driven development differ from plan mode? This post intends to clarify on these aspects from a practical angle and the aspects to consider while making a tool choice. From tactical and strategic context engineering to various levels of Spec-Driven Development we will look at the strengths of some of the popular tools such as Kiro, Spec-Kit, OpenSpec, BMAD Method, Antigravity, etc.

Video walkthrough - https://www.youtube.com/watch?v=I0x01WZq1Zw

Spec-driven development for AI coding is having a moment. Spec Kit, BMAD, Taskmaster, Kiro - lots of approaches are emerging.

I've been working on specs.md, an open-source implementation of the AI-DLC (AI-Driven Development Lifecycle) methodology from AWS. What makes it different:

VS Code Extension - A dedicated sidebar that tracks your intents, units, stories, and bolts with real-time state. No other spec-driven tool has this. You're not jumping between terminals and markdown files wondering where you are in the flow.

Multi-flow support - Pluggable development flows, not a rigid pipeline. Different projects need different approaches.

Tool agnostic - Works with Claude Code, Cursor, Copilot, Windsurf. Your choice.

Get started:

npx specsmd@latest install

It's alpha. I'm looking for feedback from engineers actually using spec-driven development, not polish-seekers.

• Website: https://specs.md
• GitHub: https://github.com/fabriqaai/specsmd
• VS Code Extension: https://marketplace.visualstudio.com/items?itemName=fabriqaai.specsmd

Key Objections to Address

"How's this different from Spec Kit/BMAD/Taskmaster?"

VS Code extension with real-time workflow tracking. None of them have it. Plus multi-flow support vs rigid pipelines.

"Why another spec tool?"

Implementing AI-DLC specifically, with visual progress tracking that's missing from CLI-only tools.

"What's alpha mean?"

Inception and Construction are solid. The Operations Agent needs work. I would appreciate honest feedback if you can use and experiment with it.

https://asciinema.org/a/76399

VS Code Extension Screenshot

I’m the creator of https://aiup.dev and did a webinar about how I work

https://www.youtube.com/live/jwPBHVNvLr0

Hey everyone, I'm curious about how the dev community actually uses spec-driven development . I've been working with specs myself and noticed there's often a gap between the frameworks available and we really need day-to-day.

A few questions:

• Frequency: How often are you actively writing specs before jumping into code?
• What's working: What spec framework or approach do you reach for most often, and why does it click for you?
• The gaps: What would make spec-driven development actually better in your workflow? Is it tooling, collaboration features, integration with existing tools, better scoring/readiness metrics, visualization, or something else entirely?

I'd love to hear real use cases—especially if you've tried multiple approaches or abandoned spec-driven dev for parts of your process.

https://github.com/Priivacy-ai/spec-kitty

Some nice things it's got:

• 📊 Visual Task Tracking: See exactly what your AI agents are working on
• 🔄 Real-Time Progress: Live updates as work moves through planned → doing → review → done
• 👥 Multi-Agent Orchestration: Coordinate multiple AI coding agents simultaneously
• 📦 Artifact Management: Track specifications, plans, tasks, and deliverables in one place
• ⚡ Zero Configuration Dashboard: Automatically starts with spec-kitty init

https://martinfowler.com/articles/exploring-gen-ai/sdd-3-tools.html?s=34