---
title: "400K Claude Code sessions: what developers actually do"
canonical: "https://agenticup.dev/posts/400k-claude-code-sessions-what-developers-actually-do/"
pubDate: "2026-06-17T00:00:00.000Z"
description: "400,000 sessions. 235,000 users. 7 months of data. Here's what Anthropic's largest-ever study of coding agent usage actually reveals."
tags: [claude code, anthropic, ai coding agents, developer productivity, research, agent adoption]
---

**TL;DR:** Anthropic published a privacy-preserving analysis of ~400,000 Claude Code sessions from ~235,000 users between October 2025 and April 2026. The data reveals a clear division of labor: humans plan, agents execute. Domain expertise matters far more than coding proficiency for successful outcomes. Every major occupation succeeds within 7 points of software engineers on coding tasks. Debugging time fell by nearly half over 7 months. The task value of the average session rose 25%.

> **Key takeaways:**
> - People make 70% of planning decisions and Claude makes 80% of execution decisions. The division of labor is clean and consistent.
> - Every major occupation succeeds at coding tasks within 7 percentage points of software engineers. Management occupations come out slightly ahead.
> - Debugging fell from 33% of sessions to 19% over 7 months. Developers spend less time fixing and more time building.
> - The expertise gradient is real but shallow. The gap between novice and intermediate (15% to 28% verified success) is bigger than the gap between intermediate and expert (28% to 33%).
> - Task value rose 25% on average. Building tasks grew 43% more valuable.

---

Anthropic published a dataset of 400,000 Claude Code sessions on June 16. I spent a week reading what the numbers actually say. The headline findings are getting attention (managers succeed at coding tasks as often as engineers). But the real story is quieter and more important.

The paper is called [Agentic coding and persistent returns to expertise](https://www.anthropic.com/research/claude-code-expertise), by Zoe Hitzig, Maxim Massenkoff, and the Anthropic Economic Research team. It analyzes ~400,000 interactive sessions from ~235,000 people across 7 months. Claude Code users now spend an average of 20 hours per week using the tool, and the share of GitHub projects with coding agent activity has more than doubled since late 2025. A separate [METR randomized controlled trial](https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/) from July 2025 found that experienced open-source developers using AI tools showed mixed productivity effects, suggesting the learning curve for effective agent use is real and uneven.

This is the largest publicly analyzed dataset of coding agent usage. Here is what it actually shows.

## What does the division of labor look like in practice?

The paper builds a decision attribution classifier that reads each session transcript and separates every decision into two categories: planning (what to do, which approach, what counts as done) and execution (which files to change, what code to write, which commands to run).

The split is stark. On average, people make about 70% of planning decisions while Claude makes about 80% of execution decisions.

This isn't a futuristic scenario. This is what 400,000 sessions already look like. The human decides the direction and the acceptance criteria. The agent fills in the implementation. The more domain expertise the human brings, the more work Claude does per instruction.

A typical session has about 4 turns. Each prompt the user sends sets off a chain of around 10 actions taken by Claude: reading files, editing code, running commands, writing about 2,400 words of output. For expert users, that climbs to 12 actions and 3,200 words per prompt. For novices, it's 5 actions and 600 words.

The gap is entirely about how well you specify what you want.

## Do you need to be a developer to succeed with AI coding tools?

This is where the paper's most surprising finding lives.

The researchers classified each session into one of 23 occupational categories from the Bureau of Labor Statistics taxonomy, based only on signals in the session itself: project context, file structure, vocabulary, referenced artifacts. The classifier is explicitly instructed not to treat the act of coding as evidence of a coding profession. A lawyer who builds a script to flag missing clauses in contracts is classified as Legal Occupations, even if the session is entirely about writing code.

The result: every occupation succeeds at nearly the same rate.

In code-producing sessions, software engineers hit verified success 34% of the time. All other occupations: 29%. That five-point gap hasn't widened or narrowed over 7 months, even as both groups improved.

Management occupations actually come out slightly above software engineers on verified success. The paper's authors suggest this may partly reflect that managers are better at specifying what they want and confirming when they get it. Skills that transfer directly to directing an agent.

Under the looser "partial success" measure, both groups converge even further: 89% for software occupations, 88% for everyone else.

| Occupation | Verified success (coding sessions) |
|-----------:|-----------------------------------:|
| Management | ~36% |
| Software / Math | 34% |
| Business / Finance | ~33% |
| Life / Physical Sciences | ~32% |
| Arts / Design / Media | ~31% |
| Other occupations | ~29% |

Every group within 7 points. Coding agents are making a coding background less relevant to successful programming.

## How big is the gap between novice and expert?

The expertise gradient exists, but it isn't what you'd expect.

Each session was rated on a five-point expertise scale based on three signals: how precisely the user frames directions, what they ask Claude to verify, and whether the user tends to correct Claude or Claude corrects the user. A senior engineer asking their first Rust question is a beginner at Rust. An accountant who has never used Python but tells Claude exactly which reconciliation rules to enforce is an expert at that task.

| Expertise | Verified success | Partial success | Abandon rate |
|----------:|-----------------:|----------------:|-------------:|
| Novice | 15% | 77% | 19% |
| Intermediate | 28% | 91% | 5-7% |
| Expert | 33% | 92% | 5-7% |

The biggest gap is between novice and intermediate. A working grasp of the domain captures most of the benefit. Deep specialization adds only a bit more.

This matters because it lowers the bar for effective use. You don't need 10 years of experience. You need to understand the problem well enough to tell the agent what done looks like.

## What changed in 7 months of agent adoption?

The paper tracks October 2025 to April 2026. The compositional shift is dramatic.

Fixing broken code fell from 33% to 19% of all sessions. Nearly halved. In its place, operating software grew from 14% to 21%, and writing plus data analysis roughly doubled from 10% to 20%.

The work itself got harder. The paper estimates each session's economic value by comparing it to freelance marketplace postings. By that measure, the average session value rose 27% over 7 months. Building tasks grew 43% more valuable. Operating tasks grew 34%. Fixing tasks grew 32%.

| Work mode | Share Oct 2025 | Share Apr 2026 | Value change |
|----------:|---------------:|---------------:|-------------:|
| Building new things | ~25% | ~25% | +43% |
| Fixing broken code | 33% | 19% | +32% |
| Operating software | 14% | 21% | +34% |
| Writing / data analysis | 10% | 20% | +~100% |
| Planning / exploring | ~14% | ~14% | |
| Testing / orchestrating | ~5% | ~5% | |

The debugging decline is the number I keep coming back to. Seven months ago, a third of all Claude Code time was spent fixing things. Now it's under a fifth. The tool is getting better, and users are getting better at using it. The compound effect is that more time goes into creating and less into repairing.

## Who is this not for?

If you're using Claude Code primarily for headless or programmatic execution (single prompts via `claude -p`), this data doesn't cover you. The study excluded CLI headless sessions because they're structurally different from interactive sessions. The paper also can't measure real-world outcomes: whether code written in a session is actually deployed, used, or discarded.

The success rates also sound low (15-33% verified success), but that's a strict measure requiring verifiable evidence: git commits, passing tests, explicit user confirmation. The partial success rate of 77-92% is the more practical number.

And the expertise finding is a snapshot, not a prediction. The paper explicitly notes that if models start supplying the judgment users currently bring, the returns to expertise could decrease. This picture will change.

## FAQ

> **What did Anthropic actually analyze?**
> A privacy-preserving analysis of ~400,000 interactive Claude Code sessions from ~235,000 users between October 2025 and April 2026. The paper was published June 16, 2026.
>
> **Is coding ability irrelevant now?**
> No. But the data suggests domain expertise matters more. A person who understands the problem deeply can use Claude Code almost as effectively as a software engineer. The coding background matters less than knowing what to build.
>
> **Why do managers succeed more than engineers?**
> The paper suggests managers may be better at specifying requirements and confirming outcomes. Skills that transfer directly to directing an agent.
>
> **What does verified success mean?**
> The strictest measure: a classifier judges the session as successful, and there's verifiable evidence like git commits, passing tests, pull requests, or explicit user confirmation that the task was completed.
>
> **How much did Claude Code usage grow?**
> GitHub projects with coding agent activity more than doubled since late 2025. Claude Code users now average 20 hours per week using the tool.

## Related Posts

- [Cursor vs Claude Code vs Copilot: 6 months of daily use](/posts/cursor-vs-claude-code-vs-copilot-comparison/). How the leading AI coding tools compare in real daily use.
- [Your agent is 1.6% model. The rest is the harness.](/posts/claude-code-harness-architecture-98-percent/). What the Claude Code architecture actually looks like under the hood.
- [Code as Agent Harness: what a 102-page survey tells us](/posts/code-as-agent-harness-survey/). A broader look at where agentic coding tools are headed.
- [88% of agents never ship. The ones that do break in silence.](/posts/88-percent-agents-never-ship-break-in-silence/). Why most agent projects fail and what distinguishes the ones that work.

---

This article was published on Agentic Up (https://agenticup.dev): practical guides for developers and founders building with AI agents. Reach me at hello@agenticup.dev