Coding Is Dead. Programming Isn't.

I've been writing code since I was eight.

So when I say coding is dead, I don't say it lightly.

For 99% of programmers, learning to write code by hand today is like learning assembly language: technically impressive, and almost never needed.

But programming isn't dead. Engineering isn't dead. They're changing shape.

Those sound like the same thing. They're not.

Coding vs. programming

Coding is typing instructions a computer understands: the syntax, the semicolons, remembering exactly how a function is spelled.

Programming is deciding what the software should do, breaking it into parts, and making sure those parts work together.

For most of computing history, you couldn't do one without the other. If you wanted to program, you had to code.

That's no longer true.

We've been here before

The common fear is that AI will replace programmers. It won't. It will replace a big part of coding, and that's a different thing.

Programmers have moved up a level many times before.

They used to write machine code: raw instructions for the processor, one tiny step at a time. Then programming languages came along, and almost nobody writes machine code anymore. Then frameworks and libraries took over most of the remaining low-level work.

Every time, people predicted the end of programmers. And every time, programmers simply moved up a level and built bigger things.

AI is the biggest jump yet. But it's the same move. The low-level work goes to the machine. The people move up to directing it.

And AI will keep climbing, taking over higher levels faster and faster. That's exactly why the skills at the top matter more every year.

Three waves

I've lived through three clear stages of AI coding tools:

1. Autocomplete. The AI guessed the next few lines as you typed. You were still coding; just faster.
2. The copilot. You could talk to your codebase. Ask for a change, and the AI would make it across dozens of files, show you what it did, and wait for your OK.
3. Independent agents. You describe a feature, and an agent goes off on its own. It writes the code, runs it, tests it, checks the result against what you asked for, and loops until it's right. You can have several running at once.

By the third wave, the programmer's job is to have the idea, describe it clearly, and judge whether the result is right.

That's not coding. But it's still very much programming.

What the job looks like now

My day as an engineer looks a lot more like managing a very fast, very literal team than typing. I describe what I want. I ask for a plan and review it before anything gets built. I check the work. When the output is wrong, I fix the instructions, not the code.

Here's what surprised me: the skills that matter didn't change as much as I expected.

You still have to think in systems. You still have to break a big problem into small parts. You still have to define what "working" means and test for it.

It's a new kind of programming, where you design systems in a mix of plain English and traditional code. But it takes the same analytical mind it always did.

The higher you go, the less you code. The engineering stays.

What this means if you're not a programmer

This isn't just about software.

Anything that can be described clearly can now be built by AI: copy, pages, campaigns, reports. The people who get the most out of it aren't the ones who type fastest.

They're the ones who can say exactly what they want, break it into parts, and tell good output from bad.

That's the skill I'd bet on for the next ten years. It's the one I'm trying to teach my own kids.

The old question was how do I make the computer do this?

The new one is what exactly should be built, and how will I know it's right?