The Pulse: Interesting AI coding stats from Cursor

The Pragmatic Engineer (Gergely Orosz) · email · 2026-07-09 Reader 🖥️

AI Unit Economics Coding Agents Human-in-the-Loop Inference Optimization Measuring AI Impact Model Routing Token Throughput

Cursor's two years of aggregated usage data show that AI-coding output is extremely power-law skewed across developers, that its cost is dominated by input/context-reading tokens (making caching decisive), and that developers are rapidly abandoning manual review of AI-written commits.

theoretical · expository data commentary in a tech newsletter — curated statistics with interpretation — Primarily informative: it reports and interprets Cursor's aggregated two-year usage data (what is the case about AI-coding usage and cost). It carries practical implications for engineering leaders (cost control, model routing, review policy), but the article's own work is reporting numbers and reading meaning into them, not prescribing a method.

Structure

Part	Role
Framing	Establishes the source: a Cursor report built on two years of aggregated usage data, previewed as containing several surprising findings.
Power-user code volume (p50 / p90 / p99)	Reports the skewed distribution of lines generated per developer and asks whether volume equals value.
Input tokens dominate usage	Shows 90% of token usage is input (reading the codebase), invoking the classic 10:1 read/write ratio as an analogy.
Input tokens dominate cost	Explains that despite output being priced ~5x higher, input tokens are ~70% of AI-coding-agent cost because they dominate volume.
Caching cuts cost ~10x	Reports that once cache reads/writes are counted, output is only 0.6% of tokens and cache reads are ~90%, so caching is ~10x cheaper.
Model cost comparison (Opus 4.7 vs Composer 2.5 vs GPT-5.5)	Reports Opus 4.7 as most capable but most expensive per agent request, and forecasts routing cheaper models to less-critical work.
Cost-per-line-accepted	Introduces an outcome-adjusted metric on which expensive models close much of the cost gap because their output is accepted more often.
40% skip manual review (headline finding)	Reports that the share of Cursor devs letting AI commit without manual review jumped from ~10% to ~40% in a month, correlating with new model releases.

Key terms

p50 / p90 / p99 (percentile usage tiers)
Percentile buckets of Cursor developers ranked by lines of code generated per week — median (p50 ~700), 90th (~9,000), 99th (~30-40K).
input tokens vs output tokens
Tokens the agent consumes reading the existing codebase and docs (input) versus tokens it emits as generated code (output); the article's central cost distinction.
10:1 read-to-write ratio
The observation that ~90% of usage is reading context, echoing Uncle Bob's 2008 claim that developers spend >10x as long reading code as writing it.
context caching (cache read / cache write)
Reusing previously processed context so it need not be re-sent as fresh input tokens; when counted, cache reads are ~90% of token usage and output falls to 0.6%.
cost per agent request
The billed cost of one agent turn/request for a given model — the metric on which Opus 4.7 is ~10x Composer 2.5 and ~2x GPT-5.5.
cost-per-line-accepted (a.k.a. cost-per-line-added)
An outcome-adjusted cost metric dividing spend by lines actually accepted, which rewards expensive-but-accurate models and shrinks the apparent cost gap.
commits without manual review
AI agents creating commits that the developer no longer personally checks before they land — the share that rose from ~10% to ~40% in a month.
tokenmaxxing Token Throughput
Raised as a possible explanation for power users' extreme volume — spending tokens to top usage leaderboards rather than to ship value.

Propositions

explicitThe median Cursor developer generates about 700 lines of code per week with the tool, the 90th percentile about 9,000, and the top 1% (p99) roughly 30-40K lines per week — the output of about 45 median devs.conf: high
explicit90% of Cursor's token usage is input tokens spent reading the existing codebase and documentation, not output tokens generating code — a roughly 10:1 read-to-write ratio that mirrors the classic developer read/write ratio.conf: high
explicitEven though output tokens are priced about 5x higher than input tokens (e.g. Opus 4.7 at $5 per 1M input vs $25 per 1M output), input tokens still account for close to 70% of the cost of AI coding agents because they so dominate usage.conf: high
explicitContext caching cuts token cost roughly 10x: once cache reads and writes are counted, output is only 0.6% of token usage, with cache reads at about 90%, cache writes 2.5%, and raw input 7%.conf: high
explicitOpus 4.7 is the most capable but most expensive coding model — about 10x more expensive per agent request than Cursor's Composer 2.5 and about 2x GPT-5.5 — so companies are likely to route less-critical work to cheaper models.conf: high
explicitOn the outcome-adjusted metric of cost-per-line-accepted, expensive models' disadvantage shrinks: Opus 4.7 matches GPT-5.5 despite ~2x the cost per agent request, and Composer is 'only' ~5x more efficient (versus ~10x on cost-per-request), because more capable models have their output accepted more often.conf: high
refinesAgentics / Tech Things: Tokenmaxxing is dead, long live tokenmaxxing · p8 — tokenmaxxing#p8 claims cheap models beat expensive frontier models on cost-per-outcome. Cursor's cost-per-line-accepted data qualifies this: on the outcome-adjusted metric the expensive models' disadvantage shrinks (Opus 4.7 matches GPT-5.5; Composer drops from ~10x cheaper per request to only ~5x cheaper per accepted line), because higher acceptance offsets higher price. Cheap still wins, but by much less than raw request price implies.
explicit⚡ disputed & corroboratedIn one month, to March 2026, the share of Cursor developers who let AI agents commit code without any manual review jumped from about 10% to about 40%, correlating with the release of Opus 4.7 and GPT-5.5.conf: high
contradictsFive studies that are changing how I think about AI in software engineering · p7 — p7 claims the developer 'bounded delegation' boundary is normative and 'will not move as models improve.' Cursor's data shows a review-related delegation behavior moving fast (10% to 40% unreviewed commits in one month) precisely as models improved (Opus 4.7 / GPT-5.5). This contradicts the temporal-stability generalization specifically; note that skipping manual review is delegation-adjacent, not identical to p7's 'delegating core logic/architecture,' so it challenges the 'won't move' claim rather than refuting the whole thesis.
supportsFive studies that are changing how I think about AI in software engineering · p10 — p10 says cognitive debt accumulates when developers accept AI-generated code without building the mental model they would have built by writing it. The 10%-to-40% rise in commits landed without personal review is direct behavioral evidence of exactly that acceptance-without-comprehension pattern.
supports ←Stop being skeptical about AI for development with Charity Majors · p8 — Corroborates, with a normative argument for why the shift is appropriate, the same author's (Orosz's) own empirical finding that unreviewed-AI-commit share jumped from ~10% to ~40% in one month.
implicitHigh volume of AI-generated lines of code does not by itself establish delivered business value; the report leaves open whether power users ship more value or merely more code and more bugs.conf: high
implicitcorroboratedBecause inference cost in coding workflows is dominated by re-reading existing context, context reuse and caching are likely to become a central axis of future AI cost-efficiency.conf: medium
supports ←AlloyDB Ships Proxy Models That Replace LLM Calls with Local Inference Inside the Database · p3 — Both identify redundant, repeated input payload as the dominant inference cost and its elimination as the central efficiency lever — Cursor via context reuse/caching of re-read code, AlloyDB via sending the shared system prompt once per batch instead of per row.
implicitCursor's decision to publish these efficiency statistics is itself a competitive signal — it frames Composer as low-cost and reminds builders that matching Cursor's caching efficiency in a home-rolled agent harness is non-trivial.conf: medium

Arguments

Input/context tokens, not generated output, are the dominant driver of AI-coding cost, so caching is the decisive efficiency lever. strength: high

Explicit premises:

90% of Cursor's token usage is input tokens for reading the codebase.
Input tokens account for ~70% of AI-coding-agent cost despite output being priced ~5x higher per token.
With caching counted, output is only 0.6% of tokens and cache reads are ~90%; without caching, cost would be 10x higher.

Implicit premises:

Cursor's aggregated usage is representative of AI-coding workloads generally, not just its own product.
The measured token/cost mix reflects genuine efficiency rather than an artifact of Cursor's specific pricing arrangements.

Inferences:

If reading context consumes most tokens and most cost, then reducing the re-processing of that context (caching/reuse) is where the largest savings live.

Developers are rapidly increasing their trust in AI-written code, delegating even the review step.