The cost of producing code is collapsing. The cost of being wrong at scale is not.
I've spent most of my career in places where being wrong is expensive. Pipelines that can't drop a message (Kafka/RabbitMQ). Websocket real-time updates for millions of users, where a bad assumption doesn't show up in a unit test, it shows up at 2 a.m. as a graph that won't stop climbing!
In those rooms, nobody ever lost sleep over how fast they could generate code. The hard part was always knowing how to build things the right way.
So when people tell me AI is going to "replace engineers", I think they've misread the job. We're not going to stop coding. We're going to stop typing.
The two curves that define the job now
Here's the shift, in one picture.
Today, generating code is cheaper. That curve is going down and it isn't coming back up anytime soon.
The other curve barely moves. The cost of shipping the wrong things to production - a race condition under load, a silent data-loss path, an API that's "done" but quietly violates a contract. That cost is exactly where it always was. If anything it's rising, because we now ship faster.
The gap between those two curves is the entire job. It's where engineering moved. Not to producing code, which is now cheap, but to making sure the cheaper code is correct at scale.
Typing was never the job
Typing was always the part you could see. The job was everything beneath it: the boundaries, the tradeoffs, and enough of the whole system in your head to know which "small" change could bring it all down.
Today's models produce that visible part faster than we ever could. A change that touches five repos, the kind that used to eat an afternoon of context-switching, branch juggling, and copy-paste across services, now lands in minutes. That's real, and it's not going back.
But there's a line the model doesn't cross. It can't own the outcome. It doesn't carry the reason this service exists, or know what it costs the business when the thing quietly lies. It'll make the same change in all five repos in minutes, and it won't pause to ask whether one of those repos was the wrong place to make it.
That's not work being taken away. It's a promotion. The leverage moves from how fast your hands are to how clearly you can think.
ACDC: the Agentic-Centric Development Cycle
So if the keyboard isn't the bottleneck anymore, what is the loop? The framing I keep reaching for is ACDC - the Agentic-Centric Development Cycle.
Four stations, and you stand in the middle of all of them:
- Intent - You state the outcome precisely. Specs, constraints, contracts, conventions. This is the step everyone wants to skip and the one that decides everything downstream.
- Generate - The agent drafts the code, the UI, the tests. Fast, and in volume. This used to eat most of the day. Now it's the fastest part.
- Verify - Tests (Unit, Integration, E2E), review (AI and Human), observability. The only question that matters here: is it right? Not "does it run" - does it survive contention, retries, partial failure, and ten times the traffic?
- Integrate - Ship it, watch it in production, and feed what you learn back into intent. The loop closes, and the next pass starts sharper.
The agent runs the cycle. You own it. The skill isn't doing every step by hand anymore - it's directing the cycle well enough that the outcome is something you'd put your name on.
A small, concrete example: directing starts with the right word
People hear "direct the agent" and assume it's some mystical prompt-craft. Far more boring than that, and a lot more learnable. A lot of it is just knowing what you want and describing it precisely.
Ask for "a dropdown thing where people can pick a few filters" and you'll get a single-select box, no way to see what's active, and three more rounds of "no, like…". But ask for "a multi-select combobox with token chips, type-ahead, and a clear-all button" and you'll get exactly that, on the first attempt.
Same model. Same task. The only thing that changed is that you knew a combobox is called a combobox.
This generalizes far past frontends. The engineer who can say idempotent consumer, backpressure, outbox pattern, read-your-writes consistency - instead of "make it not break under load" - gets dramatically better output, because precise intent is the highest-leverage input the loop has. Your vocabulary is now part of your toolchain. Sharpen it on purpose.
What to get good at now
If the typing is going away, here's where I'd focus:
- Specification. Saying exactly what you want, including the edge cases, is the new core skill. Vague in, vague out - at scale.
- System design. When code is cheap, the expensive mistakes are all structural. Boundaries, data flow, failure modes. This only gets more valuable.
- Verification. Being able to tell quickly whether generated code is actually correct - and building the tests and telemetry that prove it - is the real skill.
- Taste. Knowing which of five working solutions is the simple one. So simple a teammate can hold it in their head; yet so clever it still answers every requirement.
The part nobody can outsource
Come back to that second curve - the one that won't go down. Being wrong at scale.
This is the ground I've stood on my whole career, and it's exactly the ground agents don't cover on their own. A model will happily hand you a consumer with no idempotency, a presence system that leaks connections, a write path with a lost-update race. It'll all look right. It'll pass the happy-path test. And it'll fall over the first time real traffic finds the gap.
Catching that is judgment, and judgment is built from having been wrong before and remembering what it cost. The agent doesn't have that memory. You do. In an agentic world, that memory isn't a nice-to-have - it's the whole reason a human is still in the loop.
So, are we done writing code?
Not even close. We're going to write more software than ever - and the amount one person can build is about to get a little ridiculous. What's ending isn't coding. It's the era where the keyboard was the bottleneck, where the work was capped by how much you could personally type. Hand the typing to agents and time stops being the limit.
What's left is judgment.
So no, we won't stop coding. We'll stop typing - and start directing. The engineers who thrive won't be the fastest at the keys. They'll be the ones who know what right looks like, can say it precisely, and can prove it holds up when the traffic arrives.
That part was always the job. Now it's the whole job.
