I’ve been writing code for over two decades, and for most of that time I believed the craft of writing it was the point. The syntax, the structure, the style — these weren’t just means to an end. They were the end. They were what separated a real developer from someone who just made things work.

I was wrong. The craft was never the point. The craft was just the cost of building, and that cost is going to zero.

Everything got easier

The trajectory of software development has been a relentless march toward abstraction. I used to provision servers by hand. I’d install the OS, configure the firewall, set up the web server, manage SSL certificates, deploy code by pulling from a git repo on the machine itself. Today you click a button and your app is live on a global CDN with automatic HTTPS and continuous deployment from a GitHub push.

The code itself got easier too. Early JavaScript was a minefield. No modules, no package managers, barely any standard library. You wrote everything from scratch or copy-pasted from some forum. Now there’s a mature ecosystem for almost everything. Frameworks handle routing, state management, rendering. The problems you solve today are higher-order problems. You’re composing systems, not fighting syntax.

The death of the small arguments

There’s a funny thing that happens the longer you write code. You get more opinionated. Not about the big architectural decisions — those you learn to hold loosely because you’ve been burned enough times. It’s the small stuff that calcifies. Tabs versus spaces. Where to put the curly brace. Whether to use semicolons in JavaScript. Two spaces or four. CamelCase or snake_case. The more experience you had, the stronger you felt about these things. Teams wrote style guides that ran for pages. Code reviews devolved into formatting debates.

These were elements of craft. They signaled that you cared about your code, that you had taste, that you belonged to a particular school of thought. Your formatting was part of your identity as a developer.

Then Prettier showed up and mass-formatted everything. ESLint caught the real problems. TypeScript eliminated entire categories of bugs that we used to find through careful code review or, worse, in production. The arguments didn’t end because someone won. They ended because they stopped mattering. The tools absorbed them. What was once a matter of craft became a default setting.

And nobody misses it.

The thing I didn’t see coming

Every time a tool absorbed something I used to do by hand, I adjusted. I stopped writing my own CSS resets. I stopped configuring webpack from scratch. I stopped hand-rolling authentication. Each time, it stung a little, and then it didn’t. I told myself the things that really mattered — the way I structured code, the instincts I’d built, the taste I’d developed — those were safe. Those were the real craft. Tools could handle the busywork, but they’d never touch the art.

Then AI showed up, and it touched the art.

It didn’t just change how I worked, it forced me to completely rethink everything. Things I had cared deeply about for years just disappeared. Opinions I would have argued about for hours collapsed the moment I saw them automated away in seconds. The careful way I structured a module, the naming conventions I’d refined over a career, the architectural patterns I wore like badges of experience — none of it mattered the way I thought it did. The output was what mattered. It had always been what mattered. I just couldn’t see it because I was so close to the process.

That was the humbling part. Not that AI could write code. But that so much of what I called craft was really just friction I’d learned to love.

What comes next

This is the pattern. The things we consider craft today will be absorbed by tools tomorrow. And right now, the biggest tool shift in the history of software is underway.

I’ve spent decades learning how to translate ideas into code. How to decompose problems into functions, organize logic into modules, manage state across systems. That translation layer, the one between what you want and how the machine does it, has been the entire job.

That layer is collapsing.

The future isn’t writing code. It’s context engineering. It’s building systems by describing intent, defining constraints, and orchestrating outcomes. The unit of work shifts from the line of code to the idea itself. You’ll still need to think in systems. You’ll still need to understand logic, data flow, failure modes. But you won’t express those things as syntax. You’ll express them as structured context that machines can act on.

Imagine systems with thousands of individual moving parts, all orchestrated together, not as code, but as ideas. Not as functions and classes, but as goals, rules, and relationships. The craft won’t be in how cleanly you write a for loop. It will be in how clearly you can describe what you want to exist.

I don’t say this with nostalgia or sadness. I’ve watched every generation of tooling make the previous one look needlessly painful. Every abstraction layer that landed felt like losing something at first, then quickly felt like freedom. This will be no different.

The end of code as craft isn’t the end of building. It’s the end of building the hard way.

And for the record: spaces.