I’ve been thinking about whether it still makes sense to practice algorithms in an era where the model just writes them for me.
For most of programming’s history, the hard part was producing the code. You had a problem, you sat down, and the bottleneck was getting from “I understand what needs to happen” to “the thing exists and works.” Practice meant getting faster and more correct at that production step. Skill meant being able to make the thing.
AI has mostly collapsed that bottleneck. Production is nearly free now. So the bottleneck has moved — to judgment. Choosing what to build, recognizing whether what was built is any good, reframing the problem so the build is easier in the first place. These were always part of the craft. They just weren’t the part that distinguished people, because everyone had to get through the production step first and that’s where most of the failure lived.
Now the failure has moved upstream, and the gap between people who can supervise the model well and people who can’t is becoming the gap that matters.
The uncomfortable middle
The obvious move, if you’re starting out today, is to skip the production step. Why grind through writing your own sorting algorithm when the model writes it instantly and correctly? Why solve a hundred LeetCode problems when each one is a single prompt away?
The problem is that judgment is residue. It’s what’s left after you’ve produced things yourself, badly, many times. You can’t taste-test code well if you’ve never written code badly. You can’t tell when a generated solution is subtly wrong if you’ve never been subtly wrong yourself in the same way. The intuition that says “something is off here” is built from a felt history of being off and then finding out.
Which means the practice that builds judgment is the same practice that AI just made economically unnecessary. The cheap thing to do (let the model produce) actively undermines the expensive thing to become (someone who can judge what the model produced).
This is awkward, because it sounds like a defense of doing things the hard way for nostalgia. It isn’t. It’s just that the residue is real, and you don’t get it for free.
Practice for the residue, not the output
I think the honest reframe is this: when I sit down to practice now, the output is not the point. The model can produce a better version of the output in a second. What I’m doing when I solve a problem by hand is building the internal library that lets me supervise the model later. The output is a byproduct.
This sounds like a small distinction but it changes a lot. “I could’ve just asked Claude” stops being a reason not to do the exercise — it was never the point. And the value of practice doesn’t depreciate when production gets cheaper, because the residue is the thing being produced, and the residue doesn’t get cheaper. If anything, it gets more valuable, because fewer people have it.
It also means you have to be deliberate. Practicing for the residue looks different from practicing for the output. You go slower. You pay attention to why the move worked, not just that it worked. You ask the question from the first post — what was the small clever move here, and where else might it apply — because that question is what turns one problem into residue that transfers.
What’s left of craft
Every generation of programmers has had a layer below them they didn’t fully understand. Assembly, memory management, compilers, frameworks. AI is just the next layer. The question isn’t whether to use it — of course you use it, it’s the most powerful tool we’ve ever had. The question is where you plant your feet. What’s the layer you refuse to outsource, because that’s where your judgment lives.
For me, the answer is something like: I want to be able to do it myself, even when I don’t. I want to be the person who chose to delegate, not the person who couldn’t have done it anyway. Those two people look the same on a good day. They look very different on a bad one.
The first post in this thread said skill is residue, and residue comes from practice. The residue was always the point. It’s just easier to see now.