DEV Community: Kartikey Mishra

What Do We Even Mean by AI?

Kartikey Mishra — Sat, 12 Sep 2026 18:19:31 +0000

I read Dario Amodei's post about slowing down the AI frontier, and Sam Altman's reply saying OpenAI's been having the same internal conversation. The safety angle is real, but what actually stuck with me was a dumber question underneath it: what do we even mean by AI?

Everyone's throwing around agents, reasoning models, AGI, ASI, like the ground under these words is solid. It isn't. The meaning of “AI” has always moved as soon as computers got good at whatever we were pointing at. Computer chess is the cleanest example, Deep Blue beating Kasparov in '97 was treated as a landmark for machine intelligence. Today's engines are far stronger than Deep Blue ever was, yet nobody looks at one winning and thinks “this is intelligent.” They think “that's a chess engine.” The machine didn't get dumber. We just stopped being impressed and reclassified the whole category as computation instead of intelligence. Calculators, OCR, recommendation systems, spam filters, same arc, over and over.

So when people say AGI is five years away, or two, I want to ask: five years from what, exactly? If AGI means outperforming humans at most economically valuable work, that's one target. If it means learning any intellectual task the way a human can, that's another. And if it means something with actual understanding, emotions, or self-awareness, that's arguably a different kind of problem, not a further point on the same curve, but a different curve altogether. People swap between these definitions mid-conversation constantly, usually without noticing.

This is where physics is a useful contrast. Throw a ball up, it comes down, measurable, testable, no committee needs to agree on what “falling” means first. Intelligence has never had that kind of settled definition, and I don't think we're close to one. It's not one thing. It's learning, memory, planning, abstraction, language, adaptation, probably a dozen things we haven't even cleanly separated from each other yet.

The self-awareness question is the one I keep getting stuck on personally. Say a system gets absurdly good, solves hard math, writes large software systems, runs research, explains its own reasoning in detail. Does any of that tell you whether there's something it's like to be that system, or just that its behavior has become indistinguishable from a system that genuinely would? I don't know. I'm not sure anyone has a test for it yet.

Which is honestly why the “we need to slow down” framing caught my attention in the first place. It might be a completely sincere safety concern, I hope it is. But it also quietly tells you something else: we've gone far enough that pacing ourselves is now a serious conversation. That's not nothing. Companies don't usually announce they're slowing down unless the announcement itself does some work.

Maybe the technology really is approaching something new. Or maybe this is the same pattern AI has always followed, get excited about a capability, give it a big name, then quietly redefine the name once the capability stops feeling special. I genuinely don't know which one this is.

What I do know is I'm less interested in guessing a date than in figuring out what would actually convince me a system is intelligent, rather than just extremely good at producing the outputs associated with intelligence.

AI #AGI #ArtificialIntelligence #AIResearch #Technology

When Scale Beats Cleverness

Kartikey Mishra — Wed, 09 Sep 2026 17:52:22 +0000

I read Rich Sutton’s The Bitter Lesson the other night, and one idea kept bothering me in a good way.

It made me think about a LeetCode problem I’ve probably solved fifty times: two numbers in an array that add up to a target.

The obvious solution is a loop inside another loop, checking every possible pair.

It’s slow. It’s not particularly clever. But it works.

Then you learn the usual better approach: use a hashmap, reduce the complexity, and move on.

That comparison kept coming back to me while thinking about Sutton’s argument.

A lot of AI history can be viewed through a similar lens. We spent years trying to build the “smart solution” by encoding what we knew about the problem directly into the system.

For chess, that meant increasingly sophisticated ways of representing positions, evaluating moves, and incorporating human chess knowledge. For vision, it meant manually designing features and trying to capture the structure we believed mattered.

These approaches weren't stupid. Quite the opposite—they were often extremely clever.

But there was another direction that kept becoming more powerful: give the system a general mechanism for search or learning, and then scale the resources behind it.

Deep Blue is a good example. Its strength didn't come from reproducing the way a grandmaster thinks. A huge part of its advantage came from being able to search an enormous number of positions.

AlphaZero took a different route. Rather than being built around human chess knowledge or trained on a database of human games, it learned through self-play and search.

That distinction is what made the nested-loop analogy interesting to me.

In DSA, brute force is usually something you escape from. If you have the same problem and roughly the same input size, the nested loop doesn't become a fundamentally different algorithm just because computers get faster.

AI operates under a different constraint.

The scale keeps moving.

Compute increases. Data increases. Models get larger. Training becomes more practical. Systems can run experiments and searches at scales that simply weren't available before.

So an approach that looks absurdly inefficient at one point in time can become surprisingly effective when the available scale changes.

The important lesson isn't simply that “brute force beats intelligence.”

It's that human cleverness and machine scale behave very differently.

A human can spend years designing better rules, features, heuristics, and representations. But all of that is constrained by what we already know about the problem.

General methods have a different property: they can keep benefiting from more computation and more experience without requiring us to explicitly specify every useful piece of knowledge.

That's the part of The Bitter Lesson that I find most interesting.

We tend to associate progress with making the system more sophisticated from our perspective more knowledge, more rules, more carefully engineered components.

But some of the biggest shifts in AI have come from doing less of that and putting more emphasis on methods that scale.

The nested loop is still the nested loop.

What changes is the machine running it, the amount of computation behind it, and the scale at which you're willing to run it.

And once I started looking at AI through that lens, I began noticing the same pattern in a lot of places.