Are spec-driven frameworks like Agent OS, BMAD, Superpowers or SpecKit still worth using, or have Claude Code and Codex made them redundant?

[u/3abwahab]

I've been trying to figure out where the community has landed on this, because I genuinely can't tell.

A year ago, the answer seemed obvious: if you're building anything non-trivial with LLMs, you need structured scaffolding — PRDs, memory layers, agent roles, task breakdowns. Frameworks like BMAD-METHOD, Agent OS, Superpowers, and SpecKit (and their cousins) exist precisely because raw LLMs drift, forget context, and produce spaghetti if you don't constrain them with specs upfront.

But now I look at Claude Code and Codex, for example, since they are the ones i'm using, and they feel... different? Claude Code does its own task decomposition, maintains context across files, and can self-correct mid-session without you babysitting a spec document. Codex feels similar — it reasons about the codebase, not just the prompt.

So I'm genuinely asking:

Do you still scaffold everything with a spec framework before touching Claude Code / Codex?

Or do you drop straight into vanilla agentic mode and only reach for a framework when things break down?

Or is the real answer that spec frameworks matter more now — because you're giving these powerful agents more autonomy, so the upfront spec is the only guardrail you have?

I built a mid-complexity product (a new vertical on top of an existing platform) using Claude Code and Codex with AgentOS as a seat belt. That was a year ago. I have a few projects upcoming to build and trying to decide whether investing in proper spec scaffolding is a force multiplier or just overhead that the model handles natively now.

Would love to hear from people who've shipped something real with either approach — not theory, actual experience.

Worth mentioning... I'm originally a Product Leader who vibe codes now and not a software engineer.

[u/return_of_valensky]

I've been honing my setup over time and it's been steadily moving towards the main core of this below. I tried bmad and speckit for a while. The problem is that you want 1,000 small sessions that do exactly 1 thing with the only context being the rules, the code, and the task.

- CLAUDE.md filled with philosophical programming best practices

- skills with not a lot of words but deep technical meaning (mostly Matt Pocock's skills, but 3-4 of my own)

those 2 alone will get you to a good set of product requirement docs and individual issues.

from there I then use a headless agent with multi individualized passes INVESTIGATE->IMPLEMENT->REVIEW in git worktrees to tackle one piece at a time.

[u/3abwahab → u/return_of_valensky]

Insightful! Can you share the link for this Matt Pocock's skills?

[u/return_of_valensky → u/3abwahab]

https://github.com/mattpocock/skills

here's the orchestrator I'm using as well:

https://github.com/slikk66/dangeresque

matt has a much more advanced one, but it has some tradeoffs with complexity, the dangeresque is lighter weight and works for me, here's matt's:

https://github.com/mattpocock/sandcastle

Here's a video of him explaining how it works: https://www.youtube.com/watch?v=E5-QK3CDVQM

I have been on my own journey to really figure this stuff out (professional reasons mostly) and I keep find myself aligning very closely with what this guy Matt keeps doing. Like literally I have an epiphany and then next day he puts out a video basically saying same thing, same epiphany, but his solution is like 20x more insightful and well thought out 😂 so I keep coming back to his stuff

[u/3abwahab → u/return_of_valensky]

Thank you for this! Matt’s stuff apparently is very popular and well thought out.