Cursor recently published its first Developer Habits Report — a data-driven look at how developers are actually using AI coding tools, drawn from aggregated platform telemetry. It's a useful snapshot of where the industry is right now, and the numbers don't read like marketing material. Some of them are striking.
What the report covers
The report leans on Cursor's own product data — not surveys — so the headline stats reflect real usage rather than self-reported intent. The themes:
- Code volume is up sharply. The median developer in Cursor's data was adding about 712 lines of code per week in May 2026, up from 176 in January 2025. That's a roughly 4× increase in 16 months. Pull requests are 2.5× larger by the same measure.
- AI-generated code is sticking. The "survival rate" — the share of AI-generated code that's still present in the codebase a meaningful time later, not reverted or rewritten — landed at 80.6%. A year ago that number was meaningfully lower.
- Context window economics matter. Input tokens now drive roughly 70% of effective model costs. Cache reads make up almost 90% of total token traffic, which is what makes deeper agent sessions (averaging 145 tool calls each in May 2026) economically viable.
- A power-user gap has opened. The top 1% of developers in the dataset are producing 46× more AI-generated lines than the median developer. Gini coefficients of 0.72–0.77 confirm the distribution is heavily skewed.
- Automation is moving past suggestion. 36.3% of agent-driven changes in May 2026 reached commits without manual review, up from about 7% in January. Security-review use cases lead that shift.
The model pricing breakdown is worth a look too — Cursor's data shows per-request cost ranges from roughly $0.18 on lighter-weight models up to $1.57 on the most capable tier. The variance is significant if you're scaling any agentic workflow.
Our take
A few of these numbers are easy to wave at and move on. We won't.
The "code volume up 4×" stat is the headline, and it's not the most important one. Lines of code is a weak proxy for delivered value, and AI tools make it cheaper to write code than to delete it — so volume per developer rising is partly real productivity and partly cost-of-keystrokes falling. The number worth tracking is the survival rate. 80.6% means that the AI is producing code that holds up in review and stays in the codebase. That's the proof of value, not the line count.
The power-user gap is the most strategic finding. A 46× gap between the top 1% and the median tells you two things: (1) most developers using AI tools are leaving most of the value on the table, and (2) the gap is teachable. Power users aren't typing faster — they're structuring prompts better, decomposing tasks differently, knowing when to keep a session going versus restart it, and having stronger mental models of what the model can and can't do. On client engagements, we're now treating "how do we close the power-user gap on this team" as a real line item in any AI-tooling rollout. It's the cheapest leverage available right now.
The 36% of changes hitting commits without manual review will be controversial. It probably should be. There's a difference between "the AI made a refactor, I reviewed it, I committed it" and "the AI made a refactor, it passed CI, the commit landed." For internal tooling and well-tested codebases the second mode is fine and accelerating. For production code in client systems, we're a hard "not yet" — the cost of an AI-introduced regression in a client's checkout flow or admin panel is dramatically higher than the time saved by skipping the review. Cursor's number reflects an industry average across very different risk profiles.
The input-token cost shift is the operational story nobody is leading with. When 70% of your model cost is input tokens and 90% of traffic is cache reads, the way to control AI tooling spend isn't picking cheaper models — it's managing context discipline. Agents that prune their context, summarize earlier turns, and don't re-stuff the same files on every message will run dramatically cheaper than ones that don't. For agencies evaluating tooling decisions for clients, this is the real procurement question: not "which model," but "what's the context strategy."
What this means for your team
If you're a dev team lead, a CTO at a mid-sized company, or an agency principal:
- Measure your team's survival rate, not their AI line count. If you're not tracking how much AI-generated code makes it through review and stays, you're tracking the wrong number.
- Identify your power users and turn their workflow into team-shared practice. Office hours, recorded prompt sessions, internal playbooks. The 46× gap closes faster than people think when the patterns are explicit.
- Set an explicit policy on auto-merge of AI-generated changes — by repo, by risk tier. Don't let it happen by default in production code without an opt-in.
- Watch your context-token spend. If your monthly AI tooling bill is climbing faster than your team headcount, the problem is almost always context discipline, not model selection.
We're using Cursor on most internal work and on a growing portion of client engagements. It's not the only tool that matters — Claude Code, GitHub Copilot, and the IDE-native integrations are all moving fast — but Cursor's data here is the most concrete public look at industry-wide AI coding behavior we've seen this year. Worth reading the full report if any of this lands.
Originally published by Cursor. Full data and methodology in the Developer Habits Report (Spring 2026).
If your team is rolling out AI coding tools and you'd like a sanity check on the policy or the workflow, get in touch — we've done it on enough client engagements now to have opinions.
Originally published by Cursor. Read the full announcement here.
