Yesterday I was saying that my mental model of AI hasn’t changed since 2024 — and mid-sentence, I realized that it had.
What I thought LLMs were
Back in 2024 I formulated, for my own sake, what LLMs are:
AI is a natural-language retrieval mechanism for the whole corpus of human knowledge and culture.
The corpus is huge: all our textbooks, code, teachings, writing in every form. And it was already broadly available online. The retrieval mechanism is what makes it revolutionary: natural language and reasoning have unmatched efficiency at retrieving, reformulating and applying this knowledge. Asking “which conceptual ideas and methods could be applied to this problem?” is an order of magnitude faster than hunting for applicable answers in books and course materials.
This is an enormous result. Suddenly we are a species with immediate access to all of our culture and knowledge, in its most applicable form. That changes who we are, and it changes the relation between an individual and the culture.
It also changes the work of every knowledge worker. Mainstream, mid-level expertise is now cheap. As a human expert, people won’t pay you to get it anymore. What grows in value is the edge: risky, experimental, niche, extremely nuanced expertise, as well as unique contributions and unique voices. Our goal should be to become a source of edge expertise, and to speed-run our way there by using AI to navigate the existing corpus quickly.
I still believe all of that. But it’s not the whole picture.
What I now think they are
Models don’t just retrieve the corpus. They extrapolate it into a whole world of meanings around it: a dense cloud in which any question we ask finds an answer.
The caveat: this cloud contains multiple worlds.
It’s a metaphor, but bear with me — it’s useful. Our corpus of writing doesn’t describe one real world. LLMs deconstruct a much wider set of “worlds” from it. All of them are inferred from our writing. Many of them are plausible. Only one is real: the one where conclusions reproduce in reality.
Our job as knowledge workers is to pin down the real-world subspace as we work with LLMs.
Verification is the pin
Of course, I’m talking about verification. And it means two things:
Internal: giving the LLM a mechanism to test that a solution doesn’t just look right, but actually does what we hoped it would do. Run the code, apply the algorithm in realistic context, test user behavior.
External: a separate set of tests that we can use to check the solution ourselves - that LLM doesn’t have access to.
This means we can no longer afford to work the way we sometimes did before: doing things without understanding what they are for. We can no longer skip the “how do we know it’s what we hope it is” part.
You know the old parable of the blind men and the elephant: each touches one part, and each confidently declares the elephant a snake, a fan, a tree trunk. Partial evidence, wrong conclusion. LLMs hand us the inverse problem. Everything checks out: elephant ears, elephant nose, elephant legs, and it still can’t take you for a ride in a jungle. Every part passes inspection, and the whole is still from the wrong world.
Only the ride tells you which world you’re in.
Verification in practice
Example: we decided to build a design system and a harness to improve the quality of our UI. We built it all. But what’d the verification in this case?
Is the new code using our design tokens and components?
Is the use of colors and custom html being refactored away?
This is where many teams would focus on and build observability and healing loops for their harness, but is it what we hoped would happen? It’s actually not giving us any measures of quality of the UI improving. The goal is never just to build a tool and ensure that the tool is being used. We build it to improve something for some people. For example:
Are there fewer UI errors (and are we really tracking all of them properly)?
Are there fewer a11y problems (and same Q about observability of this)?
Are there fewer UI bug reports and what do people say about it in usability surveys and so on?
These types of questions are the ones we should ask ourselves from the get go. They are more important than ever.
If you’re building tools
The truly valuable tools and products are those that not only use AI, but those that streamline verification. Think about this:
What’s the cost of verification for generated solutions in your domain? Where checking an answer is cheap and automatic, margins will collapse fast. Where checking is slow, expensive, or physical, value will end up with whoever owns the verification channel. Ask “what does it cost to check an answer here?”
The verifier is the product. It surely can be.
Verification events are the new network effects. They compound and become the source of value.
Own data that helps verification, especially the records of outcomes: what shipped, churned, failed. Perhaps you own it already!If you build developer tools, this is probably what you are thinking already.
The ride
Generation is free but the real elephant is still rare. The one action the blind men never took but you can: take a ride in the jungle!