When two changes are waiting on you, starting a third coding agent can be the wrong move—even if the agent is cheap and the task is ready.
Agent utilization and finished changes are different things. A worker can finish generating a patch while the team still owes it a review, a repair, or a product decision. Starting more work doesn't resolve those obligations.
Put a limit on unfinished changes. Make the next task wait until the team has actually resolved one.
Count the change, not the running process
A work-in-progress limit, or WIP limit, caps how many changes the team admits at once. For agent work, count each change from admission through execution, human review, and repair.
The agent saying “done” does not release a slot. Neither does moving a card from Running to Needs review. Merge releases it. Deliberately abandoning the change releases it too, with a recorded reason.
Blocked work still counts. Otherwise, a team can hide every difficult decision in a Blocked column and keep admitting tasks while its unresolved work grows.
Start with a conservative experiment—perhaps two admitted changes for a small team. Two is an example, not an optimal number. Within that overall cap, authentication or migration work may need its own stricter lane.
Keep task diffs isolated and inspect dependencies before admitting parallel work. Separate branches do not make overlapping changes independent, and they are not security containment.
What a full board should make you do
Consider this hypothetical two-slot board, not an observed test run:
| Change | State | Next action | Uses a slot? |
|---|---|---|---|
| A: settings-save fix | Required check failed | Assigned engineer owns a bounded repair attempt | Yes |
| B: onboarding copy | Awaiting a product decision | Named product owner resolves the wording | Yes |
| C: theme cleanup | Not admitted | Wait | No |
The agents might be idle. The board is still full.
A returns to repair without becoming a new task or resetting its history. B goes to the person who can make the decision. Launching C because it looks easy leaves both blockers unresolved.
If A exhausts its repair budget, escalate to its owner. If the team decides to defer it, explicitly close this admitted attempt, preserve the evidence, and return the task to the backlog. A later attempt must be admitted again. Do not shuffle the card out of view and call that completion.
A manual board is enough to try this. No orchestration migration required.
Make the handoff small enough to review
A completion message is not a review packet. Before a change reaches human review, require:
- The exact revision and diff, plus the intended behavior.
- Each required check's command, result, and supporting output—or an explicit “not run.”
- Any unresolved decision and the person responsible for it.
For A, an illustrative handoff might read:
Settings-save fix. Attach the candidate revision and diff. Intended behavior: preserve the edited value after saving. Required checks: record the repository's actual commands and output. Outstanding decision: should a failed save retain the edited value? Owner: the assigned product owner.
This is an unfilled template. No check has been run for this example.
Missing or failed required checks return the change to bounded repair. An unavailable test environment is inconclusive, not green. Set a retry or time budget before the loop starts; when it runs out, escalate rather than letting another agent keep trying indefinitely.
Even successful checks cover only the behavior they exercise. They do not settle the outstanding product decision or authorize a merge.
Don't let automated review generate another queue
Another model can help review the diff. Forwarding every speculative concern to a person can create more triage work than it removes.
Open Code Review combines deterministic file selection and rule matching with contextual model review and structured, line-level findings. That separation is useful: keep mechanical routing predictable, then use the model where surrounding code and intent matter.
DeepCode's documented goal flow pairs a confirmed checklist with commands it runs before accepting completion. It also offers an optional independent reviewer and budget/time controls. Those mechanisms support a checked, bounded handoff; they do not implement the team-wide admission policy proposed here.
Require enough evidence to act on an escalated finding: where it occurs, what could go wrong, and why the changed code makes that plausible. A vague request to “consider improving robustness” should not automatically become a human decision.
Favoring precision can miss defects. Track dismissed noise and defects discovered later; fewer comments alone is not success. Another model's agreement is neither proof of correctness nor a guarantee of independence.
Keep CI results, product decisions, and merge permission distinct. A green test run cannot decide what the product should do. A model review cannot waive a required check.
Run one normal work period with the cap visible
Choose a conservative cap and record admitted, merged, and abandoned changes. Also record the oldest unfinished change's age, human review time, and repair loops. Keep blocked items visible so the numbers cannot improve just because difficult work disappeared.
Then adjust from observed review capacity and risk. If decisions remain stuck, resolve ownership before raising concurrency. If review stays manageable, test a higher cap rather than assuming two is sacred.
The next task can wait. Don't start work the team has no capacity to finish reviewing.
Source notes
- Alibaba Open Code Review — documented hybrid review design and precision/recall tradeoff; project benchmark claims are not used as independent results.
- DeepCode README — documented checked-goal flow, optional reviewer, and bounded execution controls.
The WIP policy, board, and handoff are proposals, not tested integrations or measured outcomes. Project behavior was not hands-on validated for this article.
Top comments (0)