By now most enterprise engineering teams have AI coding tools in some state of adoption — GitHub Copilot licences bought, a few developers running Claude Code or Cursor, possibly an official pilot. The question I get asked has shifted from "should we use these?" to "why are our results so uneven?"
And they are uneven. I've seen teams where AI assistance visibly compressed delivery timelines, and teams at the same company, on the same licence, where the main output was a 40% increase in pull request volume and a review queue nobody could keep up with. The tool was identical. Everything around the tool wasn't.
What actually changes when the tools arrive
The naive model is "same process, faster typing." What actually happens is that the bottleneck moves. Writing code gets cheaper, so more code gets written. Review, integration, and understanding-what-we-built get relatively more expensive. If you don't adjust for that, the bottleneck doesn't just move — it backs up.
Three specific shifts worth planning for:
- Review load goes up. More PRs, and bigger ones if you let them grow. The senior engineers who do most of the reviewing become the constraint on everything.
- Plausible-but-wrong replaces obviously-wrong. AI-generated code compiles, passes the happy-path test, and reads cleanly. The bugs it contains are quieter than the bugs a rushed human writes — wrong assumptions, subtly missed edge cases, confident use of an API that doesn't quite work that way.
- Codebase conventions drift faster. The model writes code in the style of its training data unless you tell it otherwise. Without guardrails, every file slowly accretes a slightly different idea of how you do error handling, logging, and naming.
The practices that separate the good rollouts
Write down how your codebase works — the tools will actually read it
The highest-leverage hour of an AI tooling rollout is writing the conventions file — CLAUDE.md, copilot-instructions, cursor rules, whichever applies. How you structure modules, how you handle errors, what your test conventions are, which patterns are deprecated, which internal libraries to use instead of reaching for npm.
Teams skip this because their conventions live in senior engineers' heads and code review comments. That worked when humans were the only ones writing code, because humans learn from review. The model doesn't attend your retros — the conventions file is how it learns. Teams with a good one get code that looks like their codebase. Teams without one get code that looks like Stack Overflow.
Hold the line on PR size
AI tools make it effortless to generate large changes, and large changes are where review quality goes to die. The teams doing this well kept their PR size discipline — some tightened it — precisely because generation got cheap. A reviewer can hold the line on a 200-line change. Nobody meaningfully reviews 2,000 lines, AI-written or not.
Strengthen CI, because review alone won't catch it
If plausible-but-wrong is the new failure mode, the safety net has to be mechanical. Teams that invested in their test suites, linting, and type coverage before scaling up AI usage got compounding returns: the tools themselves write better code when the feedback loop is tight, because they can run the tests and fix what fails. A weak test suite plus high-volume code generation is the specific combination that produces the horror stories.
Measure cycle time, not acceptance rate
Vendor dashboards love suggestion-acceptance rates and lines generated. Neither tells you whether you're better off. The numbers that matter are the ones that always mattered: cycle time from first commit to production, change failure rate, time spent in review. If those are improving, the rollout is working. If PR volume is up and cycle time isn't down, you've automated the production of work-in-progress.
Don't let juniors skip the apprenticeship
The genuinely unsolved problem. Junior developers with AI assistance produce senior-looking output, which means the traditional signal of "this person needs guidance" — rough code — has disappeared, while the underlying need hasn't. The teams handling this deliberately do things like AI-free code reading sessions, requiring juniors to explain every line of their PRs, and pairing on debugging specifically (because debugging is where you learn what code actually does). What nobody has is a way to make experience free. The tools amplify judgement; they don't supply it.
How I'd sequence a rollout today
- Weeks 1–2: Write the conventions files. Tighten CI where it's weak. Pick one team — preferably enthusiastic, not conscripted — as the first wave.
- Weeks 3–8: First wave works with the tools daily. Capture what works in shared prompts and updated conventions. Watch review load explicitly and adjust PR norms.
- Week 9 onward: Expand team by team, carrying the playbook with you. Each team inherits the conventions and the norms, not just the licence.
The licence-everyone-on-day-one approach feels decisive and produces the uneven results everyone then blames on the tool.
The honest summary
These tools are the real thing — I use them daily and wouldn't go back. But they're an amplifier, and amplifiers are indifferent to what they amplify. A team with strong conventions, solid tests, and disciplined review gets dramatically faster. A team without those gets the same chaos, delivered sooner. The work of the rollout is almost entirely the unglamorous part around the tool.
If your team's results have been uneven and you want help working out which part of the scaffolding is missing, get in touch.
More Articles
Your AI Pilot Worked. Here's Why It Still Won't Ship.
Most enterprise AI pilots succeed. Most never make it to production. The gap isn't technical — it's a handful of unglamorous decisions nobody made at the start. Here's what actually gets pilots over the line.
Prompt Injection Is Not a Theoretical Problem Anymore
The moment your AI agent reads content it didn't write — emails, tickets, web pages, documents — it can be given instructions by whoever wrote that content. Here's how to design agents that survive contact with hostile input.