How Agentic Coding Really Did Make Software Engineers Optional (And Why That's Wonderful)

---

Pull up a chair, because the most interesting thing in software this week is not a new model. It is not a fresh benchmark. It is a study from Anthropic's Economic Research team, published June 16, that took a hard look at roughly 400,000 real Claude Code sessions between October 2025 and April 2026, and asked a question most of the industry has been dodging.

Who actually wins with agentic coding?

The boring answer that turns out to be huge

Here is the result, and I want you to sit with it for a second. Sessions where the user had deep knowledge of the problem they were trying to solve reached "verified success" more than twice as often as sessions where the user was a novice at the task. An expert user got 3,200 words of output per prompt on average, against 600 for a novice. Their prompts set off action chains more than twice as long. The expert was, in every measurable way, running a different tool.

But here is the part that made me put my coffee down.

The gap between intermediate and expert is modest. Most of the gain in success rate happens when you climb out of "novice" into "I sort of know what I'm doing." Once you are competent in your domain, the curve flattens fast. The middle of the distribution gets almost everything; the very top gets a little more.

Read that again. A working grasp of your problem captures most of the benefit. Deep specialization adds a bit, but not orders of magnitude. Coding agents are not amplifying the elite. They are amplifying the competent.

What is actually happening at the keyboard

Anthropic's team is careful with their language, so let me translate the parts that matter for the rest of us.

In a typical session, the user makes about 70% of the planning decisions and the agent makes about 80% of the execution decisions. People decide what to build. The agent decides how. That division of labor is stable across occupations, across task types, across model generations.

Here is the kicker. People in software-related occupations reach verified success in about 30% of their sessions. People from other professions reach it about 26% of the time. The difference is rounding error. On coding tasks specifically, every major occupation succeeds at nearly the same rate as software engineers.

Or, as Anthropic puts it themselves: "a person with such command, in any field, may now be able to do technical work they previously could not."

We have been arguing for two years about whether AI will replace engineers, replace juniors, replace entire teams. The 400,000-session data set says we were asking the wrong question. The question is what gets amplified, and the answer is domain expertise that knows what good looks like.

The tooling is racing to keep up

You can see this in the shipping news. On June 17, an open-source project called Polypore dropped with a quietly radical pitch. The README does not call itself a code editor with an agent panel. It calls itself an "agentic desktop IDE" where "the layout, the memory system, the debug tooling, and the MCP server are all designed around the agent as the primary actor."

That phrasing is the tell. The center of gravity of the IDE is shifting. The user is not the writer of code. The user is the director of an agent. The whole interface is being rebuilt around that fact: dockable panels for Claude, Codex, preview, diff, debug, memory. The plumbing is catching up to the model.

And yes, there is a loud counter-narrative. Lars Faye published a sharp critique in May, updated this week, arguing that the "human as orchestrator" framing hides a real cost: cognitive debt, skill atrophy, vendor lock-in, and the irony that the very critical thinking required to spot bad agent output is the first thing the tools erode. He is not wrong about the trade-offs. The workflow absolutely does put a growing distance between the human and the code being committed.

But the trade-off he is naming is the price of admission, not a verdict. Every prior productivity wave looked like this from the inside. Spreadsheets made it easier to miscalculate. Photoshop made it easier to ship ugly work. Cloud made it easier to waste money. The right response was never to refuse the tool. It was to raise the floor on what "good" means.

What I would actually do on Monday

If you are an engineer reading this, the lesson is to invest harder in the part that does not show up in your git log. Talk to customers. Read the codebase you are building against until you can predict its bugs. Learn the domain. The agent will be there to do the typing.

If you are not an engineer, the lesson is the one Anthropic just put a number on. You probably have more leverage than you have ever had. The intermediate-to-expert gap being small means the floor is closer than you think. You do not need a CS degree to direct a competent agent through a problem you understand well. You need a working grasp and the patience to iterate.

The share of GitHub projects with coding agent activity has more than doubled since late 2025. Claude Code users now spend an average of 20 hours per week in the tool. Over the seven months Anthropic studied, the value of the typical task rose about 25% on average, and the share of sessions spent debugging fell by nearly half. The agents are getting better. The humans are using them on harder things. The mix is shifting.

We were promised that AI would change who could build software. The 400,000-session study suggests something more specific and more interesting. It is changing what counts as the bottleneck. It used to be typing speed and syntax fluency. Now it is knowing what to ask for and what "done" looks like.

That is not a threat. That is the whole point.