AI made practice tools cheaper. So why is deliberate practice still so rare?

You can generate a thousand quiz questions before your coffee cools.
And yet most of us still "learn" by rereading, rewatching and highlighting.

If the cost of practice material dropped to nearly zero, why didn't practice explode? I think it's because content was never the bottleneck, and AI made the wrong thing cheap.

What deliberate practice actually needs

The term comes from Ericsson, Krampe and Tesch-Römer's 1993 paper, The role of deliberate practice in the acquisition of expert performance. Stripped of nuance, their description of deliberate practice includes:

a well-defined task at the right level of difficulty
informative feedback
opportunities to repeat and correct errors
effortful focus, which is not inherently enjoyable

Notice what's not on the list: "a large supply of material". Material is necessary, but it's the cheapest ingredient.

What AI made cheap

Generative tools are excellent at producing:

questions
examples
summaries
explanations on demand

That's real progress. A developer learning a new language can get exercises in seconds. A student can get a practice set for any topic.

But look at the list again. Explanations and summaries feed the rereading habit. They feel like learning. The research on retrieval practice, like Roediger and Karpicke's Test-Enhanced Learning, points the other way: being tested beats restudying for long-term retention, even though restudying feels more productive in the moment.

So the cheapest outputs of AI are the ones closest to the least effective habits.

The four bottlenecks that didn't move

1. Difficulty calibration

Practice has to be hard enough to fail sometimes and easy enough not to quit. A generator doesn't know where your edge is unless something measures it. Most tools don't.

2. Feedback that's about your error

"Here's the correct answer" is cheap. "Here's why your answer was wrong, and what that says about your mental model" is expensive, because it requires understanding the specific mistake. That's the feedback that helps.

3. Repetition with correction

Deliberate practice isn't doing a thing once. It's doing it, getting it wrong, adjusting, and doing it again, spaced out over time. That needs memory of what you got wrong last week. A fresh chat has none.

4. Showing up

The least technical bottleneck and the biggest. Effortful practice isn't fun in the way scrolling is. Abundant material doesn't create a habit; a small, predictable, finishable daily task might.

What this means for developers

This isn't only about students. Think about how we "practice" as engineers:

We read blog posts about patterns instead of implementing them under constraints.
We ask an assistant to write the tricky function instead of attempting it first.
We watch conference talks at 1.5× and remember the jokes.

The deliberate-practice version is less comfortable: write it yourself first, then compare. Do the kata under a constraint you set yourself, like no autocomplete or no looking things up. Get a code review from someone who will point at your specific mistake.

AI is a great second step in that loop. It's a terrible first step.

The uncomfortable part is that the first step is where the learning happens. The struggle to produce something, the wrong turn, the moment you realise you don't actually know how a closure captures a variable: that's the signal. Skipping it feels efficient, and it is, for shipping. It just isn't practice.

What a good practice tool would optimize for

If I were judging any practice tool, AI-powered or not, I'd ask:

Does it make me produce an answer before it shows one?
Does it notice which mistake I made, not just that I made one?
Does it bring back what I got wrong, later?
Does it adjust difficulty based on my results?
Is a session small enough to finish on a bad day?

If the answer to most of these is no, it's a content generator with a practice label.

A one-week experiment you can run on yourself

You don't need a study to see this in your own habits. Pick one thing you're learning right now, a language feature, an API, a framework, and try this for a week:

Days 1 to 3, the usual way. Read docs, watch a video, ask an assistant to explain. Notice how productive it feels.
Days 4 to 7, answer first. Before reading anything, write down from memory how you think the thing works, or write the code without help. Then check, and note exactly what you got wrong.
On day 8, test yourself cold on both halves, without looking anything up.

Write down what you could still do on day 8 from each half. I'm not going to tell you the result, because it's yours, and it will depend on the topic and on you. But I'd bet most people find the second half felt worse and stuck better.

The point isn't the numbers. It's to feel the gap between "this feels like learning" and "I can actually do this now". Once you've felt it, it's hard to go back to highlighting.

Takeaways

Content was never the scarce ingredient of practice. Feedback, difficulty and repetition were.
AI made explanations cheap, which risks reinforcing the rereading habit.
Retrieval (answering first) beats restudying, even when it feels worse.
Use AI as the second step: attempt first, compare after.
Judge practice tools by the feedback loop, not the size of the question bank.