Describe or Enforce: Why Your AI Framework Choice Belongs on the Risk Register
The agentic framework landscape mapped by governance philosophy, not feature lists.
It was a Friday afternoon, the third call of the week with a company I had never spoken to before, and the third company in three days asking the same question.
They build AI-data centers inside shipping containers. Not the Docker kind; the steel kind, the ones that travel on cargo ships and flatbed trucks and get dropped in a field where someone needs compute power tomorrow. Their product is physical, tangible, heavy. And yet, for thirty minutes, nobody on the call talked about hardware. The entire conversation was about software governance.
The engineer on the other side showed up with the kind of energy you recognize immediately; someone who has thought about this problem before you started describing it. Within minutes we were deep into territory that most framework comparison articles never reach: determinism, audit trails, traceability of every decision point between human and machine, the ability to reconstruct a post-mortem with the five whys technique months after a deployment. Not “which AI coding tool is fastest.“ Not “how many lines of code per hour.“ The question was:
which process can my board defend to a regulator, to an auditor, to a customer whose data lives inside that container?
Three companies. Three days. Europe, South America, the United States. All from the same sector: private AI data centers. All asking the same question nobody in the agentic coding conversation seems to be answering.
That week changed the way I think about the framework landscape.
A few weeks earlier, something quieter had happened. Andrea Laforgia, Head of Engineering at Otera, published a LinkedIn post challenging what the industry calls “spec-driven development.“ He cited Colin Eberhardt, CTO of Scott Logic, who had tested GitHub’s Spec Kit hands-on: 33.5 minutes of agent execution time, 2,577 lines of markdown, 689 lines of code requiring 3.5 hours of review. The iterative approach took 8 minutes, produced 1,000 lines of code, and needed 15 minutes of review. The verdict was stark.
A comment appeared underneath from Jeff Bailey, Principal Software Engineer at Nike. He wrote that his experience aligned completely. He had tried Kilo Code, SpecKit, OpenSpec, BMAD. He found them, in his words, “overweight GenAI coding tools.“ He had been using nWave for a couple of weeks, and the experience was “significantly improved.“
That comment started a conversation. The conversation led to two blog posts hey . The blog posts led to a podcast. And somewhere in between, Jeff Bailey mapped the entire agentic coding landscape from the only perspective that actually matters: a practitioner who tried everything and kept what worked.
His journey reads like a compressed history of every developer’s last three years. GitHub Copilot in 2021, barely better than autocomplete. ChatGPT in 2023, replacing StackOverflow one copy-paste at a time. Windsurf on a contract project in late 2024, where he built a complex AWS Step Function workflow in an hour. Cursor in early 2025, impressive agent capabilities. Kilo Code, which built a comprehensive spec that took half an hour to produce the wrong solution. GasTown, Steve Yegge’s ambitious experiment with autonomous agent clusters, which Jeff left after Yegge himself published warnings about production readiness. And then nWave, where, in his words, “my ability to deliver high-quality code with GenAI shot up like a rocket.”
What makes Jeff’s account valuable is not that he chose nWave. It is that he mapped the terrain before choosing anything. And the map he drew reveals something the feature comparison articles consistently miss.
The agentic coding landscape operates at two distinct layers that most evaluations collapse into one.
The first layer is orchestration frameworks: LangGraph, CrewAI, AutoGen, MCP. These solve the plumbing question. How do agents coordinate? How do you manage state? How do you standardize interfaces? They are infrastructure. Necessary, powerful, and entirely silent on the question of what happens when the code those agents produce reaches production.
The second layer is agentic SDLC workflows: the systems that define how you build software with agents under some form of governance. GSD focuses on context engineering and solo execution. BMAD mirrors a full agile team with twelve-plus agents, governance baked into the process definition. GasTown pushes the Overton window toward autonomous agent clusters. Kilo Code and Kiro formalize intent before code generation. And nWave, which Andrea La Forgia named “Expectation Driven Development,” not spec-driven development, because the distinction matters.
Jeff Bailey drew the line that separates these approaches in a single sentence:
“Prompt frameworks describe a process. Nwave enforces it at runtime.”
That sentence deserves to sit on the desk of every CFO and CISO reading this.
A process described in a markdown file is a suggestion. The agent can skip it, shortcut it, or hallucinate past it, and nothing in the system will stop it. A process enforced at runtime is a guardrail. nWave’s Deterministic Execution System, what Jeff describes as DES, blocks skipped TDD phases and rejects unsupported “done” claims. Every agent has a counter-agent. Every specification traces to human-approved intent. The audit trail is not a report generated after the fact; it is an artifact of how the code was built and tested to prevent the test theater anti-pattern.
The question that belongs on your risk register is not which framework your developers prefer. It is which one produces evidence you can hand to an auditor.
If that sounds abstract, consider what happened to Firefox in April 2026.
Anthropic’s Claude Mythos model, running inside an agentic security harness that Mozilla built, discovered 271 previously unknown security vulnerabilities in Firefox. One hundred and eighty of them rated high severity. Some had been hiding in the codebase for fifteen years. One for twenty! Mozilla patched 423 security bugs that month; roughly twenty times their monthly average throughout 2025.
Firefox. Software considered safe, stress-tested for two decades, used by hundreds of millions of people for two decades. And an AI model, in the hands of expert security engineers, found what human teams could not find in years.
Now hold that image and turn it around.
The same class of AI technology that finds 271 vulnerabilities in Firefox when wielded by experts is the same technology generating code in the hands of people who, as Jeff Bailey put it in our podcast conversation, are “citizen developers pushing code out there with no idea what the code does under the hood.“ The asymmetry is the risk. Expert hackers with AI as a precision instrument on one side. Normal people who genuinely feel like senior engineers because AI generates confident output without signaling where competence ends and risk begins; the Dunning-Kruger effect, industrialized; shipping code without review, without governance, without anyone signing off, on the other.
The EU AI Act was supposed to force this conversation by August 2, 2026. On May 7, the EU Council postponed the high-risk compliance deadline to December 2, 2027. Sixteen additional months. Not a reprieve; a measure of how far behind the industry actually is. And in those sixteen months, how much unreviewed, ungoverned, AI-generated code will reach production systems that run payroll, process medical data, manage supply chains, operate inside shipping containers deployed where someone needs compute power tomorrow?
The organizations that build AI-governance infrastructure now will not be scrambling when December 2027 arrives. They will be sixteen months ahead.
I think about that Friday often.
The data center call in the afternoon. The energy, the alignment, the feeling that the market was finally asking the right question. Hours later, we recorded the podcast with Jeff Bailey. Three practitioners, almost a century of combined experience, talking about what it means to build software with care in an era that rewards speed above all else. The excitement of a day where everything converged.
And then, a few hours after we closed the recording, my phone rang. My grandmother had passed away.
All the excitement of that day turned into the kind of silence that reshapes everything around it. Three weeks later, I still feel it when I talk about it.
I share this not for sympathy but because it carries a truth that connects to everything in this article. Foundations matter. The things we build, whether they are families or organizations or software systems inside shipping containers, are only as resilient as what holds them up. A leader who underestimates the cost of handing teams an enterprise license and a prompt framework without engineering discipline, without governance, without someone who has walked this path before, will feel that same fragility the day the castle of cards falls. Not because they made the wrong investment. They made the right one. But the last mile, the governance layer, the human judgment, the process that can survive a five whys post-mortem; that is the part nobody told them was missing.
You are not behind. You invested right. The finish line moved. And the question those three companies asked me that week, the question the industry is finally learning to ask, has an answer: AI-governance.
It starts with knowing where you stand. The AI Readiness Assessment measures the risk gap between where your AI governance is today and where it needs to be; the distance between a controlled transformation and a crisis you did not see coming. Not to find what is wrong. To map the last mile so you can walk it with confidence.
Your timeline. Your terms. When you are ready, I am beside you.
Next week: someone mapped the entire AI-native transformation in six phases and eighteen months. What they found hiding inside every single phase will change how you think about your roadmap.