A coding agent opens a pull request before you finish reviewing the previous one. The change is small but CI is failing and the reviewer needs a decision that never made it into the issue. Someone still has to move the work forward.
Coding agents like Claude Code and Codex can shorten the path from an instruction to a proposed implementation. But writing the code is only part of completing the task.
In his Compile 26 talk, Farhan Thawar, Shopify’s head of engineering, describes a shift in the software development lifecycle: as AI takes on more coding, engineers focus more on defining the problem and validating the result.
When coding stops being the slowest step, the bottleneck moves to the work around it. For a pull request, that means establishing the expected behavior, investigating failures and deciding whether the change is ready to merge. Those decisions often sit across the tools your team already uses:
- The issue tracker holds the request but may be missing acceptance criteria or a decision about expected behavior.
- The agent session contains implementation choices and commands that the reviewer needs to understand.
- CI reports failures that someone has to investigate and return to the next attempt.
- The pull request collects review feedback and waits for a fix, an answer or an approval.
A real example is dotnet/sdk PR #56962, where Copilot proposed stabilizing a flaky project conversion test. The test sometimes saw empty output even though dotnet run exited successfully. The proposed change removed runtime output assertions and built the converted project instead, while retaining a check for the expected project reference path.

An initial reviewer approved the change, but subsequent review questioned whether it addressed the failure. A maintainer pointed out that the test was meant to exercise dotnet run before and after conversion. The PR was closed without merging. The agent had produced a change, but review still had to establish whether it addressed the failure without weakening the test.
Each tool can work correctly while the task waits between them. If the same engineer has to reconstruct the context, copy failure logs and coordinate every review, more agent output also creates more work for that engineer.
For engineers, faster implementation matters when it helps more verified work reach completion. A growing queue of open pull requests is a reason to examine how work moves from implementation through verification and review.
Why adding more coding agents doesn’t solve the bottleneck?
Parallel agents are useful for independent tasks with clear boundaries. They provide less benefit when each attempt depends on someone supplying missing context or reconstructing what happened in the previous run.
The agent needs more than a repository checkout. It needs the task’s scope, project instructions, setup commands, required checks and a clear stopping condition. If those differ between sessions, reviewers receive changes produced under different standards.
Failure handling also needs a policy. A temporary CI outage may justify rerunning a check. A failing assertion may require a code change. An unclear API contract needs a decision from the team. Sending all three back with the same instruction to retry wastes attempts and makes the result harder to trust.
You can see these patterns in public examples:
- Choosing between fixes: In microsoft/vstest, Copilot produced #15753, #15757 and #15766 for the same bug. A maintainer selected #15766.
- Setup and verification: Azure/azure-dev #5456 needed environment fixes and explicit instructions for running tests.
- Retry scope: In microsoft/react-native-windows #14786, later attempts removed unrelated functionality that a maintainer had to flag.
Coding tools can gather context, run checks and coordinate work when given the appropriate instructions and access. The organizational question is whether those instructions and rules are shared, maintained and applied to every task.
A software factory connects the request, implementation attempts, verification and review in a repeatable workflow. The team defines what work can enter it, what evidence is required and which decisions need a person.
That workflow has a maintenance cost. If your current automation already takes an issue to an acceptable pull request with little intervention, keep that in the comparison. Additional orchestration should improve an observed constraint, such as repeated CI handoffs or missing review evidence.
How SuperPlane turns coding agents into a software factory?
SuperPlane keeps the request, agent attempts and results in a shared task record. Its Factory pipeline moves work through Backlog, Implement, Verify and Done, with automations coordinating each stage.
For a workflow that produces reviewed, merged changes:
- Intake and Backlog: Import tasks through Intakes and clarify their scope and acceptance checks.
- Implement: Run the coding agent with repository context, tools and shared instructions.
- Verify and retry: Evaluate checks and PR feedback, then return actionable failures within a retry limit.
- Human review: Present the diff, verification evidence and unresolved questions for the team’s approval and merge decision.
- Done: Record the outcome under the configured completion rules. When merge is required, confirm the linked PR is merged.
The agent handles implementation. The Factory keeps handoffs, evidence and recovery visible, with broader scope decisions returned to a person.
How Does an Open PR Become a Merged PR, With or Without a Software Factory?
Let’s look at the below examples to understand how work gets completed with and without a software factory. We’ll use a small task: add a YouTube channel link to the Community page with a specified destination, accessible label and new-tab behavior.
Without a factory: an engineer coordinates the handoffs
A small maintenance example from our repository is PR #9338, which added a fifth unit-test CI job. Its public history records a Codex-named branch and a maintainer merging after two checks passed. It does not expose the agent session’s prompts or retries; the steps above illustrate the coordination involved.
For the attached PR example, an engineer must prompt the agent, inspect its PR, check CI, investigate failures and request fixes. They would then gather the verification results and coordinate review. The agent can run checks, but the engineer keeps the process moving between attempts.
With SuperPlane: the task carries its context and evidence
Let’s see how the Factory handles a GitHub issue asking it to add a YouTube channel link to the Community page. SuperPlane imports the issue and passes its requirements to the coding agent. The agent adds the link and opens a PR. Configured verification checks the change and sends any failures back for correction. The task then reaches human review with the PR, check results and run history together, ready for a merge decision.
The walkthrough shows the Factory’s planning, implementation, verification and review stages. The same acceptance criteria apply in either workflow: the link must reach the right channel, meet the requested accessibility and tab behavior and pass the required checks. The difference is who coordinates those checks and carries their results into review.
Turn faster code into shipped work with Factory
Coding agents made writing code faster. But faster code generation doesn’t automatically mean faster delivery. You don’t need more agent sessions. You need a software factory that helps your team ship.
The next step isn’t adding more agents. It’s building the system around them that handles execution, verification, retries and human review. Ready to build your first Factory on SuperPlane? Follow the Build your first Factory guide to get started.”