Earned Autonomy: Expanding What We Trust the Software Factory to Do
Earned Autonomy: Expanding What We Trust the Software Factory to Do
For several features I’ve built with coding agents, understanding the output and getting it into production took longer than developing the feature itself. The agent worked across components and repositories quickly. I still needed to establish how the changes fit together, which decisions it had made and whether I trusted the result enough to ship it.
I wrote about that experience recently. It points to a problem that becomes more consequential as agents take on more work: engineering attention has to stretch across both routine approvals and difficult judgments about what was built.
A reviewed, low-risk change waits for someone to approve it. Meanwhile, a feature spanning several PRs requires someone to reconstruct its behavior, dependencies and risks. Both enter the same human queue, even though they demand very different kinds of attention.
We need a better way to decide which responsibilities the system can carry and where people should remain involved. That requires explicit standards for delegated decisions and useful evidence for the decisions we still make ourselves.
Today, we’re introducing Approval Workflows in beta and Agent Session Review in research preview. They address those two needs. Together, they represent a practical step toward a software factory that earns greater autonomy through the quality of its decisions.
Autonomy is earned one boundary at a time
I find it useful to distinguish two levels of autonomy. In the framework I use, the difference is how much responsibility the system can carry without depending on a person to take over.
- L1: Assist. AI helps with individual tasks, while people direct and carry out the work.
- L2: Pair. People and agents work together on implementation, with people guiding the agent, evaluating its output and deciding what happens next.
- L3: Agentic SDLC. Agents carry out development workflows, but people remain essential to completing them. Changes still need human approval, and failures depend on someone stepping in to resolve them.
- L4: Lights-on software factory. The system completes a defined class of work through verification, approval and release within the authority the team has delegated. If something goes wrong, it contains the problem first by holding a change, stopping a rollout or restoring a previous version, then escalates with the evidence.

These levels describe a specific workflow within a defined scope. A team can operate at L4 for some kinds of work while keeping others at L3.
Teams need to define via policies which work the factory can complete without a person stepping in, and what it must demonstrate before moving forward. For example, a team might let it handle test-only changes in an internal service, provided the changes pass review and all required checks. To complete that work autonomously, the factory also needs permission to merge and release it, along with a reliable way to detect problems and stop or rollback. Those conditions define the boundary of its responsibility.
Engineers own those boundaries. They decide where delegation begins, examine the results and expand the scope when the evidence supports it.
Pull request approval is one concrete place to begin. Even after a change has passed review and met the team’s standards, it often waits for someone to open it and click approve. As agents produce more code, that queue grows. Defining which changes can receive approval automatically keeps routine work moving and preserves engineering attention for decisions that need judgment.
Make approval criteria explicit
Teams already make recurring judgments about which changes need close scrutiny. The opportunity is to express the repeatable parts of that judgment clearly enough for a system to apply them.
With Qodo’s new Approval Workflows, teams can turn their criteria into a repeatable approval process. They define which findings, risks and rule violations require human attention, and which PRs are safe to move to merge without explicit human signoff.
For example, a team might allow minor maintainability findings but require a person to examine any security finding. It might also limit automatic approval to changes with a small blast radius, since even a few lines of code can affect services beyond the repository being changed.
Those criteria make the team’s judgment part of the development process. Changes that meet the standard can receive approval without waiting for someone to repeat the same assessment, while work outside those boundaries stays with a person.
The team retains authority over what it delegates. Approval remains conditional on the code meeting its standards, and the reasons behind each automated decision remain available for inspection.
That gives engineers a concrete basis for trusting the process and deciding where it can take on more responsibility. Delegating routine approvals also creates room for the work where the decision cannot yet be reduced to a repeatable policy. That work needs a better interface for human judgment.
Make the agent’s decisions inspectable
An agent-built feature may span a backend service, an API and a client, with changes distributed across several PRs. The person responsible needs to understand the behavior those changes produce together. Reading each diff separately leaves them to reconstruct that behavior themselves.
That means understanding the decisions behind the implementation: how the agent interpreted a requirement, which existing patterns it followed and where it departed from the plan. Those choices can affect how the feature behaves even when each individual change passes review.
The engineer needs a way to connect those choices to their consequences. What changed beyond the original scope? Which assumptions affect other services? Which tradeoffs need a closer look? Answering those questions requires the context of the coding session alongside the code it produced.
Qodo’s new Agent Session Review makes those choices easier to examine.
Agent Session Review brings the agent’s work across PRs and repositories into one assessment, connecting requirements, coding-session context, implementation and Qodo’s review findings. It surfaces behavioral and technical decisions, highlights departures from the plan and traces execution paths through the code.
With those choices and their consequences in view, engineers have the context to weigh tradeoffs, challenge assumptions and reconsider requirements. They can decide what to accept and what needs another pass without reconstructing the agent’s work from scattered diffs and session history.
Those decisions also reveal where the factory needs to improve.
Turn repeated judgment into better rules
If the same architectural correction appears in several sessions, the team should consider turning it into an explicit standard. If a recurring ambiguity changes product behavior, it may belong in the specification. If an approval workflow repeatedly sends the same understood case to a person, its criteria may need refinement.
Some interventions will reveal work that should remain outside the delegated scope. Others will expose missing context, weak verification or an instruction that needs to be more precise.
Each is useful evidence about the system.
The important step is to evaluate the lesson before applying it broadly. A decision made for one feature may depend on constraints that do not hold elsewhere. Turning it into a rule requires understanding where it applies, what it should catch and which legitimate changes it should leave alone.
This is how individual engineering judgments can become improvements that benefit future work. It is also why the factory itself needs evaluation.
Evaluate the factory as well as its output
Engineering teams have two things to assess: the software they produce and the system producing it.
For the software, we need evidence about behavior, quality and impact. For the factory, we need to understand which decisions it handles reliably, where people still intervene, what it misses and whether changes to its rules improve the results.
The clearest sign of progress is more work meeting the team’s standards with less manual intervention. Tracking approval rates alongside defects, rule compliance and delivery outcomes shows which workflows are ready for greater autonomy and where better context, rules or verification would help. Engineers can use those results to improve the factory with the same discipline they apply to the software it produces.
Advance automation and trust together
This is the role I see for Qodo as the quality and governance layer of the software factory: helping teams make their standards actionable, evaluate work against them and understand the decisions that remain theirs.
Approval Workflows and Agent Session Review bring that approach into the daily development process. Routine approvals can proceed within explicit boundaries. More complex work arrives with the context people need to examine the agent’s choices and decide what happens next.
Automation without trust will eventually force people to take the work back. Trust that depends on a person reconstructing every change will constrain how far the factory can scale.
We need both to advance together. Every well-defined rule captures a decision the team understands. Every assessed outcome provides evidence about whether the system deserves more responsibility.
That is how we expand the software factory, one earned boundary at a time.