The Build-vs-Buy Trap: Why 32% of Enterprises Are About to Learn That Code Is Not a Commodity

The ledger shows a contradiction that most market participants are too busy to notice.

Thirty-two percent of enterprises have decided to stop buying off-the-shelf software and build their own using agentic coding tools. That is the headline number from the latest enterprise adoption surveys. But here is the number the headlines buried: only 11% of agentic systems are production-ready, according to Deloitte's 2026 Tech Trends report. And Gartner's CIO Survey shows that only 17% of organizations have actually deployed agents in production.

The gap between intent and execution is 21 percentage points. That is not a rounding error. That is a capital destruction event waiting to happen.

I have seen this pattern before. In 2021, every DeFi protocol was building its own AMM, its own lending market, its own yield aggregator. The code was the easy part. The liquidity was the hard part. Most of those protocols are dead now. The ones that survived understood something that the market is only now learning about agentic coding tools: building is not the same as shipping, and shipping is not the same as surviving.

Ledgers do not lie, but liquidity always flees.

Context: What We Are Actually Discussing

Let me be precise about what we are actually discussing, because the term "agentic coding tools" has been stretched to cover everything from autocomplete plugins to fully autonomous software development platforms.

Agentic coding tools are AI systems that do not just suggest code — they plan, execute, test, and iterate on code autonomously. The architecture is a loop: the model receives a task, plans a sequence of steps, calls tools (code editors, test runners, package managers), generates or modifies code, executes tests, observes the results, and self-corrects. This is a combination-level innovation — LLM + code interpreter + tool calling + planning strategy — not a fundamental breakthrough in model architecture.

The market data comes from multiple sources, and the convergence of these sources is what makes the analysis credible. McKinsey reports that 20% of organizations are already feeling AI operational cost pressure. Gartner predicts that 40% of agentic AI projects will be cancelled by the end of 2027. MIT NANDA research shows that internal build success rates are approximately 33%, while purchasing vendor tools yields approximately 67% success. Deloitte's 2026 Tech Trends report shows only 11% of agentic systems are production-ready. Forrester reports that 75% of organizations are "adopting" agents — a number that stands in stark contrast to the 17% that have actually deployed them.

The gap between Forrester's 75% "adopting" and Gartner's 17% "deployed" is the most important data point in this entire analysis. It tells you that the market is in the pilot phase, not the production phase. And pilot phases are where capital goes to die.

I have audited smart contracts for a living. I know what happens when teams rush to production before the infrastructure is ready. The 0x protocol audit in 2017 taught me that the difference between a working system and a secure system is not the feature set — it is the edge cases. The re-entrancy vulnerability I found in the exchange proxy contract was not visible in the happy path. It was visible only when you traced the execution flow under adversarial conditions.

Agentic coding tools have the same problem, but at a much larger scale. The happy path is impressive. The adversarial path is where the system breaks.

Core: The Seven Dimensions of the Agentic Coding Shift

Dimension One: The Technical Reality — Combination Innovation, Not Breakthrough

Let me start with the technical architecture, because everything else follows from it.

Agentic coding tools are built on large language models that have been augmented with tool-calling capabilities and planning strategies. The model does not just generate code — it generates a plan, executes the plan by calling tools, observes the results, and iterates. This is a significant engineering achievement, but it is not a fundamental breakthrough in AI capability. It is a combination of existing technologies: LLMs, code interpreters, tool-calling interfaces, and planning algorithms.

The implications of this are profound. Because the underlying model is still a statistical pattern matcher, the system inherits all of the limitations of LLMs: hallucination, context window constraints, and difficulty with long-range dependencies. In a small, well-defined coding task, these limitations are manageable. In a complex, multi-file, legacy codebase with cross-team coordination requirements, they become critical.

The data confirms this. Deloitte's finding that only 11% of agentic systems are production-ready is not a surprise to anyone who has tried to deploy one in a real enterprise environment. The system works in the demo. It works in the pilot. It breaks in production, when the codebase is messy, the requirements are ambiguous, and the integration points are numerous.

MIT NANDA's finding that internal build success rates are 33% versus 67% for vendor tools is even more telling. It suggests that the technology is not "open-box ready" — it requires significant engineering effort to make it work in real environments. And most enterprises underestimate the complexity of that effort.

I have seen this dynamic play out in crypto. In 2020, during DeFi Summer, I deployed $150,000 of my own capital into Uniswap V2 ETH/USDC pools. I wrote a rebalancing script that executed 4,200 rebalances in three months. The script worked because I understood the system deeply — I had coded it myself, tested it against historical data, and built in stop-loss parameters that would execute automatically. The script was not "agentic" in the modern sense, but it was autonomous. And it worked because I had done the engineering work to make it work.

Most enterprises do not do that engineering work. They buy a tool, expect it to work, and then blame the tool when it fails. The 33% internal build success rate is not a technology problem. It is a discipline problem.

There is a hidden technical dimension that the public data does not capture. The high-performing enterprises — the ones generating at least 5% of EBIT from AI — are not just using agentic coding tools. They are building the infrastructure that makes those tools work: internal model fine-tuning pipelines, evaluation frameworks, observability systems, and CI/CD integration layers. The technical barrier has shifted from "model capability" to "systems engineering capability." This includes code repository semantic understanding, environment sandboxing, failure recovery mechanisms, and human review loops.

Gartner's prediction that 40% of agentic AI projects will be cancelled, with "insufficient risk control" as one of the top three reasons, points to a specific technical weakness: explainability and auditability. In software development — a domain that demands high determinism — the inability to trace a model's decision-making process is a fundamental limitation. Traditional toolchains are auditable. Agentic coding tools are not, at least not at the same level.

Dimension Two: The Commercial Shift — From Buying Software to Buying the Ability to Build

The most significant commercial signal in this data is the shift from purchasing finished software to purchasing the ability to build custom software. Thirty-two percent of organizations have decided to skip the software purchase and build their own using agentic coding tools. Among high performers — organizations where at least 5% of EBIT comes from AI — nearly half are skipping software purchases, compared to 31% of average organizations.

This is a structural shift in the enterprise software market. Traditional SaaS products are being eroded from the demand side. Instead of buying a CRM, an ERP, or a vertical application, enterprises are buying model APIs, development frameworks, and cloud infrastructure, and then assembling their own solutions.

The data on success rates complicates this picture. MIT NANDA's finding that vendor tools yield 67% success versus 33% for internal builds suggests that "bare self-building" is a high-failure strategy. The commercial opportunity is not in encouraging enterprises to build from scratch — it is in providing the middle-layer products that reduce the barrier to building: development platforms, component libraries, evaluation systems, security governance tools, and AI-native application frameworks.

McKinsey's advice to treat operational costs as a design constraint is the key insight here. The commercial competition is shifting from "model capability" to "unit economics" and "full lifecycle cost transparency." Enterprises are not asking "can this AI write code?" They are asking "what does it cost per task, and is that cost justified by the business value?"

This is exactly the question I ask when I evaluate a DeFi protocol. The yield is not the question. The question is: what is the risk-adjusted return, net of all costs, including the cost of capital, the cost of impermanent loss, and the cost of smart contract risk? Most protocols fail this test. Most agentic coding tools will fail it too.

The industry distribution of adoption is revealing. Technology leads at 41%, followed by healthcare at 39%, professional services and energy at 38%. These industries share common characteristics: highly customized workflows, strict data compliance requirements, and knowledge-work intensity.

The healthcare and energy adoption rates are particularly interesting. These are not industries known for technological leadership. Their high adoption rates suggest that off-the-shelf SaaS software is insufficient for their needs, and that the customization costs of traditional software development are prohibitive. Agentic coding tools offer a path to building compliant internal systems at a fraction of the traditional cost.

But there is a darker implication. The 39% of employees who expect layoffs in the next year — up from 32% — suggests that the adoption of agentic coding tools is not just about efficiency. It is about workforce reduction. Enterprises are not just building software; they are building the capability to replace human developers.

I have seen this dynamic before. In 2021, when I liquidated my Bored Ape Yacht Club positions — 10 NFTs for $380,000, sold within 72 hours for a 110% return — my peers accused me of lacking "community loyalty." But the market crashed, and I preserved my capital. The lesson is the same: sentiment is not a strategy. The enterprises that are adopting agentic coding tools with the explicit goal of reducing headcount are making a strategic bet. Whether that bet pays off depends on whether the technology can actually deliver production-ready code at scale.

The data suggests it cannot — yet. The 11% production-readiness rate and the 17% deployment rate are not numbers that support aggressive workforce reduction. They are numbers that support cautious piloting.

There is a hidden commercial dynamic here. The high performers that "skip software purchases" are not necessarily building everything from scratch. They are more likely purchasing model APIs, development frameworks, and infrastructure, then assembling their own solutions. This means traditional software vendors like Salesforce, ServiceNow, and SAP need to reposition themselves as platform providers — or risk being excluded from the value chain entirely.

The 67% success rate for vendor tools versus 33% for internal builds is actually an implicit endorsement of mature vendor tools like GitHub Copilot, Cursor, and Replit. The article's overall cautionary tone hides a subtle validation of the vendor tool market.

Dimension Three: Industry Impact — The Knowledge Work Restructuring

Agentic coding tools are reshaping the supply and demand structure of the software industry. In the short term, they enhance existing development processes. In the medium term, they will replace some junior coding, repetitive code maintenance, and simple application development work — while compressing the traditional application software market. In the long term, enterprise IT departments will transform from "software buyers" to "platform + AI assemblers," and the role of system integrators and consulting firms will actually be strengthened — because the high failure rate creates massive demand for professional services.

The industry distribution data — technology at 41%, healthcare at 39%, professional services and energy at 38% — tells us which industries have the most urgent workflow pain points and the highest AI substitution value. These are knowledge-work-intensive industries with highly customized processes.

The 39% employee layoff expectation rate, up from 32%, reflects genuine AI substitution anxiety. But the article also notes that "internal build failure costs include employee morale," suggesting that failed technology transitions create a lose-lose situation.

There is a hidden dynamic here. The high adoption rates in healthcare and energy may not be because these industries are technologically advanced. It may be because off-the-shelf SaaS software is insufficient and customization costs are prohibitive. Agentic coding tools allow these industries to build compliant internal systems at lower cost. This suggests that vertical "shadow IT" will re-emerge.

Employee layoff expectations may also accelerate knowledge loss and organizational resistance, which could paradoxically increase agentic AI project failure rates. This is a negative feedback loop that the article does not explore.

For independent software vendors (ISVs), the impact is profound. As AI tools erode the "feature moats" of existing SaaS products, competition will shift to "data moats" and "workflow moats." The question is not whether your software has more features — it is whether your software has better data and deeper workflow integration.

Dimension Four: Competitive Landscape — The Multi-Dimensional Battle

The competitive landscape for agentic coding tools is a multi-dimensional battle. On one side are the cloud giants: Microsoft with GitHub Copilot, AWS with CodeWhisperer and Amazon Q, Google with Jules. On the other side are AI labs: OpenAI with Codex, Anthropic with Claude Code. Then there are the startups: Cursor, Replit, Cognition with Devin, Factory. And the open-source ecosystem: Meta's Llama, Alibaba's Qwen, Mistral, combined with agent frameworks like LangChain and CrewAI.

The data reveals a market that is segmenting by customer sophistication. High performers are more likely to build their own solutions, which means they are more likely to use open-source models and frameworks to avoid closed-source API pricing. Average organizations are more likely to purchase vendor tools, which have a higher success rate (67% versus 33%).

This segmentation has profound implications for competitive strategy. The winners will not be the companies with the most impressive AI demos. The winners will be the companies that can help enterprises succeed at building — whether that means providing the infrastructure, the governance tools, the evaluation frameworks, or the consulting services that reduce the failure rate.

The Gartner prediction that 40% of agentic AI projects will be cancelled is the key competitive signal. The market is not just competing on "who has the best tool." It is competing on "who can help customers avoid failure." Security, auditability, and observability are becoming the differentiating weapons.

I have seen this dynamic in crypto. The protocols that survived the 2022 bear market were not the ones with the most impressive technology. They were the ones with the most robust risk management, the clearest governance structures, and the most transparent operations. The Terra/Luna collapse in May 2022 was not a technology failure — it was a governance failure. The code was audited. The risk was not.

There is a hidden competitive dynamic that the public data does not capture. High performers using agentic coding tools to build their own solutions are likely leveraging open-source models and open-source agent frameworks — Llama 3 series, Qwen, LangGraph, AutoGPT — to bypass closed-source API pricing. This is a long-term threat to OpenAI, Anthropic, and other model vendors. The article does not mention this, but it is a critical competitive factor.

The 67% success rate for vendor tools may also include traditional software purchases, not just agentic coding tools. This makes the "buy versus build" comparison somewhat ambiguous. But the directional conclusion — that building is harder than buying — remains valid.

Finally, the fact that 40% of large enterprises are expanding their agent deployments (up from 27% the previous year) indicates that procurement decisions have escalated from "technology selection" to "IT strategy." The competition is shifting from individual developer choices to enterprise architect and CIO decisions.

Dimension Five: Security and Ethics — The Unaddressed Risks

The security risks of agentic coding tools are substantial and underappreciated. Code generation can introduce security vulnerabilities, license violations, and unknown dependency injections. Enterprises sending private codebases to third-party LLMs face data leakage risks. Agents that automatically execute code modifications can perform unauthorized operations. And when a production incident occurs, the responsibility is ambiguous — is it the developer, the vendor, or the AI?

Gartner's identification of "insufficient risk control" as one of the top three reasons for agentic AI project cancellation is the most important security data point in this analysis. It confirms that security governance is not a nice-to-have — it is a project-killer.

The industry distribution of adoption makes this worse. Healthcare at 39% and energy at 38% means that sensitive data is being fed into agentic coding tools at scale. The compliance requirements in these industries are not optional. A code leak in a healthcare system is not just a technical problem — it is a regulatory problem with potentially massive fines.

There is a hidden dynamic here that the article does not address. High-performing enterprises that build their own solutions are likely doing so, in part, to keep their code within their own infrastructure. By using open-source models and self-hosted deployment, they avoid sending proprietary code to third-party APIs. This is a security-driven build decision, not just a capability-driven one.

Agentic coding tools that automatically modify code also create a new attack surface. Malicious prompt injection or dependency package poisoning could be executed automatically by the agent. This is essentially an "AI supply chain attack" vector that did not exist before.

The employee layoff expectation itself is a governance risk. Employees who fear being replaced may resist knowledge transfer, withhold critical context, and sabotage internal build projects. This is a human factor that the technical data does not capture.

I have seen this dynamic in crypto. The protocols that survived the bear market were the ones that took security seriously — not just in their code, but in their operations. The 0x protocol audit taught me that security is not a feature. It is a discipline. The same is true for agentic coding tools.

Dimension Six: Investment and Valuation — The Bubble Question

The investment thesis for agentic coding tools is compelling but risky. On the demand side, 32% of enterprises are shifting to self-building, and 40% of large enterprises are expanding their agent deployments. This is explosive market growth. On the risk side, Gartner predicts 40% of projects will be cancelled, and MIT NANDA shows a 33% internal build success rate.

The market is pricing in the growth without adequately pricing in the risk. The "buy the expectation" pricing model is facing a reality check. The real investment opportunity may not be in the most prominent AI coding assistants — it may be in the infrastructure layer that helps enterprises reduce their build failure rate: observability platforms, evaluation frameworks, security governance tools, and private deployment solutions.

There is also a valuation risk for traditional SaaS companies. If enterprises are increasingly building their own software, the addressable market for off-the-shelf SaaS products is shrinking. This is a structural headwind for companies like Salesforce, ServiceNow, and SAP — unless they reposition themselves as platform providers rather than application providers.

The hidden beneficiaries of this trend are the cloud providers and model API companies. High performers that build their own solutions will still need compute and model access. AWS, Azure, GCP, OpenAI, Anthropic, and Google are positioned to capture value regardless of whether enterprises build or buy.

I have seen this dynamic in crypto. The infrastructure layer — the exchanges, the custodians, the data providers — captured more value than the application layer during the 2021 bull market. The same pattern is likely to play out in the agentic coding market. The picks and shovels are where the money is.

The 39% layoff expectation rate also has an investment implication. If labor costs decline as AI replaces workers, the ROI period for AI adoption shortens, which could accelerate agentic AI adoption. This is a positive feedback loop for the market.

But the 33% internal build success rate is a warning. Most of the capital being deployed into internal build projects will not generate returns. The bubble is concentrated in "proof-of-concept" projects that will never reach production.

Dimension Seven: Infrastructure and Compute — The Hidden Constraint

Agentic coding tools are among the most compute-intensive AI applications. A single coding task can require dozens or even hundreds of LLM calls, as the model plans, executes, tests, and iterates. The token consumption is 10-100 times that of a typical chat or Q&A interaction.

McKinsey's finding that 20% of organizations are already feeling AI operational cost pressure is the key signal here. The cost of running agentic coding workflows is not sustainable at scale without significant optimization. Enterprises need low-latency, high-throughput model serving, long-context KV cache optimization, intelligent caching, model routing (small models for simple tasks, large models for complex tasks), and potentially local deployment of open-source models.

The McKinsey partner's advice to treat operational costs as a design constraint is the most practical guidance in this entire analysis. Most enterprises do not think about unit economics when they adopt AI tools. They think about capability. But capability without cost discipline is a path to budget overrun and project cancellation.

The infrastructure requirements also explain why high performers are more likely to build their own solutions. They have the engineering capability to optimize inference costs — through self-hosting open-source models, fine-tuning, and sophisticated resource scheduling. Average organizations do not have this capability, which is why they are more likely to purchase vendor tools.

I have seen this dynamic in crypto. The protocols that survived the bear market were the ones that managed their treasury efficiently. The ones that burned through their capital on marketing and development without a clear path to revenue died. The same is true for agentic coding projects. The ones that treat compute costs as a design constraint will survive. The ones that do not will be cancelled.

The 11% production-readiness rate from Deloitte and the 17% deployment rate from Gartner are partly infrastructure problems. The compute cost and latency of agentic coding workflows have not yet reached the point where they are viable for broad production deployment. This is a technical constraint that will improve over time, but it is a real constraint today.

There is a hidden infrastructure dynamic. High performers with EBIT contribution from AI are more likely to have model deployment and inference optimization engineering capabilities. They can self-host open-source models or fine-tune cloud resource scheduling to reduce inference costs. This is a competitive advantage that average organizations do not have.

Internal build project failures are often caused by underestimating the compute and latency requirements of autonomous agents. Projects that look viable in the planning phase become economically irrational in the execution phase.

Contrarian: The Trap That the Market Is Missing

Here is the counter-intuitive angle that the market is missing.

The build-vs-buy shift is a trap for most enterprises. The data is clear: internal build success rates are 33%, while vendor tool success rates are 67%. The market is telling you that most enterprises do not have the capability to build their own software with agentic coding tools. Yet 32% of them are trying anyway.

This is not a rational decision. It is a herd decision. The same dynamic played out in crypto in 2021, when every protocol was building its own AMM and its own lending market. Most of them failed. The ones that survived were the ones that understood their limitations and focused on their core competencies.

The real winners in this shift are not the enterprises that build their own software. The real winners are the infrastructure providers — the cloud providers, the model API companies, the development platforms, the governance tool vendors, and the consulting firms that help enterprises navigate the build-vs-buy decision.

The 33% vs 67% success rate data is the most important signal in this entire analysis. It tells you that the market is overestimating the capability of the average enterprise to build its own software. It tells you that the "build" trend will generate massive consulting revenue for firms like McKinsey, Deloitte, and Accenture. It tells you that the infrastructure layer will capture more value than the application layer.

And it tells you something else: the 40% project cancellation rate that Gartner predicts will not be evenly distributed. The cancellations will concentrate among enterprises that rushed into building without the necessary engineering discipline. The high performers — the ones with 5%+ EBIT from AI — will survive because they have the systems engineering capability to make building work.

There is another counter-intuitive angle. The security risks of agentic coding tools may actually drive more enterprises toward building their own solutions, not fewer. The fear of sending proprietary code to third-party LLM APIs is a powerful motivator for self-hosting open-source models. This means the security risk is simultaneously a threat and an opportunity — it threatens enterprises that use third-party tools, but it creates demand for private deployment infrastructure.

I watched the ape sell; the code still audits. The same is true here. The market is selling the narrative of autonomous software development. The code — the actual production-ready systems — will tell a different story.

Takeaway: What the Next 12-24 Months Will Look Like

The next 12-24 months will separate the enterprises that understand the build-vs-buy decision from the ones that are following the herd. The ones that treat operational costs as a design constraint, that prioritize security and governance, and that honestly assess their own engineering capabilities will survive. The ones that rush into building without discipline will join the 40% of cancelled projects.

For the crypto industry specifically, the implications are profound. Agentic coding tools will transform smart contract development, but they will also introduce new security risks. The protocols that adopt these tools without rigorous auditing and governance will be the next victims of the next bear market.

In the audit, we find the truth that price hides. The price of agentic coding tools is the promise of autonomous software development. The audit — the production-readiness data, the success rates, the cost pressures — tells a different story. The technology is real. The discipline is not.

Strategy is the bridge between chaos and profit. The enterprises that cross that bridge will be the ones that treat agentic coding tools as what they are: powerful but immature technologies that require significant engineering discipline to deploy successfully. The ones that treat them as magic will be the ones that lose their capital.

Trust the protocol, verify the exit. The protocol is the technology. The exit is the production deployment. Verify it before you commit.

We trade the code, not the culture. The code is the production-ready systems that actually work. The culture is the hype, the herd mentality, the fear of missing out. Trade the code. Ignore the culture.