The world’s most expensive game of telephone
The enterprise software industry has spent four decades perfecting a business model that, when you describe it to someone outside it, sounds like a prank.
A CRO says what they want. A business analyst writes it down. A consultant rewrites it as requirements. An architect rewrites the requirements as a design. A developer rewrites the design as code. A QA team rewrites the code as test cases. A change manager rewrites the test cases as training material. Eighteen months and $40 million later, the CRO logs in and says “this isn’t what I asked for.”
This is not a system. This is a game of telephone played by adults in business casual, billed at $400 an hour, with a Gantt chart.
We’ve normalized it because everyone in the room makes money from the dysfunction. The SI bills for the translation. The software vendor bills for the seats. The internal IT team builds a career out of managing the project. The CRO eventually gets fired and a new one starts the cycle. Implementation, as the enterprise practices it, isn’t a thing you do to get software. It’s an industry that exists because software is hard to get.
That industry is about to have a very bad decade.
No, this isn’t another “AI will replace developers” post
Let’s get this out of the way. The bottleneck in enterprise software has never been the supply of code. SAP has 400 million lines of it. Oracle has more. Salesforce has so many lines of code that nobody, including Salesforce, knows what they all do. The enterprise does not have a code shortage. It has never had a code shortage.
What it has is an intent translation shortage. The expensive, slow, error-prone part of every implementation isn’t writing the software. It’s getting from “what the business wants” to “a configured system that does the thing.” That gap — the translation gap — is where SIs live. It’s where the 18-month timeline lives. It’s where the change order economy lives. It’s where careers are made.
Generated code doesn’t close that gap. It just makes the gap faster to fill with more code. Which, if you think about it for thirty seconds, is the opposite of what anyone wants. Nobody is paying $40 million because they don’t have enough custom code. They’re paying $40 million because they don’t have a way to express what they want in a form the system can execute without a six-month relay race of humans translating between dialects of corporate.
You don’t fix the translation gap with a faster typist. You fix it by removing the translation.
The quiet death of no-code, low-code, and the CMS-industrial complex
Before we get to the new model, we have to do an honest funeral.
For thirty years, the entire premise of no-code, low-code, and the CMS-industrial complex was a single load-bearing claim: writing code is expensive, so we’ll minimize it. That was the bargain. You give up expressiveness. The platform gives you guardrails. Your business gets squeezed into pre-built shapes — workflow templates, content models, drag-and-drop pipelines — and in exchange, you don’t have to pay developers. It made sense when a line of code cost real money. It was a rational trade.
The trade is no longer rational. The cost of a line of code dropped from “meaningful” to “rounding error” sometime in the last 24 months, and almost nobody in the no-code category has updated their thesis. They’re still selling 2018’s answer to a problem that stopped existing in 2024.
But the bigger issue isn’t the price of code. It’s where governance lives.
In the configuration era — SAP, Salesforce, Workday, every CMS ever built — governance lived in the platform. The platform’s config shapes were the guardrails. You couldn’t express something the platform didn’t permit, and that was the whole point. Configuration was safe because it was constrained. The lossy compression of your business into the platform’s mental model wasn’t a bug; it was the governance model. You traded fidelity for safety.
No-code inherited this bargain and made it worse. You trade expressiveness for guardrails, and the guardrails are now proprietary, opaque, and owned by a vendor whose interests don’t actually align with yours. Try porting a 4,000-step Power Automate flow off Microsoft sometime. Try auditing what your headless CMS actually does to your content schema on a Tuesday. The “low-code” platforms turned out to be the highest-lock-in software ever sold.
Here’s the thing nobody in that category wants you to notice: every enterprise with non-trivial pricing, non-standard contracts, or real M&A complexity discovered the same thing. The config shape fits the first 80% of reality and breaks on the rest. The 20% that doesn’t fit is where the actual business lives — the edge cases, the workarounds, the stuff in spreadsheets, the rules in someone’s head. Configuration couldn’t express the business. And because it couldn’t, there was no governance artifact for the behavior that mattered most. The exceptions lived in places nobody could audit.
The pro-code answer doesn’t abandon guardrails. It moves them. The specification becomes the guardrail. Evals — executable tests that say what the system must do — replace the platform’s config shapes as the governance layer. You don’t constrain how the system gets built. You constrain what it must do once built. The intent is the contract. The eval suite enforces it. The implementation is free to change. The behavior isn’t.
That’s the inversion. Evals are the new configuration. They govern by specification instead of restriction. They enforce by execution instead of policy. And they’re the artifact the next decade of enterprise software gets built around.
Once you accept that, no-code stops looking like a category and starts looking like a transitional technology — the dial-up modem of the configuration era. It made sense for a while. It doesn’t anymore.
This is what makes intent-driven implementation possible. Not the agents. The governance model.
Intent-driven implementation: what it actually is
Here’s the new shape.
A business owner writes a brief. Not a 200-page requirements document. A brief — a few paragraphs of plain English describing the revenue motion they need, the integrations it touches, the data it depends on, the rules it has to respect. The brief becomes a plan. The plan spawns specialist agents — one for the integration, one for the data model, one for the evals, one for the UI. Each agent produces configuration against a governed platform that already exists. Hours later, the business owner is clicking through a working system, finding the things they didn’t know they wanted until they saw them, and iterating in real time.
Notice what didn’t happen. Nobody wrote a requirements document that took six weeks and three workshops. Nobody held a design review with twelve stakeholders. Nobody opened a JIRA ticket. Nobody waited for a sprint. The brief was the requirements. The agents were the design. The configuration is the system. The working system is the UAT.
The artifact isn’t a pile of generated code that some poor bastard has to maintain in five years. The artifact is configuration — declarative, governed, version-controlled, replayable. The platform underneath does the heavy lifting. The agents do the translation. The human does what humans are actually good at: deciding what the business should do.
This is intent-driven implementation. It’s what happens when the system is good enough, the agents are governed enough, and the platform is opinionated enough that the translation layer collapses to zero.
It’s also, not coincidentally, what happens when implementation timelines collapse from quarters to hours.
”But this is just vibe coding for the enterprise” — and why that’s wrong
Someone in the comments is already typing this. Let me save them the effort.
Vibe coding works for a weekend Replit project because the blast radius of getting it wrong is one disappointed user. The enterprise version of vibe coding — letting an LLM hallucinate its way into your production OMS — is how you end up on the front page of the Wall Street Journal explaining why a Fortune 500 just shipped 40,000 wrong invoices to oncology clinics.
Intent-driven implementation is the opposite of that. Remember the inversion from two sections ago: governance moved from the platform’s config shapes to the specification itself. That’s the entire control story. The agents can only produce configuration the platform will accept. The evals run before deploy, not after. The blast radius is bounded by what the spec demands, not by what the agent imagines. The configuration is the source of truth — readable, diffable, reviewable — not a pile of generated React components that mutated past anyone’s ability to follow.
Traditional implementation has no control plane. It has a project manager and a hope. The majority of ERP implementations fail or run materially over budget, and the failure mode is almost always the same: the gap between what was specified and what got built was too big to close in UAT, and by the time anyone noticed, $30 million had been spent on the wrong thing. The specification was a Word document nobody updated. The behavior was whatever the developers remembered from the last workshop. There was no executable contract between intent and reality.
Intent-driven implementation closes that gap structurally. You can’t drift from intent because intent is the artifact. The configuration is generated from the intent, against a platform that won’t accept invalid configuration, governed by evals that fail loudly when behavior doesn’t match contract. The vibe coding analogy is upside down. Consumer vibe coding is fast and uncontrolled. Enterprise intent-driven implementation is fast because it’s controlled.
The boring secret is that the control plane is the entire point. The agents are commodity. Anyone can spin up an agent. The thing nobody else has is the governed platform underneath, with the eval suite as its enforcement layer, that makes the agents safe to let loose on.
Who dies, who’s born
Let’s do the part everyone in the SI world has been quietly hoping nobody would write.
What’s dying: The SOW economy. The 200-page requirements document. The fixed-price implementation contract. The change order as a margin engine. The implementation partner whose value is “we have a thousand offshore consultants who can be onsite Monday.” The career architect whose entire skill is reading SAP IMG screens. The PMO that exists to coordinate the dysfunction. The eighteen-month go-live. The “we’ll do a Phase 2” promise that everyone knows is a lie.
What’s born: Implementation as a continuous activity, not a project. Configuration as the deliverable, not code. The architect as the highest-leverage role in the building, because the architect is the only one who can write a brief precise enough to drive an agent fleet. A new kind of SI partner whose value isn’t labor arbitrage but intent capture and governance design — the people who help the enterprise figure out what to ask for and how to keep the platform safe while it executes. Smaller engagements. Faster outcomes. Higher margins for the partners smart enough to reposition. A market that rewards thinking, not staffing.
If you’re a boutique SI or a forward-thinking pod inside a Big Four practice, this is the best news you’ve had in a decade. The legacy SI’s moat — armies of body-shop consultants billing 60% utilization on a five-year program — becomes a liability overnight. Their cost structure is built for the world that’s ending. Yours isn’t. The opportunity isn’t to compete with them on their terms. It’s to make their terms irrelevant.
If you’re running a 4,000-person ERP practice at one of the big firms, I’d be having a hard conversation with the partner team this quarter. Not because the work disappears. Because the work that’s left looks almost nothing like the work you’ve been selling.
The 24-month window
Every category shift in enterprise software has a window — the period between when the new model becomes possible and when the market accepts it as the default. Cloud was a four-year window. SaaS was a five-year window. Mobile was a three-year window.
Intent-driven implementation is a 24-month window. It’s already possible — the agents work, the platforms exist, the early proofs are in production. What’s not done is the market figuring out that this is what implementation looks like now. In 24 months, that fight is over. The CIOs who moved early will have shipped four revenue motions in the time their peers shipped one. The SIs who repositioned will have built reference accounts the legacy firms can’t match. The platforms that got there first will have eaten the configuration layer of the entire enterprise stack.
The companies still running 18-month implementations in 2028 will look exactly like the companies still running on-prem data centers in 2018. Not dead. Just visibly losing.
Implementation is the new configuration. The translation layer is collapsing. The SOW economy is on the clock.
The only real question is which side of the window you want to be on.
