The lever snapped at 2 PM on a Tuesday. Not a physical lever—the kind that breaks in the machinery of enterprise software procurement. McKinsey's latest data landed in my inbox showing 32% of organizations are now skipping the software aisle entirely, choosing instead to build their own tools with agentic coding systems. The number itself isn't the story. The story is what happens when you dig into the 67% success rate of vendor tools versus the 33% success rate of internal builds. When the lever breaks, the story begins.
I've spent the last five years tracking narrative shifts in crypto markets, watching communities build and abandon entire ecosystems based on sentiment alone. The enterprise software world is now experiencing its own version of the DeFi Summer I documented in 2020—except this time, the "liquidity" isn't capital. It's engineering talent, and the "yield" is software autonomy.
The Context: From Buying Software to Building Capability
Let me rewind to what actually changed. For thirty years, enterprise software followed a simple procurement logic: buy the best available product, customize it within vendor constraints, and pay annual licensing fees. Salesforce for CRM. SAP for ERP. ServiceNow for IT service management. The SaaS model worked because building custom software was expensive, slow, and risky—far cheaper to rent someone else's engineering.
The agentic coding shift breaks this contract at its foundation. When a tool like GitHub Copilot or Cursor can generate, test, and self-correct code across multiple files, the calculus inverts. Why buy a generic CRM when your internal team can build a custom one in weeks instead of years? Why accept the limitations of off-the-shelf healthcare software when an AI agent can construct something tailored to your exact regulatory requirements?
The data confirms this isn't hypothetical. Deloitte's 2026 Tech Trends report shows only 11% of agentic systems are production-ready. Gartner's CIO Survey indicates just 17% of organizations have actually deployed agents. Yet Forrester claims 75% of organizations are "adopting" these tools. That gap—between pilot enthusiasm and production reality—is where the real narrative lives.
I've seen this pattern before. In 2021, I built "The Mood Ring," a dashboard tracking NFT trading volume against Twitter sentiment. The disconnect between what people said they were doing and what on-chain data revealed was staggering. The same dynamic plays out in enterprise AI adoption: the story being told to analysts and the story being told by deployment metrics are two different narratives entirely.
The Core: Why 33% vs 67% Changes Everything
Here's the number that should terrify and liberate you simultaneously: MIT NANDA's research shows internal build success rates at approximately 33%, while purchasing vendor tools yields roughly 67% success. That's not a small gap—it's a chasm. And it's the single most important data point in this entire narrative shift.
Let me break down what this actually means through the lens of my experience tracking protocol migrations in crypto. When SushiSwap forked Uniswap in 2020, the community believed they could build something better by taking the open-source code and modifying it. Some succeeded. Most didn't. The ones who failed shared a common trait: they underestimated the complexity of the underlying system they were trying to replicate.
The same principle applies to enterprise agentic coding. The 33% internal build success rate isn't about intelligence—it's about infrastructure. Building an effective agentic coding system requires more than a good LLM. You need:
- Semantic understanding of your codebase
- CI/CD pipeline integration
- Secure sandboxing for autonomous execution
- Failure recovery mechanisms
- Human review loops
- Observability infrastructure
Most organizations don't have these systems in place. They have a GitHub repository and a dream. The 67% success rate for vendor tools reflects something deeper: these tools embed years of accumulated engineering knowledge about how codebases actually work, how tests should be structured, and how to recover from failures.
But here's the contrarian angle that most analysts miss: the 33% internal build success rate is actually a massive opportunity hiding in plain sight. When I analyzed the Terra Luna collapse in 2022, I found that the narrative failure—the story of a "digital yen" that couldn't withstand market pressure—was more damaging than the mathematical failure. The same dynamic applies here. Organizations that attempt internal builds and fail aren't just losing development time. They're losing organizational stability, employee morale, and institutional knowledge.
The McKinsey data showing 20% of organizations already feeling AI operational cost pressure adds another layer. Agentic coding workflows can trigger dozens or even hundreds of LLM calls per task. The inference costs are 10-100x higher than traditional chat-based AI applications. This isn't a technical footnote—it's a fundamental economic constraint that will determine which organizations can actually scale these systems.
The Contrarian Angle: The Hidden Winners in the Build-vs-Buy Shift
Everyone's focused on the obvious players: Microsoft with GitHub Copilot, OpenAI with Codex, Anthropic with Claude Code, and the startup darlings like Cursor and Replit. But the data tells a more nuanced story about who actually captures value in this transition.
High-performing enterprises—those generating at least 5% of EBIT from AI—are nearly twice as likely to skip software purchases entirely. Nearly half of them are building custom systems. This isn't because they're technologists at heart. It's because they've realized something crucial: the real competitive advantage isn't in the AI tool itself, but in the proprietary data and workflows that train and constrain it.
This is where my experience with the ERC-20 Pulse Tracker becomes relevant. In 2020, I built a Python script to scrape Uniswap V2 swaps, capturing 1.5 million transaction logs in three weeks. The code wasn't sophisticated. The insight was: sentiment shifts faster than price, and the data to measure that sentiment was available to anyone willing to look. The same principle applies to enterprise AI. The organizations winning with agentic coding aren't those with the best models—they're those with the best data infrastructure and the willingness to build custom evaluation systems.
But here's what the article doesn't tell you: high-performing enterprises building internal systems are likely using open-source models and frameworks. Llama 3, Qwen, Mistral, LangGraph, CrewAI—these tools allow organizations to bypass closed-source API pricing and keep their code within their own infrastructure. This is a direct threat to OpenAI and Anthropic's business models, and it's completely absent from the mainstream narrative.
The 67% success rate for vendor tools also hides a critical ambiguity. Does "vendor tools" include traditional low-code platforms? How was the control group constructed? The MIT NANDA research doesn't provide methodological transparency, which means we're making decisions based on data we can't fully verify. This is the same problem I encountered analyzing Terra's algorithmic stablecoin—the math looked sound until you examined the assumptions underneath.
The real winners in this shift might be the consulting firms. McKinsey, Deloitte, Accenture—they're positioned to capture value from both sides of the build-vs-buy equation. They can help organizations evaluate whether to build or buy, and then charge premium rates to implement either solution. The article's inclusion of a McKinsey senior partner interview isn't accidental. It's a signal of where the value capture is heading.
The Takeaway: Falling Through the Floor to Find the Foundation
The build-vs-buy shift isn't really about software at all. It's about organizational capability. The 32% of enterprises choosing to build their own tools are making a statement about their future: we believe our internal knowledge, our proprietary data, and our specific workflows are more valuable than any generic solution.
But the 33% success rate for internal builds tells us something uncomfortable: most organizations don't actually have the capability they think they do. The gap between aspiration and execution is where the real risk lives.
I've watched this movie before. In 2022, I wrote a 15,000-word forensic analysis of Terra's collapse titled "The Algorithmic Illusion." The core insight wasn't about the math—it was about the narrative failure. The story of a "digital yen" detached from reality, and the market punished that detachment brutally. The same dynamic is playing out in enterprise AI adoption. The narrative of autonomous coding agents is running ahead of the technical reality, and the correction will be painful for those who bought the story without examining the infrastructure.
The organizations that will succeed aren't those with the most impressive AI tools. They're those with the discipline to treat operational costs as design constraints, the humility to buy vendor tools when internal builds don't make sense, and the wisdom to understand that the real competitive advantage lies in the data and workflows that make AI systems valuable in the first place.
Mapping the chaos to find the hidden narrative arc: the build-vs-buy shift is really a story about who gets to own the means of software production. For thirty years, that ownership belonged to software vendors. Now, for the first time, enterprises have a genuine choice. The lever has broken. The question isn't whether you'll build or buy. The question is whether you understand what you're actually building toward.
The pulse didn't stop. It just changed rhythm. And the organizations that learn to dance to this new beat will find themselves falling through the floor—only to discover the foundation was there all along.