The Experts Keep the Wheel

There is a paper circulating right now — field observations of thirteen developers, qualitative surveys of ninety-nine more — about how experienced engineers actually use AI agents in their work, and the headline finding is almost too tidy to be true: they use agents as a productivity boost, they feel good about it, and they keep control of everything that matters.

The agents do not design software. The agents do not make architectural decisions. The experienced developers retain their agency — the paper literally uses the word "insistence" — on software quality, and they develop strategies for steering agent behavior that draw directly from their expertise. This is not incidental. It's the mechanism.

Which means the people getting the most out of AI agents are the people who already know what they're doing.

Sit with that for a second.

The thing agents are supposed to democratize — the ability to build software — turns out to be gated by the same expertise it was supposed to replace. You need to know enough to direct the agent, catch its mistakes, recognize when it's going sideways, and correct it before the error propagates into something that takes three hours to unpick. The expert developers in this study are confident about "complementing the agents' limitations." Junior developers, by definition, don't know what the limitations are yet.

This is not a criticism of the paper. The paper is excellent — required reading, actually — precisely because it documents this clearly instead of burying it. The researchers went out and watched real professionals work, not undergrads in a lab, not self-reported surveys about hypothetical behavior. Thirteen people, observed in the field. That's how you find out what's actually happening instead of what people imagine is happening.

What's actually happening is: the agent is a powerful tool in expert hands, and a confident disaster in everyone else's. The expert brings taste, judgment, a sense of what "correct" looks like that can't be prompt-engineered into existence. They know which tasks to hand off and which to hold. They know when the agent's output is subtly wrong in ways the agent itself cannot detect. They have the pattern library to recognize the shape of a mistake before it becomes a bug.

The agents, in this model, are not replacing senior engineers. They are making senior engineers faster. Which is fine and good and also means the leverage is accruing to exactly the people who already have it.

The paper frames this as an opportunity — better agentic interfaces, better guidelines for agentic use — and that's probably the right institutional posture. But the finding underneath the framing is that software development best practices are not an obstacle to using agents effectively. They're a prerequisite.

Nobody planned this.