AI has changed the first question in a build-versus-buy discussion.
A working internal tool can now appear in days instead of quarters. A small team can connect an interface to company data, automate a workflow, and demonstrate value before a conventional procurement process has finished collecting requirements.
That is a real economic shift. It does not mean that custom software has become free.
AI reduces the cost of producing a first version. It does not remove identity management, data governance, integrations, incident response, monitoring, user support, compliance, upgrades, documentation, knowledge transfer, or eventual retirement.
The critical question is no longer only:
Can we build this?
It is:
Can we own this for as long as the business depends on it?
The Build-Versus-Buy Boundary Is Moving
Several 2026 studies suggest that organizations are reconsidering software purchases because AI makes internal development more accessible. They do not show that building is always cheaper or better.
| Evidence | Reported signal | What it does not prove |
|---|---|---|
| Stack Overflow Developer Survey 2026 | Overall, 18.6% of respondents said they build software to replace paid vendors. Among that vendor-replacement cohort, 54.4% reported using AI for those builds. | The 54.4% figure is not the share of AI builders replacing vendors. Neither result establishes that the internal replacement succeeded or produced lower lifecycle cost. |
| McKinsey State of AI 2026 | 32% of respondents said their organization had decided against at least one software purchase or feature because agentic coding tools enabled an internal build. | The survey is self-reported and does not show that each internal replacement produced lower lifecycle cost. |
| Retool Build vs. Buy Report 2026 | Among 817 Retool customers and builders, 35% said they had replaced at least one SaaS tool, while 60% had built something outside IT oversight. | Retool's sample is product-adjacent and should not be generalized to every company. |
| Temporal State of Development 2026 | In a selected sample of 554 AI-agent users, 92.3% said they had tried to rebuild software they previously bought. | The sample consists of active agent users and is not representative of all engineering organizations. |
| Gartner forecast | Gartner forecast that up to $234 billion in enterprise application spending could be exposed to agentic AI through 2030. | This is a forecast about exposed spending, not observed savings or completed replacement. |
| Technology in Society model | A scenario-based study found that build-versus-buy break-even points change substantially by use case, scale, utilization, infrastructure, specialist labor, and deployment horizon. | The model is not an econometric test and does not establish one universal threshold. |
The direction is clear: AI lowers the barrier to attempting a build.
The outcome is less clear. Creating software and owning software are different economic events.
Build Cost Is a Moment. Ownership Cost Is a Stream.
A prototype concentrates cost near the beginning. Ownership distributes cost across every month the tool remains useful.
This distinction is easy to miss because the first visible result arrives quickly. A team sees a functioning workflow, compares it with a vendor subscription, and concludes that the license has been replaced.
The comparison is incomplete.
| Lifecycle stage | Cost that AI can reduce | Ownership cost that remains |
|---|---|---|
| Prototype | Boilerplate, interface creation, initial workflow logic, test generation | Problem definition, acceptance criteria, data access decisions |
| Production readiness | Some implementation, migration scripts, documentation drafts | Architecture review, security controls, permissions, auditability |
| Integration | Connector code, mapping logic, API clients | Contract changes, schema drift, rate limits, failure recovery |
| Operations | Diagnostic suggestions, runbook drafts, monitoring code | On-call responsibility, incident response, availability commitments |
| Evolution | Refactoring suggestions, upgrade assistance, feature scaffolding | Prioritization, regression risk, user support, compatibility decisions |
| Retirement | Migration utilities, data export scripts | Replacement selection, record retention, user transition, decommissioning |
The license price of purchased software is visible. The ownership cost of internal software is distributed across engineering time, operational attention, risk, and opportunity cost.
That distribution can make custom software look cheaper than it is.
Buying Software Buys More Than Features
A vendor does not only sell a screen or workflow. The price may also cover hosting, backups, security work, uptime processes, documentation, regulatory commitments, compatibility updates, customer support, and a team that remains responsible when key employees leave.
Not every vendor delivers these capabilities well. Buying can create lock-in, poor integration, inflexible workflows, and escalating fees.
But replacing a vendor means accepting the obligations that the vendor previously carried.
If no one names those obligations, the company has not removed the cost. It has made the cost less visible.
Every Internal Tool Creates an Ownership Contract
The contract may never be written, but users behave as if it exists.
Once a workflow becomes part of finance, support, sales, engineering, or customer delivery, the business expects it to remain available and correct. The team that built it becomes responsible even if the original project was described as an experiment.
| Ownership obligation | Required owner | Failure when ownership is implicit |
|---|---|---|
| Product decisions | A named business and product owner | Features accumulate without a durable reason to exist |
| Security and access | Security, platform, and application owners | Permissions drift and sensitive data reaches the wrong users |
| Reliability | An operational owner with escalation paths | Failures become emergency work for whoever still understands the code |
| Integrations | Teams responsible for both sides of each boundary | API or schema changes silently break critical workflows |
| Knowledge continuity | A team, not one individual | Departure of the original builder turns the tool into an orphan |
| Lifecycle and retirement | A budget owner and decision forum | Low-value software survives because no one is authorized to remove it |
AI can make the initial implementation accessible to more people. That makes explicit ownership more important, not less important.
The risk is not that employees will build useless prototypes. The larger risk is that useful prototypes quietly become unsupported production systems.
The Shadow Software Portfolio
Retool reported that 60% of its surveyed builders had created something outside IT oversight during the previous year. The same report found that only 8% used AI-generated code without changes and 44% said they tested thoroughly before deployment.
Those figures describe both sides of the shift.
People can solve real problems without waiting for a central software program. They also recognize that generated output still needs review and adaptation.
The organizational problem begins when locally useful tools become business dependencies without entering an inventory, receiving a risk classification, or gaining a funded owner.
A company may believe it reduced SaaS spend while simultaneously creating:
- more repositories to maintain;
- more credentials and data paths to govern;
- more integrations that can drift;
- more operational knowledge concentrated in individuals;
- more systems competing for the same engineering capacity;
- and more software that no budget explicitly funds.
This is not an argument for centralizing every small automation. It is an argument for matching governance to consequence.
A personal script and a revenue-critical workflow should not face the same process. They should also not be treated as if they create the same ownership obligation.
When Building Is the Right Decision
Building can be the better choice when software represents a genuine source of differentiation.
A company may have proprietary data, unusual workflows, specialized regulatory constraints, or integration requirements that generic software cannot serve economically. Internal development can also prevent vendor lock-in and make changes possible on the company's schedule.
The decision becomes stronger when:
- the workflow is strategically differentiating;
- requirements are stable enough to support sustained investment;
- proprietary context materially improves the outcome;
- the organization already has the necessary engineering and operational capabilities;
- user demand is broad or intensive enough to absorb fixed costs;
- and there is a named team that will own the system after launch.
AI changes the threshold at which building becomes plausible. It does not remove the threshold.
Build, Buy, or Combine Both
The useful decision is rarely ideological. It is a choice about where the company should carry complexity.
| Approach | Strongest fit | Primary advantage | Primary risk |
|---|---|---|---|
| Build | Differentiating workflows, proprietary context, unusual integrations | Maximum control over behavior and evolution | Long-term engineering and operational ownership |
| Buy | Commodity capabilities with mature vendors and standard requirements | Faster adoption with externalized maintenance | Lock-in, limited customization, and recurring license cost |
| Hybrid | Unique orchestration around stable vendor capabilities | Custom value without rebuilding every foundation | Boundary complexity and dependency on both internal and external systems |
| Retire or avoid | Low-value workflows with weak demand or unclear ownership | Prevents new software from becoming permanent overhead | Teams may continue manual work unless the underlying process is redesigned |
Hybrid approaches are often underrated.
A company can buy identity, payments, messaging, observability, or workflow infrastructure while building only the logic that differentiates the business. It can also preserve an escape path by keeping data portable and integrations explicit.
The goal is not to maximize the amount built internally. The goal is to own the right complexity.
Total Ownership Economics Need a Longer Window
Comparing a yearly SaaS invoice with the hours required to generate a replacement is not a total-cost comparison.
A more useful assessment includes:
- initial implementation and migration;
- security and compliance work;
- infrastructure and model usage;
- testing and verification;
- support and incident response;
- dependency and integration upgrades;
- ongoing product changes;
- documentation and knowledge transfer;
- opportunity cost for the engineering team;
- and eventual replacement or retirement.
The recent Technology in Society study makes the same general point through a scenario model: break-even thresholds vary with use case, number of users, utilization, infrastructure costs, specialist labor, maintenance assumptions, and time horizon.
Its results should not be copied as universal benchmarks. The useful lesson is that there is no single build-versus-buy threshold.
The economics depend on what is built, who uses it, how long it survives, and what it takes to keep it trustworthy.
The Decision Must Be Measured After Merge
Before launch, most build-versus-buy models depend on estimates. After launch, repository history begins to provide evidence.
GitMe does not replace procurement analysis, security review, compliance, SRE, or financial total-cost modeling. It adds a missing engineering perspective: what happened to the work after it entered the codebase.
| Leadership question | GitMe signal | Interpretation | Possible action |
|---|---|---|---|
| Is AI creating real leverage or only more output? | AI Leverage | High leverage is valuable only when the resulting work remains useful and does not create disproportionate correction work | Compare leverage with rework and survival patterns |
| Did the internal tool create meaningful engineering value? | Real Effort Value | High value indicates substantial engineering contribution, but not automatically good lifecycle economics | Connect engineering value with business adoption and operating cost |
| Is speed creating a verification or maintenance tax? | Rework patterns | Repeated correction may reveal weak requirements, unsafe generation, or rushed review | Improve context, tests, review boundaries, and coaching |
| Is the system becoming easier or harder to change? | Refactoring patterns | Persistent reactive refactoring can indicate structural debt or changing requirements | Revisit architecture, ownership, or the build decision |
| Does the work continue to survive in the product? | Effort Survival Cohort | Durable survival supports the case that effort continued to matter after merge | Compare cohorts across teams, repositories, and internal products |
The signals become more useful together.
- High AI Leverage, low rework, and durable survival suggest a build that may scale responsibly.
- High AI Leverage and high rework suggest a hidden verification or maintenance tax.
- High Real Effort Value followed by weak survival may indicate a large investment that did not remain useful.
- Low AI Leverage with strong survival may represent deliberate specialist work, not poor performance.
- Rising refactoring around the same boundaries may show that ownership cost is growing faster than visible feature value.
These are investigation signals, not individual performance rankings.
The purpose is to find where a tool needs better context, stronger review, architectural attention, a clearer owner, or a renewed build-versus-buy decision.
A Better Operating Model for AI-Built Software
Organizations do not need a heavyweight approval board for every automation. They do need a path that becomes more rigorous as consequence increases.
A practical model includes:
- Inventory what exists. Record the owner, users, data access, repository, integrations, and business dependency.
- Assign a risk tier. Base governance on data sensitivity, operational impact, external exposure, and reversibility.
- Name the long-term owner. The creator is not automatically the durable owner.
- Fund the lifecycle. Budget for support, security, integration changes, and retirement, not only initial delivery.
- Keep commodity foundations external when appropriate. Build differentiation instead of rebuilding every layer.
- Review the decision periodically. A rational internal build can later become a rational purchase, consolidation, or retirement.
- Use engineering evidence for coaching. Investigate rework, refactoring, leverage, and survival without turning the data into a simplistic leaderboard.
The operating model should make useful experimentation easier while preventing experiments from becoming invisible infrastructure.
The Cheapest Software to Create May Be Expensive to Own
AI has made software creation cheaper, faster, and available to more people. That is an important advantage.
It also makes it easier to create more systems than an organization can responsibly own.
The build-versus-buy decision now requires two separate judgments:
- Is this capability worth creating internally?
- Is this organization prepared to own it after the first version works?
A convincing demo answers the first question only partially. Durable value depends on the second.
The companies that benefit most from AI-built software will not be the companies that generate the most applications. They will be the companies that know which applications deserve ownership, measure what survives after merge, and retire what no longer earns its place.
See Whether In-House Software Creates Durable Value
GitMe connects AI Leverage with Real Effort Value, rework, refactoring, and Effort Survival Cohort so leaders can distinguish durable internal software from maintenance debt.
Start with GitMeRelated GitMe Reading
- AI Speedup Is Not AI Value
- AI Can Refactor Code and Still Make It Harder to Maintain
- AI Didn't Eliminate Engineering Work. It Made It Invisible.
- The New Engineering Bottleneck Is Verification, Not Coding