There's a sentence I keep offering to teams wrestling with what AI assistants have done to their craft, because it reframes the whole debate in seven words: the difficulty didn't decrease — it relocated.
The dominant narratives both miss this. One camp says programming is being solved — describe what you want, accept the suggestion, ship. The other says the tools are overhyped autocomplete. Both camps are arguing about the amount of difficulty, when the interesting change is its address. Programming today is not easier and not the same. It is differently difficult — and the new difficulty is, if anything, the more demanding kind.
The paradox at the gate
Start with the genuinely good news. For its whole history, programming's entry fee was brutal memorization: libraries, syntax variations, error-handling idioms, the thousand incantations that separated people who could make computers do things from people who couldn't. Enormous numbers of capable thinkers bounced off that wall — not because they couldn't reason about systems, but because the recall tax came before the reasoning ever got exercised. That wall is now crumbling, and I won't mourn it. People who think well in problems and structures — but never stockpiled idioms — have a workable path in. The field is opening, and it should.
But watch what happens at the next gate, because this is the paradox that defines the era: as the barrier to producing code falls, the barrier to producing good code rises. Generated code arrives fluent, confident, and plausible — which means distinguishing appropriate from inappropriate, maintainable from brittle, secure from subtly exposed, now demands more discrimination than when all code was handmade and its flaws were at least your own, and legible to you. The old gate kept people out before they could reason. The new gate lets everyone produce — and then quietly separates those who can evaluate from those who can only accept. Judgment turns out to be harder to develop than recall ever was: recall you can grind — flashcards, repetition, immersion. Judgment only grows through experience with consequences: designs that aged badly, abstractions that leaked, incidents traced to a choice that looked fine at review.
Where the hours actually go
The relocation shows up concretely in how development time is spent. Writing accelerates dramatically; checking inflates to fill the freed space. Every experienced user of these tools knows the texture of it: the suggestion appears instantly, then the real work begins — does this handle the empty case, is this the right abstraction for our system, does it respect constraints the model has never heard of, why did it import that? The assistant compresses production and expands evaluation, and evaluation is the activity that was always scarcer.
The novice's struggle has moved up a level accordingly. Beginners once fought syntax errors and API confusion — annoying, but self-announcing: the compiler told you, loudly, when you were wrong. Beginners now fight a subtler battle: assessing whether a working solution is the right solution — aligned with system constraints, maintainable, appropriate. Nothing announces failure there. The code runs. The flaw waits. And the studies of AI-assisted learners capture the trap in miniature: faster task completion, more visible progress, and self-reported confusion about how or why the solutions work — output racing ahead of comprehension, with actual learning gains measuring small and unstable.
Medicine already lived this transition, and the parallel is exact. Diagnostic technology lowered the burden of memorizing obscure clinical minutiae — and raised the stakes on interpretation, judgment, and error detection. Nobody argues the scanner made doctoring easy. It made the residual human contribution more intellectually concentrated, not less. Programming is undergoing precisely that redistribution.
The skill nobody can grind
This relocation has an uncomfortable implication for how our industry develops people. We are excellent at teaching recall-shaped things: syntax courses, framework tutorials, certification ladders. We are poor at deliberately teaching evaluation — the capacity to look at plausible code and ask the questions that expose it. Why this approach? Why not the simpler one? What happens under load, under failure, under the input nobody mentioned? The "why" and "why-not" questions are the entire game now, and they resist curriculum precisely because they're judgment, not knowledge.
Meanwhile the old apprenticeship pipeline — juniors building judgment by writing the low-level code seniors then critiqued — is being automated away at its entry rung. The tasks that used to build evaluative muscle are exactly the tasks the assistant now does. If we don't consciously replace that training pathway — code reading as a discipline, critique as a first-class exercise, deliberate exposure to consequences — we'll produce a generation fluent in prompting and helpless at appraisal, working in an era that rewards appraisal above everything.
Working the new difficulty
So, practically. If you're an individual: reallocate your self-development to match the relocation. The scarce skill is no longer knowing how to write it — it's knowing whether what's written makes sense. Practice reading adversarially. Form the habit of stating, before accepting any suggestion, what would have to be true for it to be wrong. If you're a team lead: stop measuring throughput of production and start attending to quality of evaluation — review depth, incident post-mortems that trace to acceptance decisions, the questions asked before merge. If you're hiring: the résumé that lists memorized stacks tells you about the tax that no longer matters; probe instead for the candidate who can critique a plausible-looking solution and articulate why it doesn't fit.
The craft isn't shrinking. Strip away the recall tax and what's left is the explicitly intellectual core: clarity, structure, discrimination, foresight. Harder to teach, slower to grow, and more valuable than what it replaced. Easier to start. Harder to be good. That's the honest state of programming now — and for those willing to build the judgment, it's the best trade the field has ever offered.
