You know what I’ve come to realize my “big” take on AI is?
I think we’re sprinting headfirst down the same path the early inventors took when trying to make a flying machine: staring at birds so hard that they missed the fact that even a sheet of paper can soar when folded the right way.
For centuries, we assumed that if we wanted to fly, we needed to understand how to be like a bird (or an insect, if we’re feeling particularly steampunk).
Wings flap, that’s the rule.
But it wasn’t until we stepped back and started to grasp what flight actually required that the Wright brothers were able to get us going anywhere.
And I keep wondering if we’re at the same point with artificial intelligence.
Maybe it’s the assumptions about “artificial intelligence” as an idea that are holding us back.
“Artificial intelligence” is an extraordinarily broad label, even by the standards of computer science. It can describe everything from a chess engine to a recommendation system to the increasingly human-seeming language models we now casually talk to every day.
Somewhere along the way, though, the term picked up a second meaning: the idea of an artificial intelligence as a thing in itself, some discrete synthetic intelligence steadily approaching the capabilities of a human mind.
The more I think about it, the more I’m unconvinced that this is a useful way to think about LLMs at all.
But if artificial intelligence isn’t a helpful model, then what is?
It’s something I have to spend a lot of time thinking about in my role as CEO of SkillSaige, largely because I have had a direct hand in much of the architecture behind what we build.
That includes plenty of very ordinary software engineering (I am so tired of planning serverless cloud architecture topology) but it also includes some genuinely strange and exciting work around the Logic Lattice technology that powers Saige’s practice scenes.
That has given me an unusually close view of what LLMs actually do once they leave the glossy demo and have to survive contact with a real product.
I also have a fairly deep skepticism of “thought leadership” that exists separately from grounded, applied experience. To me, expertise gets truly interesting only when the abstractions have to hold up inside an actual system serving actual people.
I mean, no matter what you’re doing, eventually the architecture has to work. Costs, latency, reliability, state, user behavior, and all the other deeply unglamorous parts of engineering start applying pressure to whatever story we were telling ourselves about the technology in a vacuum.
And under that pressure I’m left with one, single, profoundly intriguing sense: LLMs are NOT independent artificial intelligences. They’re far stranger than that.
So if they’re not “emerging minds”, then what are they?
The popular framing tends to treat them as emerging artificial minds whose abilities can be measured by how successfully they reproduce tasks we associate with human intelligence (which is a whole other problem: it seems to be increasingly clear that human intelligence is not one neat singular concept at all).
Sure, that framing creates some genuinely useful research questions, but I’m less convinced it gives us a useful engineering model of the technology itself. Intelligence is already a notoriously fuzzy concept when applied to humans, animals, institutions, or groups. Turning it into a single implied quantity that a machine possesses “more” or “less” of tends to carry with it far more assumptions than it resolves.
But more importantly, functional resemblance can be deceptive. After all, we stared longingly at the birds for so long that we missed the actual principles of lift beneath them.
So what are LLMs when we use them in the real world, then?
If I had to imagine how we’ll look at them in 20 years, I keep arriving at a very different comparison than “artificial mind.”
I think, instead, they’re far more likely to be viewed as a new form of fundamental compute.
Think about it: a CPU allows us to perform rapid, discrete logical operations. A GPU optimizes for parallelized mathematical operations, originally necessary for heavy geometric processing that games depend on and now used for so much more. And other specialized processors like quantum processing continue to exist because the structure of a given problem can make one computational approach dramatically more effective and useful than another.
In that frame, LLMs seem to be giving us something similarly unusual. For the first time, we have a system capable of operating directly over the deep relational structure of language in a largely stable and linguistically predictable way, even while its specific outputs are neither deterministic nor even always logical from a common-sense sort of perspective.
Which is not something the purely tech-minded among us have been well-equipped to confront.
“You need to be able to grasp the poetic nuance and layered meaning of language” is not a critique usually heard in computer science classes.
Yes, that all sounds less dramatic than “artificial intelligence.” At least, until you stop and think about how much invisible weight we actually put into language (for better or worse).
Language is weird, and fuzzy. Fluid yet concrete. It carries relationships, assumptions, abstractions, procedure, stories, culture and convention, and all sorts of highly compressed human experience.
Language has always been hard for software (it’s hard enough for humans).
And for most of computing history, software has interacted with it awkwardly and at great expense. We can store it, search it, index it, parse pre-programmed chunks of it, or encapsulate our own assumptions about it in huge rigid structures to let computers emulate our specific perception of it.
But LLMs completely change the shape of that problem.
All of a sudden, we have a broadly applicable computational tool that can accept language as native input, transform it, compare it, infer from it, traverse the relationships within it, and produce functional predictions from massive structures that would be extraordinarily difficult, if not computationally impossible, to encode as conventional software at the scale we’re dealing with.
That by itself is an incredible capability without ever even asking us to decide whether the computer “understands” those structures like a person.
And it raises a much more valuable, and more interesting engineering question.
If LLMs are some early, simulated form of a new computational primitive, what happens if we stop designing every damn system around the assumption that the natural endpoint is a chatbot? What if we start developing airplanes, instead of trying to mimic birds poorly?
Our work at SkillSaige has increasingly pushed me in that direction. Some of the most interesting capabilities appear when the language model becomes one component inside a larger architecture. When we constrain it by conventional software, give it only specific responsibilities, and stop crossing our fingers and hoping it will be “smart enough”, whatever that means. We use it where the fuzzy linguistic nature of it is genuinely valuable, and nowhere else.
There’s this weird paradox we’ve found in our work at SkillSaige: the smaller the box you put the LLM in, the more valuable, more useful, and more genuinely irreplaceable it becomes, even as its percentage of the stack shrinks to sub-single digits.
That architectural shift has practical consequences, too. In our own internal comparisons, SkillSaige’s non-chatbot, skill-practice scenes use roughly 1/30th the LLM processing of a comparable scene built as a primarily LLM-driven system.
Maybe chatbots are where we start, but that doesn’t mean it’s where we should go.
If all that continues (and at least for us at SkillSaige, it certainly appears to be accelerating), then maybe chatbots and agents and all these heavy context-driven systems will eventually look less like the destination we think they are.
Maybe they end up being more like the first thing we thought to build: our modern equivalent of the word-processing terminals of the 1970s that came before the personal computer revolution.