We Lost the Craft

I miss the keystrokes.

Not the RSI. Not the 3 AM debugging sessions. But that specific, almost meditative rhythm of translating thought into logic, character by character, until something alive emerged from your fingertips.

The code was ours. It had our signature — the way you named variables, the particular structure of your loops, the elegance (or lack thereof) of your error handling. It was craftsmanship. It was art.

Now? Now I review. I prompt. I supervise. The code appears, fully formed, correct (mostly), and utterly anonymous.

The Grief Is Real

Let’s not minimize this. There is a genuine sense of loss when you realize the skill you’ve spent decades refining — the ability to write beautiful, efficient, maintainable code — has been commoditized. Not by cheaper labor overseas, but by a model that learned from millions of us and now generates in seconds what used to take hours.

It’s not about productivity. It’s about identity. We were makers. Now we’re… curators? Managers? Prompt engineers? The words taste like ash.

But Here’s the Thing

I’ve been thinking about why this hits some engineers harder than others. And I keep coming back to my roots.

I started as a sysadmin. Before I was a “software engineer,” I was the guy keeping servers alive, debugging kernel panics at 4 AM, learning that the machine doesn’t care about your feelings. I spent years understanding systems — not just code, but the messy, chaotic, real systems that code runs on.

And that context changes everything.

Code Was Never the Point

When you’ve spent enough time in the trenches of infrastructure, you learn a truth that pure developers often miss: code is the easy part. The hard part is knowing where to put it, how it scales, what breaks when it breaks, and why it matters to the business.

The AI writes excellent code. It really does. But it has no intuition for:

• The way a database will choke at 10M rows
• The subtle failure modes of distributed systems
• The organizational politics that determine whether a project lives or dies
• The smell of a solution that looks right but will cost a fortune in six months

That intuition — the kind you develop after watching systems fail in production, after debugging race conditions that only happen under specific lunar phases, after understanding that software exists in a context larger than its own syntax — that intuition is still ours.

The Art Moved Up a Level

Maybe the art was never in the keystrokes. Maybe the art was always in the decisions — which keystrokes to make, which tradeoffs to accept, which complexity to embrace and which to reject.

If that’s true, then the art hasn’t disappeared. It’s just become more concentrated. The canvas is larger now. Instead of crafting individual functions, we’re crafting systems. Instead of optimizing loops, we’re optimizing architectures. Instead of writing code, we’re writing the specifications that generate code — and that is, arguably, a higher form of the same craft.

The Sysadmin Advantage

I think sysadmins — or anyone with an infrastructure background — have an unfair advantage in this new world. We never identified primarily as “coders.” We were problem-solvers, troubleshooters, the people who understood that technology is a means to an end, not an end in itself.

We learned early that the most elegant script in the world is useless if it doesn’t handle the failure case you didn’t think of. We learned that systems are chaotic, that Murphy’s Law is optimistic, and that the real skill isn’t writing perfect code — it’s writing resilient systems that degrade gracefully when (not if) things go wrong.

The AI doesn’t have scar tissue. It hasn’t been paged at 3 AM because a certificate expired. It doesn’t know the weight of a production outage, the way your stomach drops when you realize the database is corrupt and the backups are empty.

That weight — that visceral understanding of consequences — that’s still ours.

What We Keep

So yes, I mourn the keystrokes. I miss the flow state of pure creation, the satisfaction of a well-crafted function, the pride of elegant recursion.

But I’m also recognizing that my value was never really in my typing speed or my memory of syntax. It was in my judgment. My experience. My ability to see around corners and anticipate problems before they happen.

The craft isn’t dead. It’s just moved up the stack. And those of us with a systems perspective — who always knew that code was just one piece of a larger puzzle — might be better positioned than we think.

The New Craftsmanship

The new craftsmanship looks different. It’s less about semicolons and more about semantics. Less about algorithms and more about architectures. Less about implementation and more about intention.

It’s understanding that an AI can generate a perfect CRUD API, but only you can decide:

• Whether that API should exist at all
• How it fits into the broader system
• What happens when it fails
• Who maintains it and at what cost

These are human questions. They require context, judgment, and wisdom — the kind that comes from decades of experience, not just training data.

Looking Forward

I don’t know what the future holds. Maybe the agents will get good enough to handle the architecture too. Maybe my current advantage is temporary, and in five years I’ll be nostalgic for the days when at least I got to review the code.

But for now, I’m trying to reframe. Not as loss, but as evolution. The stone masons mourned the advent of the steam saw, but the builders who learned to use the new tools built things the masons couldn’t have imagined.

The craft changes. The craftsperson adapts. And maybe — just maybe — the art was never in the stone, but in the vision of what to build.

I still miss the keystrokes, though. Some days, I open a terminal and write a shell script by hand — inefficient, unnecessary, perfect — just to remember what it felt like to be a craftsman in a world that no longer needs one.

Then I go back to my real job: thinking, deciding, directing. The art moved up. I moved with it.

That’s enough for today.