How Coding Agents Boost Developer Productivity: Evidence from Cursor’s Field Study

What the Cursor study reveals about coding agents

Researchers are still mapping how coding agents change day-to-day developer work and organizational throughput. A recent field study by Suproteem Sarkar, an assistant professor of finance and applied AI at the University of Chicago, analyzed tens of thousands of Cursor users to measure early effects after Cursor made its agent the default workflow. You can read the full paper here. For more background on AI tools transforming engineering workflows, see our AI Tools & Apps section.

Key findings at a glance

• Merged PRs rose by 39%: Organizations that adopted Cursor’s agent as default merged about 39% more pull requests relative to similar organizations that weren’t using Cursor during the analysis window. This aligns with broader trends in Generative AI–driven productivity gains.
• Seniority matters: More experienced developers accepted agent-generated edits at higher rates and tended to plan more before asking agents to code.
• No large trade-offs detected: PR revert rates didn’t increase significantly, average lines edited and files touched per merged PR remained stable, and bugfix rates slightly decreased.

How did the study measure agent use and acceptance?

The researchers tracked two broad signals: (1) how often developers sent requests to Cursor’s agent, and (2) how often they accepted the agent’s code edits. Acceptance depends on two practical things: whether the generated output matches developer intent and the developer’s threshold for applying synthetic changes. For deeper context on autonomous agents, see our guide on Agentic AI.

Why senior devs accepted agent code more

Contrary to a naive expectation that junior developers would lean on agents more, the study shows that senior developers were more likely to accept agent output. For each standard deviation increase in years of experience, the acceptance rate rose by roughly 6% relative to the mean. There are several plausible explanations:

• Better prompting and context management: Experienced engineers may frame problems more precisely, use custom rules, and manage context windows to get higher-quality outputs.
• Stronger evaluation skills: Senior engineers can quickly validate agent suggestions and determine when a generated change is safe to accept.
• Work scope: Seniors often work on well-scoped changes that agents can complete reliably with fewer iterations.

In my experience reviewing tool adoption, this pattern aligns with broader technology uptake: experts often extract more value because they know what to ask for and how to vet the results.

Does agent use actually improve productivity?

Productivity is tricky to measure. The study used proxies — merged PRs as a throughput metric and revert/bugfix rates as quality controls — comparing organizations already using Cursor before agents launched (“eligible”) to a baseline group that wasn’t using Cursor in the same period. The headline: merged PRs increased by 39% relative to time trends in the baseline group. For more examples of AI-accelerated developer work, explore our breakdown of AI developer productivity tools.

What didn’t change much

• PR revert rate: no significant change, suggesting teams didn’t accept substantially more broken changes.
• Average lines edited & files touched per merged PR: stable, implying agents didn’t simply fragment or bloat edits.
• Bugfix rate: slightly decreased, tentatively suggesting agents didn’t harm code quality.

How are developers actually using agents?

The study sampled 1,000 users’ conversation-starting requests and grouped them into three broad intents:

• Implementation (~61%): Asking the agent to write or generate code.
• Explanation & debugging: Asking the agent to explain code, error messages, or test failures.
• Planning & design: Asking for an outline, step-by-step plan, or approach before writing code.

Notably, more experienced developers tended to plan more — drafting steps and constraints before generating code — which likely produces higher-quality agent outputs and fewer iterations.

Small case study: A hypothetical engineering team

Imagine a 20-person backend team that makes ~200 PRs per month. If adopting Cursor’s agent led to a similar 39% increase in merged PR throughput without raising reverts, that team might go from 200 merged PRs to ~278 — a meaningful bump for feature velocity. If experienced devs spend 10–20% less time on repetitive refactors or tests because the agent scaffolds code, team leads can reallocate that time to design, code reviews, or product collaboration.

Limitations and open questions

• Causal complexity: Field studies control for many factors, but unobserved confounders can remain. Adoption style, project type, and organizational incentives all affect outcomes.
• Long-term effects: Early gains in throughput don’t automatically translate to long-term productivity without changes in processes and developer skills.
• Security & compliance: The study doesn’t deeply analyze how agents interact with licensing, secrets, or internal policy constraints — a key practical concern for many orgs. For more, see our AI & Cybersecurity section.

Practical takeaways for engineering leaders

• Train to prompt: Invest a few sessions on how to craft prompts, manage context, and validate agent outputs — this often pays for itself quickly.
• Start with well-scoped tasks: Use agents first for small, clearly defined changes such as refactors, tests, or simple feature scaffolding.
• Measure the right metrics: Track merged PRs, revert rates, review times, and developer sentiment, and combine quantitative data with qualitative feedback.
• Encourage planning: Teach devs — especially juniors — to write short plans before asking the agent to code. The study suggests planning improves outcomes.

Related research & further reading

For a deeper dive, see Suproteem Sarkar’s full analysis on SSRN: https://papers.ssrn.com/sol3/papers.cfm?abstract_id=5713646. For context on how AI tools are reshaping developer workflows, see our article on Agentic AI.

Early, encouraging signals — but watch the horizon

Cursor’s field data offers encouraging early evidence that coding agents can increase throughput (merged PRs) without clear quality regressions. In my experience, the real value unlocks when teams combine good prompting habits, clear scoping, and review processes. That said, organizations should monitor long-term impacts, security boundaries, and onboarding ramps. Technology rarely replaces craftsmanship — instead, it amplifies it when used wisely.

Read the complete study here.