What Cursor Developer Habits Report 2026 Says About Development

Cursor has released the first Cursor Developer Habits Report based on data from the last 2 years. The report clearly shows how AI is changing development not in theory, but through real usage patterns.

And the most important thing we talk about all the time:

1. Developers started moving faster
2. AI is gradually moving from a simple assistant to automating parts of the SDLC

I won't go through the entire report, but there are two topics that resonated with me the most.

About developer productivity

The most obvious effect is that developers began to make more changes.

According to Cursor:

• the number of added lines per developer per week increased from approximately 3.6K to 8.6K;
• according to p75, the growth of lines added to PR is approximately from 126 to 345 lines;
• share of PR with 1000+ changed lines - from 8% to 13.8%;
• the average number of tool calls in agent sessions increased by approximately 30% over two months;
• AI code survival rate increased from 76% to 81%.

Yes, lines of code are not an ideal metric at all. More code doesn't always mean more value.

But what is important here is not the volume itself, but the change in the format of the work itself.

AI allows the developer to take on larger chunks of tasks: not just "fix a component," but full-fledged and large-scale refactoring, migration, tests, and preparation of the entire PR.

That is, acceleration occurs not only at the level of code typing speed.

The size of the work unit changes.

If previously the team could manage the flow of small tasks and PR, now AI helps generate larger changes faster. This means that code reviews, QA, tests, and even architectural rules must scale with them.

Otherwise, all this acceleration easily turns into an accelerated accumulation of chaos.

About development automation

The second topic is even more interesting.

AI development tools began as tools to speed up an individual developer: auto-complete, chats, generation of code chunks, help with tests.

But now we can see a movement in the other direction: AI is becoming an infrastructure for automating development through agents.

The share of changes that make it to commit without a separate manual code review increased from 7% in early 2026 to approximately 36% in May.

True, this does not mean that code review is no longer needed. Although in many cases it can already be avoided. Quite the opposite: code review becomes more important, but changes the level.

There is no longer any sense or physical ability for a person to check each line with his hands. It is important to create the right conditions for safe development.

That is, the role of the developer is greatly shifting from "I write all the code myself" to "I manage a huge flow of changes and the quality of the result."

But the role of technical managers is changing from "how to speed up people" to "how to build a system where people and agents safely release products."

What does this mean for teams?

For me the main conclusion sounds something like this:

AI adoption in development is not a story about buying licenses and holding a workshop. This is already a question of the operating model of the company or team.

If AI increases the volume and size of changes, you need to reconsider:

• how we decompose tasks;
• how to review large PRs;
• what checks are automated;
• what parts of the SDLC can be given to agents;
• how we measure the effect;
• how to control the cost of all this AI-booth;
• how we grow power user agents;
• how we give AI the correct context: code, requirements, documentation and other internal standards.

Development is not just about writing code. This is an understanding of the task, architecture, quality, security, supportability, release process and responsibility for the result.

If the engineering system is weak, then AI will simply accelerate the chaos.

If she is mature, she will become a real animator.

The report itself is available at the link: cursor.com/insights.