What 400,000 Claude Code sessions reveal — domain expertise beats a coding background, and the gap is widening

Anthropic just published its largest look at how Claude Code is actually used — roughly 400,000 interactive sessions from about 235,000 people between October 2025 and April 2026. The coverage settled on one line: AI coding rewards domain expertise, not a coding background. For once the headline is basically right. The data underneath it is more interesting — and in two places, sharper — than the headline suggests.

This is the read-the-data version: what the study found, what the numbers actually say (including the ones the headlines skip), and what it means for the question you actually have — should you still learn to code?

The 30-second version

1. The study: ~400,000 Claude Code sessions, ~235,000 people, Oct 2025–Apr 2026. Anthropic classified each session by the user’s likely domain expertise and measured whether it reached verified success.
2. The headline holds. Among the ten largest occupations, every one lands within 7 percentage points of software engineers. Non-software occupations hit 29% verified success vs 34% for software ones. A coding background helps less than you’d guess.
3. But success is low across the board. Novices reach verified success 15% of the time; intermediate and expert users top out at 28–33%. This is not “anyone can ship now.”
4. Humans plan, Claude executes. Users make about 70% of planning decisions (what to build, what counts as done); Claude makes about 80% of execution decisions (how to write it).
5. Expertise widens the gap. Experts don’t just succeed more — each prompt does more: ~12 actions and ~3,200 words of output per turn, vs ~5 actions and ~600 words for novices. Same tool, very different leverage.
6. What it means: the scarce skill is understanding the problem, not the syntax. Good news if you have domain depth; a warning if the plan was to let the AI supply the judgment too.

What the study measured

Anthropic took transcripts from real Claude Code usage and, for each session, estimated the user’s expertise and whether the work reached a verified result — code that demonstrably did what the session set out to do, not just code that got produced. It then sliced outcomes by expertise level (novice, intermediate, expert) and by the user’s likely occupation.

Two definitions carry the whole study, so it’s worth being precise. Verified success is the strict bar: the session reached a confirmed working result. Partial success is the loose bar: it made real progress but didn’t fully land. Almost every finding below is more striking on the strict bar than the loose one — and most headlines quote neither.

The headline, accurately: background matters less than understanding

This is the part that travelled, and it survives scrutiny. Sliced by occupation, the ten largest groups in the dataset all finished within 7 percentage points of software engineers on verified tasks. In aggregate, non-software occupations reached 29% verified success against 34% for software-related ones — a real gap, but a narrow one given that one group writes code for a living and the other doesn’t.

Anthropic’s own framing is blunter than the press version: “Coding agents are making a coding background less relevant to successful programming,” and “success is determined by how well a person understands the problem they are trying to solve.” The thing that predicts whether you get working code out of Claude Code is not fluency in a language — it’s clarity about what you’re trying to build.

That’s the genuinely new claim, and the data backs it.

The part the headlines skip: “success” is still rare

Here’s what almost none of the coverage led with. Read the strict bar and the numbers are humbling:

• Novices: 15% verified success.
• Intermediate and expert users: 28–33% verified success.

Even for experienced users, roughly two out of three sessions don’t reach a verified result. The optimistic-sounding numbers you may have seen — 77% for novices, 91–92% for experienced users — are partial success: progress was made, the thing didn’t fully work. Both bars are real; they answer different questions. “Did Claude help me move forward?” is usually yes. “Did the session produce confirmed working code?” is usually no.

That matters because the comfortable reading of this study — anyone can ship software now — isn’t what the data says. What it says is that anyone can make progress, and that turning progress into verified, correct output is still the hard part. Which is exactly where understanding the problem (and being able to check the answer) earns its keep.

Expertise widens the gap, it doesn’t close it

The most counterintuitive finding is that AI coding doesn’t level the field — it tilts it further toward people who already know what they’re doing. Expertise shows up less in raw success rate than in leverage: how much each instruction accomplishes.

*Intermediate users sit in the same 28–33% / 91–92% band as experts. The jump is from novice to intermediate; intermediate-to-expert adds little to the success rate but a lot to leverage.

Read the bottom two rows. An expert’s single prompt sets off an action chain more than twice as long and carries over five times the output. Anthropic’s line for this is “domain experts are able to direct Claude to do more work with each instruction they give.” Same model, same tool — the expert simply asks for more, more precisely, and gets more back. And when a session goes sideways, experts claw it back to a verified result almost four times as often (15% vs 4%).

So the optimistic story — give everyone a coding agent and the skill gap shrinks — runs backwards. Hand the same tool to a novice and an expert, and the expert pulls further ahead, because the tool rewards the ability to specify and verify work.

Humans plan, Claude executes — which is also the usage manual

The cleanest practical finding is the division of labor: across sessions, users made about 70% of the planning decisions — what to build, what the constraints are, what “done” means — while Claude made about 80% of the execution decisions — how to structure the code, which calls to make, how to wire it up.

That’s not just a description; it’s instructions. The human’s job is the part the model is worst at and you’re best at: deciding what’s worth building and what correct looks like. The leverage gap above is downstream of this — experts get more per prompt because their planning is sharper, so each instruction carries more usable intent.

It also tells you where to spend effort in the tool. If the win comes from better planning and clearer problem statements, then the artifacts that encode your intent matter more than your prompting tricks: a precise spec, and a well-written CLAUDE.md that hands the model the constraints and context it can’t infer. The study is, in effect, an argument for treating your CLAUDE.md as the place your judgment lives — because the model supplies the execution, and you supply almost everything else.

So should you still learn to code?

Yes — but the center of gravity moves. The study reframes the value of a coding background from writing the code to judging the code. Verified success tops out around a third of sessions even for experts, which means someone has to catch the two-in-three that don’t work — and that someone needs enough fluency to tell working code from plausible code. The skill that’s depreciating is typing syntax from memory. The skills appreciating are problem definition, domain depth, and verification.

For most people the actionable read is: invest in understanding a domain deeply enough to specify and check work in it, treat programming literacy as the thing that lets you verify rather than the thing that produces output, and stop measuring yourself by how much code you can write unassisted. If you’re choosing where to get better, the data points at judgment over keystrokes.

The caveats that matter

This is a large, careful study, but it measures less than the headlines imply, and Anthropic says so:

• It can’t see real-world outcomes. “Verified success” is judged inside the session. Whether the code was actually shipped, used, or quietly thrown away afterward is invisible to the study.
• It excludes non-interactive usage — a substantial share of how Claude Code is actually run (scripts, automation, headless jobs). The picture is of interactive sessions only.
• The classifications lean on a model reading transcripts, which the researchers concede “remain challenging to validate at scale,” and some session complexity exceeds what humans can reliably label as ground truth.

None of that sinks the findings, but it sets the right altitude: this is strong directional evidence about how the tool is used and who gets results, not a precise benchmark. Read it as a map, not a measurement.

The through-line survives all the caveats anyway. AI coding agents are quietly repricing skills — down for writing code, up for understanding problems and checking answers. The people who win the next stretch aren’t the fastest typists. They’re the ones who know what to build and can tell when the machine got it wrong.

Companion reading

• Best AI coding agents right now — what to point this judgment at
• How to write a great CLAUDE.md — where your planning and constraints actually live
• The CLAUDE.md guide — everything that changes Claude Code’s behavior
• Claude Code agent teams: worth the tokens? — when more agents help, and when they don’t
• State of AI coding agents — June 2026 — the wider picture this study sits in

Sources

1. Agentic coding and persistent returns to expertise — Anthropic research
2. AI Coding Agents Reward Domain Expertise, Not Coding Skill: Anthropic Study of 400K Sessions — Tech Times
3. Anthropic releases economic research on Claude Code usage — Crypto Briefing

FAQ

What did Anthropic’s 400,000-session study find? That success with Claude Code is predicted by domain expertise — how well you understand the problem — far more than by a coding background. Across the ten largest occupations, all landed within 7 points of software engineers (29% verified success for non-software occupations vs 34% for software ones), studied over ~400,000 sessions from ~235,000 people, Oct 2025–Apr 2026.

Does this mean you don’t need to learn to code? No. Verified success was still only 15% for novices and 28–33% for experts, so someone has to judge whether the code is right — and a coding background helps you do that. The scarce skill shifts from writing syntax to understanding problems and verifying output.

Who succeeds most — engineers or non-engineers? Engineers still edge it (34% vs 29% verified), but the gap is small. Expertise level matters more than job title: novices hit 15%, intermediate and expert users 28–33%.

Does giving everyone AI coding tools close the skill gap? The study suggests the opposite. Experts direct Claude to do far more per instruction (~12 actions and ~3,200 words per prompt vs ~5 and ~600 for novices), so the same tool widens the gap between those who can specify and verify work and those who can’t.

What are the study’s limitations? It can’t see whether code was used or discarded after a session, it excludes non-interactive usage, and its classifications depend on a model reading transcripts — which the researchers say is hard to validate at scale. It’s directional evidence, not a precise benchmark.