The AI-Fication Of Everything

Adding AI to your product isn't the same as improving it.

AI isn't creating an innovation boom. It's exposing how little rigorous problem-thinking was happening to begin with.

A lot of what's shipping right now is useful. But useful and innovative aren't the same thing — and the gap between them is where the most interesting questions live.

What we're seeing across the industry is an evolution in interface, not a rethinking of the problem. AI search. AI writing assistants. AI copilots layered into tools that already exist. A chat box here. A "help me write this" button there. The product looks different. The underlying problem it's solving often hasn't changed at all.

That shift in interface matters — it makes software more fluid, more accessible, easier to interact with. But fluency of access isn't the same as depth of solution.

That's not a criticism of AI. It's a diagnosis of how we're applying it.

We've seen this pattern before.

The web started as a digital version of things that already existed. Brochures. Directories. Catalogues. Newspaper archives. Web 1.0 was the internet pulling the old plough — taking what existed in the physical world and putting it online. Useful, yes. Transformative in access, yes. But the underlying model hadn't changed. You were still consuming the same things, just through a screen.

Web 2.0 was the reframing. Social networks, user-generated content, platforms built around participation rather than publication — these weren't faster versions of what came before. They were different questions entirely. Facebook wasn't a digital noticeboard. YouTube wasn't a television channel. They created entirely new behaviours, new economies, new social structures that couldn't have existed in any previous medium. The technology finally stopped imitating the past and started imagining something new.

AI right now is deep in its Web 1.0 moment. We're taking existing workflows and wrapping them in LLM interfaces. We're layering intelligence onto the status quo rather than reimagining what the status quo could become. That's not a failure — it's how every major technology finds its footing. But it's worth being honest about which phase we're in, because mistaking the imitation phase for the innovation phase is how we end up optimising the wrong things.

The question worth sitting with is: what's the AI equivalent of Web 2.0? What becomes possible that couldn't have existed in any previous form — not just faster, not just more accessible, but genuinely new?

Most products aren't trying to answer that question yet. Most are still pulling the old plough.

There are two different problems here — and they need different thinking.

The first is about building from scratch. When you're starting with a blank canvas, the fundamentals haven't changed. Start with the problem. Understand it deeply — not the surface version of it, but what's actually broken and why. Then decide what to build, and whether AI belongs in it at all. That discipline should be constant regardless of how fast the tools let you move. Speed of development is one of the genuinely great things AI unlocks for builders. But speed in the wrong direction is still the wrong direction.

The second — and this is where the real issue lives — is about improving existing products. This is where the thinking tends to break down most visibly.

When a team looks at an existing product and asks, "How do we add AI to this?" they've already made a mistake. They've started with the answer. The question they should be asking is: what are our users actually struggling with, and is AI genuinely the right way to address it? Those are different questions with different answers — and skipping the first one produces exactly what we're seeing everywhere: AI that's present in a product without being purposeful in it.

I've seen this up close — in codebases, product specs, roadmaps. The AI layer gets added not because it unlocks a meaningfully better solution for the user, but because it signals that the team is paying attention to the moment. The underlying problem the product was supposed to solve remains largely untouched. The chat box just sits on top of it.

Most AI products today are still in the tractor-pulling-old-ploughs phase.

When tractors were invented, the first thing farmers did was use them to pull the same old ploughs. Same process. Just motorised. It took years before anyone asked a better question: what does farming look like if you start from what the tractor makes possible? The combine harvester — which reaps, threshes, and processes grain in a single pass — wasn't an improvement on the old way. It was a reframing of the whole question.

That's the shift that's missing from most AI integrations right now. Not "how do we add AI to what we already do?" but "given what AI makes possible, what should we be doing differently — and for whom?"

The difference matters. One question produces a chat box. The other produces a genuinely different product.

The category error worth naming.

Not every problem is an AI problem. Many are automation problems. Some are just system problems — solvable with clearer thinking, better process design, or a well-placed rule. Reaching for AI first isn't ambition. It's often avoidance of the less glamorous work that would actually fix the thing.

There's also a reliability argument that gets overlooked. Deterministic logic — if a user does X, do Y — is reliable, permanent, and introduces zero ambiguity. Replacing that with probabilistic inference introduces uncertainty into interactions that didn't have any. That's not always an upgrade. Sometimes it's complexity dressed as intelligence.

The honest question to ask about any AI integration is: Does this genuinely change what the product is able to do for the user, or does it just change how the product feels to interact with? Both can be valuable. But they're not the same thing, and conflating them is how we end up measuring AI adoption instead of user outcomes.

Where AI actually earns its place.

The version of AI that lives up to its billing is narrower than the current hype suggests. It's when AI changes what a product is able to attempt — not just how fast it does what it was already doing. When it makes something previously impossible possible. When it surfaces things users couldn't have found on their own, connects data in ways no interface could have structured manually, or handles complexity that would have required significant human effort to process.

That version of AI is genuinely integrated — not bolted on. It's present because the problem required it, not because the roadmap did.

It's also the version that rewards the hard thinking upfront. The products that use AI most effectively tend to be the ones where the team spent the most time understanding the problem before they wrote a single line of AI code.

The filter I apply to any AI integration: does this change what the product is able to do for the user, or does it just change how it feels to use? Both can be valuable. But they're not the same thing — and knowing which one you're doing is the difference between a feature and a solution.

The real shortage.

We're not short on AI-powered products. We're short on honest problem-definition — and that's exactly why so much of what ships feels like AI for the sake of it.

The most innovative thing a product team could do right now might be to ask one question before the next integration: what problem are we actually solving, and does AI genuinely belong in the answer?