Adam Hagestedt. ← back to the résumé
Field guide · enterprise AI adoption

The 3-phase adoption playbook

Most enterprise AI rollouts stall at proof-of-concept: the licenses get bought, a pilot gets announced, and nothing changes about how work is done. This is the playbook I used to take one agentic coding tool from 0 to 500+ active users in a 3,000+ person organization — written product-agnostic, because the playbook is the durable asset, not the tool.

0 → 500+active users
~17%of a 3,000+ person org
~50%of engineering
Any platformports to any agent tool
Prove the model on your own team first, then make adoption frictionless. Evangelism without proof doesn't scale.
Phase 1

Prove

Weeks 0–4 · one team, real work, visible wins

The goal of Phase 1 is not adoption — it's an existence proof inside your own walls that leadership can't argue with and neighboring teams will envy.

  • Pick one team with real deliverables, not an innovation lab. The proof must happen on work someone is already accountable for, or it proves nothing.
  • Pair an executive sponsor with a working operator. The sponsor clears blockers; the operator uses the tool daily and ships with it. If the senior owner doesn't personally use it, the org notices.
  • Instrument before/after on a small number of workflows — cycle time, review turnaround, output shipped. Two or three honest numbers beat a wall of vanity metrics.
  • Ship something visible in the first two weeks. A real artifact the rest of the org can see and touch converts more people than any deck.
  • Start the security review now, not at rollout. The security gate is the single most common place enterprise AI adoption dies — clearing it is Phase 1 work even though its payoff is Phase 2.
Gate to Phase 2: a team lead who would fight to keep the tool, and one before/after number you'd defend in front of the CFO.
Phase 2

Expand

Months 1–3 · follow the pull, remove the friction

Expansion works when teams ask to join. Push-based rollouts create compliance theater; pull-based rollouts create users.

  • Expand along the pull. Publicize the Phase 1 wins internally, then onboard the teams that raise their hands first — they become the next proof points.
  • Name a champion per function. Adoption spreads peer-to-peer inside a discipline; a champion who ships with the tool beats a central enablement team broadcasting at everyone.
  • Make onboarding frictionless: licenses pre-provisioned, access pre-approved, a 30-minute setup path, office hours, and working examples from their own function — not generic demos.
  • Build function-specific playbooks. "How engineering uses it" and "how operations uses it" are different documents. Write them from real usage, not speculation.
  • Clear the security and compliance review completely — data handling, retention, acceptable use. One published, approved policy unlocks every conservative team at once.
  • Let the laggards lag. Chasing the resistant 20% in Phase 2 burns the energy you need for the willing 80%.
Gate to Phase 3: multiple functions using the tool on real work without your involvement, and demand arriving faster than you're recruiting it.
Phase 3

Operationalize

Month 3 onward · make it survivable without the evangelist

A rollout that depends on its champion is a pilot that hasn't admitted it yet. Phase 3 turns adoption into infrastructure.

  • Build usage observability. You cannot govern, defend, or expand what you can't see. Instrument who uses the tool, how often, and on what — I built this layer myself (scraper → SQLite → FastAPI → React/D3) rather than wait for a BI project.
  • Report ROI in operator terms: hours returned, cycle-time deltas, output per team — laddered to the business metrics leadership already tracks. Adoption percentage is an input, not the result.
  • Set the policy and guardrails in writing: what's encouraged, what's reviewed, what's off-limits. Ambiguity re-freezes the conservative middle of the org.
  • Govern cost per outcome, not cost alone. Spend that returns hours is a bargain; unexamined spend is how programs get cut in the next budget cycle.
  • Institutionalize the enablement: training curriculum, onboarding for new hires, champions with named backfills — so the capability survives any single person leaving.
Done looks like: adoption still growing in a quarter where you personally did nothing to push it.

The failure modes this is built against

Pilot purgatory — a proof-of-concept with no accountable deliverable, quietly renewed forever. The security stall — review started at rollout instead of day one, freezing the program for a quarter. Evangelism without proof — roadshows before an internal team has a defensible win. Mandate-driven adoption — usage dashboards that measure logins while work happens elsewhere. Each phase above exists because I watched one of these kill a rollout.

The playbook is product-agnostic by design: the tool in my rollout happened to be Claude Code, but the same three phases port to any agent platform. Tools change quarterly; the adoption physics don't.