Rolling Out Coding Agents to Your Team: A 90-Day Plan for Engineering Managers
2026-11-16 · 9 min read · Team Health
The licences are bought. There's an all-hands slide that says "AI-first". And three weeks later, half your team has tried the agent once, two people use it constantly, and nobody can say whether anything got better.
That's the normal outcome of a rollout that's really just a purchase. Coding agents change how work flows — who writes code, how big PRs get, what review has to catch — and that change needs managing like any other.
Here's a practical 90-day plan an Engineering Manager can run with one team. It's deliberately boring: get a baseline, run a small pilot, spread what works, then review honestly.
Before Day 1: Decide What "Success" Means
Write down, in a few sentences, what you want after 90 days. Good versions are about the work, not the tool:
- "Agents handle most of our dependency upgrades, migrations and test backfills."
- "PR cycle time drops without change failure rate rising."
- "Every engineer has tried agents on real work and has an informed view."
Avoid "100% adoption" or "everyone uses AI daily". Those targets produce performative usage, not better work.
Days 1–15: Baseline
You can't tell whether anything changed without a starting point. Capture four things.
1. Current agent use, from the work itself. How much of your team's commits and PRs already carry an agent's signature? (If you haven't looked before, see how to tell which agents your team uses.) Many teams find a few early adopters already well ahead.
2. Delivery metrics. PR cycle time, deployment frequency and change failure rate for the last six to eight weeks. See DORA metrics for EMs if you don't track these yet.
3. Review health. Median PR size and time to first review.
4. How people feel. A short, anonymous survey: what they've tried, what helped, what worries them. This is about sentiment, not usage — self-reported usage is unreliable, which is why the first item comes from Git.
Also in this phase: sort out the basics. Which tools are approved? What code and data can they see? Are there repos (security-sensitive, regulated) where agents shouldn't be used? Settle this with your security team now, not after someone's already pointed an agent at the payments service.
Days 16–45: Pilot
Pick the work, then the people. Agents are strongest on well-specified, verifiable tasks: dependency upgrades, framework migrations, test coverage, small bug fixes with a clear reproduction, internal tools. Pick a handful of these for the pilot.
Pick a small, mixed group. Two or three engineers: at least one enthusiast and at least one sceptic. The sceptic's experience is the more valuable data.
Agree a few working rules with the pilot group, for example:
- The engineer who opens the PR owns it fully — they must be able to explain every change.
- Keep agent PRs reviewably small; split large ones.
- Leave the agent's commit signature on, so the team can see where agents are used. (It's a credit line, not a confession — see Co-Authored-By trailers explained.)
- Note what worked and what didn't, in a shared doc.
Check in weekly, briefly. What saved time? What wasted time? Where did review catch something? Fifteen minutes is enough.
Days 46–75: Spread What Works
By now the pilot group has found a few workflows that genuinely help. Spread those, not the tool in general.
Demos beat documents. A 20-minute session where a pilot engineer runs a real task end to end — prompt, review, fix, PR — does more than any wiki page. Record it.
Write down the playbook. One page: the tasks agents are good for on your codebase, the setup that works, the review rules, the places not to use them.
Invite, don't mandate. Offer pairing sessions with pilot engineers. Suggest a starter task to each person. Then let people choose. Some work genuinely benefits less, and some engineers will be more effective without agents for now.
Use 1:1s. This is the moment for individual conversations about how it's going — framed as curiosity, never as a quota. See how to talk about AI usage in 1:1s.
Watch review closely. This is when agent-written code volume rises fastest. Look for growing PR sizes, faster-than-plausible approvals, and reviewers who feel they're rubber-stamping. Code review in the AI era covers what to adjust.
Days 76–90: Review Honestly
Compare against your baseline — the same four things.
| Question | Where to look |
|---|---|
| Did agent use grow, and is it steady or spiky? | Share of AI-assisted commits and PRs, weekly trend |
| Did work move faster? | PR cycle time, deployment frequency |
| Did quality hold? | Change failure rate, incidents, review depth |
| How do people feel now? | A repeat of the short survey |
Then decide what's next, based on what you found:
- Adoption up, speed up, quality held → keep going, widen the playbook to more task types.
- Adoption up, quality slipping → tighten review rules and PR size limits before pushing further.
- Adoption flat → find out why. Often it's tooling friction, unclear permissions, or the work simply not suiting agents.
Share the result with the team, including what didn't work. Honesty here buys you credibility for the next change.
Reporting to Leadership
Keep it to three lines (more in AI adoption metrics for engineering leaders):
- Trend: "Agent-assisted work went from 9% to 27% of our commits and PRs over the quarter."
- Caveat: "That counts work an agent signed. Autocomplete isn't counted, so real usage is higher."
- So what: "Cycle time is down and change failure rate held. Next quarter we're extending agents to test backfills and on-call tooling."
Common Mistakes
- Mandating usage. Targets create the appearance of adoption and hide real problems.
- Ranking engineers by AI use. It turns a team practice into a competition and corrupts the signal.
- Skipping the baseline. Without it, "did this help?" is a matter of opinion.
- Ignoring review. Agent output shifts the bottleneck to reviewers. If you don't adjust review, quality pays.
- Rolling out everywhere at once. A small pilot finds the sharp edges cheaply.
How Emtricks Helps
Emtricks gives you the baseline and the review automatically: the share of agent-assisted commits and PRs across every repo your team works in, a fair adoption score for the team and each engineer, and the weekly trend — next to PR cycle time and delivery metrics in Pulse. Each engineer's view sits on their 1:1 page for the individual conversations, and the Team Report packages the trend with its caveat for leadership. If your company runs its own agent, add it in Integrations and it's counted too.
Key Takeaways
- Define success in terms of the work, not tool usage.
- Baseline first: agent use from Git, delivery metrics, review health and sentiment.
- Pilot small with a mixed group on agent-friendly tasks, with clear ownership and review rules.
- Spread proven workflows through demos and pairing — invite, don't mandate.
- Review against the baseline after 90 days and decide based on quality as well as speed.
Get your baseline in minutes and watch the rollout week by week — from your Git history. Try Emtricks free for 30 days.