Why Coding Agents Do Not Eliminate Expertise — with Evgeny Sergeev

Anthropic's study examines 398,198 interactive Claude Code sessions from roughly 234,751 users between October 2025 and April 2026. It excludes Anthropic employees, SDK activity, third-party IDEs, and headless runs. A model classifies the work, task-specific expertise, human and agent decisions, and signals of successful completion. This offers an unusual view inside a real tool, but only for one product's audience and events visible in its session logs.

The central definition is that expertise is local. Seniority, occupation, and total experience do not guarantee knowledge of a technology or domain. A senior engineer encountering Rust may behave like a novice; an accountant may automate reconciliation successfully because they know its rules and exceptions. The useful question is not how experienced a user is in general, but how well they understand this task, its constraints, and the criteria for a correct result.

Humans more often decide what should be done and why, while Claude makes most local decisions about implementation. Experts provide specific context, sustain longer action chains, request verification, and redirect the work. Their sessions average about twelve agent actions and 3,200 output words, compared with five actions and 600 words for novices. This is not passive trust: a knowledgeable practitioner detects drift, explains the problem, and recovers after mistakes, making a larger delegation envelope safe.

The clearest gain appears between novice and competent practitioner, not as an endless premium for each additional level. Verified success rises from about 15 percent for novices to 28–33 percent at intermediate levels and above. In troubled sessions, experts recover verifiable results more often, while novices abandon attempts much more often. Work also shifts: less effort goes into fixing existing code and more into operations, analysis, and documentation. The agent moves expert work toward framing, monitoring, and evaluation rather than removing it.

The paper relies on proxies. Task value comes from prices for comparable freelance work, while success is inferred by a model reading the session. Telemetry cannot see whether code produced business value, passed production validation, caused an incident, or required later rework. The association also does not prove that expertise caused the outcome: experienced users may choose different tasks and have better context, tools, or checks. These findings show a plausible mechanism, not a universal law of the labor market.

The practical response is to measure outcomes independently of the agent. Teams need reproducible tests, product acceptance criteria, decision logs, evidence, and an accountable person who can explain the result. Training should emphasize decomposition, constraints, verification, and real failures instead of magical prompt formulas. Execution becomes cheaper, while choosing the problem, applying domain judgment, and accepting risk remain scarce. A coding agent converts expertise into throughput only when a control loop surrounds it.