The developer job was always two jobs wearing one hoodie. One was translating intent into syntax — the typing, the boilerplate, the "how do I center this div" tab over to Stack Overflow. The other was deciding what should exist and why — the architecture, the tradeoffs, the taste. For twenty years we paid people as if those were one job, because you couldn't buy the first without hiring a human who, given enough years, might grow into the second.
That bundle just got unbundled, and most of the commentary about it treats code as the product.
The doomers say we're all obsolete. The boosters say learn to prompt and 10x yourself. Both are wrong in the same way. Code was never the product. Code is the exhaust of a series of decisions. AI is spectacularly good at producing exhaust and mediocre-to-dangerous at making the decisions. So the value didn't disappear — it moved. It moved to the exact skill our industry spent two decades failing to teach on purpose.
The scarce resource is no longer the ability to produce code. It's the judgment to know which code should exist, and the willingness to delete the rest.
You got worse at the wrong thing
Vague futurism is how people dodge accountability, so here's a specific case.
Last month a competent mid-level engineer shipped a caching layer an AI wrote in about two minutes. It worked. It passed the tests the AI also wrote. It went to production. It also keyed the cache on the request path alone, so authenticated responses landed in a shared namespace — and User A started intermittently getting User B's account page. Nobody caught it in review because the diff looked fine: clean, idiomatic, well-commented. The comments were the problem. They were confident. They described what the code did, never whether it should do that.
The old failure mode was "I can't figure out how to build this." The new one is "I built the wrong thing, beautifully, and I couldn't tell." That second failure is more expensive and far harder to detect. A compile error announces itself in seconds; a plausible-but-wrong design announces itself in a postmortem. And it's now the default state of any developer who outsourced their thinking to the autocomplete.
AI optimizes for plausibility: code that looks correct, compiles, and passes the tests it also generated. But plausibility without correctness is exactly what ships incidents, and the gap between the two is now your entire job. If your whole value lived inside "make the thing compile," you are in genuine trouble, and no amount of reassurance changes that. This is the part the boosters gloss over. Not everyone comes out ahead. The people who treated coding as a typing job and never developed opinions about systems are getting commoditized in real time.
The junior crisis is real and we're sleepwalking into it
You develop judgment by writing bad code, shipping it, watching it break at 3 a.m., and internalizing why. That loop — struggle, failure, scar tissue — is how a junior becomes a senior. It is the only way anyone has ever done it. There is no shortcut and there never was.
We are now handing juniors a tool that removes the struggle and hands them the answer. We are removing the exact mechanism that manufactures senior engineers, and calling it a productivity gain. We are eating our seed corn.
I don't have a tidy solution, and anyone who offers you one is selling something. But I'll name the trap: a company that fires its juniors because "AI does junior work now" is trading a six-figure salary today for a seven-figure hole in five years, when it looks up and finds it has no seniors — because it stopped growing any. The judgment we're all suddenly getting paid a premium for has a supply chain, and that supply chain is human beings failing at small things until they're trusted with big ones. Cut it, and the shortage you're profiting from becomes the shortage that guts you. It's a structural crisis, and it doesn't trend only because it's slow.
What actually gets more valuable: taste, and the nerve to enforce it
So what do you do — this week, as an individual, not as a think-piece abstraction?
You get more opinionated, not less. The consensus was that AI would flatten everyone into interchangeable prompt-jockeys. The opposite is happening. When code is cheap, the constraint isn't "can we build it" — it's "should we, and in what shape." That question is answered by taste, and taste is the most defensible moat you have left, because it's the one thing that can't be pattern-matched out of a training set.
Concretely, the developers pulling ahead right now are the ones who can:
- Look at a working, AI-generated 400-line function and say no — not because it's broken, but because it drags in a concept the system shouldn't have to carry. That's an aesthetic judgment with load-bearing consequences.
- Hold an entire system's data flow in their head and spot that the "obvious" fix introduces a write-after-write race three services away, where two events now land out of order under load. The AI sees the file. You see the org.
- Kill features. Delete code. Say "we don't need this," which no model will ever volunteer — because models are trained to be helpful, helpfulness means producing, and half of good engineering is refusing to produce.
I now spend more time reviewing than writing, and I've had to relearn how to review. Reading AI code is nothing like reading a junior's. A junior's mistakes cluster around inexperience — you learn their tells, you know where to look. The machine's mistakes are uniformly distributed and uniformly confident. There's no tell, no tired hour, no weak spot. So you can't skim. You have to reconstruct the intent and check the code against it every time — which means you have to have an intent, sharply, before you read a single line. If you don't know exactly what correct looks like, the machine will happily show you something adjacent to it, and you'll nod.
Neither camp is being honest
To the doomers: the craft isn't dead, it just moved up a floor. The part of you that loved thinking about systems is worth more now than at any point in my career. The part that loved typing is worth what typing is worth.
To the boosters: stop pretending the transition is painless and universal. It has victims, it's hollowing out the entry level, and no one's minding the store. "Learn to prompt" is not a career, it's a party trick, and selling it as salvation to a laid-off junior is grotesque.
AI made the floor of getting something to work trivially low and made the ceiling of getting it right the only thing that pays. That's not a golden age and it's not an apocalypse. It's a filter — it sorts people by whether they ever bothered to form an opinion about their craft, it does it fast, and it does not care about your tenure.
Get opinionated. Develop convictions about architecture. Learn to say no to a machine that never stops saying yes. That's the job now. It was probably always the job — we just finally ran out of places to hide from it.