Video summary

Spec-Driven Development in 2026: What Actually Changed

Main summary

Key takeaways

Technology

Summary of the video’s key points (Spec-Driven Development, 6-month update)

1) GitHub momentum: one framework surged, others diverged

  • OpenSpec surged the most: ~4.1k stars (Oct) → ~39.5k (now), +863% in six months.
  • Spec Kit grew strongly too: ~39.3k → ~87.5k, +123%.
  • BMAD grew but didn’t lead: ~19.1k → ~44.4k, +133%.
  • Agent OS had the slowest relative growth: ~2.5k → ~4.3k, +72%, with signs of stagnation.
  • Taskmaster barely grew: ~22.5k → ~26.5k, +18%, described as effectively “going backwards” versus the market’s overall doubling.

The creator emphasizes the spread (runaway winner vs stalled frameworks), not just averages.

2) Why OpenSpec won (and what replaced parts of the “framework need”)

Main claims:

  • OpenSpec became clearly faster while maintaining comparable output quality versus Spec Kit (“same quality, just much faster”).
  • Spec Kit was criticized as too slow to plan (the creator notes a ~5-minute planning phase back in the October test).
  • Later, even OpenSpec was deprioritized because:
    • Claude Code’s built-in plan mode began covering most daily needs.
    • Superpowers handled larger/bigger-feature workflows.

OpenSpec product changes (v1 rewrite):

  • Significant rewrite: less output noise, clearer structure, less “markdown sprawl.”
  • YC Winter 26 batch participation.
  • Expanded compatibility: now supports 25+ agents and IDEs (as claimed in the subtitles).

Community sentiment:

  • Generally positive on technical merits.
  • The creator recommends OpenSpec as a starting point for newcomers because it’s lightweight and won’t bury users in spec markdown before coding.

3) BMAD: active community + “heavy ceremony” tradeoff, plus scope/fit critique

Product milestones:

  • v6 came out Feb 17, then point releases (v6.3 early April).
  • The stable release described as a ground-up rewrite:
    • Consolidated agents into a persona called Amelia
    • Introduced Skills Architecture
    • Shipped a Cross-Platform Agent Team across 20+ runtimes
    • 12+ specialized agent personas
    • BMad Builder spun out (for custom agents/workflows), already at v1.4
    • A small marketplace of community-contributed skills
    • Dev Loop Automation as part of the ecosystem

Critiques (most common):

  • “Ceremony” is the main drawback:
    • Many markdown/spec files
    • Heavy PM→developer handoff rituals
    • A PRD phase that asks for business success metrics even for what might be a short weekend effort

Creator’s retest note:

  • The creator did a fresh full four-phase flow retest (Planning → Solutioning → Implementation).
  • Result: 7 hours to build a small “cat game” versus 10 minutes with plan mode.
  • Important clarification from comments: BMAD is intended for bigger scopes, so small tests don’t reflect its strengths.
  • Creator plans a future retest focused on lighter modes (“Party Mode” and “Quick Flow”) rather than the full heavy ceremony.

How the creator frames BMAD:

  • Not really a “team tool” in the typical sense; more for solo builders who want the full agile/aggressive multi-agent ritual alongside AI coding.

4) Spec Kit: strong growth, but markdown verbosity + review fatigue

Product/market expansion:

  • 138+ releases since October.
  • Support for 14+ agent platforms (Claude Code, Cursor, Windsurf, Copilot, etc.).
  • Microsoft Learn published an official training module for Spec Kit (enterprise-style validation).
  • Founder context: Den Delimarsky left Microsoft but built Spec Kit as a GitHub project for Anthropic “along the way.”

Community reception (mixed):

  • Sharp critique via Martin Fowler:
    • Spec Kit generates 8+ markdown files per spec
    • Files were described as “repetitive, verbose and tedious to review”
    • Fowler’s conclusion: he’d rather review code than the markdown spec set
    • Agents often ignored instructions in specs

Creator’s technical take:

  • Spec Kit is faster than BMAD, but slower than OpenSpec.
  • Output quality felt similar, but it arrives in a much larger pile of markdown.
  • Creator suspects growth may be driven partly by GitHub brand + Microsoft Learn rather than product superiority alone.
  • Recommends: test Spec Kit against OpenSpec on a real task before adopting it for a team.

5) Agent OS: downsized after “frontier models” absorbed the work

Growth stagnation explanation:

  • Last release v3 on Jan 20, with no updates for ~3 months.
  • The creator describes the project as functionally abandoned.

v3 changes (explicit refocus):

  • The framework was publicly downsized because frontier models now handle tasks Agent OS previously orchestrated:
    • spec writing
    • task breakdown
    • implementation orchestration
  • It now focuses on standards discovery and injection (5 narrow commands):
    • /discover-standards
    • /inject-standards
    • /index-standards
    • /shape-spec
    • /plan-product
  • “Steel-man” argument: Agent OS may be valuable if you specifically need automated standards injection (e.g., into Claude Skills/subagents/prompts), beyond manual CLAUDE.md editing.
  • The key question remains whether it’s worth a full framework given its lack of recent activity.

6) Taskmaster: stalled due to monetization/licensing/telemetry concerns + slower releases

Observed changes:

  • Moved to a dedicated repository.
  • Launched a commercial offering: Hamster (tryhamster.com).
  • Open-source license is MIT + Commons Clause (restricts commercial resale), and the creator notes Taskmaster is the only non-pure MIT project among the leaderboard set.
  • Community concerns included Sentry telemetry shipped by default with opt-out rather than opt-in.
  • Release cadence slowed to about monthly from more frequent earlier shipping.

Technical praise retained:

  • Rick Hightower cited Taskmaster as shining at the decomposition layer, producing dependency-aware task graphs.
  • Creator agrees the engine produces good results.

But UX criticisms:

  • Task scoping uses tags; switching between tag buckets didn’t feel natural.
  • Tasks stored as JSON—fine via CLI, but unpleasant to skim/edit manually.

Creator’s interpretation:

  • The stall is likely connected to the commercial pivot timing + license + telemetry + slower cadence.
  • Framed as a case study in monetization timing.

7) “Around the edges”: new/adjacent projects competing for attention

The creator argues spec-driven development can’t be discussed without adjacent large projects:

  • Superpowers (Jesse Vincent): ~156k stars Not strictly a spec-driven framework, but a skills + TDD enforcement and structured brainstorm-plan-execute workflow for Claude Code. Presented as the largest structured AI coding project on GitHub.

  • GSD (Get Shit Done) by TACHES: ~51.6k stars Execution-first, with wave-based parallel orchestration and fresh context windows.

  • Beads by Steve Yegge: ~20.8k stars Distributed graph issue tracker for AI agents, backed by Dolt (version-controlled SQL DB). Thesis: replace messy markdown plans with a dependency-aware graph. The creator flags it as interesting and likely worth its own future video.

8) Major meta-change: native tool features absorbed what frameworks used to provide

Core conclusion of the update:

  • Claude Code now ships with:
    • skills
    • plan mode
    • ultra plan mode
    • CLAUDE.md project-level standards
  • As these features improved, some spec frameworks grew slower because the “framework value” got baked into the coding tool itself.

The creator also references a Medium mapping article listing 30+ agentic coding frameworks, concluding the space is crowded and only some will survive—those with strong communities or clear reasons to exist alongside native features.

9) Debate and adoption: SDD is accepted academically/industrially, but still disputed

Broader legitimacy gained:

  • Wikipedia page exists; 4 arXiv papers on SDD (noted as in the first quarter).
  • Thoughtworks included SDD on its Technology Radar in the Assess category.

Key skeptical arguments:

  • Martin Fowler: warns SDD resembles model-driven development (a past movement that mostly didn’t work as promised). Concern: the “spec → generated code” promise may fail similarly.
  • François Zaninotto (Marmelab): “The Waterfall Strikes Back” — claims SDD reintroduces waterfall problems in markdown form.
  • Marc Brooker (AWS) rebuts: SDD supports designing earlier and more iteratively, not locking into upfront waterfall design.

Enthusiast evidence:

  • Prezi Engineering: reports teams using SDD workflows.
  • Anecdote: migrating an application to Material UI in 2 minutes with SDD vs 12 months elsewhere.

Overall headline of the video

  • Spec-driven development is “real now” with major growth and institutional attention.
  • But not all frameworks win: some are rewritten, some downsize, some stall due to licensing/commercial factors or lack of releases.
  • A key dynamic: native capabilities inside tools like Claude Code are replacing parts of the need for external spec frameworks.

Main speakers / sources mentioned

  • Primary speaker/creator: the video narrator/reviewer (referenced throughout as “I”; no name provided in subtitles)
  • Framework creators/maintainers:
    • OpenSpec team (OpenSpec creator not explicitly named in subtitles)
    • Den Delimarsky — Spec Kit
    • Rick Hightower — frequent external comparison/analysis cited
    • Brian Casel — Agent OS
    • TACHES — GSD (Get Shit Done)
    • Steve Yegge — Beads
    • Jesse Vincent — Superpowers
    • Brian Casel again (v3 rationale for Agent OS)
  • Community/industry sources:
    • Martin Fowler — criticism of Spec Kit and broader skepticism about SDD
    • François Zaninotto (Marmelab) — “The Waterfall Strikes Back”
    • Marc Brooker (AWS) — rebuttal to waterfall criticism
    • Vishal Mysore — framework mapping across 30+ agentic coding frameworks
    • Thoughtworks — Technology Radar mention

Original video