AI and Learning: What Actually Helps You Learn, and What Just Creates the Illusion of Progress

AI Made Learning Cheaper, Not Necessarily Better

The old barrier was simply finding an explanation. Making sense of an unfamiliar topic meant digging through a couple of textbooks, scrolling forums, asking someone who already understood it, and waiting for a reply. Today an explanation is available in seconds, in any quantity, from any angle you ask for. The problem didn't disappear, it flipped direction: there's now so much information available that the sheer volume itself gets in the way.

John Sweller described this back in the 1980s in Cognitive Load Theory: working memory is a narrow bottleneck with a hard cap on throughput. Feed it too much finished material at once and part of it never makes it into long-term memory, no matter how good the explanation was or how clear it felt in the moment. AI didn't solve this problem, it made it worse: you can now get an exhaustive, neatly structured answer to any question in a couple of seconds, and that volume immediately becomes something you have to deal with.

The main guide on how to learn with AI covers working techniques for specific tasks: prompts, spaced repetition, study plans. Here I want to dig into a narrower and, I think, more important question. When explanations were scarce, information itself was the scarce resource, and almost any step you took with it automatically demanded effort: find it, read it through, work it out. Now an explanation is nearly free, and that's exactly why the scarce resource quietly became something else.

The Real Test: Does It Still Work If You Remove AI?

Before going through specific scenarios, it's worth pinning down the test I'll be applying to each one below, because the usual metric doesn't cut it. "AI saves time" says nothing about what you actually learned: you can save an hour and walk away with zero skill that outlives closing the browser tab.

The working question is different: after talking with AI, am I now able to do this myself, without it? If yes, that step was learning. If no, it was consuming a finished result, and there's nothing shameful about that as long as you're honest with yourself about it. What's not fine is calling it learning when it wasn't.

This test isn't just a personal hunch. Freeman and colleagues' 2014 meta-analysis (PNAS, 225 studies across STEM courses) found that students in classes with active engagement scored about 6% higher on exams, and were roughly 1.5 times less likely to fail the course than students in passive lecture-based formats. Both groups heard roughly the same material. The difference came from whether the student actually worked with that material themselves, out loud and on paper, rather than just absorbing it by ear.

What Actually Works

AI as a Personal Tutor

The difference between "explain topic X" and a working tutoring scenario isn't in the quality of a single answer, it's in the loop itself. A working exchange looks like this: explanation → comprehension check → review of your answer → a targeted hint if you're stuck → a harder version of the problem if you got it easily. A one-off "explain this" delivers information. The loop forces you to apply it, and application is what turns information into a skill.

This isn't a new idea, it's an old effect at new scale. In 1984, Benjamin Bloom described what's now known as the "2 sigma problem": students working one-on-one with a tutor scored, on average, two standard deviations higher than students in a conventional classroom, a gap that's physically impossible to scale to every student when tutors have to be human. AI doesn't invent anything fundamentally new here. It makes the one-on-one format available at close to zero cost, and adapts to your current level roughly the way Lev Vygotsky's "zone of proximal development" describes: don't explain what you already know, and don't jump ahead to what you're not ready for yet.

A technique worth building into the system prompt from the start, not remembering halfway through the conversation: an explicit rule against giving a finished answer until the learner has gone through at least a couple of leading questions. A single "give me a hint, not the answer" at the top of the chat usually gets forgotten by the model a few messages in, especially in a long conversation. Working prompts for specific subjects, and what to do when the model still slips back into handing you finished answers, is exactly what I covered in the piece on setting AI up in tutor mode instead of solver mode.

AI as a Practice Generator

Wherever you need not one example but fifty different variations of the same concept, AI changes the economics of practice completely. The old constraint was the sheer number of exercises physically printed in a textbook: sooner or later you just memorize the specific answers in the back of the book instead of the underlying principle. A model removes that constraint by generating as many fresh variations on the same concept as you want, which makes memorizing a specific answer instead of understanding the pattern much harder to do by accident.

This rides on a mechanism neuroscience has confirmed for decades: spaced repetition and active recall remain the gold standard for retention, going back to the classic work by Jeffrey Karpicke and Henry Roediger showing that trying to retrieve an answer yourself strengthens memory more than rereading a finished explanation. AI doesn't replace this mechanism, it fuels it. That shows up clearly in programming, languages, math, and exam prep: anywhere the bottleneck is volume of practice, not a single flash of insight.

A practice I think is underrated next to ordinary flashcards: generating not abstract textbook problems but simulations and cases tied to your actual work context. Nonstandard test cases built around a specific QA engineer's real assignments instead of a generic checklist. Language dialogues built around the exact professional situation you'll actually be in, not a generic tourist phrasebook.

AI as Feedback

The difference here comes down to one word in the prompt, not the model's capability. "Fix this" hands you a finished patch you can paste in without reading it. "Explain what's wrong here" forces you to understand the diagnosis first, then write the fix yourself, on your own code, essay, or solution.

Paul Black and Dylan Wiliam wrote one of the most cited reviews on this: timely, substantive feedback during the work, not just a final grade at the end, produces one of the largest gains of any educational practice studied, an effect in the range of 0.4 to 0.7 standard deviations, where most educational interventions barely reach 0.2 to 0.3. AI doesn't replace feedback from a real person, but it removes the main practical constraint: a detailed review of your code or writing used to cost another person's time, and you could only get it rarely, not on demand at any hour. A prompt like "find the weak points in this design, but don't rewrite the code for me" keeps the effort on your side and turns the model into a reviewer, not a co-author.

AI as a Comprehension Check

Of all these scenarios, this is the one I use least myself, and probably shouldn't: it catches the gap between "I think I understood" and "I actually understood" better than any of the others. Instead of "explain topic X," the prompt runs in reverse: "Ask me questions about TCP congestion control. Don't explain the answer until I've responded." The model takes the role of the one asking, not you, and that uncomfortable position is exactly what reveals where your understanding genuinely holds up and where it falls apart at the first specific question.

This is a direct application of the Feynman technique: the best way to check whether you understood something is to try explaining it, or to answer pointed questions with no chance to peek at a hint. Another working version of the same idea is reverse roleplay. You take the role of the expert or the interviewee, and the model, playing a skeptical colleague or a nitpicky junior, asks the uncomfortable questions in exactly the spots where surface-level understanding usually breaks down. This is more interesting than the usual chatbot scenario precisely because the model is testing you, not the other way around.

What Doesn't Work, or Works Worse

"Just Solve It for Me"

The most obvious anti-pattern doesn't need a long breakdown. Copying an entire problem statement into a chat and getting a finished solution back is a working way to get a homework assignment done and a zero-percent way to learn anything. In this scenario, the model isn't a tutor or a reviewer, it's an answer key that hands you the result faster than a browser tab full of solved examples ever could. The test from the second section catches this instantly: remove AI from the chain, and what's left where the result used to be is a blank page, not partial progress.

Rereading Instead of Recall

This trap is subtler than "solve it for me," and it works the same way no matter where the finished text came from: a textbook, your own old notes, or an AI's answer. The source isn't the problem. What matters is what you do with the text after you've got it.

Recognition and recall aren't the same thing. Recognition means "yes, I've seen this before, and the text looks familiar." Recall means "I can write this myself, staring at a blank page." The gap between the two is the main source of false confidence in what you actually know. Psychologists call the mechanism behind it the fluency heuristic: if a text reads easily, smoothly, and logically, the brain mistakenly treats that ease of reading as a sign the material has been absorbed. In reality, reading fluency and memory strength are two different, loosely related things. A well-written explanation, wherever it came from, reads smoothly and convincingly, which is exactly why it triggers this mistake more easily than a rough one does. The clearer the text, the less of the friction that normally signals "slow down here and check yourself."

The working defense is simple and doesn't require giving up any tool, notes or AI explanations included: after reading anything, however clear it felt, close it and try to reproduce it in your own words from memory. If you can, that was learning. If you can't, that was reading, and that's fine as long as you're honest about it instead of crediting yourself with having learned the topic just because it read easily.

AI Writes It for You

Most visible in four kinds of tasks: essays, code, homework, research writing. The logic is the same as with reading, but it's built into production rather than consumption. The more of the actual intellectual work gets handed to AI at the drafting stage rather than at the final polish, the less material is left for your own thinking to train on. Structuring an argument, reconciling conflicting sources into one conclusion, catching a flaw in your own reasoning: these are skills that only get trained by actually doing them, and delegating that specific step, not the wording polish afterward, costs more than the time it saves.

The Most Interesting Problem — the Illusion of Learning

Conversations about AI in education usually get stuck on one question: did the model get something wrong. That's a real risk, but not the main one. The main risk is quieter, and it operates even when the model answers with complete accuracy.

The problem from the previous section isn't limited to notes and reading material. It's built into the mechanics of talking with AI itself: any scenario from the first half of this piece, if you run it on autopilot instead of holding it to the "could I do this myself" test, eventually slides into the same pattern. Tutoring dialogue, error review, a practice problem: all of it works right up until the point where you're still the one formulating the answer first. The moment the phrasing consistently arrives from the model first and you're just nodding along because it sounds logical, the line between a working scenario and the illusion of learning disappears, even if every individual explanation the model gave was flawless.

That's the real cost of convenience. Not that AI sometimes gets things wrong, but that a coherent, smooth, persuasive-sounding explanation (which is how AI answers almost all the time) creates a feeling of understanding all on its own, whether or not real absorption actually happened. As explanation quality goes up, this effect gets harder to notice, not easier: a badly written text at least honestly stumbles wherever your understanding stumbles too.

So How Do You Actually Use AI Right

Everything above adds up to one working principle instead of another list of prompts for every occasion: yourself first, then AI, then yourself again.

1. Try it yourself first. Draft the answer, work the problem, write the first version of the code before opening the chat. Not because the first attempt has to be correct, but because it's the attempt that trains the exact mechanism you'll need to check afterward.
2. Use AI for feedback, not for solving. Not "solve this," but "find the mistake in my solution" or "point out where the reasoning goes wrong." The same distinction as in the feedback section above.
3. Take only as much of a hint as you need, no more. One leading remark, not a full explanation with the answer at the end, even when the model politely offers the full answer first.
4. Put together the final version yourself. Don't copy the model's patch wholesale. Rewrite the solution yourself, using what the hint taught you.
5. Test yourself without AI. Close the chat and try to reproduce the solution or explanation from scratch. It's the same recall test from the illusion-of-learning section, just applied to your own work instead of someone else's text.

I didn't arrive at this principle in theory, I arrived at it through my own mistake. When I was writing this site's backend in Rust, for the first couple of weeks, every time I hit a compiler error about lifetimes, I just copied the error text into a chat and asked for a fix. It worked fast: the code compiled, the feature shipped. Two weeks in, I couldn't explain in a separate conversation why one data structure needed an explicit lifetime and the one next to it didn't. I'd skipped all five steps above, and got exactly the result this section predicts: the code worked, and the understanding never showed up.

I had to backtrack. On the next few similar errors, instead of asking for a fix, I asked for a line-by-line breakdown of what the compiler message actually meant and why Rust required that guarantee in the first place. Almost twice as slow on each individual error. But after a couple of weeks of that, I started predicting on my own where the compiler would demand a lifetime, before I'd even written the code and hit the error. Same tool, same model. The entire difference was in what I asked it, and which of the five steps above I actually used.

A good AI learning tool is built so that the more you use it, the less of its help you need for a task of the same difficulty, not one that just answers faster and better every time. That's sharper and more useful than the standard line about "AI as your personal teacher": a teacher you turn to more and more often, not less, would land you in exactly the same place as an answer key.

What Actually Changes

The honest takeaway isn't "AI will replace universities," a catchy headline that explains nothing about the actual mechanism. The more accurate version: AI doesn't change the learning process itself, it changes the cost of personalizing it.

Personal feedback, from a teacher, a tutor, a mentor, or a course with hands-on grading, used to cost real money precisely because it required another person's time. A chunk of that function (explanation pitched at your level, practice with endless variation, first-pass feedback on a draft) is now available nearly for free, on demand. That's a genuine economic shift, not hype: what only a few people could once afford is now available to almost anyone, regardless of budget or where they live.

None of that changes the underlying biology of memory. Hebb's rule, formulated in 1949 and confirmed many times since, is usually summarized as "neurons that fire together, wire together": a synaptic connection strengthens only when a neuron itself generates an impulse, not when information simply passes by as someone else's finished text. No model can do that part of the work for you, because it doesn't happen in the chat window, it happens inside your own head, and only in response to your own activity: recall, solve, write, get it wrong, get feedback, try again. AI can make each of those cycles cheaper and more accessible. None of them can happen in your place.

The Scarcity Shifted

This piece opened with a simple idea: AI made getting an explanation cheap. The old barrier was access to information. That barrier is essentially gone now.

But cheap information doesn't mean easy learning, and everything above is really about that gap. While explanations were expensive and scarce, information itself was the scarce resource, and almost any step of working with it automatically demanded effort: find it, read it through, work it out. Now an explanation is nearly free, and that's exactly why the scarce resource quietly became something else: your own willingness to stop, recall, and try before accepting a finished, smooth, convincing answer as knowledge you actually have.

That's the whole filter from this piece in one line: a tool works for learning if you walk away from it knowing more than you did, not just feeling more certain that you already understand.