AI isn't making me dumber (it's making me discover more)

There’s a pessimist take you hear a lot: AI is going to do our work and, little by little, make us dumber. If the model writes the code, reasons about the design and remembers the API for us, why would we learn anything at all?

After a few months using AI daily in development, my experience is the opposite: it makes me learn more, not less. But I don’t want to sell you hype, so let me start by giving the pessimist their strongest version —stronger than usually admitted— and then explain why, even so, I think they’re wrong.

The pessimist take, in its strong form

Let’s be fair. The pessimist isn’t talking about you on your best day; they’re talking about the average case and the long run, and there they have ammo:

• Juniors. Someone who has never fought a problem by hand can learn to ask for the solution without ever learning to solve it. The skill never forms.
• The long run. Just as GPS can leave you with no sense of direction, delegating daily can leave you without the reflexes you thought you had. The damage doesn’t show in a month; it shows over years.
• Willpower doesn’t scale. “I’ll verify later, I’ll understand later” sounds great until the deadline hits. Under pressure, we all take the easy path: copy, paste, move on. And that’s exactly the mechanism the take describes.

If your answer to the pessimist is “just use it well,” you’re conceding the point: for most people, “using it well” isn’t the default.

What’s happening to me

All that said: in my case AI hasn’t replaced my judgment, it has accelerated it. I use it less as an oracle that spits out solutions and more as another developer sitting next to me —one who has read the entire documentation, remembers the specific API, and answers in a second what would take me half an hour to look up.

With someone like that beside you, you don’t stop thinking. You think better and faster. The question is why it adds up for me and subtracts for the pessimist. The answer isn’t that I have more willpower. It’s method.

Its best card: discovering what you didn’t know existed

The biggest change isn’t that AI solves what I already know how to do. It’s that it shows me what I didn’t even know existed.

Large, mature platforms are full of under-advertised capabilities, modules that don’t show up in the first tutorial, out-of-the-box ways to do something you’d been hand-rolling. Finding that used to be down to luck: a colleague who mentioned it, a buried forum thread, hours of Google. Often you never got there, because you can’t search for what you don’t know exists.

AI collapses that distance. I describe the problem in plain language and it tells me “the platform already has X for this”. From there I go to the official docs, verify it and understand it. It doesn’t hand me a blind answer: it hands me the name of the door I didn’t even know was there. And this —unlike almost everything else— isn’t “faster Google”: it’s access to something I might never have found.

What you can delegate and what you can’t

This is the key to the long-run argument. Not all knowledge is equal:

• Lookup knowledge —exact syntax, a method name, which table a field lives in—: delegate it without guilt. Every abstraction layer in history “deskilled” the one below, and nobody mourns not writing assembly.
• Judgment —why a design holds, which edge case breaks it, what fits your architecture—: never delegate.

The right question isn’t “does something atrophy?” (something always does), but “does the thing that matters atrophy?”. Used well, AI takes the lookup and frees you for judgment. Used badly, you hand over the judgment too —and there the pessimist is dead right.

It’s not willpower, it’s method

The pessimist’s strongest point is that discipline fails under pressure. They’re right, so the solution can’t rely on virtue: it has to live in how you use the tool, so that understanding is the byproduct, not extra effort. Three habits that make it automatic for me:

• Predict, then verify. Before asking, I guess the answer. If I’m right, it reinforces; if I’m wrong, I learn exactly what I didn’t know. Asking cold doesn’t teach; checking your prediction does.
• Ask it to explain and cite, not just produce. “Give me the solution and why, with the doc link.” The reasoning comes built in and verifying is one click.
• Use AI to attack my design. “I’m going to do it this way, what breaks?” I treat every output as a hypothesis to falsify, not an answer to accept. I even ask it to argue against me. That defuses the biggest risk —believing a confident, wrong AI— and forces me to defend the why before writing the first line.

None of the three is willpower. They’re a way of asking. And that way can be taught —to a junior too. That’s where “it depends how you use it” stops being an excuse and becomes a plan.

So

I don’t think the pessimist take is false; I think it’s incomplete. It’s right about the average case and the long run if the interaction is designed to produce rather than to teach. But that’s not a law of nature: it’s a choice of method.

So I’m not defending a universal “AI doesn’t make us dumber.” I’m defending something narrower and, I think, more honest:

AI doesn’t make you dumber if the interaction is designed to teach —and that design is the whole ballgame.

In my case, these months have made me discover parts of the platform I hadn’t seen in years, design with sharper judgment, and learn at a pace I wouldn’t have reached alone. Not from more willpower. From asking better.