For more than fifteen years, the thing that made me an engineer was a kind of moat: I could speak a language most people couldn’t. Not English — the languages computers understand. Coding was never really about typing. It was about having learned the machine’s tongue, the patient, unglamorous fluency that let me turn an idea into something a processor would actually run. That fluency was the moat. It was the whole job, and it was mine.

That moat is what AI came for. And for a long while, watching it come was bearable, because it was always a question of how good — never whether.

The argument we were all having

You know the two camps, because you’ve sat in both at different hours of the same day. One says the tools are dumb — confidently wrong, plausible and shallow, not there yet, give it years. The other has quietly handed over the keyboard and isn’t looking back. For a couple of years that argument was the discourse: is it good enough yet, is it good enough yet, refreshed daily.

I want to be honest about which side I was on, because it makes today land harder. This past January I didn’t trust it. None of us in my circle did. We said it would take years to do what we do. We said we’d review every line. We said — I said — I can’t just let my code be written for me; at minimum I need to read it. We meant it completely. We were wrong about the timeline by an order of magnitude.

The day

So let me mark the day, because I think it’s one of those quiet hinges that only look obvious later.

I was in a room of engineering leaders — peers, people who run teams of thirty, forty, fifty engineers at companies whose names you’d know. We were talking, of all the ordinary things, about productivity. And one of them said, plainly and without lowering his voice, that his engineers have stopped hand-coding. Not as a confession. Not as a worry. As a simple statement of fact about how the work gets done now. And nobody in the room flinched. A few months ago that one sentence would have started a two-hour fight. Today it was just the weather.

That’s the shift. Not a model release, not a benchmark. A room of serious people, responsible for a lot of code, agreeing without friction that the old way is over.

The moat was never the code. It was knowing exactly what we wanted — and that part just became the whole job.

— what I caught myself thinking in that meeting

We were always going to stop reading

Here’s the part that finally made my own resistance dissolve. We keep saying we should review the code the AI writes. And we should, at the edges, where it matters most. But the volume has already passed the point where a human reads all of it, and pretending otherwise is a performance.

Think about what we already accept. None of us read the machine code our compilers emit. None of us audit the ones and zeros. We could, in theory, and we never do, because decades ago we decided the compiler does that job better than we would and we moved up a layer to spend our attention somewhere it counts. We didn’t lose anything we miss. We gained altitude.

The line of what humans read keeps rising A stack of abstraction layers from machine code at the bottom to intent and orchestration at the top. The line marking what humans actually read has risen, in months, from the source code up to the level of intent. WHERE HUMANS READ — AND WHAT WE TRUST BELOW intent · orchestration the code AI now generates high-level code — once hand-written assembly machine code · ones and zeros months ago — we read the code today — we read only this far rose in months We never read the ones and zeros — we trust the compiler. We’ve stopped reading the generated code too. The line simply moved up the stack again.
We have always trusted the layer below the one we work in. For decades that line sat at the source code. In a matter of months it climbed to the level of intent — and we stopped reading what’s beneath it.

That’s all that happened again, just faster and higher. The line of what humans actually read has climbed the stack one more rung — from the source code up to the intent — and below that line we’ve started to simply trust, the way we’ve always trusted the layer beneath the one we work in. It feels like surrender because it happened in months instead of decades. It isn’t surrender. It’s the same trade we’ve made at every layer before this one.

So what is the job now

If it isn’t writing the language, what’s left? Everything that was always the hard part, now without the comforting busywork that hid it.

The job is orchestration. How clearly you can say what you actually want. How precisely you can define what done means — in terms a machine can check, not a feeling you’ll know when you see. How well you verify that what came back actually meets the bar, instead of trusting that it does. How efficiently you wield something that is, let’s be plain, a genuine superpower, without letting it run off a cliff while you weren’t looking.

I’ve been circling this in everything I’ve written lately — that the loop is the real unit, that context is a budget, that an instruction without a check is only a wish. This is where those threads tie off. The new moat isn’t fluency in the machine’s language. It’s fluency in intent: the ability to want something precisely enough, and to prove you got it. That skill was always rare. It just used to be hidden behind the typing.

Marking it

I don’t know exactly what this profession becomes from here, and anyone who tells you they do is selling something. But I know a line was crossed today — not loudly, not at a keynote, but in an ordinary meeting about productivity, between people who would have argued the opposite a season ago.

Fifteen years I spent learning to read the code. Today I watched a room of us agree, gently, that we mostly don’t anymore. I wanted a record that I was here when it turned.

This day. I’m marking it.