Are we cooked ?

It comes up in every dev conversation now, somewhere between the second coffee and the standup. A junior asks it sincerely. A senior asks it as a joke that lands a little too flat. Someone screenshots an agent building in twenty minutes what took their team a sprint, and the group chat goes: are we cooked?

I've given the reassuring answer at meetups and the doomer answer at 2am, and I no longer believe either. Here's the answer I actually believe, and it requires splitting the question in two — because "we" was never one group, and "cooked" was never one thing.

The job was never the typing

Start with what's actually being automated. An LLM produces code — spectacularly well, some days. But look at where your last three production incidents came from. Mine didn't come from badly typed code. They came from a requirement that meant two different things to two different teams, a cache invalidation assumption nobody wrote down, and a third-party API that behaved differently under load. The code was fine. The understanding had a hole in it.

That's the job: translating fuzzy, contradictory human intent into a system that doesn't fall over, and holding the model of that system in your head while it grows past anyone's ability to read it whole. The typing was always just the visible part — the part you could film for a hiring ad. We're shocked that machines write code the way accountants were shocked that machines could add. Addition wasn't the job. The job was knowing which numbers to add, and noticing when a total couldn't possibly be right. The spreadsheet didn't kill accounting; it killed the version of accounting that was secretly just arithmetic. Hold that thought, because the parallel cuts both ways — some of what we call software engineering is secretly just arithmetic.

The inversion nobody priced in

Here's the outside-the-box part, the thing I think most takes miss: AI didn't make software cheap. It made generation cheap and left verification expensive — and that inversion changes the profession more than any productivity number.

Before: writing was slow, so writing was the bottleneck, so we organized everything around authors. Now a plausible implementation costs thirty seconds, and the question "is this plausible thing correct?" costs what it always cost: attention, context, skepticism, the instinct that something is off in a diff that looks perfectly fine. The bottleneck moved from production to judgment. We all became editors-in-chief of a very fast, very confident, very junior writer who never gets tired and never says "I'm not sure."

And editing is a harder job than writing when you do it honestly. Anyone who's done real code review knows the trap: the subtle bug doesn't live in the code that looks wrong, it lives in the code that looks right. Reviewing AI output is that, all day, at volume. The "10x productivity" stories quietly assume the verification is free — that someone reads the generated code with the same care they'd have spent writing it. Mostly, nobody does. We're currently shipping a civilization-sized experiment on what happens when generation outruns verification, and the results aren't in yet.

Someone still has to sign

Which is why the most durable thing about this job isn't a skill at all. When production goes down at 3am, when the regulator asks why the system did what it did, when a migration eats data — a human is accountable. Not metaphorically: contractually, legally, reputationally. An LLM cannot be responsible. It can't be fired, can't testify, can't feel the specific cold sweat of having broken prod. Responsibility is load-bearing in every engineering discipline, and it doesn't transfer to tools — the bridge engineer's stamp survived CAD.

But notice what that implies, because it's not comfortable: signing for something you don't understand isn't accountability, it's liability cosplay. The moat isn't "being human." It's understanding what you ship. The engineers who let that understanding atrophy — who approve what they can no longer explain — are converting themselves into a rubber stamp, and rubber stamps are very, very automatable.

The part that is actually cooked

So no, I don't think the profession is cooked. But one piece of it is on fire, and we're not talking about it enough: the ladder.

Every senior engineer was forged the same way — years of boring tickets. The CRUD endpoint, the pagination bug, the form validation. We treated that work as grunt work, but it was secretly the apprenticeship: ten thousand small encounters with how systems actually fail, compounding into the instincts that make a senior senior. That's exactly the work AI eats first, and it eats it cheerfully. Why give the junior three days when the agent takes ten minutes?

Run that policy for a decade and you get a profession with no new seniors — editors-in-chief who never wrote, signatories who never built the understanding their signature claims. Juniors aren't cooked because AI replaces them; they're cooked if we stop letting them do the work that was always more education than output. The fix isn't complicated, but it is a choice: keep giving humans work the machine could do, on purpose, the way pilots still hand-fly approaches the autopilot could handle — because the skill has to exist in a human for the day it's needed. Some team leads make that choice. The ones who don't are strip-mining their own future.

So: are we?

Here's the split, then. If "the job" means converting tickets into code that probably works — yes, cooked, on a timeline measured in years, and pretending otherwise is a disservice to everyone planning a career. If "the job" means owning systems: deciding what to build, knowing why it's built that way, catching the confident wrong answer, signing for the result and meaning it — not cooked. In more demand than ever, actually, because the volume of software is exploding and every line of it eventually needs an adult.

The discomfort is that nobody gets to claim the second job by seniority or by job title. You claim it by still understanding what you ship — which, in the age of infinite generated code, is a daily, deliberate act of swimming upstream. I use these tools all day. They wrote none of the decisions in this post, and if a day comes when I can't tell whether they got those right either — that's the day I'm cooked, and it won't have been the machine that did it.