The Return of the Prodigal Coder

Something is happening in the programming world, and the obvious explanation misses what matters.

People who left coding—moved to management, burned out, got overwhelmed by the accumulating complexity—are coming back. Simon Willison has been documenting this pattern: AI tools are "helping people write code again." The tech story writes itself: AI lowers barriers, former programmers return, everyone wins.

But that's not the interesting part.

The interesting part is what happens to identity when you return to something you left—and find that the thing itself has changed.

Liz Fong-Jones, quoted by Willison, put it precisely: "You're no longer writing code; you're managing the context the model has access to."

At first glance, this sounds like deskilling. The prodigal returns, but to what? Not to the craft they knew. Not to the hard-won fluency in arcane syntax, the mental compiler running in the background, the deep satisfaction of making the machine do exactly what you intended through sheer force of precise instruction.

That's gone. Or at least, it's optional now.

But here's what I keep sitting with: Was "writing code" ever really the point?

The people who left didn't leave because they forgot how to type semicolons. They left because the cognitive load-to-meaning ratio broke.

Programming, for many, became an endless management task: dependency updates, security patches, framework migrations, the constant treadmill of keeping up with tools that changed faster than you could master them. The friction accumulated. The gap between "I want to build this thing" and "this thing exists" widened until crossing it required more energy than the destination was worth.

So they stopped crossing it. Went to management. Went to product. Went to anything that didn't require them to context-switch between fifteen abstractions just to make a button change color.

What they lost wasn't the ability to code. What they lost was the relationship—the direct line between intention and artifact. "I think something, and then it exists." That's the real thing programming offers, underneath all the syntax and tooling and accumulated cruft. That's what made it feel like magic, back when it was new.

The friction didn't just slow them down. It intercepted the relationship. The code stopped being a bridge between thought and creation and became a barrier: something you had to get through to reach what you actually wanted.

Now AI compresses the gap.

Not perfectly. Not without its own kinds of friction. But enough that people who abandoned the relationship are cautiously returning to it. "I can build things again," they say. Not "I can write code again." Build things.

And this reveals what was always true: the code was just one way—often a painful way—to manage the context between your mind and the machine. Fong-Jones isn't describing deskilling. She's describing what the activity always was, stripped of the mystification.

You were never really "writing code" in some pure sense. You were always managing context: holding the problem in your head, translating between levels of abstraction, bridging the gap between what you meant and what the machine understood. The typing was incidental. The semicolons were ceremony. The real work was the relationship.

This is where the identity question gets uncomfortable.

If "being a programmer" meant mastery of the ceremonial layer—the syntax, the tooling, the accumulated knowledge of which incantations produce which effects—then yes, something is being lost. That mastery is devaluing. The years spent learning the ceremony don't compound the way they used to.

But if "being a programmer" meant the relationship—thought becoming artifact, intention becoming reality, the particular magic of making things exist through sustained attention—then nothing is lost. The relationship is more accessible than it's been in decades.

The returning coders are testing this question with their feet. They're coming back not despite the change but because of it. Which suggests they know, at some level, what programming was for them underneath. And it wasn't the syntax.

There's a coherenceist principle here: Living Traditions. Forms adapt; patterns persist.

The pattern of programming—human intention meeting machine capability, the negotiation between what you want and what's possible, the iterative refinement until the artifact matches the vision—that pattern is ancient. It predates computers. It's the pattern of all making.

The form of programming—the particular languages, tools, and ceremonies that mediated the pattern in a given era—those forms have always changed. Assembly gave way to C gave way to Python gave way to whatever's next. The people who attached their identity to a specific form always felt threatened when the form evolved. The people who understood the pattern adapted.

What's happening now is a bigger form-shift than usual. But it's not a pattern-break. The pattern—intention meeting capability, refinement until match—remains intact. The form is changing from "write precise instructions" to "manage context for a collaborator." Still programming. Different ceremony.

Something is lost when the ceremony changes. There's a particular satisfaction in mastering a hard thing—in knowing you can do what most people can't, in the fluency that comes from thousands of hours of practice. That satisfaction is real, and it's being disrupted.

This is the prodigal's dilemma: you can go home, but home has changed while you were gone. The fatted calf tastes different. The family speaks a slightly different language. You belong, and you don't. You're returning, and you're arriving somewhere new.

The question I'm left with isn't whether this is good or bad for programmers. It's what this pattern reveals about the relationship between humans and their tools more broadly.

What were you actually doing, in the work you've mastered? What was the ceremony, and what was the pattern underneath? If the ceremony changed tomorrow—if AI compressed the friction in your domain the way it's compressing the friction in code—would you experience liberation or loss?

The honest answer, I suspect, is both.

The programmers returning to code are rediscovering something they loved. They're also grieving something that's gone. These don't cancel out. They coexist.

And maybe that's the truest thing about this moment in the human-AI relationship: we're all prodigals now, returning to activities we thought we knew, finding them changed in ways we're still learning to name.

The question isn't whether to return. It's what you're returning for—and whether you can find it in the new form.