For most of the last 20 years, there has been a bright line in enterprise technology between software and services. Software was code that scaled: write once, sell it a thousand times. The gross margin of the marginal software customer approached 100%. Services, on the other hand, were people-intensive, professional services: revenue grew only by adding headcount, and the margin was capped by what humans could bill.
The two symbiotic segments lived in different but adjacent financial universes. The market priced each differently, based on growth rates and profitability: software at 5-20x revenues, services at 6-10x EBITDA. Software companies deliberately avoided implementation revenues for this reason and cultivated ecosystems of services players to manage their customers. Software was an empty black box shell that services filled by working with customers. As a result, the best services companies have built durable customer relationships, extensive knowledge and expertise in specialized workflow and are trusted to be the stewards of customers proprietary data assets. The line was structural and reinforced by the public and private markets.
This bright line is being erased, removing the premise that made it a line at all. And because so much of how software and services businesses are valued rests on which side of that line they sit, its disappearance is one of the most consequential and least understood shifts of the AI era.
The software–services line dissolves with AI-native solutions that perform most of the work, subject to human-in-the-loop guardrails.
Why 'vibe coding' doesn't apply to enterprise applications-lessons from the open source world
The line was never really about code versus people. It was about a functional divide: software coordinated work, and services performed it. A CRM did not sell anything — it tracked the salespeople who did. An HCM system did not manage anyone — it recorded the managers who did. Enterprise applications organized, routed, and stored the work; the work itself, the judgment and the doing, stayed with humans, and humans were sold as services. That divide is what produced the margin and multiple gap. Coordinating is inherently scalable; performing, when a person does it, is not.
The development of open source software offers an interesting parallel that has revolutionized infrastructure and middleware software but has not gotten traction in applications for good reason. AI-native solutions bundle autonomous software with an embedded service layer to sell an outcome rather than a tool, capturing the full value of the job to be done; the open-source model does the opposite, offering commodity software for free and pushing integration, customization, and maintenance onto a systems-integrator whose margin sits in labor, not in the result. That trade-off works beautifully at the infrastructure and middleware layers--think of Linux, Kubernetes, Postgres, Kafka--because those components are standardized, stable, and invisible to the end user, so the value migrates to whomever integrates and operates them.
This dynamic breaks down at the application layer for structural reasons:
- applications are dynamic, evolving continuously with the business, whereas a customize-once services engagement produces a static artifact that drifts out of date the moment requirements change;
- applications are visible, sitting at the point of differentiation and brand, where enterprises want to own the experience rather than deploy a commoditized clone their competitors also run;
- applications are highly outcome-accountable, and open source deliberately disclaims the warranty and SLA;
- applications are data- and feedback-driven, not well suited to free, forkable code
Open-source software has commoditized the infrastructure and middleware layers of the technology stack, but it has consistently failed to penetrate the application layer — and artificial-intelligence "vibe coding" is likely to repeat that pattern for the same reasons. Infrastructure rewards convergence, technical buyers, and operational monetization — precisely the conditions under which the open-source model excels. Everyone benefits from the same Linux kernel, the same Postgres database, the same Kubernetes orchestrator, so contribution concentrates, a canonical standard emerges, and the value migrates to whoever integrates and operates the commodity layer. Applications invert those conditions.
Value resides in differentiated design, continuous iteration, a proprietary data and feedback loop, and an accountable party who will sign a service-level agreement, indemnify against a breach, and commit to a roadmap. The volunteer-plus-support model supplies none of these reliably, which is why open-source applications remain marginal wherever they compete with well-capitalized incumbents. The market evidence is unambiguous: the leading commercial open-source CRM holds under one percent share (SugarCRM at roughly 0.93 percent against Salesforce's category dominance - citation), and LibreOffice, the leading open-source office suite commands roughly four one-hundredths of one percent of tracked deployments (citation).
Vibe coding, the generation of functioning applications from natural-language prompts, fails the bar for enterprise applications because enterprise software was never gated on the cost of producing code. It is gated on everything surrounding the code: security, maintainability, auditability, integration, and contractual ownership. The risk is measurable. Independent tests published by Veracode found that 45 percent of AI-generated code introduce exploitable security vulnerabilities (see study and here). Such risk collides with the accountability and compliance requirements that have long excluded open source from mission-critical, differentiated, continuously evolving enterprise systems.
How software's relationship to work performed changes with AI-native solutions
The moment software can perform the work rather than coordinate it, the divide between software and services collapses from both directions. A "software" product now delivers what used to require a "service": the contract isn't tracked, it's drafted; the claim isn't routed, it's adjudicated; the schedule isn't stored, it's analyzed and re-sequenced. The output that a person used to produce — billed as a service — now comes out of the software. The category label stops describing anything real, because the same company is, functionally, both.
The convergence runs in two directions at once, which is why it's so disorienting to value. Services firms are moving up into software: productizing the judgment that used to live in their people, so that expertise which was once delivered by the hour is now delivered by a system at near-zero marginal cost. And software firms are moving down into services: extending their products to perform the work their customers used to do by hand. They are meeting in the middle, at a new category that is neither — AI-native software that does the work a services firm used to do, with the economics of software and the value proposition of labor.
In practice, the convergence rarely produces a fully autonomous product, especially in the regulated, high-consequence domains where the work is worth the most. It produces a hybrid: software performing the volume and the pattern recognition, with human judgment held at the points where accountability, ambiguity, and relationships live. This is the human-in-the-loop model, and it is the literal embodiment of the vanishing line — a single offering that is part software and part service, sold as one thing, priced as one thing, and impossible to file cleanly under either heading. The best AI-native companies don't choose between software and services. Their combination is the AI-native solution.
Which software and services players get caught in the middle
If a company is functionally both software and services, VC valuation logic that underwrote a generation of deals stops working. Value it as pure software and you overstate the scalability, because there's a human-judgment layer that doesn't compress to zero. Value it as pure services and you badly understate it, because the software layer genuinely does scale and performs work that used to require more skilled knowledge workers. The result is a next-generation hybrid with a margin structure that starts with services-like gross margins but the opportunity for long-run software margins as the automation deepens. The target revenue opportunity is far greater than the software opportunity alone and by tapping the labor market, vertical niches that might have been too small to justify the cost of supporting a niche software product can now support multiple solutions providers. Niche markets that were too small for SaaS might be large enough for AI-native solutions.
The disappearing line is an opportunity for some businesses and a death trap for others. The difference between winners and losers is a through-line in the AI era. A company with genuine domain depth is better positioned than ever. With proprietary data, regulated-industry expertise, an embedded customer base, it can move across the old software-services boundary in either direction and train a better algorithm: its services capture the data that trains the AI-native software, and its software deepens the customer relationships that anchor the services. A company without that depth - e.g., a horizontal software application like a project management tool or a plain-vanilla services company like a value added reseller (VAR) or business process outsourcer (BPO) - gets squeezed. A horizontal, generic software layer is vulnerable to an agent replicating it; a generic services low value-added services or labor-arbitrage services shop is vulnerable to an agent just replacing it. The disappearing line eliminates the artificial category convention that protected these generic horizontal players from competing directly against automation.
