TL;DR: AI-assisted coding is revealing a split among developers that was always there but invisible when we all worked the same way. I’ve felt the grief too—but mine resolved differently than I expected, and I think that says something about what kind of developer I’ve been all along.
A few months ago, I wrote about how making computers do things is fun. The gist: I’ve never been in it for the elegance of code. I’ve been in it for the result. I learned BASIC on a Commodore 64 at age 7 not because BASIC was beautiful—it wasn’t—but because I wanted to make things happen on screen. Then I learned 6502 assembly because BASIC was too slow for what I wanted to do.
That post was my attempt to explain why AI coding tools felt like a natural fit for me. But since then, I’ve been reading other people’s reactions to this moment, and I want to come back to it—because I think something bigger is going on.
The Mourning
James Randall wrote a piece that hit a nerve. He’s been programming since age 7, like me—started in 1983, a year after I did. But his experience of this moment is subtly different from mine:
The wonder is harder to access. The sense of discovery, of figuring something out through sheer persistence and ingenuity — that’s been compressed. Not eliminated, but compressed. And something is lost in the compression, even if something is gained.
Nolan Lawson put it more starkly in “We Mourn Our Craft“:
We’ll miss the feeling of holding code in our hands and molding it like clay in the caress of a master sculptor. We’ll miss the sleepless wrangling of some odd bug that eventually relents to the debugger at 2 AM. We’ll miss creating something we feel proud of, something true and right and good. We’ll miss the satisfaction of the artist’s signature at the bottom of the oil painting, the GitHub repo saying “I made this.”
These are real feelings about real losses. I’m not here to argue otherwise. But reading these posts, I kept having this nagging sense that we were mourning different things—and that the difference mattered.
The Split
Here’s what I think is happening: AI-assisted coding is exposing a divide among developers that was always there but maybe less visible.
Before AI, both camps were doing the same thing every day. Writing code by hand. Using the same editors, the same languages, the same pull request workflows. The craft-lovers and the make-it-go people sat next to each other, shipped the same products, looked indistinguishable. The motivation behind the work was invisible because the process was identical.
Now there’s a fork in the road. You can let the machine write the code and focus on directing what gets built, or you can insist on hand-crafting it. And suddenly the reason you got into this in the first place becomes visible, because the two camps are making different choices at that fork.
I wrote about this split before in terms of my college math and CS classes—some of us loved proofs and theorems for their own sake, some of us only clicked with the material when we could apply it to something. I tended to do better in classes focused on application and did not-so-well in pure math classes. (I still want to take another crack at Calculus someday, but that’s a different story.)
My Grief Was Different
I want to be clear: I’ve felt grief too. I’ve gone through a real adjustment period over the past 18-24 months.
I was afraid I wouldn’t be able to understand the new tools. But, it seems I have. I was worried I wouldn’t understand the output—that I’d lose my ability to judge whether the code was actually right. But it turns out decades of reading and reviewing code doesn’t evaporate. I can still tell when something’s wrong and I still have taste.
I was afraid the puzzle-solving was over. But it wasn’t—it just moved up a level. Which, when I think about it, is exactly what’s happened at every other transition in my career. I went from placing bytes in memory on a C64 to writing functions to designing systems. The puzzle got more abstract each time, but it never stopped being a puzzle. Now the puzzle is architecture, composition, directing the assistant. It’s different. It’s still satisfying—to me, anyway.
So most of my fears got tested against reality and thankfully didn’t hold up. But some grief stuck.
The Grief That Sticks
I grieve for the web I’ve known. Not for writing HTML by hand—I grieve for the open web as an ecosystem, threatened in ways that have nothing to do with whether I personally type code or not. AI training on the commons, the further consolidation of who gets to shape how people experience the internet—that’s a real loss, and it doesn’t go away because I’m personally more productive.
I grieve for the career landscape shifting under me. Webdev’s been my thing for over three decades. But, it’s not a hot field anymore, whether folks like it or not: mobile apps took some big bites, but AI engineering is really ruling the roost now. I spent time worrying whether I could make that shift. I think I have been, but the anxiety is genuine, and I don’t think it’s finished.
Here’s what I notice about my grief: none of it is about missing the act of writing code. It’s about the world around the code changing. The ecosystem, the economy, the culture. That’s a different kind of loss than what Randall and Lawson are describing. Theirs is about the craft itself. Mine is about the context and the reasons why we’re doing any of this.
Neither Side Is Wrong
Kevin Lawver wrote a response to Lawson that I mostly agree with. He argues for redirecting craft and passion rather than clinging to how things were. But I’d go further than framing it as nostalgia vs. pragmatism. (And you know I’ve got plenty of nostalgia—but that doesn’t pay my mortgage.)
I think recognizing which kind of grief you’re feeling is the actually useful thing here. If you’re mourning the loss of the craft itself—the texture of writing code, the satisfaction of an elegant solution—that’s real, and no amount of “just adapt” addresses it. You might need to find that satisfaction somewhere else, or accept that work is going to feel different. Frankly, we’ve been lucky there’s been a livelihood in craft up to now.
If you’re mourning the context—the changing web, the shifting career landscape, the uncertainty—that’s real too, but it’s more actionable. You can learn new tools. You can push for the web you want, even if it’s a small web. You can grieve and adapt at the same time.
I’ve been trying to do a lot of both. I’m not entirely sure how it’s going. I do really feel for what Nolan Lawson said here:
I don’t celebrate the new world, but I also don’t resist it. The sun rises, the sun sets, I orbit helplessly around it, and my protests can’t stop it. It doesn’t care; it continues its arc across the sky regardless, moving but unmoved.
But, you know, I’d be lying if I said it didn’t excite me a bit, amidst the grief & terror.
Make Computer Do Thing
I started programming in 1982. Every language I’ve learned since then has been a means to an end—a new way to make computers do things I wanted them to do. AI-assisted coding feels like the latest in that progression. Not a discontinuity per se, just another rung on the ladder.
But I’m trying to hold that lightly. Because the ladder itself is changing, the building it’s leaning against is changing, and I’d be lying if I said I knew exactly where it’s going.
What I do know is this: I still get the same hit of satisfaction when something I thought up and built actually works. The code got there differently than it used to, but the moment it runs and does the thing? That hasn’t changed in my over 40 years at it.
