Every dev has heard of TDD. Most Rails developers have worked with BDD. But I've been wrestling with a nagging question lately: in a world where AI writes most of the implementation, what philosophy sits above BDD?

I found the answer. It's already happening. And it changes how you think about your job.

TDD is about correctness. Write a failing test. Write code to pass it. Refactor. The test is the driving artifact. It answers: is the code right?

BDD moved the abstraction up a level. Given-When-Then scenarios. Feature specs. The behavior is the driving artifact. It answers: are we building the right thing?

Both are still valuable. Kent Beck — the creator of TDD — actually says TDD is a superpower with AI agents, because agents introduce regressions constantly and tests are the only reliable guardrail. That hasn't changed.

But there's a level above both that most developers haven't formalized yet.

GitHub released a toolkit in 2025 called Spec Kit. AWS shipped an entire IDE around the same idea called Kiro. Thoughtworks put it on their Technology Radar. They're all pointing at the same thing: Spec-Driven Development (SDD).

The core idea: intent becomes the source of truth, not code.

The workflow looks like this. You write a structured specification — user stories, acceptance criteria, domain constraints, architectural decisions. Then AI agents generate the behaviors, tests, and code beneath it. Humans own the specification. AI handles everything below it.

GitHub's Spec Kit describes the pipeline explicitly: Constitution → Specification → Plan → Tasks → Implementation. You live at the top two levels. AI executes the rest.

AWS Kiro takes a prompt and turns it into user stories with acceptance criteria, then architecture docs, then a sequenced implementation plan. Delta Airlines deployed it and reported a 1,948% growth in AI tool adoption in six months. Product owners with no coding experience were generating production-ready prototypes.

The specification is the new codebase.

Here's how I think about the hierarchy now:

Level 1 — TDD (Code-Driven). Does this method return the right value? The test is the artifact.

Level 2 — BDD (Behavior-Driven). Can the user complete this workflow? The behavior spec is the artifact.

Level 3 — SDD (Spec-Driven). Does this specification capture full intent? The specification is the artifact. This is where the industry is right now.

Level 4 — Outcome-Driven Development. Does this achieve the business result? The outcome is the artifact. Reduce churn by 15%. Enable a new revenue stream. This is the frontier — where Impact Mapping and Jobs To Be Done thinking meets AI-assisted development.

Each level subsumes the ones below. The higher you operate, the more human value you're providing.

Rails is uniquely positioned for this shift. Convention over configuration means the gap between a high-level spec and working code is narrower than almost any other framework. AI has been trained on millions of Rails apps following identical patterns — same directory structure, same naming conventions, same RESTful routing.

A spec like "User subscribes to a plan via Stripe, receives a confirmation email" maps almost deterministically to models, controllers, jobs, and mailers that an AI agent familiar with Rails can generate without hand-holding.

Your CLAUDE.md file? That's your Constitution layer. Your spec documents? That's your Specification layer. The AI handles everything beneath.

Andrej Karpathy described the maturation in early 2026 as moving from "vibe coding" to "agentic engineering." His framing is sharp: "The biggest prize is in figuring out how you can keep ascending the layers of abstraction."

That's it. That's the whole game now.

Kent Beck put it plainly: the skills being deprecated are syntax and language expertise. The skills being amplified are vision, strategy, task decomposition, and judgment.

Martin Fowler's team at Thoughtworks came to the same conclusion at a retreat earlier this year: writing code was never the bottleneck. Which means AI's velocity multiplier becomes a debt accelerator without proper engineering practices to go with it.

Dave Farley said verification is now the new bottleneck. "I can't read 12,000 lines of code carefully enough. The trust has to come from executable specifications and continuous verification."

TDD + BDD + SDD aren't competing philosophies. They're a stack. The engineer who can operate across all four levels — writing precise tests when needed, defining behaviors for stakeholders, crafting specifications for AI agents, and connecting everything to measurable business outcomes — is the most valuable person on any team.

The code is the easy part now. The hard part is knowing what to build and why.

How long have you been shipping features without a clear spec layer above your tests? Email me at jonathan@rubygrowthlabs.com with the subject "Dev Philosophy" and tell me what you're building.