Back to rankings

Windsurf: Devin Introduces Stacked PRs for Easier Code Review

WindsurfView original changelog

Windsurf's Devin now automatically decomposes large coding tasks into stacked pull requests — an ordered series of small, independently reviewable PRs — instead of opening one monolithic diff. The feature draws on DeepWiki, Devin's continuously indexed map of a repository's architecture, to find natural seams for splitting work, and it automatically rebases and re-verifies CI across the whole stack whenever review feedback arrives. Devin can also reverse-engineer an existing oversized PR into a stack after the fact. The change responds to research showing AI-assisted teams are shipping far more pull requests without a corresponding improvement in review throughput.

Key Takeaways

  • Devin now splits large tasks into stacked pull requests instead of one monolithic PR, aiming to make agent-generated code easier and faster to review.
  • Decomposition relies on DeepWiki, Devin's continuously indexed architecture map, to find natural seams for splitting a codebase's changes along module boundaries.
  • When reviewers request changes on one layer, Devin automatically rebases affected downstream layers and re-verifies CI across the entire stack.
  • Developers can hand Devin an existing oversized PR and have it reverse-engineer a stacked structure from it after the fact.
  • The feature responds to Faros AI's 2025 telemetry findings that high-AI-adoption teams merged 98% more PRs while review time per PR grew 91% and average PR size grew 154%, without matching delivery gains.
  • Devin only creates a stack when a task is intentionally split into an ordered series designed to land together, not simply because branches happen to build on one another.

Devin Tackles the Code Review Bottleneck

Windsurf's Devin no longer opens a single monolithic pull request when it completes a large task. Instead, it now breaks the changes into a stack of smaller, self-contained PRs, built in partnership with GitHub's own stacking workflow. The move addresses a problem that has become increasingly visible as AI coding agents scale up: code generation stopped being the bottleneck a while ago, and code review is now the constraint that doesn't scale the same way implementation does.

Devin's announcement cites a 2025 telemetry study from Faros AI covering more than 10,000 developers across 1,255 teams. Teams with high AI adoption merged 98% more pull requests than lower-adoption teams, but review time per PR grew 91% and average PR size grew 154% — and despite all that extra throughput, organization-level delivery metrics didn't actually improve. As Devin's team put it, "when agents produce code, the engineer's job shifts from implementation to review. And review doesn't scale in the same way."

Automatic PR Decomposition

To split large tasks intelligently rather than arbitrarily, Devin leans on DeepWiki, described as "a continuously indexed map of your repository's architecture: the modules, the boundaries between them, and how they depend on each other." That architectural awareness lets Devin identify where a change naturally divides into independent layers — the seams of a good stack, according to Devin's team, are almost always architectural rather than incidental.

Keeping Stacks in Sync

Splitting a change into a stack only helps if the stack stays coherent as review happens. When reviewer feedback comes in on one layer, Devin reacts automatically: it rebases the affected downstream layers, resolves any resulting conflicts, and re-verifies CI across the entire stack, so reviewers aren't left untangling a chain of PRs that has drifted out of sync.

Retrofitting Existing PRs

The feature isn't limited to work Devin originates itself. Developers can hand Devin a large PR that already exists — including ones a human wrote — and Devin will re-derive a sensible stacked structure after the fact, effectively decomposing a problematic existing pull request into reviewable layers.

A Worked Example

Devin's announcement illustrates the workflow by converting a monolithic 47-file authentication implementation (+2,881 lines) into five focused PRs:

  • Core authentication and sessions (19 files, +585 lines)
  • Password reset and security features (16 files, +498 lines)
  • Account settings (8 files, +393 lines)
  • Teams functionality (14 files, +636 lines)
  • Development tooling (7 files, +774 lines)

Design Philosophy

Devin's team was deliberate about when a stack gets created at all. "A stack is only created when Devin has intentionally split one piece of work into an ordered series designed to land together, not merely because one branch builds off another." In other words, the feature is meant to reflect genuine architectural decomposition, not simply chain unrelated branches together for the sake of it.

Availability

Stacked PRs are available immediately at devin.ai. Devin's team frames the pitch simply: "give Devin a big task, or a big PR you've been dreading, and review it one focused diff at a time."