.png)
It’s hard to have a conversation in the software (and broader investment … and well frankly, entire …) world these days without AI dominating the agenda. Much of the narrative centers on the disruption of traditional software: the so-called “SaaS-pocalypse,” where AI eats the existing software stack and leaves a trail of stranded assets in its wake. I understand the instinct, but I think the narrative is too simple and quite misleading.
My view is that many existing software companies are actually quite well-positioned going forward — not all, but many. And that is not despite AI, but actually because of it!
That’s not to ignore the very real risks. Competition is increasing from all directions: AI-native startups building from scratch, large incumbents deploying AI at scale across their platforms, and well-capitalized growth-stage players all racing toward similar market opportunities. That’s not to mention the LLMs themselves, for companies directly in their line-of-sight.
But competition has always been part of the software world, and the code has rarely been the actual moat. In fact, we started RAC 10 years ago built in large part on the idea that code was cheaper and easier than ever to develop. Today the tools available to write code, and execute on other business activities, are more powerful than ever and are in many ways democratizing the ability to write code. But what differentiates software companies in this world is what they’ve built around that codebase: their domain expertise and depth, their distribution, their trust with customers, their brand, and their ability to leverage whatever tools are available to solve a real problem for their customers. And that is the part that is hard to replicate.
Over the next few posts, I’ll dig into several key points of differentiation for encoded software in the growing world of AI. For my first topic, I want to start with a concept that I don’t think gets nearly enough attention in the current conversation: the fundamental difference between probabilistic and deterministic systems, and why it matters enormously for software defensibility.
AI Is Probabilistic — by Design!
Let’s start quickly with what a large language model (LLM) is. Highest-level, it is a tool. Just like any other tool — like a hammer or a screwdriver. Obviously it’s much more sophisticated, but like any tool, it has its purpose, and LLMs are awesome at what they do well. But also like a hammer that doesn’t work so well at screws, and a screwdriver that ain’t so hot as a hammer, it also has some things it’s not so great at.
At its core, a large language model is a probability engine. It ingests tokens, calculates likelihoods across a vast distribution of possibilities, and produces output. Most of us experience this in conversational form: language in, language out — English to English, English to French, or English to Python — and it’s genuinely remarkable. The same underlying mechanics enable natural language processing, code generation, data analysis & summarization, and a host of other transformative applications.
But that probabilistic nature also defines its boundaries — specifically in processes where the exact result matters, and/or where it has to be right every single time. This isn’t a criticism of AI so much as an honest accounting of where it fits and where it doesn’t.
Think about what that means in practice. You cannot use a probabilistic system to automate a prescription refill in a way that’s reliable enough to trust without human review. You cannot run a regulated financial workflow through a model that produces the right answer most of the time but has a non-trivial chance of producing the wrong one. In these contexts, probability-weighted isn’t a viable operating standard — the consequences of the wrong outcome aren’t mildly awkward, they’re compliance failures, patient harm, or financial loss. For processes like these, you need something deterministic: a system governed by pre-programmed rules and logic, where the same inputs produce the same outputs, often with guardrails, and without variance.
Probabilistic tools have inherent boundaries, and a significant portion of the most valuable business workflows sit right up against those boundaries. Recognizing where those boundaries are is key — both for companies building with AI and for customers and investors evaluating them.
Where Incumbent Software Retains Durable Value, in my opinion.
This is one of the key areas where many existing software companies hold their ground. The workflows encoded in their platforms weren’t built overnight. They were developed over years, often in close collaboration with customers in regulated, complex, or high-stakes industries, with a deep and exacting understanding of how those processes actually need to run. The logic embedded in that code reflects not just the “what” of the workflow, but the nuances of compliance requirements, edge cases, exception handling, and operational dynamics that are extremely difficult to replicate without that accumulated domain knowledge.
That institutional understanding is genuinely hard to build — and it doesn’t transfer simply because a new entrant has access to capable foundational models. It requires rigorous product management, earned customer trust, and often years of iteration. You can’t prompt your way to it. At least not yet.
The Incredible Opportunity: Marrying AI With Deterministic Workflows
The most interesting product development evolution I’m seeing — including across companies we work with — isn’t about choosing between AI and deterministic software. It’s about combining them! One of the patterns that’s emerging is to leverage the power of LLMs in combination with encoded software. Often the software will call out to the LLMs where needed — sometimes as the natural language interface, or sometimes in specific analytical tasks — but then pair it with encoded deterministic workflows for other parts of the execution workflow. Natural language in; precise, rules-governed output out. The LLM handles the parts it’s great at; the encoded software handles the parts where it’s strongest.
That combination is powerful precisely because it plays to the strengths of both. And for software companies that have already done the hard work of encoding complex domain logic — the deterministic backbone — adding AI on top of that foundation is an acceleration, not a reinvention. In my opinion, the companies that have earned the right to operate in these workflows, and built the software infrastructure to do so reliably, are well-positioned to deliver a next generation of products that couldn’t have existed before, with more value delivered to their customers than ever before.
That’s what makes the current moment interesting, rather than just threatening, for a lot of existing software businesses. The AI wave isn’t washing them away — for many, it’s providing a powerful new set of capabilities to make what they’ve already built considerably more valuable.
In the next post, we’ll look at another dimension of defensibility: the dynamics of encoded software, and what speed and cost to deliver really mean in a world where AI is changing the economics of software development.
