How are coding agents changing software engineering?
Cursor · 2026-05-29
💡 Quick Take
1. Developer coding speed is doubling year-over-year.
2. Pull requests (PRs) are getting significantly larger, with a 2.5x increase in lines added per PR year-over-year.
3. "Mega PRs" (with 1000+ lines of change) are becoming more common.
4. AI-generated code is sticking around longer, with accepted AI lines still present after 60 minutes.
5. Tool calls (like editing files, running shell commands, web searches) are increasing by about 30%, indicating improving agent capabilities.
6. Model intelligence and quality are generally improving over time.
7. There's a significant "power user gap" where a small percentage of developers are vastly more productive with AI coding agents.
8. Top 1% power users consume more tokens, often in pursuit of upskilling and exploring AI agent workflows, even with some token waste.
9. Merged PRs by median active users are 15 times higher than non-AI assisted developers.
10. Input tokens, especially context, are dominating non-cached model usage, making context the main token cost.
11. Caching of tokens is crucial for agent work, especially with growing context and long conversations.
12. A significant portion of code changes (36%) are accepted without manual review, though this is lower than online hype suggests.
13. The trend is shifting towards building "software factories" and automating best practices for scalable software development.
📊 Detailed Explanation
1. Developer coding speed is doubling year-over-year. This means developers are getting way faster at writing code. It's not just about adding more lines, but about being more efficient and productive in their weekly output. This acceleration is a direct result of integrating AI tools into the development process.
2. Pull requests (PRs) are getting significantly larger, with a 2.5x increase in lines added per PR year-over-year. This is a huge shift! It suggests that developers are tackling bigger chunks of work in a single go, likely empowered by AI to handle more complex changes. It's not just a small tweak; they're making substantial contributions at once.
3. "Mega PRs" (with 1000+ lines of change) are becoming more common. This is pretty wild! While it can sometimes be due to things like lock file changes or accidental code generation, it also points to developers using AI to generate larger features or refactors. It highlights the power of these tools but also the need for careful management.
4. AI-generated code is sticking around longer, with accepted AI lines still present after 60 minutes. This is a really telling stat. It means the code that AI helps generate is not just being thrown away; it's actually being integrated and used. This shows that AI is becoming a more reliable partner in the coding process, not just a brainstorming tool.
5. Tool calls (like editing files, running shell commands, web searches) are increasing by about 30%, indicating improving agent capabilities. This is a great proxy for how smart and useful AI agents are becoming. When agents can effectively interact with their environment – making changes, fetching info – they're proving their worth and becoming more integrated into workflows.
6. Model intelligence and quality are generally improving over time. This is the underlying trend that enables all the others. As the AI models themselves get smarter and better at understanding and generating code, they become more capable assistants, driving the acceleration and complexity we're seeing.
7. There's a significant "power user gap" where a small percentage of developers are vastly more productive with AI coding agents. This is super interesting! It's like the 1% who really master these tools are pulling ahead dramatically. It shows that there's a learning curve and a skill to effectively leveraging AI, and those who crack it are seeing massive productivity gains.
8. Top 1% power users consume more tokens, often in pursuit of upskilling and exploring AI agent workflows, even with some token waste. These power users are really pushing the boundaries. They're willing to use more resources (tokens) to experiment, learn, and automate, even if it means some of that usage isn't perfectly efficient. It's about the bigger picture of mastering AI-assisted development.
9. Merged PRs by median active users are 15 times higher than non-AI assisted developers. This is a fantastic metric! Merged PRs imply human review and acceptance, meaning this code is actually going into production. The fact that AI-assisted developers are merging so many more PRs really underscores the productivity boost.
10. Input tokens, especially context, are dominating non-cached model usage, making context the main token cost. This highlights how important it is for AI models to understand the broader picture. The more context you give them (your codebase, documentation, etc.), the better they can perform. This also means managing and optimizing that context is key to cost-effectiveness.
11. Caching of tokens is crucial for agent work, especially with growing context and long conversations. Since context is so important and costly, caching previous interactions and information is vital. This allows AI agents to "remember" what's happened, avoid re-processing, and maintain efficiency, especially in extended coding sessions or complex tasks.
12. A significant portion of code changes (36%) are accepted without manual review, though this is lower than online hype suggests. While the online buzz might make it seem like code is just flying into production unchecked, the reality is more nuanced. Many teams still prioritize code review for quality and compliance, but AI is enabling more direct acceptance of changes.
13. The trend is shifting towards building "software factories" and automating best practices for scalable software development. This is the big picture evolution! Instead of just using AI ad-hoc, teams are building systems and processes. This "factory" approach aims to automate quality checks, security reviews, and other best practices, ensuring consistent, high-quality software at scale.
🎯 Expert Opinion
Wow, this report from Cursor is seriously eye-opening! As someone who's been deep in the trenches of software engineering for years, seeing these trends play out is both exciting and a little daunting. The doubling of coding speed and the massive increase in PR size aren't just numbers; they represent a fundamental shift in how we build software. We're moving from meticulous, line-by-line coding to more of a "sculpting" or "directing" role, where AI handles a lot of the heavy lifting. The "mega PR" phenomenon is a double-edged sword. On one hand, it's a testament to the power of AI to generate complex functionality quickly. On the other, it puts immense pressure on code review and maintainability. This is where the "software factory" concept becomes critical. We can't just blindly accept large AI-generated PRs. We need robust automated pipelines for testing, security scanning, and even AI-assisted code review to ensure quality and prevent technical debt from spiraling out of control. The fact that 36% of changes are accepted without manual review, while lower than some might expect, is still a significant number. This necessitates a move towards more sophisticated automated quality gates. The "power user gap" is a classic adoption curve pattern, but amplified by AI. Those who invest time in understanding prompt engineering, agent orchestration, and integrating AI into their core workflows will achieve exponential productivity gains. For the rest of us, it's a clear signal that continuous learning and adaptation are no longer optional; they're survival skills in this new era of AI-assisted development. The increasing token consumption by these power users, even with some "waste," shows a willingness to experiment and push boundaries, which is how innovation happens. The emphasis on context and caching is also a huge deal. As AI agents become more sophisticated and handle larger codebases, the ability to efficiently manage and recall context is paramount. This isn't just about reducing costs; it's about enabling more complex, long-running tasks. I foresee significant advancements in context management strategies, perhaps involving more intelligent summarization, selective retrieval, and even custom knowledge graphs that agents can query. Ultimately, this report paints a picture of software engineering evolving from a craft to a more industrialized, automated process. The challenge for us as professionals is to embrace these changes, master the new tools, and ensure that while we're accelerating development, we're not sacrificing the long-term health and maintainability of our software systems. The "software factory" is the future, and it's going to require a new set of skills and a new mindset to build and operate it effectively. This is a thrilling time to be in tech, but it demands constant vigilance and a commitment to continuous improvement.Kanal: Cursor