Cursor's Developer Report Shows AI Coding Speed Doubled and Review Is Vanishing
Cursor's inaugural Developer Habits Report reveals coding speed has doubled, a 46x output gap between top and median developers, and agents now commit code without human review 36% of the time
Takeaways
- Coding speed doubled YoY: Lines added per developer per week rose from 3.6K to 8.6K; lines per PR up 2.5x. Full report
- Massive power user gap: P99 developers produce 46x more AI lines than the median; the gap is widening as total usage grows.
- One in three agent commits skips human review: Auto-committed agent changes jumped from 7% to 36.3% in 2026, raising governance concerns.
- 7x cost spread across model families: Cost per accepted line ranges from 0.18¢ (Composer 2.5) to 1.19¢ (Opus 4.6); Composer 2.5 leads on cost-quality ratio.
- Context now dominates token costs: Input tokens rose from ~50% to ~70% of price-equivalent costs; cache reads make up 89% of all token activity.
- Automation is spreading: Cursor Automations and SDK runs are growing, signaling AI's shift from developer tool to full SDLC infrastructure.
Cursor's inaugural Developer Habits Report is the most data-rich picture of AI-assisted software development published to date. Built from aggregated usage across Cursor's entire platform, it covers agent sessions, token consumption, accepted diffs, and merged PR activity, spanning all major model families. The findings are striking, and in some cases, unsettling.
The numbers that matter
The headline stat is simple: coding speed has doubled year-over-year, PRs are getting larger and deeper, and agent-generated code is surviving review at higher rates than ever. But the details behind that headline tell a more nuanced story.
- Lines added per developer per week went from 3.6K in January 2025 to 8.6K by May 2026, a roughly 2.4x increase.
- Lines added per PR are up roughly 2.5x year over year, and the growth rate is accelerating.
- Mega PRs, defined as PRs with at least 1,000 lines changed, are becoming more common. There was a notable jump in January 2026, when many developers were trying out the latest improvements in coding agents and models.
- In just the last two months, average tool calls per session have risen roughly 30%. Coding agents are taking on more complex work, reading and editing files, searching code, running shell commands, and browsing the web more frequently.
- The share of accepted AI lines still present after 60 minutes has risen from roughly 76% to 81%, suggesting the code quality is improving, not just the volume.
The model economics are wild
One of the most practically useful sections of the report is its breakdown of cost across model families. Cost per agent request varies by nearly 9x across model families, showing that the same workflow can have very different cost profiles depending on the model behind it. But raw request cost is a misleading metric.
Cost per accepted line varies by roughly 7x across model families, compared with nearly 9x for cost per request, suggesting that higher-cost models partially make up the difference by producing more accepted code per request. In other words, expensive models earn some of their premium back through efficiency.
The standout on the cost-quality frontier is Cursor's own Composer 2.5, which scores 63.2% on CursorBench 3.1 at just $0.55 per task, outperforming models that cost 5-20x more per task. GPT-5.5 at max settings reaches 64.3% but costs $4.37 per task. Opus 4.7 at max hits 64.8% at $11.02 per task. The cost-quality tradeoff is real, but the gap is narrowing fast at the frontier.
The power user gap is becoming a chasm
This is arguably the most consequential finding in the report. While AI is leading to broad productivity gains, the change is most pronounced in the top 1% of developers. The data quantifies just how extreme this concentration is.
P99 developers produce 46x more lines than the median active user and merge 15x more PRs than the median active PR author, while p90 users show large but much smaller gaps. AI usage is also highly unequal in financial terms, with Gini coefficients of 0.77 for AI lines generated, 0.75 for AI spend, and 0.72 for token consumption. For context, a Gini of 1.0 would mean one person does everything; the US income Gini is around 0.39.
This gap is not static. P90 developers are pulling farther away from median developers in absolute lines added per week, with p99 users even farther out in the tail. As the total volume of AI-assisted work grows, the absolute distance between heavy users and everyone else keeps widening.
A separate University of Chicago study conducted with Professor Suproteem Sarkar adds important context here. Developers first used better models to do more work of similar complexity, and only later began taking on more complex tasks. The implication: the power user gap may reflect who has had the time and skill to discover what agents can actually do, not just who has access.
Context is eating the token budget
There is a structural shift happening in how models consume tokens, and it has real cost implications. The rise of context shows a dramatic increase in input tokens, and the shift toward cache-read tokens, which is giving agents the working memory to take on more complex tasks and produce higher-quality code.
The input-to-output token ratio went from roughly 4.5x in January 2026 to over 13x by late April, before settling around 11x. Input tokens now account for more than 90% of non-cache token volume. And once you include cache reads, the picture shifts even further: cache-read tokens make up roughly 89% of all token activity. This matters for cost because cache reads are priced at a fraction of fresh input tokens, meaning agents are getting smarter about reusing prior context rather than re-reading everything from scratch.
Input tokens have become the majority of price-equivalent token costs, rising since the start of the year from roughly half of input/output token costs to nearly 70%. The implication for teams managing AI spend: optimizing context and caching is now more important than optimizing output length.
The automation threshold is being crossed
Perhaps the most structurally significant finding is how quickly human review is being removed from the loop. More than 5x as many agent-generated changes are reaching commits without a separate manual diff acceptance step, jumping from 7% to 36.3% in 2026. That is not a rounding error. More than one in three agent-generated changes is now being committed without a human reading the diff.
This creates a governance problem because velocity scaled the unit of risk faster than the unit of review. A single agent-authored PR can now carry over 1,000 lines that committed without manual diff acceptance, so the architectural decisions inside it are made during generation, not during review.
Cursor is also seeing early traction in full automation workflows beyond the IDE. Adoption of Cursor Automations is growing, with security review emerging as a leading use case. SDK runs, which let companies turn Cursor's agent infrastructure into a programmable platform, are also picking up, signaling a shift from AI as a developer tool to AI as software development infrastructure.
What this means for your team
The largest increases in AI usage were in documentation (+62%), architecture (+52%), code review (+51%), and learning (+50%), while more self-contained tasks like UI/styling grew far less (+15%). This suggests that the highest-leverage place to invest in AI tooling is not code generation itself, but the surrounding work: understanding what was generated, reviewing it, and keeping the architecture coherent.
- If you manage a team: The power user gap means a small number of developers may be driving a disproportionate share of your AI-assisted output. Understanding who they are and what workflows they use is worth the effort.
- If you care about cost: The 7x spread in cost per accepted line across model families means your model choice is a major cost lever, not just a quality lever. Composer 2.5's cost-quality ratio is hard to ignore.
- If you care about code quality: The rising survival rate of AI-generated code (now 81% after 60 minutes) is encouraging, but the jump in auto-committed changes without manual review is a risk that needs a governance answer.
- If you are building tooling: Context management and prompt caching are now the dominant cost drivers. Optimizing for cache hit rate is more impactful than shrinking output tokens.
Cursor's annualized revenue exceeded $2.0 billion by February 2026, and the company raised $2.3 billion at a $29.3 billion post-money valuation in its Series D. The report is partly a product of that scale: the dataset underpinning it is larger than anything a survey could produce. Whether you use Cursor or not, the behavioral patterns it captures are the clearest signal yet of where AI-assisted development is heading.