What 400,000 Claude Code Sessions Reveal About Agentic Coding

What the research actually measured

Anthropic has published an economic research report based on a privacy-preserving analysis of roughly 400,000 interactive Claude Code sessions from about 235,000 people between October 2025 and April 2026. Rather than running benchmarks, the team looked at how the tool gets used in the wild: what kinds of tasks people bring to it, who is doing the work, and whether sessions end in success.

To make sense of that volume, each session is classified into one of nine "work modes"—the single activity that best describes what it was trying to accomplish. Four of those involve writing or maintaining code (building, fixing, testing, and orchestrating other agents). The rest cover operating software, understanding existing systems, planning changes, analyzing data, and writing prose documents.

The breakdown is worth noting if you assume coding agents are only for code. About 56% of sessions involved writing, fixing, testing, or orchestrating code. But 17% were about operating software—deploying, configuring, running pipelines, monitoring. Another 14% were planning or exploring, and 13% produced analysis or prose. In other words, a meaningful chunk of agentic coding sessions aren't really about typing code at all.

The division of labor and why expertise wins

The report's central finding is a clear split: people decide *what* to build, and the agent decides *how* to build it. In a typical session, humans make most of the planning decisions while Claude handles execution. That framing matters for anyone designing automated workflows—the agent is good at carrying out a well-defined intent, but the intent still has to come from a person who understands the problem.

The more interesting claim is about who succeeds. Anthropic measures success as accomplishing what the person set out to do, backed by verifiable evidence like passing tests or committed work. On coding tasks, nearly every major occupation succeeds at roughly the same rate as software engineers. What separates outcomes is domain expertise, not coding proficiency. People who understand the problem they're solving get more work done per instruction and recover more easily from errors and misunderstandings.

There's a useful nuance here: the gap between *intermediate* and *expert* users is modest. You don't appear to need deep mastery to use the tool effectively—solid working knowledge of your domain seems to be enough. That's a more encouraging signal for teams than "only the top 1% can drive these agents."

The practical read is that agentic coding rewards understanding the problem over knowing the syntax. If you're a marketer who deeply understands attribution, or an analyst who knows your data model cold, you may direct an agent more effectively than a generalist developer who's unfamiliar with the domain.

What changed over seven months

Because the data spans October 2025 to April 2026, the report can show movement over time rather than a single snapshot. Two shifts stand out.

First, the share of sessions spent debugging fell by nearly half. Usage moved toward more end-to-end agentic work: deploying and running code, analyzing data, and writing non-code documents. That's the direction automation builders care about—less time babysitting broken output, more time handing off complete tasks.

Second, Anthropic estimates the value of the typical task by comparing it to freelance job postings, and reports that this value rose in almost every category—about 25% on average over the period. Treat that number with appropriate caution: it's an estimate derived from freelance pricing as a proxy, not a direct measure of business outcomes, and it comes from the vendor analyzing its own product. Still, the trend lines up with the qualitative shift toward more complex, higher-stakes work.

It's also worth keeping the framing honest. This is research on how one tool gets used, not a controlled study of productivity gains, and the population is people who already chose to use Claude Code heavily—the report cites an average of 20 hours per week. Self-selected power users are not the general workforce. Anthropic itself frames these as "early signals," and that's the right level of confidence.

Why it matters for automation builders

If you build workflows with tools like n8n, Make, or Zapier, the underlying lesson transfers well beyond Claude Code. Agents perform best when a person who understands the problem defines the goal clearly and the agent handles execution. The bottleneck is rarely the model's ability to write code; it's whether the human can specify what "done" looks like and verify it.

The shift away from debugging toward end-to-end use also suggests where to invest your effort: clear task definitions, verifiable success criteria like tests or committed output, and giving agents the context they need about your specific domain. The report's evidence that intermediate domain knowledge is nearly as effective as expert knowledge is a hint that you don't have to be a specialist to get value—you just have to actually understand the work you're automating.

Anthropic's broader point is that coding agents aren't substituting for domain expertise; they're amplifying it. The more understanding you bring, the more quality work the agent can produce. That's a reasonable lens for deciding where to point automation first.

If you want help putting agentic coding to work in your own stack, browse the provider directory to find people who do this for a living.