AI is changing how developers work
AI coding tools are often sold on a simple promise: developers get more done, faster. Cursor’s Developer Habits Report points to a more interesting shift. Developers are writing more code, opening larger pull requests, and handing more implementation work to AI agents.
That doesn’t mean every developer is finishing every task faster by some fixed percentage. The report tracks things like code volume, tool adoption, and the size of changes—not how long each task takes from start to finish. Still, the numbers suggest developers are using AI to take on more work at once and tackle larger chunks of it.
More code, but not a simple productivity score
Weekly lines added per developer rose from about 3.6K at the start of 2025 to roughly 8.6K by May 2026. That’s an increase of about 139%.
It’s a striking change, but lines of code aren’t the same as useful work. A larger codebase might reflect faster implementation—or unnecessary complexity, duplicated logic, and extra maintenance. The figure is best read as a sign that developers are producing more code, not as proof that they’re delivering 139% more value.
The size of pull requests tells a similar story. At the 75th percentile, lines added per pull request rose from about 126 to 345—around 2.7 times as many. The share of pull requests with more than 1,000 changed lines went from roughly 8% to 13.8%.
That may point to a change in how developers use AI. Instead of asking for help with a single function or test, they can give an agent a broader assignment: inspect the repository, update several files, run commands, revise tests, and prepare a change for review. The work is shifting from individual lines toward features, migrations, and other larger tasks.
AI-generated code is sticking around
The share of AI-generated code retained in the codebase rose from about 76% to 81%. That suggests more of the code produced with AI is making it into projects and staying there.
But retention is not a quality score. Code might stick because it’s useful and well designed; it might also pass basic checks without being revisited. The figure tells us something about adoption, but not whether the code is secure, maintainable, or correct.
The report also shows that a growing share of changes reach commits without a separate manual diff-acceptance step. That figure rose from about 7% at the start of 2026 to 36.3% by May.
That doesn’t necessarily mean developers have stopped reviewing code. It does suggest that more people are letting agents apply groups of changes rather than approving each modification through the usual step-by-step workflow.
That can save time, but it raises the stakes for review. One generated line is easy to inspect. A change spanning dozens of files, configuration, and tests is much harder to assess manually. Teams relying more heavily on agents will need dependable tests, continuous integration, static analysis, security checks, and clear boundaries for what agents can change. High-risk work should still have explicit human approval.
The gains aren’t evenly shared
AI use varies widely across developers. The report says developers at the 90th percentile produce about ten times as many AI-assisted lines as median users and merge around four times as many pull requests. At the 99th percentile, they produce roughly 46 times as many AI-assisted lines and merge about 15 times as many pull requests as median active users.
That’s unlikely to mean they’re simply typing 46 times faster. They may be using AI throughout more of the development process, running several agent sessions at once, working in larger repositories, or taking on more tasks in parallel.
The difference may have as much to do with workflow as with access to the tool. Experienced users may be better at breaking work into manageable pieces, providing relevant context, delegating repetitive tasks, and checking an agent’s output. For organizations, that means handing everyone the same tool may not be enough. Shared instructions, reusable workflows, and practical training can matter too.
Context helps—but needs managing
Agents are also working with more context about repositories, codebases, and ongoing tasks. That makes sense: a useful change depends on more than the function being edited. An agent may need to understand project conventions, dependencies, tests, configuration, and the surrounding architecture.
With the right context, an agent can work across files and follow patterns that would otherwise take a developer time to explain. But more context isn’t automatically better. It can add processing costs, and irrelevant or conflicting information can get in the way. Keeping instructions useful and deciding what an agent actually needs to know are becoming part of the job.
So, are developers getting faster?
The report doesn’t support a simple claim like “AI makes every developer 2.5 times faster.” It shows that developers are adding more code, making larger changes, retaining more AI-generated code, and relying more on agents to carry out implementation work.
That points to higher throughput and a broader range of tasks developers can manage. It doesn’t tell us whether every task takes less time, or whether every additional line is valuable. Some of the time saved on writing may be spent reviewing, testing, debugging, or maintaining the result.
The more useful question is whether teams are delivering reliable software with less wasted effort. To answer that, they’ll need to look beyond code volume—to deployment time, defects, review delays, rollback rates, model and infrastructure costs, and long-term maintainability.
AI may help developers take on larger tasks and move through implementation more quickly. Whether that becomes a lasting productivity gain depends on what happens around the code: testing, architecture, review, security, and maintenance.