Cursor’s cloud agents now produce 35% of their internal merged pull requests—production code shipping to millions of users. Launched February 24, these aren’t assistants that autocomplete your code. They’re autonomous agents running in isolated virtual machines that write code, test it by navigating UIs in browsers, record video proof of their work, and ship merge-ready pull requests. When one developer can manage 10-20 agents simultaneously, code review becomes the bottleneck, not writing code.
This is what “AI replacing developers” actually looks like: not replacement, but a fundamental shift in what developers do.
Autonomous Agents That Test Through The UI
Each Cursor cloud agent runs in its own isolated VM with a full development environment. The workflow: agent clones your repo, installs dependencies, writes code, runs tests, opens browsers, navigates to localhost, clicks through UI elements to verify everything works, records videos and screenshots, then creates a PR with all artifacts attached.
The differentiator is the Computer Use API. Unlike GitHub Copilot’s autocomplete or Claude Code’s terminal-only approach, Cursor agents interact with software through the GUI. Consequently, they catch visual bugs that pass every unit test because they see what users see.
Moreover, isolation means failed builds never touch your local environment. Each of the 10-20 agents you can run simultaneously operates in its own sandbox, competing for cloud compute instead of your laptop’s resources.
The 35% Threshold – Proof This Is Real
35% of Cursor’s internal merged pull requests come from autonomous agents. That’s production code at a $29.3B company with $1B in annual recurring revenue—not a demo metric.
Cursor CEO Michael Truell confirmed developers who adopt this workflow have agents write nearly 100% of their code. Developers now spend time breaking down problems, scoping tasks, and reviewing artifacts instead of writing implementations. Additionally, multiple agents run in parallel rather than manually guiding each line.
Real use cases at Cursor demonstrate the range: agents reproduce security vulnerabilities by building exploit demos and executing attacks with video proof; they build features like source code links for the Cursor Marketplace, verify functionality through the UI, resolve merge conflicts, and ship; BugBot, Cursor’s code review agent, scans PRs for logic bugs and security issues, then spawns cloud agents to fix them—35% of these fixes merge without human modification.
Therefore, the one-third threshold matters. When autonomous agents produce 35% of production code at a major tech company, this transitions from experimental to operational.
Code Review Is Now The Bottleneck
When developers manage 10-20 parallel agents, code review becomes the constraint. Writing code is no longer the slow part—evaluating what autonomous agents produced is.
Alexi Robbins, Cursor’s co-head of engineering for asynchronous agents, describes the shift: “Instead of having one to three things running at once, you can have 10 or 20 of these things running.” Furthermore, the Stack Overflow 2025 Developer Survey confirms the tension: 84% of developers use AI tools, but only 3% trust the output unconditionally. In addition, 66% report frustration with AI solutions that are “almost right, but not quite.”
Consequently, the developer role shifts from writing to orchestrating. You define problems, scope tasks precisely enough for autonomous execution, then review outputs efficiently to stay unblocked. Cursor’s video artifacts help—watching an agent navigate a UI is easier than parsing a 2,000-line diff.
However, this only works for teams with strong review practices. Cursor has robust CI/CD pipelines, code review culture, and test suites. Agents operate within engineering processes, not around them. For teams lacking these foundations, autonomous agents could introduce problems faster than they solve them.
What This Means For Developers
This isn’t replacing developers—it’s redefining the role. Morgan Stanley research suggests AI will create more software engineering jobs, growing the market 20% annually to $61 billion by 2029. Senior developers remain critical: AI doesn’t make tough calls on architecture, compliance, or security. It can’t fully understand business logic or ethical implications.
Nevertheless, the skills that matter are shifting. Understanding how code works trumps simply writing it. System design, performance, security, and how technologies interact in production separate valuable developers from replaceable ones. Gartner predicts by 2027, 80% of the engineering workforce will need upskilling for generative AI.
The biggest challenge hits junior developers. AI isn’t replacing entry-level positions—companies are choosing not to invest in growing talent. Forrester forecasts a 20% drop in computer science enrollments and doubling of time-to-fill for developer roles. When agents handle routine implementation work, the traditional junior developer path—learn by doing small tasks—disappears.
Developers who embrace AI tools effectively will thrive. Those who don’t adapt face challenges. The adaptation isn’t optional.
Key Takeaways
- Cursor cloud agents run in isolated VMs, write code, test through UIs, record video proof, and ship production PRs—35% of Cursor’s merged PRs now come from these agents
- Unlike Copilot (autocomplete) or Claude Code (terminal-only), Cursor agents interact with GUIs and verify code works visually
- Developers can run 10-20 agents in parallel, shifting focus from writing code to orchestrating agents and reviewing output
- Code review becomes the bottleneck—teams need strong review practices, CI/CD pipelines, and test suites to benefit
- Senior developers with architecture, review, and system design skills will thrive; entry-level positions face the biggest disruption as routine implementation work becomes automated
