The Last Slow Thing

Almost everything about building software got a fast mode this year. Reasoning effort is a dial you can crank. Code review runs in the loop as a hook. Release is a pipeline that auto-rolls-back. Agents merge pull requests around the clock for pennies on the token. Pick any stage of the old lifecycle and there’s now a setting that makes it faster.

One thing never got a dial. Sitting with a person long enough to understand what’s actually worth building. That conversation runs at exactly the speed it ran at twenty years ago, and this year, for the first time, that makes it the slowest thing in the entire process.

The Bottleneck Keeps Moving Up

I’ve spent a lot of posts here chasing the same animal: every time AI absorbs a layer of the work, the constraint doesn’t vanish, it moves up to the next layer that still needs a human. Faster code didn’t make us faster, it moved the bottleneck to review. Faster review moved it to release. The SDLC collapsed into delegate, review, own, and the owning is where the humans pooled.

Follow that arrow far enough and it points somewhere specific. Past the code. Past the diff. Past the deploy. It lands on the question those things were always in service of: what should we build, and for whom, and why. Discovery. The part of the job that happens in a room with a person describing a problem badly.

Every layer that compressed had one thing in common: it was legible. Code is text. A diff is a list. A deploy is a state transition. Machines eat legible things. A half-formed problem in a customer’s head, the constraint nobody wrote down, the workflow they’ve worked around for so long they’ve stopped seeing it, none of that is legible. It doesn’t compress, because it was never written down in the first place.

The Tell Is in the Labs’ Own Org Charts

Here’s the part that should make anyone declaring software engineering dead go quiet for a second.

The companies building the models that supposedly retire engineers are hiring engineers as fast as they can, and shipping them to customers’ offices. Postings for the forward-deployed engineer, the embedded “make the AI actually work here” role Palantir invented two decades ago, jumped more than 800% across 2025. Google is hiring hundreds. Anthropic stood up a dedicated services firm and an Applied AI team built around the role; OpenAI formalised the same thing as “The Deployment Company.” Between them the two reportedly spent billions on consultants this year. The job pays $300k to $600k, and it is, stripped of the title, go understand the customer’s problem in person.

Why would a frontier lab spend that, when its whole pitch is that the model does the work? Because roughly 95% of enterprise AI pilots produced no measurable impact, and not because the models were weak. They failed in the gap between what the model can do and what the business actually needs, a gap that only closes when a human who understands both sides sits in the room. CIO called forward-deployed engineers “the new AI limiting factor.” Read that again. The limiting factor on the most advanced AI on earth is not compute. It’s a person who understands the problem.

The labs just told you, with the most honest signal a company has, their hiring budget, that the scarce resource in AI is not the model. It’s someone who understands what to point it at.

Why the Conversation Won’t Compress

A model can draft the spec in seconds. But the spec is only ever as good as the understanding behind it, and that understanding has no fast mode. It comes from tacit, unwritten things: the reason they tried the obvious solution and it failed, the politics that kill half the options, the thing they actually do versus the thing the process says they do. You don’t prompt your way to that. You sit there until it surfaces.

And the stakes went up, not down. When delivery was slow, a shallow understanding produced one wrong feature a quarter. Now that delivery is nearly free, a shallow understanding produces wrong software at machine speed. Speed without understanding isn’t velocity, it’s just arriving at the wrong place sooner. Build around the problem, not the capability, or you’ll build a great deal of the wrong thing very quickly.

The Good News

So the death-of-the-software-engineer story has the polarity backwards. The job didn’t disappear. It moved to the front of the room.

Software engineering was never really about typing code. It was about understanding a problem well enough to build the right thing, and the typing was the tax you paid to express it. AI didn’t kill the job, it refunded the tax. What’s left is the part that was always the point, and the market has noticed: the engineer who can sit with a customer, absorb a mess, and translate it into something a fleet of agents can execute is the most expensive hire at the most advanced companies in the world. That’s not the end of the profession. That’s a promotion nobody asked for.

What This Doesn’t Mean

The honest caveats, because “go talk to humans” is easy to romanticise:

• Time with people is not automatically insight. A calendar full of customer calls produces nothing if you’re listening to confirm what you already decided. The skill is the listening, not the meeting. Bad discovery is still bad, just slower.
• Not everyone wants this job. Plenty of excellent engineers chose the work precisely because it let them avoid customers, travel, and politics. “The valuable work is now customer-facing” is good news for the profession and unwelcome news for a lot of individuals in it.
• It’s still consulting. Billions in services revenue is also an admission that the product doesn’t deploy itself, and consulting has always been a margin-thin treadmill. Don’t mistake a forward-deployed engineer for proof the models are magic; it’s closer to proof they aren’t.
• AI does touch discovery at the edges. It synthesises interview notes, drafts the spec, surfaces patterns. The edges speed up. The core act, one human understanding another’s problem, is the part that stays slow.

Closing

Everything that could be made fast got made fast. Strip all of it away and what’s left is the thing software was always actually about: a person understanding another person’s problem well enough to know what to build. It resisted every dial and every hook because it was never legible enough to automate, and that turns out to be the most durable moat there is.

The most advanced AI companies on the planet just put a $600k price tag on it and ran into customers’ offices. The lesson is not subtle. Go spend the time. It’s the last slow thing, and it’s the only one that was ever the point.