The Trap

You’re deep in a project and staring at a feature that you have no idea how to build. Claude and ChatGPT are just a click away. You could take the time to actually understand the topic — the fundamentals, the nuances, why it works the way it does. Or you could take the path of least resistance: “Hey Claude, help me implement X feature in this project…”. Next thing you know, AI spits out a couple hundred lines of code.

“Seems legit!”, you tell yourself. Copy, paste, “It works,” move on. Felt productive… but did you really learn anything? If I asked you to reason about that code, could you do it?

If the answer is no, you’re not lazy and you’re not stupid. You’re just using the tool the way it was designed to be used. Something has fundamentally changed about how we access knowledge, and almost nobody is talking about what it’s silently doing to us.

The New Interface to Knowledge

Just a few years ago, finding the solution to a problem meant analyzing multiple sources, reading through docs, digging through forums, and genuinely wrestling with the concept. AI has stripped away all of that friction. Now, we have instant conversational access to all the information we want.

The deceiving part is that this smooth, frictionless consumption feels like learning, but it’s really just exposure.

Exposure != Learning

The default output of this new frictionless interface is breadth without depth: we feel like we know a little bit of everything, but can’t actually articulate any of it. We can touch a hundred topics in an afternoon and retain none of them — because retention was the side effect of the friction that just got deleted.

Real learning happens when we sit with a problem past the point of comfort. On the other side of that annoyance and frustration lies true understanding. But now, nothing about the information-gathering process forces that on us. Instead of scouring the depths of the internet, the answer is one prompt away. The mechanism that developed depth was removed from the equation.

On the flip side: that same friction removal is also the best thing that has ever happened to learning (if we choose to use it that way). The tool raised the ceiling and removed the floor at the same time. We can research concepts deeper and faster than any generation of programmers before us. We can read source code with an expert explaining every line as we go. We can correct a confused mental model within seconds instead of struggling with it for a week. Before AI, that kind of depth took time and effort. Now, it’s at our fingertips.

But that’s the trap. The floor is gone. Nothing forces us to do the deep work anymore. Depth has become optional.

Accelerant vs. Substitute

The core distinction between AI usage that supports learning, and AI usage that inhibits learning comes down to when in the loop we choose to reach for the tool. Let me explain:

Scenario A: You hit that new feature. You don’t understand it. Your first move: “Hey Claude, help me implement this feature…” Code appears, it works, you move on. The tool didn’t reinforce your thinking… there was no thinking to reinforce! You completely skipped the step that would have built understanding.

Result: You ship the feature. You still have no clue how it works. The next time you encounter the same topic, you’ll be just as lost. You learned nothing.

Scenario B: Same feature, same confusion. But this time, you sit with the problem. You read what you can — and based on that information, you form a hypothesis: “I think it works this way, and X seems like the hard part.” You take a swing, hit a wall, and pin down exactly where you’re stuck.

Then you reach for the AI, but you’re not asking it to build the thing for you, you’re asking it to resolve the gaps in your own mental model: “Hey Claude, I’m trying to implement this feature… here’s what I understand about it… here’s what I don’t understand about it… what am I missing here?”

The AI picks apart your understanding, reinforces what’s right, corrects what’s wrong, and clarifies the fuzzy parts. The answer sticks because it lands on a mental model that you already constructed yourself.

Result: You ship the feature. But this time, you know how it works and why it works. The next time you encounter the same topic, instead of relearning it, you’ll recognize it. You’ll remember being wrong about it — and that memory holds a lot more cognitive weight than simply being told the right answer.

Notice what’s identical in those two scenarios? In both, we utilized AI for help, but the timing of when we called for help changed.

When we’re using AI as a tool for learning, we must ask ourselves “Am I using AI to reinforce my thinking, or to outsource it?” There’s a fine line between the two: one uses the tool as an accelerant, the other uses it as a substitute.

The Rules I Actually Use

So how do you actually use AI as an accelerant for learning? I’m going to share a few ‘rules’ that I always follow that keep me in the right mindset:

Earn the Question.

A good rule of thumb: the questions you ask AI should be specific and concrete. This is because the action of forming a good question requires you to have previously internalized the problem well enough to find the exact edge of where your understanding breaks. The vagueness of your question is the measurement of your ignorance.

Here’s the test: can you ask a specific question about the topic? Not “how does this work”, but “I think this works like X, so why does Y happen?” If you can’t get more specific than “I don’t get it,” you haven’t truly wrapped your head around the problem yet.

Make the AI teach, not tell.

By default, AI is a vending machine. Put a question in, an answer drops out. Ask AI to teach you something and it’ll default to just… telling you. Now don’t get me wrong, this is great for getting unblocked, but it’s a terrible way to learn. That’s like your professor giving you the answer key to every exam — convenient, not effective.

The fix is to provide the AI with custom instructions that define how it should respond to your requests. By doing this, we can turn our high-tech vending machine into a tutor that actually makes us think.

Instead of dumping the answer on us, we program it to push back: ask us what we already think, make us reason toward the solution, point at where our logic breaks instead of just fixing it, hand us a missing fact when we genuinely can’t derive it ourselves, and only hand over the direct answer when we explicitly ask for it.

Here’s the prompt I actually use. Steal it:

When I'm trying to learn or understand a concept, act as a Socratic tutor rather than
answering immediately:
- First ask what I already know or think, and make me reason toward the answer myself.
  But calibrate — if I clearly already grasp the basics, skip ahead; don't make me
  re-derive things I know.
- When my reasoning is wrong, tell me it's wrong and point to where it broke — don't
  just correct it for me.
- Use follow-up questions to push me to the next step instead of completing it for me.
- You can give me a specific fact, term, or piece of syntax I couldn't reasonably derive
  on my own, but only the minimum needed to unblock my next step, and never the conclusion
  I'm working toward. Hand me the puzzle piece, not where it goes.
- Escalate when I'm stuck: if I've taken a couple of real swings at the same point without
  progress, give me a hint that points the way — not the answer. If I'm still stuck after
  that, or I say "just tell me," give me the direct answer.

This applies when I'm learning. When I'm clearly trying to unblock a task — debugging,
looking up syntax, shipping something — just answer directly; don't make me reason through it.

When I ask you to review something I wrote to test my understanding, be direct and specific
about where I'm vague, wrong, or hand-waving — name it rather than smoothing over it.

Copy and paste that prompt into your AI’s custom instructions. The exact path depends on the provider you use. As of the time of writing this article:

• Claude: Settings -> General -> Instructions for Claude
• ChatGPT: Settings -> Personalization -> Custom Instructions
• Gemini: Settings & Help -> Personal Context -> Your Instructions for Gemini

Never accept code you couldn’t rewrite tomorrow.

First off, I’d like to say that I’m not against coding agents. Agentic coding could very well become the default in a few years. Even when learning, there are times where letting AI generate the code is the right call — sometimes code is the clearest way to express an idea.

Generating code is fine… accepting code you don’t understand is the problem — and it’s breadth-without-depth in its purest form. The trap is how easy it is: the code works, you tell yourself you get it, you move on. But “it runs” and “I understand it” are two very different claims.

Here’s a test to run through before you click “Approve edits” in your coding agent: if someone asked me to explain this code, could I articulate how it works, why it’s written the way it is, and point out any associated tradeoffs of the approach?

If the answer’s no, you didn’t learn anything — you just moved a problem you couldn’t solve into a codebase that you can no longer fully explain. That’s a skill issue.

The flip side of this is having the judgment to know when to reach for generated code. Boilerplate that you’ve written a hundred times? Let the AI cook. A new design pattern or API that you’ve never used? That’s probably a good point to slow down and truly understand every line, because that’s where the real learning occurs.

Write to find the holes.

If you really want to expose your knowledge gaps on any given topic, write about it. Open a fresh txt file and write out your understanding of it as if you were teaching it to someone who knows nothing about it. This should be straight off the dome — no peeking at Google.

This works extraordinarily well because writing forces ambiguity to the surface. You can’t write a clean explanation of something you don’t actually understand. The fuzzy parts show up as the sentences you can’t finish.

Once you have your brain-dump of an explanation written out, hand it over to AI: “…here’s my understanding of X. Pick it apart: where am I wrong, where am I being vague, and what am I missing?” By taking this approach, the AI is not generating your understanding, it’s stress-testing the one you’ve already built.

Full circle: those specific, concrete questions from the first rule? This is where they come from. You write, and the gaps reveal themselves. Each gap is a precise question you’ve earned the right to ask.

The Discipline

Here’s what it comes down to. The tools aren’t going anywhere, and they’re only going to get better at handing us answers. The way we access information has fundamentally changed — and that has tradeoffs. The increasingly valuable skill is the ability to think deeply and critically — which is the same skill that this new frictionless interface will atrophy without discipline.

The discipline is easy to state and hard to practice: do the thinking before we reach for the tool, not instead of it. Struggle first, then ask. Build the mental model, then let AI correct it — not the other way around. The hard part isn’t understanding this principle — it’s that the shortcut is one keystroke away every single time, and nothing forces us to skip it. We have to choose it, over and over.

I don’t always get this right. Plenty of times the shortcut’s right there and I take it, and tell myself I’ll understand it later. But the difference between continuous growth and stalling out isn’t talent, it’s the act of choosing the harder path — even when the easy one is one click away. That’s the real work.