Olivier Guillaume - Nov 17, 2026Making a PO autonomous all the way to production: what to put in place, what stays with the developers
A PO can ship to production with AI. Not alone, not right away, and not on just any application. It is first a flow problem, in the Lean sense: find where work is waiting, then make it move without degrading quality. Three things need to be in place, in this order: a readable application (consistent code, documentation, automated tests), a delivery flow written down in black and white, then a risk assessment based on what the code actually touches. What stays with the developer: building that pipeline and remaining accountable for what goes to production.
I am Head of Delivery at exFabrica. On Lysia, our internal ERP, used by 40 people every day, I also act as Product Owner. That is where I lived this. Here is what I take away from it, step by step.

The bottleneck moves: from developer availability to the PO
To make a PO autonomous, you first need to know what is holding them back. On Lysia, the answer was simple: developer availability.
Every change, even a small one, depended on a developer who knew the application. In other words, on staffing. There were periods when we moved forward. And others when it was impossible, because nobody was available. Business needs, however, do not stop. Requests pile up. The PO knows what needs to be done, but waits. In Lean terms, this is the first kind of waste: pure waiting.
Once that wait is removed, the bottleneck does not disappear. It moves to the PO. Understanding the need, specifying it, mocking it up, testing it: all of that stays with the PO. And since we deliver faster, the PO has more work than before, not less.

My takeaway: before trying to make a PO autonomous, look at where the waiting is. If it comes from developer availability, the goal is not to replace the developer. It is to stop depending on their presence for every small change. But plan for what comes next: the pace will be set by the PO's capacity to understand and specify the need.
Standardize before you automate
This is the step you are tempted to skip. Don't. An AI working on heterogeneous code, with no documentation and no tests, produces changes that nobody can verify.
On Lysia, we started by modernizing. Three workstreams:
- make the technologies consistent;
- retro-document the existing application;
- set up automated tests that run on every build.
Only the front end was modernized. The method mattered as much as the tool. The tech lead first migrated a few pages by hand, to set the way of doing it. It is a basic Lean principle: set the standard before speeding up. Then the agents migrated the rest in 16 hours, for 1 billion tokens.
That figure is impressive. But it is not what cost the most. The most expensive part was acceptance testing. It surfaced tests that passed, and others that failed. Everything was fixed before going live.

My takeaway: migration by agents is fast, verification is not. If you are planning this kind of modernization, budget acceptance testing as the main cost. And have a human set the standard on a few cases before letting the agents loose on the rest.
Build quality into the flow
Once the application is readable, you need a framework. Not a general intention, a written framework.
On 28/09/2026, we set 27 requirements for the flow that goes from idea to production. Here are the essentials:
- an HTML mock-up built on top of the existing screens;
- a validation of the impact on the data model;
- a named branch and tracked changes;
- automated tests;
- acceptance testing before the PR, not after;
- a change record: why, intent, business rules, impacts;
- human review of PRs, scaled to the risk;
- updated documentation;
- autonomy that grows with trust.

The common thread is Lean's: quality is built into the flow, not inspected at the end. A defect found in acceptance testing before the PR costs a fix. The same defect found in production costs an incident.
The last item on the list is, in my view, the most important. Autonomy cannot be decreed. It is earned, delivery after delivery, through small improvements. One example: at first, every PR was reviewed. Today, green PRs no longer are. The framework has to say so explicitly, otherwise you swing between two extremes: controlling everything or letting everything through.
My takeaway: write your requirements before the first delivery. Put acceptance testing before the PR. And plan from day one for the level of autonomy to evolve.
The PO gains upstream and in responsiveness
The first gain was not where I expected it. It is upstream.
I now build mock-ups myself, based on the existing screens. The result: far fewer back-and-forths. Users react to something concrete. Misunderstandings surface before development, not during acceptance testing. Every back-and-forth avoided means less waiting and less rework.
The second gain is responsiveness. A production issue was diagnosed on 08/10. The fix was live on 09/10 at noon. Before, that lead time depended on who was available.

There are also less expected gains. Videos presenting new features are now generated. And a substantial change, tracking customer satisfaction on projects, was made almost entirely through iterations between the AI and me. It touched every layer: a questionnaire, Slack notifications, a new database table, a new monitoring tab and access rights.
My takeaway: do not measure development time only. Measure end-to-end lead time, from need to production. The time lost in back-and-forths before development often weighs more. That is where an autonomous PO adds the most value.
Scale review to risk, and read that risk from the code
We assess every change with a three-level grid: green, orange, red. The color does not decide who ships. It decides how much attention the PR gets. Recently, green PRs stopped being reviewed. It is a Lean principle: scale control to risk, rather than inspecting everything the same way.
The grid still has to be right. At first, it was too cautious. From 06/10 to 20/10, out of 11 items, only 1 was rated green. If almost everything is orange or red, almost every PR needs careful review. Autonomy exists only on paper. The tech lead becomes the mandatory checkpoint again, and you are back to the original bottleneck.
The problem came from the source: we assessed risk from the description of the need. Not from what the change actually touches. Risk must be derived from the code: permissions, roles, the data model, screens.
But a fully generic grid is not enough. Every application has its sensitive areas, tied to its business. On Lysia, our ERP, any change that touches a business rule that can affect financial figures is red. That criterion is specific to Lysia. On another application, it would make no sense, and other criteria would replace it.

My takeaway: start from technical criteria read from the code, then add the business criteria specific to your application. No generic grid knows them for you. And calibrate it over time: a grid that rates almost everything red prevents any autonomy.
Developers do not disappear, their role changes
I am often asked whether this model replaces developers. My view: no. It changes their role.
The developer builds the pipeline. They modernize the application, set the standard before the agents take over, put the tests in place, define the requirements with the PO. Without that work, none of what I describe is possible.
Then they are accountable for what goes to production. They review PRs, with an attention level that depends on the risk.
And one thing surprised me: validating a PR sometimes requires a face-to-face conversation. The change record is not always enough. Why? When the AI frames a change with me, it asks me to decide: this option or that one. I give my decision. But I rarely say what tipped me one way rather than the other. The AI codes the decision, without its reason. The developer sees the choice in the code. They cannot guess the why, since nobody spelled it out.

My takeaway: make room for that conversation in the flow, when the review calls for it. It is not a loss of efficiency, it is what makes the review real. And get into the habit of spelling out the why behind your choices, not just the choice.
Conclusion
Making a PO autonomous all the way to production does not start with AI. It starts with the flow: finding where work is waiting. Next, you need a readable application: consistent code, documentation, tests on every build. Then a written flow, with quality built in: acceptance testing before the PR and human review scaled to the risk. Finally, a risk assessment based on what the code touches, complemented by the application's business specifics, and calibrated over time.
In that order, the PO gains upstream and in responsiveness, at the cost of a heavier load on framing and acceptance testing. Developers do not lose their place: they build the pipeline and remain accountable for what goes to production. Skipping a step moves the bottleneck instead of removing it. And even when done right, the bottleneck moves: you need to know where it sits now.