There is a particular kind of silence that has crept into my work lately. I describe what I want, and it appears. The function is there. The tests pass. The diff is clean. And I realize, with a small jolt, that I did not write any of it. I supervised it into existence.

For most of my career, writing code was a craft. Not in the romantic sense of artisans bent over a workbench, but in the literal one: a skill built through repetition, refined through failure, held in the hands as much as the head. You learned the shape of a problem by struggling against it. You earned your intuitions. The craftsmanship of writing code, the part where you actually make the thing, is becoming a dying art. And I am not sure we have reckoned with what that means.

What the Struggle Was For

I’ve written before that code was always a barrier, that AI is dissolving the wall between thought and execution, and I believe that. The barrier really was holding people back. But a wall is also a kind of teacher. When you had to fight the compiler, the fight left something behind in you.

Reaching for the right data structure without thinking about it. Feeling, in your gut, that a loop is one level too deep before you can explain why. Knowing the difference between code that works and code that is correct. None of that came from reading about it. It came from writing it, badly, a thousand times, until the badness wore off.

That’s the thing about craft. The output was never really the point. The point was what the practice did to the practitioner.

The Atrophy Is Real

When you stop doing a thing, you lose it. This is not nostalgia; it is physiology. The pathways you don’t use get pruned.

I noticed it first in small ways. I’d reach for a solution and find the recall a half-second slower than it used to be. I’d read generated code and accept it a little too easily, because checking it carefully felt like more work than letting it ride. That second one frightened me more than the first. The danger of the machine writing your code is not that it writes bad code. It’s that it erodes your ability to tell.

I still believe what I tell every candidate who sits across from me: using AI is allowed, but mastery is required. You have to understand the output. You have to catch the mistakes. But mastery is not a static thing you acquire once and keep forever. It’s a muscle. And I could feel mine getting soft.

So I Went Back to the Gym

I started doing LeetCode again. Not to interview. Not to chase some metric. Just to keep my hands from forgetting.

There’s something almost stubborn about it, I know. Drilling two-pointer problems and graph traversals in an era where I could simply ask for the answer. But that’s exactly why it works. The value isn’t the solution; it’s the deliberate refusal of the shortcut. It’s sitting with a hard problem and not letting anything solve it for me. The friction is the entire point.

It’s the same reason a pilot still trains in a simulator after a decade of autopilot. The machine flies most of the hours. But when the machine can’t, you’d better still know how. The skill you practice when you don’t need it is the skill you have when you do.

Holding the Line

I don’t think we should fight the tide. The tide is good. More people can build more things, and the barrier that made technologists feel powerful deserved to fall. I’m not arguing for some return to artisanal hand-coded purity.

But I am arguing that someone has to stay fluent. The judgment that lets you look at generated code and know, instantly, that something is off, that judgment is downstream of having written enough code yourself to have earned it. If the entire profession outsources the writing, we keep the supervisors and lose the people who can actually tell whether the work is any good. We become a generation of editors who never learned to write.

So I keep my hand in. Not because the craft is coming back, but precisely because it isn’t. The dying art is worth keeping alive in at least a few of us, the way a language is kept alive by the last speakers who refuse to let it go quiet.

The machine can write the code. I still want to be the kind of person who could have.