The gap this programme closes
Most engineering teams are somewhere between “we use AI tools” and “we know what AI changes about how we ship”. One engineer uses a coding agent for whole features. Another uses chat for boilerplate and pastes the results in. A third has stopped using anything after a bad experience. Pull requests have got bigger. Reviewers cannot tell which code was generated or how it was checked. Leadership has licence numbers and anecdotes, and no way to say whether delivery improved.
This programme replaces that with one workflow the team agrees on, piloted on real work and measured against a baseline. It is not a training day and it does not depend on one product.
What changes
The programme works on four levers, in this order:
Coding workflows. Which task types the team uses AI for and which it does not. How work is broken down so generated changes stay reviewable. How prompts, project instructions and context files are kept in the repository and reviewed like code. How AI-assisted pull requests are labelled.
Mechanical guardrails. Quality should not depend on a reviewer noticing a subtle bug in a 900-line generated diff. The pilot puts checks where they cannot be skipped: tests on changed code, types, linters, required CI checks and pull-request size limits. This is the method I have published as Vibes Inside Guardrails: let people move fast inside constraints that machines enforce.
Engineering culture. A clear rule that the person who opens a pull request owns it, whoever or whatever wrote it. Agreed boundaries for what agents may do without approval. Review that focuses on design and risk, because the guardrails catch the mechanical errors.
Measurement. A small set of measures taken the same way before and during the pilot, so the result is evidence rather than enthusiasm.
How the programme runs
Baseline. I read recent pull requests, talk to engineers and pull data from your repositories and tracker: cycle time from first commit to production, pull-request size, time to first review, review rounds, change-failure rate and escaped defects. This is the comparison point.
One-team pilot. With one team, we design the workflow and the guardrails, then use them on the team’s normal backlog for at least two full sprint cycles. I pair with engineers, review alongside them and adjust the rules every week from what goes wrong.
Measure and decide. We take the same measures again and compare. The report says what improved, what did not and why. You decide to roll out, revise or stop.
Playbook and rollout. The pilot team writes the playbook with me. Rolling out to further teams is planned as a separate step led by your internal owner, using that playbook.
The signature deliverable
You end with an engineering enablement pilot and rollout: the baseline, the measured pilot result, the playbook and a rollout plan. Illustrative example of the measurement summary:
| Measure | Baseline | Pilot | Note |
|---|---|---|---|
| Median cycle time (first commit to production) | measured | measured | Same repository, same task mix |
| Median pull-request size (lines changed) | measured | measured | Size limit introduced in pilot |
| Review rounds per pull request | measured | measured | |
| Escaped defects per sprint | measured | measured | Tracked for both periods |
| Share of pull requests labelled AI-assisted | n/a | measured | Adoption, not success |
Illustrative example. The table shows the format; values come from your own data.
Ownership and handover
The playbook, the CI checks and the measurement queries belong to your internal owner from the start. The pilot team presents the result to the next team, not me. When I step back, your owner can run the measures, change the guardrails and onboard a new team.
Choosing a narrower route
If you have already chosen a platform, the Claude Code and GitHub Copilot pages go into that product’s settings and controls. If agents are opening pull requests on their own, start with coding-agent rollout and team practices. If review load is the main pain, see AI-assisted code review and release controls. If your engineers need to learn to build and run LLM features, see build internal AI engineering capability.