Cursor Developer Habits Report: How AI Coding Is Changing Developer Productivity

AI coding assistants are often described as tools that make developers faster. Cursor’s Developer Habits Report presents a more nuanced picture. Its data shows that developers are producing more code, opening larger pull requests, and delegating more implementation work to AI agents.

However, the report does not prove that every developer completes every task faster by a fixed percentage. Its metrics primarily measure coding output, workflow adoption, and the scale of completed changes—not the time required to finish each individual task.

The broader conclusion is that AI is increasing development throughput and allowing developers to manage larger units of software work.

Code output has more than doubled

One of the report’s clearest indicators is the number of lines added per developer each week. This figure rose from approximately 3.6K lines at the beginning of 2025 to around 8.6K lines by May 2026.

Based on these approximate figures, weekly output increased by about 139%:

(8.6 − 3.6) ÷ 3.6 × 100% ≈ 138.9%

This does not mean that every developer became 139% faster. Lines of code are an imperfect measure of productivity. More code can reflect greater output, but it can also indicate unnecessary complexity, duplication, or poor design.

The figure is therefore best understood as a measure of coding activity rather than a complete measure of engineering value. Even so, the trend suggests that developers using AI are handling a much larger volume of implementation work than before.

The bigger change is the size of the task

AI may be changing software development less by helping developers type individual lines and more by allowing them to complete larger units of work.

At the 75th percentile, the number of lines added per pull request increased from approximately 126 to 345. In other words, the later figure reached about 2.7 times its previous level, representing an increase of roughly 174%.

The share of pull requests containing more than 1,000 changed lines also rose from approximately 8% to 13.8%.

These figures suggest that developers are increasingly using AI for broader tasks. Instead of asking an assistant to complete one function or generate a small test, they can ask an agent to inspect a repository, modify multiple files, run commands, update tests, and prepare a larger change for review.

This represents a shift from line-level assistance to task-level execution. The basic unit of development is becoming larger: a feature, migration, refactor, or complete workflow rather than a single function.

More AI-generated code is being retained

The report also indicates that the share of AI-generated code retained in the codebase increased from approximately 76% to 81%.

Retention indicates that AI-generated code is increasingly being kept and used as part of software projects. It does not, by itself, demonstrate that the code is correct, secure, or maintainable.

Code may remain in a codebase because it is useful and well designed. It may also remain because it has passed basic checks or has not yet been revisited. The metric should therefore be interpreted as evidence of adoption and persistence, not as a complete measure of quality.

AI-generated code is becoming a more persistent part of software projects, but retention alone does not prove that the code is high quality.

Developers are delegating more implementation work to agents

Another notable change is the increase in modifications that reach commits without a separate manual diff-acceptance step. This share rose from approximately 7% at the beginning of 2026 to 36.3% by May.

This does not necessarily mean that developers have stopped reviewing code. Rather, it suggests that the interaction model is becoming more automated. Developers are increasingly allowing agents to make and apply groups of changes instead of manually approving every individual modification through the traditional workflow.

That creates both an opportunity and a risk.

When an AI assistant changes one line, a developer can usually inspect the result directly. When an agent modifies dozens of files, changes configuration, updates tests, and restructures a module, line-by-line inspection becomes more difficult.

Teams adopting agentic coding should therefore invest in:

• Reliable automated tests;
• Continuous integration;
• Static analysis and security scanning;
• Clear architectural constraints;
• Small and well-defined tasks;
• Audit trails for agent actions;
• Human approval for high-risk changes.

AI may reduce the amount of code developers write manually, but it increases the importance of systems that can validate large volumes of generated changes.

The benefits are unevenly distributed

AI productivity also varies substantially between developers.

According to the report, developers at the 90th percentile produce approximately ten times as many AI-assisted lines as median users and merge around four times as many pull requests. At the 99th percentile, the difference is even larger: these developers produce roughly 46 times more AI-assisted lines and merge about 15 times as many pull requests as median active users.

These figures do not necessarily mean that the most productive developers are simply typing 46 times faster. They may be using AI across more stages of development, working on larger repositories, running multiple agent sessions, or handling more tasks in parallel.

One possible interpretation is that the advantage comes not only from access to AI, but also from the workflow built around it. Highly effective users may be better at:

• Breaking large tasks into manageable steps;
• Supplying relevant repository context;
• Writing clear instructions;
• Delegating repetitive work;
• Reviewing and correcting agent output;
• Integrating AI into testing, debugging, and documentation.

This means that giving every developer access to the same tool is unlikely to produce identical results. Organizations may also need shared repository instructions, reusable workflows, training, and clear rules for agent use.

More context enables broader workflows

The report points to a significant increase in the amount of context used during AI coding sessions. Developers and agents are working with more information about repositories, codebases, and ongoing tasks.

This matters because software development is highly contextual. A useful code change depends on more than the immediate function being edited. An AI system may need to understand the surrounding architecture, project conventions, dependencies, tests, configuration, and product requirements.

With more relevant context, agents can work across multiple files and follow existing patterns more effectively. They can perform changes that would previously have required a developer to provide extensive explanations manually.

There is, however, a trade-off. More context can improve the quality of an agent’s output, but it can also increase processing costs and introduce irrelevant or conflicting information.

Cached context can make long workflows more practical by reducing the cost of repeatedly supplying the same repository information. It should not necessarily be understood as permanent memory of the codebase. Effective context management is becoming an important engineering skill: developers need to decide what information an agent requires, what it can ignore, and how instructions should be maintained over time.

Are developers really getting faster?

Cursor’s report does not provide a single universal answer such as “AI makes every developer 2.5 times faster.” Instead, it presents several related indicators:

• Weekly lines added increased from approximately 3.6K to 8.6K.
• Lines added per pull request at the 75th percentile rose from about 126 to 345.
• Pull requests containing more than 1,000 changed lines increased from approximately 8% to 13.8%.
• The share of AI-generated code retained in the codebase rose from roughly 76% to 81%.
• Changes reaching commits without a separate manual diff-acceptance step increased from about 7% to 36.3%.
• The most active AI users now operate at a dramatically different scale from median users.

Together, these findings suggest that AI can increase development throughput and expand the size of the tasks developers can manage.

They do not, however, prove that every task is completed faster or that every additional line creates additional value. A developer may produce more code while spending more time reviewing, testing, debugging, or maintaining it.

The most accurate conclusion is that AI coding is making software development more scalable. The size of the improvement depends on the developer, the workflow, the task, and the quality-control system surrounding the tool.

Higher speed creates new management challenges

When developers work faster, teams do not automatically become more effective.

Larger pull requests can make code review more difficult. More generated code can increase maintenance costs. Agents can accelerate both good architectural decisions and bad ones. If testing, documentation, and governance remain unchanged, AI may simply accelerate the accumulation of technical debt.

Engineering teams should therefore measure more than code volume. Useful metrics may include:

• Time from task definition to deployment;
• Defect rates after release;
• Pull-request review time;
• Test coverage and test reliability;
• Rollback frequency;
• Infrastructure and model costs;
• Long-term maintainability;
• The amount of developer time spent on design and problem-solving.

The goal should not be to maximize the number of lines produced. It should be to deliver reliable software with less wasted effort.

Conclusion

Cursor’s Developer Habits Report does not show that every developer is a fixed percentage faster. It shows something broader: developers are producing more code, completing larger changes, using deeper agent workflows, and allowing AI to take on a greater share of implementation work.

The real productivity gain may come less from typing faster and more from changing the size of the task a developer can manage. A developer who once needed several separate interactions to implement, test, and document a feature may now delegate much of that workflow to an agent.

Whether this translates into better business results will depend on more than output. Testing, architecture, code review, security, and maintenance must improve alongside AI-assisted development.

AI can increase software development throughput. The central challenge is ensuring that quality and engineering discipline increase with it.