title: "Team Rollout Playbook" description: "Phased rollout plan for introducing AI coding tools to an engineering team — training, metrics, and change management" section: "Adoption" readTime: "15 min"

Team Rollout Playbook

Rolling out AI coding tools to a team requires more than just installing software. Without structure, you get uneven adoption, security exposure, and frustration from engineers who don't know how to use AI effectively. This playbook gives you a phased approach.

Phase Overview

Phase 1: Pilot (Weeks 1–2)

Select Your Pilot Group

Choose 3–5 engineers who are:

• Curious and self-directed (not just the most senior)
• Working on a project with clear deliverables (so you can measure output)
• Willing to share what's working and what isn't

Tool Selection Decision

Before Phase 1 starts, decide which tool to pilot. Don't pilot all three simultaneously. Data-handling needs (not editor preference) should drive the shortlist: check each vendor's plan terms, retention, and deployment options (for Claude Code, direct via Team/Enterprise/Console, or through Bedrock, Vertex AI, or Foundry on your cloud account) with your security team.

Claude Code pilot baseline: officially, average cost is around $13 per developer per active day and $150–250 per developer per month, with 90% of users under $30 per active day. Use the pilot to establish your own baseline before sizing the full rollout, and check the analytics dashboard and spend report for real numbers.

Week 1 Goals

• All pilot members have accounts and have completed setup
• Each person has run at least 3 AI-assisted tasks
• Weekly 30-min sync scheduled to share findings

Pilot Success Criteria

At end of Week 2, assess:

• At least 2 pilot members use the tool daily unprompted
• At least 1 concrete time-saving example documented
• No security incidents or policy violations
• Common friction points identified

Phase 2: Foundation (Weeks 3–4)

Shared Configuration

Create a repository of shared config that all engineers will use:

For Claude Code teams:

# CLAUDE.md (commit to every repo)
## Team Conventions
- Use TypeScript strict mode
- All API endpoints require input validation with Zod
- Never log request bodies or user PII
- Commit convention: conventional commits (feat/fix/chore/docs)

Run /init in a repo to generate a starter CLAUDE.md, then trim it to what is true and useful. CLAUDE.md is guidance Claude usually follows, not enforcement; put hard rules in permission settings (see below). Keep it concise, since it is loaded every session.

For Copilot teams: commit .github/copilot-instructions.md to each repo (see the Copilot customization guide).

For Cursor teams: commit project rules under .cursor/rules/ (the legacy root .cursorrules file is deprecated).

Shared Claude Code settings: commit .claude/settings.json for team-wide permission rules, hooks, and shared skills and plugins. Personal overrides go in .claude/settings.local.json (git-ignored).

Security Baseline

Before expanding beyond the pilot, establish:

1. Data classification: What code can go to AI APIs (is your IP/PII concern addressed)?
2. Secrets policy: Confirm .gitignore covers all secrets; configure git-secrets or similar
3. Prompt injection awareness: Brief on what prompt injection looks like in code comments
4. API key management: All keys through secrets manager, never in code
5. Enforce, don't just document (Claude Code): deploy managed settings (managed-settings.json, MDM, or server-managed settings in the claude.ai admin console) with deny rules for secret files, and consider disableBypassPermissionsMode. See Policy Templates for a working example.

See Security Hardening for the full checklist.

Training Plan

Workshop agenda template:

0:00 — Why AI coding tools (concrete examples from pilot)
0:20 — Demo: live feature build with AI assistance
0:50 — Hands-on: each person tries on their own code
1:20 — Common mistakes and how to avoid them
1:40 — Team Q&A and setup support

Phase 3: Full Rollout (Weeks 5–8)

Rollout Checklist

Support Structures

AI Champion Network: Designate 1 champion per team/squad. Their job: answer questions, share tips, escalate issues. Rotate quarterly to spread knowledge.

Weekly Tips Digest:

• Each week, two team members share their best AI prompt/workflow
• Keeps adoption high and surfaces tricks others haven't discovered
• Takes 10 minutes to prepare, high value

Failure Post-Mortems:

• When AI produces wrong/harmful output, document it
• Share the failure mode and how to avoid it
• Builds institutional knowledge faster than success stories

Phase 4: Optimize (Ongoing)

Measure What Matters

Track these weekly (see Measuring ROI for detail):

• PR cycle time: Time from PR open to merge (should decrease)
• Suggestion acceptance rate and active users: Claude analytics dashboard or Copilot usage metrics; watch the trend, not a fixed target
• Test coverage trend: AI should help increase coverage
• AI-generated churn rate: % of AI lines modified within 7 days (signal of quality)

Quarterly Reviews

Every quarter:

1. Survey engineers: satisfaction, friction, perceived time savings
2. Review security incidents (hopefully zero)
3. Update shared config based on what the team has learned
4. Re-evaluate model choices and defaults as new models are released (for Claude Code, Sonnet is usually the cost-effective default; reserve the largest models for hard tasks)

Change Management Tips

"Augmentation, not replacement" framing: Engineers who fear job displacement adopt poorly. Frame AI as handling the boring parts so they can focus on the interesting problems.

Address the "cheating" concern: Some engineers feel AI assistance is "cheating." Normalize it by comparing to using Stack Overflow, documentation, or autocomplete — all normal tools.

Senior engineer buy-in first: Junior engineers will follow. If senior engineers are skeptical and vocal about it, adoption stalls. Get them use-case wins early.

Don't mandate AI for every task: AI works well for some tasks and poorly for others. Engineers who feel forced to use it for everything will resent it. Let them use judgment.