AI Sprint Planning When Agents Outrun Your Reviewers
Coding agents can produce more changes than your qualified reviewers can inspect. Plan the sprint against review capacity per skill and decide what waits.

Say your agents could run ten tasks this sprint. How many could your reviewers actually inspect?
That second number is the one to plan against. When coding agents can produce more changes than your people can check, AI sprint planning works best with two limits in view: what agents can execute, and what your qualified reviewers can review this sprint, counted per review skill. Select only the work both can absorb. Let review-bound items wait with a stated reason. Treat the Sprint Goal as the commitment and the selected items as a forecast. This is a proposed method assembled from the Scrum Guide, the Kanban Guide and public code review guidance. The Scrum Guide doesn't prescribe it, and I have no measured study to offer for it.
It's written for small engineering teams whose agents finish tasks faster than the one person who understands billing, auth or the product can look at them.
Why review became the slow part
In October, Linux memory-management reviewer Lorenzo Stoakes put it bluntly on the kernel mailing list: "What kills the project is having 1,000 slop submissions that 2 or 3 people have to do something with." 1 Those figures come from a policy argument and are rhetorical. A month later, Tom's Hardware reported that he had stepped back from some of his memory-management review duties, and tied the decision to inbox pressure 2. I couldn't open the November mailing-list message itself, so that detail rests on the report.
One open-source maintainer is a single case. It still illustrates the shape: when submissions multiply, the extra work lands on the two or three people qualified to say yes.
Review also costs more than one look. Google's engineering practices say "One business day is the maximum time it should take to respond to a code review request" 3, and they treat a first response and a finished review as different things. A change that comes back with questions usually returns to whoever asked them. That routing is my assumption about most teams; Google's page doesn't say it. Either way, review load arrives as a series of response cycles. If you want the longer argument about who absorbs generated work, it's worth reading before any capacity arithmetic.
What does a sprint actually commit to?
In Scrum, the Developers commit to the Sprint Goal. That takes some pressure off, because the Guide leaves room in how you get there:
Although the Sprint Goal is a commitment by the Developers, it provides flexibility in terms of the exact work needed to achieve it. 4
The selected items are a forecast, and the Guide names what makes that forecast confident: "the more the Developers know about their past performance, their upcoming capacity, and their Definition of Done, the more confident they will be in their Sprint forecasts." 4
Two things follow. Upcoming capacity has to include the people who review, because the Guide is equally plain that "Work cannot be considered part of an Increment unless it meets the Definition of Done." 4 If qualified review is part of your Definition of Done, a generated change that hasn't passed that review is still inventory. And when review is short, shrink the forecast and leave the Definition of Done alone.
A small vocabulary note: code review here means inspecting a change, and the Sprint Review is a separate Scrum event. Same word, different meeting.
AI sprint planning needs review capacity by skill
For sprint capacity planning, treat review time as several separate pools. Teams often quote a single figure, something like "about 25 review hours this sprint", and that figure hides the problem. An hour of product acceptance cannot approve a change to token handling. Spare domain time doesn't cover a missing security reviewer. Each review skill is its own narrow door, and the plan has to fit through each door separately.
So split capacity by the skills your review gates actually need. For many teams that's security, domain and product acceptance. Ask the people who hold each skill how much time they genuinely have, after meetings, on-call and their own work. Then hold some back for second passes, since review arrives in cycles 3. How much to hold back is a local call; I don't know of a measured rate worth borrowing.
The submitter side changes the estimate too. An agent handoff with no stated intent, risk or validation turns the reviewer into the first real author, who now has to reconstruct reasoning the submitter could have written down. Agreeing on what developers owe reviewers is part of estimating review demand.

A worked sprint, with made-up numbers
Every number in this section is illustrative. It's a hypothetical team, built to show the mechanism, and nothing here is a measured result.
The Sprint Goal: customers can export invoices as CSV without opening a support ticket. Two weeks. Agents can run all eight candidate items. Review windows, after holding time back for second passes:
- Security: one qualified reviewer, 8 hours, 2 held back, 6 usable.
- Billing domain: two reviewers, 14 hours combined, 3 held back, 11 usable.
- Product acceptance: 8 hours, 2 held back, 6 usable.
That's 23 usable review hours. Both plans below use the same 23. The only difference is whether you pool them.
Illustrative example: hypothetical first-pass review hours for one invented sprint, not measured data.
| # | Candidate item | Sprint Goal link | Review need (illustrative hours) | Pooled plan | Per-skill plan | Release condition |
|---|---|---|---|---|---|---|
| 1 | CSV export endpoint | Goal | domain 4, security 3 | Select | Select | None needed |
| 2 | Export button and empty states | Goal | product 3 | Select | Select | None needed |
| 3 | Rate limit on export | Goal | security 3 | Select | Select | None needed |
| 4 | Move invoice PDFs to new storage | Not goal | security 4, domain 4 | Select | Wait | Security window next sprint, or a slice with no security-sensitive change |
| 5 | Billing test cleanup | Supports goal | domain 3 | Not selected | Select | None needed |
| 6 | Admin SSO change | Not goal | security 5 | Not selected | Wait | A security window opens |
| 7 | Email copy updates | Not goal | product 2 | Select | Select | None needed |
| 8 | Tax-rounding rewrite | Not goal | domain 10 (first slice: domain 3) | Not selected | Split: first slice only | Later slices wait for domain time |
Now look at the security door. That same plan needs 3 + 3 + 4 = 10 security hours, and there are 6. Four hours over, on the one skill nobody else can cover. Something stalls, and it may well be a goal item, since two of the three need security review.
The per-skill plan takes items 1, 2, 3, 5 and 7 plus the first slice of the tax rewrite. Security comes to 3 + 3 = 6 of 6. Domain is 4 + 3 + 3 = 10 of 11. Product is 3 + 2 = 5 of 6. That's 21 of 23 hours, with two to spare. Both plans picked the three goal items. Only the per-skill selection stays inside every review budget; pooling hid the security overload.
Which items wait, and what lets them back in?
Each candidate gets one of three outcomes.
Select when an agent can run it and a named reviewer with the right skill has the window.
Split when a smaller slice fits a window now and can be reviewed and accepted on its own. Chopping one large diff into three tickets that only make sense together keeps the same review load and adds paperwork. DORA's guidance on working in small batches notes that large AI-generated changes are hard to review and integrate safely, and warns against regrouping small pieces of work into big handoffs downstream 5. In the example, the storage migration could split only if a slice genuinely touched nothing security-sensitive.
Wait when neither fits, and here the item stays unstarted. This is the counterintuitive one. If the agent is free, why not generate the change anyway and park it? Because a generated, unreviewed change is started work that isn't finished. The Kanban Guide is direct about this: "Kanban system members must explicitly control the number of work items in a workflow from started to finished." 6 A parked diff can also fall behind the main branch while it waits, and someone still has to remember it exists.
Every waiting item also gets a release condition written next to it: a named reviewer's window, a smaller slice, or scope renegotiated with the Product Owner that frees a reviewer without endangering the Sprint Goal 4. "Later" doesn't count. The same habit applies to any blocked work, and there's a useful piece on what would release a waiting dependency when one shared reviewer is the constraint.
Objections worth taking seriously
Doesn't our velocity already include review?
It does, when your reviewers, your mix of work and your process are stable. In that case historical velocity is the better forecast, and this check doesn't replace it. Reach for the per-skill check when something changed: your agents now produce more changes than your history reflects, the security reviewer is out for a week, or the Sprint Goal is unusually security-heavy. Just don't stack the two by adding review estimates on top of a velocity that already absorbed review. That counts the same hours twice.
Can't AI reviewers take the load?
Partly, perhaps. Automated critique may catch some avoidable problems before a person sees them. Whether that actually shortens human review per change is a hypothesis I haven't seen measured. Nothing I inspected shows it removing the need for a qualified human to accept the change. A reply in a Reddit thread about review fatigue put the risk neatly: "otherwise three agents can agree while the same broken interaction still reaches you." 7 That's a single commenter's view, not evidence. If your automated checks really do cut review time, measure it on your own completed items, then raise the plan.
Do AI sprint planning tools solve this?
I opened four prominent roundups of AI sprint planning tools 8. They cover drafting tickets, estimating from history, capacity flags and integrations, and at least one discusses how history goes stale once agents speed things up. Helpful stuff. A planning suggestion still can't confirm that the one person qualified to review auth code is free on Thursday. Some tools may help collect that answer. The answer itself has to come from the reviewer.
Isn't an idle agent a waste?
My working assumption is that an idle agent costs a team less than an unfinished change sitting in a queue, which spends reviewer attention, merge effort and context. So leaving an agent idle can be the better deal, though that's a judgement I can't back with a measured saving. If you want the agent busy, give it bounded work with its own purpose and a review path someone can actually cover.
When this is the wrong lens
Check before you declare review the bottleneck. Slow builds, flaky environments, pending product decisions or release controls can dominate instead, and splitting review hours won't fix any of them.
The method also assumes a qualified human accepts changes. Solo projects, teams without a separate review gate, and low-risk changes that are validated mechanically need different treatment. For emergencies, write an explicit exception policy that everyone can see, so any lowered bar is a visible decision.
A sprint planning checklist for review capacity
- Name the review skill each candidate item needs.
- Ask each qualified reviewer for their real window this sprint.
- Hold back time for second passes.
- Select against the narrowest skill first, starting with Sprint Goal items.
- Write a release condition on every item that waits.
It fits on a sticky note, which is about the right size for a sprint planning checklist.
So, which review skill is the narrowest door in your next sprint: security, domain knowledge, product sign-off, or one I haven't listed?
References
- Lorenzo Stoakes, "Re: [PATCH] docs: remove Assisted-by references," linux-kernel mailing list, archived by The Mail Archive, 12 October 2026. https://www.mail-archive.com/linux-kernel@vger.kernel.org/msg2663049.html. Accessed 18 November 2026.
- Bruno Ferreira, "Linux kernel reviewer steps down from memory management duties due to influx of AI slop patches," Tom's Hardware, 11 November 2026. tomshardware.com. Accessed 18 November 2026.
- Google Engineering Practices, "Speed of Code Reviews." https://google.github.io/eng-practices/review/reviewer/speed.html. Accessed 18 November 2026.
- Ken Schwaber and Jeff Sutherland, "The 2020 Scrum Guide," Scrum Guides, November 2020. https://scrumguides.org/scrum-guide.html. Accessed 18 November 2026.
- DORA, "Capabilities: Working in small batches." https://dora.dev/capabilities/working-in-small-batches/. Accessed 18 November 2026.
- Kanban Guides, "The Kanban Guide," May 2025. https://kanbanguides.org/the-kanban-guide/2025.5/. Accessed 18 November 2026.
- arthaudm, reply in an r/AI_Agents thread on human review fatigue, Reddit, October 2026. https://www.reddit.com/r/AI_Agents/comments/1x1h82c/the_real_bottleneck_of_building_with_ai_isnt_code/. Accessed 18 November 2026.
- AI sprint planning tool roundups inspected for this article: Augment Code, updated 16 September 2026, augmentcode.com; Superdots, updated 4 May 2026, superdots.sh; AI PM Tools, undated, aipmtools.org; Bito, updated 20 July 2026, bito.ai. Accessed 18 November 2026.
Put this project board inside ChatGPT
Open Agiflow in ChatGPT to plan campaigns, create tasks, and check what needs attention. Create a free Agiflow account when you are ready to keep the board for your team.
More to read
Project dependencies need reasons and release conditions
Before keeping or relaxing a task dependency, name its reason, the evidence that releases it, and who can make that call. A hypothetical release shows where parallel work must stop.
5 min readGemini 4 Argon Overnight Runs: Review Each Proposal in Three Layers
Review each overnight Gemini 4 Argon proposal against repository tests, consumer contracts and a reserved workload before deciding what to merge.
5 min readHow to Build an AI Code Review Workflow in Agiflow
Build a decision-ready review queue for AI-generated code with a clear task contract, inspectable evidence, visible gaps, and a named human decision.
5 min read