Your AI SaaS will die. That's not the problem.

PCs, the internet, AI: three waves, one mechanic

I watched PCs arrive in the workplace. Within a few years, entire professions had changed shape, and nobody asked permission from the people who practised them.

I watched the internet arrive. That time it wasn't work that changed, it was the world economy: distribution, access to information, the structure of value chains themselves.

And four years ago, I started building against the OpenAI API, before LLMs reached the general public. Back then you had to write code to get anything usable out of it. Today we're talking about AI agents that complete tasks without anyone describing the route in advance. The distinction is worth spelling out, because it sits at the heart of this piece: with automation, you describe the path and the machine executes it. With an agent, you describe the outcome and it finds the path. For the first time, the "how" has left your hands.

Three waves, one mechanic. Each of them removed a barrier, and killed off whoever's value was that barrier.

The PC removed the barrier of calculation and formatting. The internet removed the barrier of distribution and access to information: the middlemen who sold access to the catalogue, the timetable, the classified ads all died. The ones who sold something other than access survived.

AI removes the barrier of production. Production of text, of code, of analysis, of structured reasoning. Publishers who sell access to production will go the same way as the rest.

One difference, and it's a big one: the two previous waves played out over decades. This one is measured in quarters. Which shifts the problem entirely: the question is no longer whether your product will be swept away, but what you'll have built alongside it by the time it is.

"What is the best AI tool?" is a stock question asked of a market that has become a flow

"What is the best AI tool?" is the most asked question on this market, and it has no stable answer.

An AI tool ranking is a photograph. True the day it's taken, debatable three months later, wrong within six. Line up three rankings published six months apart: half the names have vanished, replaced by tools that didn't exist when the first list was written. The problem isn't the quality of the ranking, it's that no answer survives its own publication.

For an AI SaaS publisher, the question is actively dangerous, because it installs the wrong reflex: is my tool good? That's a performance question. It gets reset to zero with every model release, and you don't control that calendar.

The better question sits elsewhere: is my tool becoming hard to leave, for the right reasons?

The distinction matters. The wrong reason is lock-in: no export, hostage data, annual commitments. That holds a customer once, and you pay for it in reputation. The right reason is accumulation: after six months, the tool knows the context, the in-house vocabulary, the history, the edge cases. Leaving is expensive because everything would have to be relearned somewhere else, not because the door is bolted.

There's a third case, sitting between lock-in and accumulation: your place in the stack. An AI tool wired into the CRM, the billing system and the customer's internal data doesn't get swapped out easily, not because the door is bolted, not because anything needs relearning, but because everything would need rewiring. That exit cost is entirely honest: the door is wide open, it's the move that costs money, and it's the customer who piled up the furniture. The strategic consequence is worth stating, because it cuts against instinct: for the same effort, an integration protects you better than a feature. A feature is copied in two weeks. A place in the customer's stack isn't taken back in two weeks.

AI development time has collapsed in both directions

Everyone celebrates the first half of this story. The second half gets far less airtime.

Time to build has collapsed. A useful tool takes three weeks. That's genuinely good news, and it's what makes this period exciting.

Time to be caught has collapsed too. Same coin, other face. Technical difficulty used to be the barrier: if it took you six months to build something, it took the next person six months to reach you. That delay was your competitive advantage, and nobody ever had to name it. It's gone. What's easy for you to do is easy to do against you, with the added bonus, for whoever copies you, of starting from your finished product rather than a blank page.

And a third risk almost nobody saw coming: your customer can replace you themselves. The line between buying and building has moved. A manager tinkering with a coding assistant produces, in a weekend, a version of your tool that does only what they need, in their vocabulary, plugged into their data. It's worse than yours on every count except the one that matters to them: it was made for them.

Then add the competitor who doesn't behave like a competitor: your model provider. With every release, an entire layer of AI tools gets absorbed into a checkbox. This isn't a market battle you win on execution, it's a ceiling coming down. Plenty of publishers think they're competing horizontally when they're competing vertically, with their own supplier.

My estimate, having watched this market for four years: an AI SaaS launched today has roughly eighteen months before its original value proposition is copied, absorbed or made trivial. That's not a statistic, it's a practitioner's order of magnitude. Treat it as a working hypothesis, not a prediction.

The next-model test: does your AI SaaS survive it?

One test tells you where you stand.

If the underlying model becomes twice as good and free tomorrow: do I lose my product, or do I gain margin?

If you lose your product, you're a feature awaiting absorption. If you gain margin, you're a product, and every advance in the model works for you instead of against you.

That's the dividing line between capturing the model's value, reselling access behind a nicer interface, and creating value around it, taking on a business problem end to end, with responsibility for the outcome.

The same logic applies to the customer who could rebuild you: what protects you isn't that it's hard to build, it's that nobody wants to maintain it. A customer can ship a version 1. They don't want the edge cases, the updates when the model shifts underneath them, the compliance work, the Friday-night support, or the liability when the system gets a client file wrong. A tool that's only a feature will be rebuilt in-house. A tool that carries a burden won't. The question becomes: what am I carrying on their behalf that they don't want to carry?

Death by contagion: your customers' inertia is not protection

The natural reflex is to take comfort in slow customers. The ones who don't like change, who've trained their teams, who've wired your tool into their processes. They won't leave. Churn stays low, the dashboard is green.

It's a false signal. A customer who stays because they don't want to change isn't a loyal customer, they're a stationary one. In an accelerating market, standing still has an expiry date.

There are really two clocks. Your product's lifespan, which we've just covered. And your customer's lifespan in their own market. Most publishers watch the first. It's the second one that takes them out.

The cascade always runs in the same order. Your customer keeps an ageing tool, out of comfort. Their competitor adopts faster, ships faster, offers better or cheaper. Twelve months later, your customer is losing market share. They cut budgets, and tooling budgets go first. You lose the customer. You didn't lose them to a competitor of yours: you lost them because they lost.

You don't inherit your slow customers' loyalty, you inherit their lag.

Two practical consequences. First, churn measures whether your customers are leaving, not whether they're doing well: a stable book of business made up of companies losing ground is a book of business dying slowly, and the most reassuring metric on the dashboard is precisely the one hiding it. Second, watch the profile of your new customers. The day they're structurally slower than your first ones, your product has started to die, well before churn moves: the innovators have gone elsewhere and you're serving the back of the pack. Revenue can still climb for another six months. It's already over.

This changes the nature of the product too. A tool that merely wraps itself around a customer's existing habits sustains the lag that will kill them both. Change management stops being a courtesy to the customer and becomes self-preservation.

Three levers to extend an AI SaaS lifespan, and a fourth that builds itself

Which brings us to the question that actually matters: where can you outperform? Three levers, which don't replace each other but take turns over time. And a fourth that isn't quite a lever, because you don't decide it: it settles, as you pull the other three.

Cheap innovation: product roadmap cadence becomes a feature

The collapse in production cost works against you when it comes to being copied. It works for you when it comes to moving, and the symmetry isn't perfect: you start with customers, field feedback and an understanding of the trade. Whoever copies you starts with a screenshot.

Cadence stops being an internal operations question and becomes part of the offer. A customer who sees their tool improve every month doesn't wonder whether to leave. A customer looking at a product frozen for six months starts looking around, or opens a coding assistant to see what it would take in-house.

The point isn't the volume of features shipped, it's staying one notch ahead of the stated need. Shipping what the customer asked for keeps you level with anyone else who was also listening. Shipping what they haven't yet learned to articulate, because you see fifty customers where they see one, is the only lead that can't be copied from the outside. That's exactly what comes out of regular conversations with your users.

That book of fifty customers produces something beyond product intuition: data none of them can manufacture alone. Serve fifty companies in the same trade and you can tell each one where it stands against the others. Benchmarks, reference points, trends spotted before they become visible: the customer building their own version in-house will never produce that asset, by construction, because their sample size is one. This is already accumulation, and it's the fourth lever falling into place without anyone deciding it: a moat that widens with every customer signed, and that no model release can absorb.

Pricing: accept a shrinking margin, and know what it buys

The most counter-intuitive lever, and the most accurate. Put plainly: your price competes with your customer's internal build cost, and that cost falls every month.

This has nothing to do with a conventional price war. At constant value, your price has to come down, because the "I'll do it myself" alternative gets more accessible every quarter. The only way to hold price is to add value faster than the alternative gets cheaper. In practice, the same subscription has to contain more every year, while your infrastructure and model costs rise with sophistication. The margin gets squeezed from both ends.

That's not a defeat, it's the rent you pay to stay in place. With one condition, without which it becomes a slow bleed: the margin you give up has to buy something that accumulates. Deeper usage, context data, references, a healthy dependency. If you shave the margin and nothing accumulates in return, you're funding your own decline.

There is a threshold, and it needs recognising: the day holding margin becomes impossible without stopping investment, it's no longer a pricing problem, it's the end-of-cycle signal for the product.

Reliability, security, compliance: the guarantees AI never accelerated

The most powerful of the three levers fits in one sentence: AI made production instant. It did not make trust instant.

A clone gets built in a weekend. A certification does not. Eighteen months of uptime history can't be bought. Documented compliance, qualified hosting, a clear data handling policy, liability cover, support that answers when everything breaks: none of it was accelerated by the models, because these are assets of time and commitment, not of production.

And it's exactly what the customer building their own version doesn't want to carry. They can do the feature. They don't want to sign for compliance, or be the one people turn to when the system hallucinates on a client file. At that point your value is no longer the outcome: it's being answerable for it.

This gets truer every quarter as the regulatory framework tightens. Most publishers experience compliance as a cost. It's actually one of the few barriers that falling production costs don't erode: in a market saturated with interchangeable AI tools, sorting by reliability becomes the only workable sort. It's also, word for word, the language of the decision-maker who approves the spend.

Pushed to its conclusion, this logic has a commercial endpoint: if your value is being answerable for the outcome, the ultimate pricing model is charging for the outcome rather than for access. A copycat can't follow you there, because it takes a track record and a confidence in your own system that can't simply be declared. That deserves an article of its own; for now, just note that every guarantee you accumulate today is what will make that pricing model possible tomorrow.

Summary table: what each lever protects

The line to remember: innovation buys you months, guarantees buy you years. Most publishers put everything into the first lever, because it's visible, gratifying, and it looks like product work. Then they die of the third. As for that last row, it's the only one whose right-hand column says time is working for you: provided you meant it, rather than merely letting it happen.

AI product lifecycle: accept the ending, prepare what follows

The mental model we all inherited is the heirloom product: you build a product, you grow it for ten years, it becomes a company. That model existed because build time was long and copy time was long too. Both collapsed, and the model collapses with them.

What replaces it is the product with an accepted lifespan. An AI SaaS that lives eighteen months, serves people, makes money, then stops because its reason for existing got absorbed, is not a failure. It's a complete cycle. The failure is spending twelve months defending a dead product out of loyalty to the original idea.

So resilience isn't about holding on. It's about making sure the end of the product isn't the end of the venture. One rule for that: what you accumulate has to live partly outside the product.

The audience and the mailing list belong to you, and they're why the next launch starts with a thousand people rather than zero. A deep understanding of a trade belongs to you, and it's why you spot the next irritant before anyone else, because you've been in those conversations for two years. The reputation belongs to you. The distribution channels belong to you. They're the only assets no model release can absorb.

Hence the real reversal. Don't ask how do I make my product last, ask what's left the day it stops. If the answer is "nothing", the problem isn't your product, it's how you built around it.

And if the cycle is short, waiting for the decline before moving means moving too late. The time to prepare what follows is while the product still works, still earns, and nothing suggests anything needs to change. Which is, psychologically, the hardest possible moment to do it. If you don't make your product obsolete, someone else will, and they won't invite you.

So, what is the best AI tool?

The one worth more on day 300 than on day 1. Not the best performing: the one that accumulated something in between.

For your users it translates simply: the best AI tool is the one that has disappeared into their day, because it knows their context and they can't picture working without it. For you, it's a discipline. Hold the cadence, trade margin knowing what it buys, invest in guarantees that return nothing for a while, and accumulate beside the product the things that will outlive it.

Your product is mortal, and increasingly fast. So are your customers. A publisher's job is no longer to make the product immortal: it's to pull customers forward, and to build alongside it whatever will outlive you both.

One of those assets can be built today, before your product even reaches maturity: visibility with people who are actively comparing tools. That's the role a directory like AI Shortlist plays, and if your tool isn't listed yet, the Submit a tool page is the way in.

Checklist: will your value outlive your AI SaaS?

• If the underlying model doubles in power tomorrow, I gain margin rather than lose my product

• My tool knows something about my users that a competitor cannot reconstruct from the outside

• I carry a burden my customers don't want: maintenance, compliance, responsibility for the outcome

• My new customers aren't structurally slower than my first ones

• The margin I give up each year buys something that accumulates

• I have at least one serious guarantee in place: documented security, qualified hosting, an uptime commitment

• My audience, my mailing list and my reputation exist outside the product

• I know what would be left if I shut the tool down in six months

Six boxes or more: your value doesn't depend on your product's lifespan. Four or five: you've started building outside the product, but a pillar is missing. Look at which empty boxes concern guarantees or outside-the-product assets, because those are the slowest to build and therefore the ones to start first. Fewer than four: your company and your product have exactly the same life expectancy, and that isn't good news.