Skip to main content
Home: Florian Bruniaux Engineering & AI Contact

Florian Bruniaux / Explore

Search the site

Search in English or French, or jump to a section.

↑ ↓ to navigateEnter to openEsc to close

EN
Colour theme

AI speeds up production. Who helps teams keep up?

When AI speeds up development, work can pile up in code review, CI or product decisions. A Méthode Aristote case from The CTO Playbook.

16 min read
Jump to summary ↓

At Méthode Aristote, we sometimes added features faster than we could explain them or check that they met a need. Users told us the result felt like a Netflix catalogue: plenty of choice, with no clear place to start. I tell that story on The CTO Playbook with Adam Horner.

I enjoy building. When an idea becomes easier to implement, I want to try it. That experience reminded me of my responsibility for what enters the product. Choosing the next feature is still a product decision.

My Chief AI Officer playbook starts there. It draws on my work at Méthode Aristote, client engagements, and experience in startups, scale-ups, small and medium-sized businesses, and large organisations. I work on how AI is used, the people doing the work, and the decisions that let them move forward.

TL;DR

When AI speeds up development, work can pile up in code review, CI or product.

  • Follow a real request. Find the pending decision, missing information or team that cannot yet take it over.
  • Name who reviews and who accepts. Review the revised version after a fix.
  • Make time to learn. Provide authorised tools and name who can help on a real task.
  • Measure before expanding. Compare use, quality, waiting and effort with the baseline.

Decisions and information are part of the work

Adam and I talked extensively about technical review. Product teams may also have more questions to answer, decisions to make, acceptance checks to perform, and changes to explain to users. We need to look at where work waits in our own workflow.

I want to follow a real request with the people involved. Who is waiting for an answer? What context is missing? Who can receive the next piece of work? Those questions help identify a specific cause: an unowned decision, scattered instructions, information lost in a handoff, or a team without capacity to take over.

At each handoff, I want to clarify:

  • The decision needed, who can make it, and which decisions the team can make within its agreed scope.
  • The decision record, its reasoning, and what changes for the people affected.
  • The handoff itself: the result, its current state, what has been checked, and the next action expected.

5 steps: a precise question; who decides, the team within its scope or the designated owner; a written decision with its reason, status, current version and condition for reopening; a handoff; a receiving team with time, access and context, or work that is reduced or deferred. Below: a named owner for the shared harness and an internal person named to take over.

Some debates come back every week because nobody can point to the decision. I keep each written decision small enough to settle one or two questions, with its reasoning, its status, where its current version lives, and the situation that would justify reopening it. Without that condition, every new participant can restart the discussion. A record that covers a whole design tends to collect every objection at once, so it stays open while the work moves on without it.

A rule can look clear to the people who wrote it and vague to the team applying it. Before adding a meeting, I ask that team to apply the rule to a real case, then fix the text, the owner, or the handoff. A written decision, a named owner, or a usable handoff often helps more than a new ritual.

Faster production also loads the receiving side: review, continuous integration, test environments, and product decisions. I check that load before speeding anything up, and I bring product and design into a trial from the start.

AI can prepare a summary or extract open questions. A person still needs to check the context and confirm the decision. Keep the current decision discoverable, and link to the live work where it is maintained. My team-knowledge guide separates durable documentation, live information, and reusable procedures. A copied summary needs a source and a freshness check.

In P&G’s product-innovation experiment, AI helped participants produce proposals that crossed the usual R&D/commercial split. It was a one-day workshop, which leaves sustained coordination open. I would test whether a team can prepare a decision with less missing context.

Clarification after the recording: this develops my answer to Adam about scaling, making initiatives visible, and communication. The points on decision records, receiving capacity, and the diagram come from my client work and were added after the recording. It is a proposed way of working, without a measured productivity gain attached. I develop the comparison method in Lean AI: work that reaches users.

Learning needs room in the job

I spend a lot of time trying tools because I enjoy it. I cannot expect everyone to make the same investment in their personal time.

If leadership wants practices to change, it needs to provide time, access to tools, and someone available to help. I discuss those conditions in Learning needs room in the job. Access means tools the organisation authorises, a known budget or quota, and permission to use them on real work. When only some people get access, say who, why, and when the others will follow. Otherwise the gap creates tension before anyone has learned anything.

Completing a course does not yet tell us what a person can do on their next real task, and a catalogue of agents does not change practices on its own. I look at what people reuse and improve in their work, not at the number of items published.

Augustin, at Aristote, knew the product and its business rules. Supporting his contribution meant adapting the environment, defining its scope, and working through difficulties together. His knowledge also improved the context shared with the rest of us.

The early contributions needed review and corrections. Some areas remained with experienced people. The detailed account of Augustin’s experience has a duration in its title. It describes one case, without promising the same learning time for another team.

An analysis of a staged AI rollout in customer support found larger gains for less experienced workers. It measures resolved issues per hour in one workplace. I would adapt support to different experience levels, then check what transfers to the next task.

Sharing needs an owner and protected time, or it is the first slot to be cancelled. The person who found an improvement presents it, someone collects topics from the teams, and a reuse by another team counts as much as a new idea. To keep the skills a team needs for verification, I leave part of the work done without assistance and ask people to explain in review what they accept.

Delegation keeps a person responsible

In the discussion of acceptance at 57:25, I explain that people who use Claude remain responsible for what they accept. They need to understand the result and be able to explain their decision.

We still need to name that person and their authority. Contributing, verifying, and accepting are responsibilities to make explicit, even when one person holds several roles. Using a tool does not automatically give someone permission to publish or make a commitment on a client’s behalf. Those roles should stay visible in the tools as well: an agent acting under a shared identity hides who decided.

I also want to clarify what I said about reviewers. Agreement between them draws attention to a possible issue. It does not, by itself, establish that either the finding or the proposed fix is right. Both need to be checked against the work concerned. My historical review export separates visible human responses from correct fixes: a bot resolving its own thread does not record a person’s acceptance.

The 6 steps of the playbook

I walk through the loop at 49:54 in the episode.

  1. Frame the need.
  2. Write the plan and challenge its assumptions.
  3. Build a change small enough to verify.
  4. Verify through tests and code review.
  5. Accept the result, then observe its use after delivery.
  6. Keep the lessons for the next change.

The 6-step delivery loop.

The change needs to be small enough for an identified person to examine. Planning may send us back to the need. A correction means checking the revised version again. The technical workflow is covered in From code to merge.

The harness evolves too: the shared context, procedures, tools, and controls around our AI work. The shared team harness is separate from my personal setup. Shared instructions need an owner, distribution, and checks in the environments concerned. At Aristote, a teammate was blocked by a three-reader review requirement when an external reviewer was unavailable. The contract was changed to require the tool’s own review, add external readers when available and eligible, and retain the full trio on explicit request.

The preparation material documents the change. Its rollout across workstations and its effect on review time remain open questions.

Shared rules work in layers: the organisation, the team, and the person. A team can add a stricter rule; removing or contradicting a shared one goes through its owner. A copied skill stops receiving fixes, so I prefer a versioned source that each repository references, with an owner, a few evaluated cases, and a review before updates reach every team. Something that arrives with the repository reaches more people than a step each person has to install, and a local hook is easy to bypass.

Outside support ends. From the start, I ask for the name of the internal person who will maintain the harness, and for a handoff that this person has reread before I leave.

A confirmed code defect may need a regression test; a false review alert may need better context for the reviewer. I keep those improvement loops separate. Each change needs an owner and evidence that it helps.

Observe what the change actually helps

I spent more time on acceptance than on observing user outcomes during the recording. I expand that part in the guide. I want to examine these observations together:

  • Use: can the intended person do the work we expected?
  • Quality: what defects, corrections, or rework remain?
  • Waiting: which decisions, missing information, or handoffs hold up the next step?
  • Total effort: what does implementation, verification, support, and maintenance require?

A faster run can still leave a longer queue. My evaluation guide separates feedback latency, run duration, human attention, and time to accepted work. Lower tool consumption is not enough to establish a business result. The cost of accepted work also includes attempts and rework.

Before changing anything, record the initial state with the observations you plan to use afterwards. Each trial needs a start, an end, a budget, an owner, a person who decides what happens next, and a log that keeps the failed attempts. Without an end date, a pilot keeps stretching and never produces a decision.

Usage traces need the same care. A marker left in the commit history is a lower bound: people who use AI without leaving it drop out of the count. Usage, accepted work, and provenance stay separate observations. A gain people report is a hypothesis to test, not a measurement.

Those observations should help us decide whether to expand the use, adjust it, limit it, or stop. If evidence is missing, we still need to collect it.

The Chief AI Officer playbook brings together the visuals, examples, and worksheets for working with a team. For a first trial, I would start with a decision that is waiting and a named person who will receive the work. That gives us a specific handoff to examine and improve.