Why domain knowledge predicts Claude Code success better than coding fluency
What predicts success with Claude Code is how well you understand the problem you are solving, not whether you have a software-engineering background. That is the core finding of Anthropic's June 16, 2026 study Agentic coding and persistent returns to expertise, which analyzed 398,198 interactive sessions from 234,751 people between October 2025 and April 2026 (Anthropic, 2026-06). It is a usage study at session scale, not a benchmark — and the gap between technical and non-technical professions is far smaller than most builders would guess.
Quick Answer: In Anthropic's 398,198-session Claude Code analysis (Oct 2025–Apr 2026), software-related occupations hit verified success in about 34% of code-producing sessions versus about 29% for everyone else — a roughly five-point gap. Domain expertise in the problem, not coding background, drives outcomes.
The dataset is deliberately scoped. It covers interactive agentic coding through the Claude Code CLI, Claude.ai, and the Claude Code desktop app, and it excludes Anthropic's internal usage along with headless, zero-human-turn work such as programmatic CLI calls, third-party IDE integrations, and SDK automation (TheRouter, 2026). So this is a picture of humans steering the agent in a session, not Claude Code's full economic footprint — which is exactly the setting where you would expect coding skill to dominate, if it dominated anywhere.
It does not. In code-producing sessions, software and math occupations reached verified success in about 34% of cases against about 29% for other professions — a gap of only about five points. On the looser partial-success measure, the gap nearly disappears: roughly 89% for software users versus about 88% for everyone else (Tech Times, 2026-06).
The practical reading is a reframed competitive moat. An accountant who can specify reconciliation rules precisely and catch an edge case is, for that task, the expert in the loop — and that subject-matter knowledge predicts outcomes more reliably than years writing production code. The sections that follow unpack how Anthropic measures expertise, why expert sessions extract more than twice the work per prompt, and where the gap actually sharpens.
How the five-point expertise rating redefines who is a novice by problem domain
Anthropic's expertise rating is a five-point, task-specific scale that measures command of the problem in front of the user, not their résumé — and crucially, the same person can sit at different points on it from one conversation to the next . The score is inferred per session, so a developer can be an expert when refactoring familiar TypeScript and a novice an hour later when probing a domain they have never touched. Expertise is read off the transcript, not declared up front.
Three behavioral signals drive the rating: how specifically the user sets up the task, what kind of verification they apply to Claude's output, and who corrects whom when the agent goes off course . A vague prompt followed by uncritical acceptance reads as low expertise; a tightly scoped request, a concrete test of the result, and the user catching Claude's mistake read as high expertise. Job title and years of experience never enter the calculation .
That design produces the report's most counterintuitive reclassifications. A senior engineer asking their first Rust question — unsure of the idioms, unable to spot a wrong borrow-checker workaround — is rated a novice for that task . Meanwhile an accountant who specifies reconciliation rules precisely and catches an edge case in the generated logic is rated an expert, because the transcript shows tight setup, real verification, and the human steering the correction .
The scoring itself is machine-applied, which sets the boundaries of what it can see. Most of Anthropic's classifiers ran on Claude Sonnet 4.6 at temperature 0.2, reading transcripts that were truncated to 25,000 characters overall with individual turns middle-truncated at 5,000 characters . In very long sessions that truncation can drop context the rating never gets to weigh — a limitation Anthropic flags directly. The expertise label is an inference from behavior, not a measured credential.
Anthropic frames the takeaway plainly:
"Domain expertise — understanding the problem being solved — predicts success in agentic coding more reliably than a formal software-engineering background." — Anthropic Economic Research, Agentic coding and persistent returns to expertise (source: Anthropic, 2026-06).
Twelve Claude actions per prompt vs five: the output multiplier by expertise
Expertise shows up most directly in how much work Claude does per instruction. In an expert-rated session, each user prompt triggers about 12 Claude actions and roughly 3,200 words of output; in a novice-rated session the same prompt yields about 5 actions and roughly 600 words. That is a 2.4x gap in actions and roughly a 5x gap in words — the agent's leverage scales with the operator, not just the model.
For baseline, the typical interactive session runs about four user-Claude turns, and across all sessions each prompt averages about 10 Claude actions and roughly 2,400 words (source: Anthropic, 2026-06). An "action" here means a discrete agent step — reading a file, editing code, running a command — so the action count is a proxy for how much Claude executes before handing control back.
The distribution has a heavy tail. Most sessions cluster near the average, but about 2% of sessions average more than 100 actions per prompt, roughly 1 in 270 average more than 200, and about 1 in 2,300 average more than 500. These are sessions where a user hands Claude a well-specified problem and lets it run long chains of work — the high end of agentic delegation.
| Metric (per prompt) | Novice-rated | Expert-rated | Gap |
|---|---|---|---|
| Claude actions | ~5 | ~12 | 2.4x |
| Claude output words | ~600 | ~3,200 | ~5x |
| All-session average | ~10 actions / ~2,400 words | — | |
The relationship is graded, not binary. After controls, each step up Anthropic's five-point expertise scale adds about +9% actions and +13% output, a gradient significant at p < 0.001 (source: Anthropic, 2026-06). Practitioner analysis at TheRouter reads these multipliers as a case for per-profile token budgeting and model-tier routing — though that is downstream inference, not an Anthropic recommendation, and should be treated as analysis.
The mechanism worth noting: higher output is not Claude being more verbose for its own sake. Expert operators give the agent enough specification and verification scaffolding that it can take more steps confidently per turn, which is exactly why the same model produces five times the work for one user and a fraction of it for another.
Completion by expertise band: the gap sharpens when sessions hit trouble
That extra work only pays off if it lands, and Anthropic's session data shows completion rises steadily with expertise — then diverges most sharply exactly when a session goes wrong. On the strict verified-success measure, novice-rated sessions succeed about 15% of the time versus 28–33% for intermediate-or-higher bands . The report could not observe real-world outcomes directly, so it combined transcript classifiers with hard signals — passing tests, commits, pull requests, and explicit user affirmation — and excluded the roughly 7.7% of sessions with no clear goal from the success analysis .
Quick Answer: Expertise barely changes whether a smooth session finishes, but it dominates recovery. In troubled sessions, verified success runs 4% for novices versus 15% for experts, and abandonment is 19% for novices against 5–7% for every higher band — domain knowledge steers agents out of failure .
The bar you choose changes the story. On the looser partial-success measure, novices reach 77% while intermediate-and-up bands sit at 91–92% — the gentler threshold compresses a roughly two-to-one gap into a 14-point spread . In other words, most users get something usable most of the time; the expertise premium is concentrated in whether the result is verifiably correct, not whether the agent produces output at all.
| Measure | Novice | Intermediate+ / Expert |
|---|---|---|
| Verified success (all sessions) | 15% | 28–33% |
| Partial success (all sessions) | 77% | 91–92% |
| Verified success (troubled sessions) | 4% | 15% |
| Abandonment (troubled sessions) | 19% | 5–7% |
The divergence is steepest once a session hits trouble. Among sessions that run into problems, verified success climbs from 4% for novices to 15% for experts, and abandonment falls from 19% for novices to 5–7% for every other band . That pattern is the report's strongest evidence for its central claim about steering.
"Domain expertise helps users steer agents out of trouble rather than simply write better first prompts," — Anthropic, Agentic coding and persistent returns to expertise (source: Anthropic, 2026-06).
The practical reading: a strong opening prompt gets you in the door, but recovery is where subject-matter knowledge separates outcomes. An operator who understands the problem catches the wrong turn, supplies the missing constraint, and redirects — instead of accepting a plausible-but-wrong result or walking away. Crypto Briefing framed the same data as humans still doing most of the thinking, and the troubled-session numbers are where that thinking is most visible. One caveat carries over from the methodology: "success" here means task completion, not long-term maintainability, since Anthropic cannot directly measure whether code was ultimately shipped, secure, or high quality .
Every measured profession finishes within seven percentage points of technical roles
The expertise gradient does not translate into a professional caste system. Across the ten largest occupation groups in the dataset, every one landed within about seven percentage points of Computer and Mathematical users on verified success . In code-producing sessions specifically, software-related occupations reached verified success in roughly 34% of sessions versus about 29% for everyone else — a five-point spread — and on the looser partial-success measure the two groups were nearly indistinguishable at about 89% and 88% . That is the empirical core of the headline: a profession's job title barely moves the completion needle once you account for how well the user understands the task in front of them.
The composition of who is actually using Claude Code reinforces the point. Anthropic could infer an occupation in about 70% of sessions; the remaining 30% lacked enough signal and were excluded from occupation-level analysis, so these breakdowns describe the inferable majority rather than the full sample . Within that majority, the five largest groups by session count were, in order:
- Computer and Mathematical Occupations — the largest single group
- Business and Financial Operations
- Arts, Design, Entertainment, Sports, and Media
- Management
- Life, Physical, and Social Sciences
So accountants, analysts, designers, and scientists are not edge cases in this data — Business and Financial Operations sits in second place by volume, directly behind the developers the tool was built for. That ordering is consistent with the report's broader argument that subject-matter knowledge, not coding fluency, is the binding constraint on agentic-coding success .
The trend lines point further away from the developer-first audience. Over the October 2025 to April 2026 window, the fastest-growing non-software occupation groups were Management, Sales, and Legal . None of those roles is defined by writing code, yet all three are expanding their share of interactive sessions — a signal that agentic coding is leaking out of engineering org charts and into adjacent knowledge work where the user supplies the domain rules and Claude supplies the implementation.
One caution belongs on these numbers. Anthropic warns that explicit-confirmation behavior may partly explain why management occupations edged slightly above software users on verified success, because users who reply with clear affirmations register more "verified" completions regardless of the underlying code quality . Read the seven-point band as evidence that profession is a weak predictor of completion, not as a ranking of which job titles write the best software.
Who decides the approach vs the implementation: the 70/80 split
In interactive Claude Code sessions, humans own the strategy and the agent owns the keystrokes. Anthropic's session analysis attributes about 70% of planning decisions — what to build, which approach to take, and what counts as done — to the human, while Claude makes roughly 80% of execution decisions: which files to edit, what code to write, and which commands to run . The division is clean: judgment stays with the person, mechanics shift to the model.
That split reframes what "agentic" means in practice. The agent is not choosing the destination; it is covering ground toward a destination the user has already set and continues to police through acceptance criteria. Crypto Briefing read the same numbers and summarized the takeaway bluntly — humans are still doing most of the thinking — which is consistent with why domain expertise predicts success: steering only matters if you still hold the wheel.
The decision split also lines up with how far Claude now runs before checking back. Anthropic's February 2026 autonomy analysis found that the longest-running Claude Code turns nearly doubled — from under 25 minutes to over 45 minutes — between late September 2025 and early January 2026, even as the median turn stayed around 45 seconds . The tail got longer while the typical interaction stayed conversational. So the agent can execute for longer unsupervised stretches, but those stretches are bracketed by a human who framed the task going in and judges the result coming out.
This is the load-bearing distinction for anyone deciding how much to delegate: the 70/80 split describes supervised delegation, not autonomous replacement. The human still defines the goal and the bar for "done," and — as the troubled-session data showed earlier — is the one who intervenes when the agent drifts. Boris Cherny, who leads Claude Code at Anthropic, has framed the near-term shift as coding moving from typing toward specifying intent (video: Sequoia Capital), which is precisely what a 70% share of planning decisions looks like in transcripts. Execution scales; ownership does not transfer.
For builders, the practical reading is that adding Claude Code to a workflow does not remove the person who decides what good looks like. It removes the typing between that decision and a working artifact. The bottleneck moves from implementation throughput to the quality of the goal, the approach, and the acceptance test — all of which remain human.
From debugging to operating: how the session composition changed between October and April
What people use Claude Code for shifted measurably over the seven-month window. Debugging and fixing fell from about 33% of sessions in October to about 19% by April, while operating software — running, configuring, and orchestrating systems rather than writing new code — rose from about 14% to about 21% . Writing plus data analysis roughly doubled over the same period, from about 10% to about 20% of sessions . The center of gravity moved away from repairing existing code and toward running things and producing non-code output.
A point-in-time snapshot of the work mix shows where the tool sat by the end of the window. About 56% of sessions were code-producing, split into roughly 25% building, 26% fixing, and 5% testing or orchestrating; another 17% were operating software, 14% were planning or exploring, and 13% were analysis or prose . That distribution matters for anyone budgeting tooling spend on a single mental model: roughly two in five sessions are no longer writing or fixing application code at all.
The composition shift lines up with the falling share of debugging. Fixing dropping from a third of sessions to under a fifth is consistent with the steering story from earlier expertise bands — fewer sessions stuck in repair loops, more spent running and extending systems. It is also consistent with the broader user base widening beyond software occupations, since operating, analysis, and writing are the modes where domain specialists who are not career engineers tend to land first.
Anthropic also attached a rough economic read to the trend using a coarse proxy that matched sessions to freelance-market postings. By that estimate, the average task value rose about 27% between October and April, with building up about 43%, operating up about 34%, and fixing up about 32% . Anthropic summarizes this as roughly 25% value growth across nearly every kind of work, not a single category pulling the average .
Two cautions belong on that number. The value proxy maps sessions to freelance postings, so it tracks the market price of similar tasks rather than realized outcomes, and Anthropic repeatedly notes it cannot observe whether the code was ultimately used, discarded, or maintained . Read directionally, the seven-month picture is a tool moving up the value chain: less time on repair, more on operating and producing, with the work that grew fastest being the work that started highest.
For architects and founders: reading the 5x output gap correctly
For anyone building a Claude Code–powered product, the practical lesson is to capture domain knowledge, not to gate users on coding fluency. Anthropic's session data shows software-related occupations reached verified success in roughly 34% of code-producing sessions versus about 29% for everyone else — a five-point gap. The moat sits in subject-matter specificity (reconciliation rules, edge cases, what counts as done), so onboarding flows that elicit that context will outperform ones that assume a developer background.
The output multiplier has direct cost and routing consequences at scale. Expert-rated sessions trigger about 12 Claude actions and roughly 3,200 words per prompt against about 5 actions and 600 words for novices — a 2.4x action gap and roughly 5x output gap. Across a fleet of concurrent sessions, that compounds into very different per-user token budgets. Practitioner analyses (TheRouter) read the multipliers as an argument for per-profile budgets and model-tier routing, though that is secondary inference rather than Anthropic guidance, so treat it as a hypothesis to test against your own telemetry.
- Capture context, don't gate on it: every one of the ten largest occupations finished within seven points of technical roles.
- Budget for the long tail: about 2% of sessions average more than 100 actions per prompt.
Two caveats should bound any decision you make on this. First, "verified success" captures task completion only. Anthropic combined classifiers with hard signals like passing tests, commits, and pull requests, but it cannot observe whether the generated code was ultimately used, secure, or maintainable. Second, generalization is unverified: the study measures Claude Code specifically, so extrapolation to Codex- or Gemini-based agents is not supported, and METR cautions that its own time-horizon benchmarks skew toward software engineering, ML, and cybersecurity rather than the messy job-level work mix seen here .
The concrete takeaway: instrument your product around expertise, not job titles. Surface prompts that pull domain rules out of users, watch the action-per-prompt distribution as a budget signal, and verify quality with your own tests and review rather than trusting completion as a proxy for it. The dataset of about 398,198 sessions describes who finishes tasks — not whose code ships and survives. That last mile is still yours to measure.
Frequently asked questions
Does coding experience actually matter for Claude Code success?
It matters, but less than you might assume. In code-producing sessions, software-related occupations reached verified success in about 34% of sessions versus about 29% for everyone else — a gap of only roughly five percentage points . Every one of the ten largest occupation groups in the dataset landed within seven points of software and math users on success . What predicts outcomes more reliably is domain expertise in the specific problem being solved, not a formal software-engineering background per se.
How does Anthropic define expertise in this June 2026 analysis?
Expertise is rated on a five-point, task-specific scale built from three signals: how specifically the user sets up the problem, what kind of verification they apply, and who corrects whom during the session . Crucially, it is not tied to job title — the same person can be a novice on one problem and an expert on another, so a senior engineer asking a first Rust question scores as a beginner for that task . The ratings were assigned by Claude Sonnet 4.6 classifiers at temperature 0.2 .
Why do expert-rated prompts generate so much more Claude output?
Specific, well-specified prompts give Claude room to plan and execute sub-actions autonomously instead of pausing for clarification. After controls, each step up the expertise scale adds about +9% actions and +13% output, significant at p < 0.001 . The effect accumulates: expert sessions average about 12 Claude actions and roughly 3,200 words per prompt, versus about five actions and 600 words for novices — a 2.4x action gap and roughly 5x output gap .
What is Claude Code actually being used for, based on this data?
A point-in-time breakdown puts about 56% of sessions on writing, fixing, testing, or orchestrating code, 17% on operating software, 14% on planning or exploring, and 13% on analysis or prose . The mix shifted over the seven-month window from October 2025 to April 2026: debugging and fixing fell from 33% to 19% of sessions, while operating software rose from 14% to 21% and writing plus data analysis roughly doubled from about 10% to 20% .
How reliable is the 'success' measurement when Anthropic can't see production outcomes?
The measure combines transcript classifiers with hard signals — passing tests, commits, pull requests, and explicit user affirmation — and excludes the roughly 7.7% of sessions with no clear goal . Anthropic repeatedly cautions that this captures task completion only, not whether the code was ultimately used, discarded, secure, or maintainable . Treat "success" as a signal that a task finished, and verify shipping quality with your own tests and review.
