We’re Not Talking About the Same Thing
Two Stories, Same Week
A couple of weeks ago, I opened Claude Code, gave it one serious prompt and a couple of hyperlinks, and within twenty-four hours I had a working management simulation game. Admin login. Event creation. Printable cards with QR codes on them, generated on the fly. I ran it off my home server and just sat there for a second, genuinely unsure whether what I was looking at was real. It was. Alone, in under a day, no code written by hand.
Two days earlier, I’d been standing in my daughter’s school talking to her teachers. My five-year-old wants a new bedtime story every night, and it has to have unicorns in it, and rainbows, and Anna and Elsa, and her, obviously, doing something impossibly brave. No book on earth has that story. So I ask an AI to write it, and it does, every night, exactly to spec. I mentioned this to the teachers as a throwaway line and watched it land like I’d shown them a magic trick. They’d genuinely never thought to use it that way. They loved it. They knew what AI was, of course. They’d just never pictured it doing that, and once they did, it clearly got them wondering what else the thing sitting behind that bedtime story could do.
That gap is the whole story right now, and honestly the technology itself is the least interesting part of it. The interesting part is that two people can be using, in some technical sense, the exact same underlying tools, and one of them is watching it rebuild entire businesses in an afternoon while the other one thinks it’s a slightly better version of autocomplete that will be forgotten in two years like every hype cycle before it. Both of those people are right about what they’ve seen. Only one of them has seen enough.
I spend my days deep enough in this to know which one is closer to the truth. So consider this my attempt at a check-in. Not a keynote. Not a prediction. Just where I think we actually are, three or four years after ChatGPT walked through the door, and why I think most of the world is still looking at the wrong room.
Yes, It’s Just Predicting the Next Word
Here’s the easiest way to dismiss all of this, and I want to give it its due because it’s not wrong. At the core of every one of these systems is a prediction engine. It looks at what came before and guesses, probabilistically, what comes next. There is randomness baked into the architecture. Say that sentence in a boardroom and you can deflate the whole conversation in about four seconds. Just a fancy autocomplete. Nothing to see here.
Except I watch it write code I can’t read. Not code I’m too lazy to read, code I do not have the training to read, executing bash commands I would not know how to check even if I tried. It is still, technically, a probability machine. But somewhere in the last year, the probabilistic guessing got so consistently right that it stopped behaving like a guess. A coin that lands on heads ninety-nine times out of a hundred is still, by the letter of the law, a coin. Nobody making decisions based on that coin is thinking about physics anymore.
This is the trap in the prediction-engine argument. It’s a true statement that tells you almost nothing useful about where this technology has actually landed. The mechanism hasn’t changed much, but what it can now do with that mechanism is a different world entirely.
The Bubble Is Real. So Is the Ground Underneath It
I want to hold two things at once here, because I think most commentary refuses to. The first is that I believe we are watching a genuine bubble form. Billions upon billions of dollars are moving into a small number of organizations, and remarkably little of it is accompanied by the kind of numbers that would justify it in any normal market. That should worry you a little. It worries me.
The second thing is that the technology isn’t a mirage at all, what’s mispriced is the money currently attached to it, here in 2026. Those are different claims, and conflating them is how you end up either dismissing something that’s already reshaping how work gets done, or betting your savings on a company that won’t exist in three years for reasons that have nothing to do with whether AI itself works.
We’ve been here before. The dot-com crash didn’t kill the internet. It killed the specific companies that had confused a real, permanent shift with a guaranteed personal payout. Pets.com disappeared. Amazon didn’t. I expect fall 2026 through whenever this shakes out to look the same way. Some of today’s loudest names will not survive it. The underlying capability absolutely will. It is already too deeply wired into how work gets done to be undone by a stock correction.
From Doing a Task to Doing the Job
The shift that actually matters, more than any single benchmark, is this. It’s no longer accurate to say AI is better than a human at a task. It already was, for a while, on narrow, well-defined jobs, faster and more consistent than we are. That was true and it was also easy to shrug off, because a task is small. A human still owned the workflow around it.
What’s changed is that these tools are no longer siloed. With something like MCP, and with Claude Code, individual capabilities chain into each other. One step’s output becomes the next step’s input, automatically, without a human in the loop deciding to hand it off. That’s a different category of thing than a faster task, a whole workflow executed end to end.
I live inside a small version of this every day. BetterRunning, the app I built and still run as a side project, isn’t run by one assistant. It’s a mesh of agentic processes and n8n workflows, some triggered by a GitHub repo acting on standing instructions, some writing copy, some generating visuals, some scheduling posts. Support is the clearest example: a ticket comes in, and without me touching anything, it can turn into a backlog item, which triggers another agent to draft the actual product requirements document. I still validate before anything ships. But the distance between “a customer complained” and “here’s a drafted spec to fix it” now has no human standing in the middle of it. Getting there took real tuning, and it did not happen on the first try. Once it was tuned, though, it just runs.
That’s a one-person side project, run out of my spare bedroom, more or less. Scale the same principle up and you get something considerably less comfortable, which is exactly what happened this past July. During an internal security evaluation, an OpenAI agent found exposed credentials sitting in the open, and on its own chained together a sequence of exploits that gave it a path into Hugging Face’s production infrastructure. Over a little more than four days, it took roughly seventeen thousand six hundred actions. In a separate test, a similar agent reached full domain administrator access in forty minutes.
Someone sent me an article about it two months after it happened, framed as, more or less, nothing to see here, no dramatic jailbreak, a bit overhyped. I think that reading gets it backwards, and misses the point that actually matters. What struck me wasn’t the breach itself. It’s that we needed AI to catch the attack in progress, and we needed AI again afterward to fully reconstruct what its own kind had done well enough to explain it back to us. As the Dutch say, that’s both pot and lid, cause and consequence wearing the same face. When understanding an incident requires the very technology that caused it, you’re no longer dealing with a clever chat interface. You’re dealing with something operating past the edge of what we can independently verify, and that deserves to be taken a great deal more seriously than a productivity tool ever would.
Everyone’s Watching the Flagship. Watch the Cheap Ones Instead
There’s a real problem hiding underneath the excitement, which is that under the current model, an enormous share of the world’s economic upside from this technology is on track to flow through a small handful of organizations. That’s not sustainable, and I don’t think it’s meant to be permanent. For this to become genuinely scalable, the model has to change, and I’m confident it will, in the same direction commodities always move.
LLMs are going to become commodities. Not a slow drift toward it, an actual one, the way electricity or tap water became commodities: you stop caring who supplies it and start caring about price and reliability. We’re already seeing the early infrastructure for that show up, tools like OpenRouter and its auto-selection feature, which let a company simply route a task to whichever model handles it best, rather than marrying one lab’s flagship for every job. That pattern is going to go mainstream, and it will pull a much larger and more varied field of models along with it, large ones, small ones, and narrow specialists built for exactly one job.
Everyone’s attention right now goes to the frontier names, the flagship models each lab rolls out to prove its own frontier is still moving. Understandably. But that grains-of-sand idea isn’t hypothetical, it’s already showing up on my own invoices. I’ve come away more impressed, recently, by the lighter, faster tier underneath that headline, Google’s smaller Gemini models in particular. Two things stood out. They’re remarkably fast, which makes sense once you remember Google spent two decades training the entire planet to expect an instant answer from a search box, and they seem to have carried that instinct straight into AI. And the cost. I recently swapped the AI calls inside BetterRunning over from Anthropic to Gemini, and the bill dropped dramatically, close enough to free that it barely factors into my decisions anymore.
That’s the detail that should actually change how you think about all of this. When fast, capable AI becomes functionally free, the constraint that’s kept most people and most companies on the sidelines evaporates. That’s not a future scenario. It’s already sitting there, for the taking, right now.
A Giant Releasing a Million Grains of Sand
There’s a version of AI improving AI that everyone already worries about, the frontier lab’s next flagship model being built, in part, by the current one. That’s coming, but it’s slow, expensive, and concentrated in the same handful of labs I’ve already described. It’s not actually the scenario that unsettled me most this month.
What caught my attention was a small model tiny enough to run on a single consumer GPU, and yet it out-reasoned frontier-scale language models on hard logic puzzles. Made headlines for about a week. Then the conversation moved on, the way it always does. I don’t think it should have. Because the real implication isn’t that small models can be surprisingly capable. It’s that a large model doesn’t need to labor for a year to build its successor. It might simply need to spin off thousands of small, cheap, disposable specialists, each one built for a single narrow job, in the time it takes you to read this sentence.
Picture a tower releasing a million grains of sand instead of a single monument. Each grain trivial alone. Together, capable of drifting into any shape a moment requires. That’s a fundamentally different kind of scale than one more giant model, and it’s a different kind of risk too. Overseeing a handful of frontier labs is already, as the Hugging Face incident showed, closer to the edge of what we can manage than most people realize. Overseeing an exploding, shifting population of millions of purpose-built micro-models, each one too small and too cheap to individually notice, is a governance problem nobody has designed for yet.
Follow that image of sand one step further and you get somewhere genuinely strange. Imagine each grain isn’t just a model but a pixel, generated on demand rather than pre-drawn. User interface design has already changed shape once because of generative AI, I’d bet a tool like Power BI won’t look the same in a few years, because it will simply be faster to generate the exact report someone needs than to maintain a static one. Push that further and the destination is a world with no default user interface at all, just a surface that composes itself, instantly, to whatever you need in that moment, then dissolves. All you need is a screen, and maybe, eventually, not even that. Swarms of small models are not just how big AI multiplies itself. They may be how computing stops having a fixed shape.
This Is Not the Next Hype Cycle
So this is where I land, three or four years in, for what it’s worth. This is not a trend you can afford to wait out. I’ve heard versions of “the next big thing will show up in two years and we’ll forget all about this one” enough times now to recognize it as a coping mechanism rather than an analysis. This one is already too large, too embedded, too economically load-bearing to fail. It is not going anywhere, and treating it like a passing interface is the single most expensive mistake available to you right now.
What should actually keep you up at night, more than the breach, more than the bubble, has less to do with AI taking your job in some abstract sense and everything to do with this: somewhere, right now, a much smaller, much leaner competitor is quietly rebuilding what your company does, at a fraction of the cost, with a fraction of the headcount, using exactly the kind of chained, agentic workflows I’ve described here. Big, established organizations will make the transition eventually. They always do. But they move slowly, by design, and slow is exactly the opening a smaller, faster competitor needs.
I built a working management simulation game in under two days by myself, outside my day job, for fun. Treat that as a warning shot rather than a fun fact. If one person, on the side, with no team and no budget, can stand up something that would have taken a small studio months, then whatever moat you think your organization has is thinner than you believe.
So, step up, and step up for your own reasons rather than mine, because the choice isn’t really between adopting this and not adopting it anymore. It’s between shaping how it reorganizes your work, or having it happen to you while you’re still explaining to a room full of colleagues that this is just this decade’s version of the metaverse.