What do you do Monday morning?
A concrete 30/60/90 day plan, by org size. Pick the path that matches your context. Each path ends at a specific, measurable milestone.
You've read the coordination problem. You've done the assessment. You know roughly where your org stands. Now what?
The 90-day plan exists because most AI engineering transformations stall at the planning stage. The space between "we understand the problem" and "we have working infrastructure" is where organizations lose months. This plan gives you the specific actions, in the right sequence, for your org size and context.
Three paths. Pick the one that matches your situation. Each path ends at a concrete milestone that you can verify. Not "we have a strategy," but "we have a working, governed workflow that runs reliably."
Three paths
Which context fits you?
5–30 engineers
Startup or growth-stage. Engineers work closely together. Few formal processes. AI tools have been adopted but coordination is still informal.
30–200 engineers
Scaling phase. Multiple teams. Some AI workflows exist. Inconsistent governance across teams. Review queues are probably backing up.
200+ engineers
Multi-team or regulated. AI tools are widespread. Governance exists on paper. The actual enforcement varies wildly by team.
Path A · 5–30 engineers
Small team: from AI tools to coordinated workflows
At this size, the main risk is fragmentation. Engineers have adopted AI tools individually and are working from different mental models of what's acceptable. The first 90 days are about creating shared context and basic verification before scaling up.
Document architecture and conventions
Create one CLAUDE.md or AI context file for the whole team. Include your architectural decisions, coding conventions, and the three most common mistakes agents make in your codebase. This is your first shared context layer.
Implement stop conditions
Add test gates, lint gates, and type-check gates that run on every PR. If these don't pass, the PR can't be submitted for review. Agents can't route to humans until they clear the gates. This is your first eval harness.
Build your first loop
Pick one repetitive task: daily triage, test coverage for new features, or changelog generation. Automate it with a simple loop (trigger, agent run, verification gates, human sign-off only if gates fail). Run it for 30 days, measure the error rate.
Add cross-engineer coordination
Create a shared context file that all engineers update after significant architectural decisions. Add a policy: anything touching your core data layer or authentication goes to the most senior engineer, regardless of who wrote it. Write it down. Put it in CI.
90-day milestone
Agents work from shared context. Changes verify themselves before reaching humans.
Path B · 30–200 engineers
Growing team: from informal AI usage to systematic governance
At this size, you probably have teams doing AI well and teams doing it poorly, and no systematic way to tell the difference. The first 90 days are about making governance explicit and implementing it in infrastructure, not relying on individual engineer judgment.
Audit your verification infrastructure
Measure your test suite latency. Can an agent run it in under 60 seconds and self-verify? Measure your AI-generated PR acceptance rate by team. Find the team with the highest acceptance rate and the team with the lowest. Interview both about what's different.
Define decision tiers
Write down three categories: autonomous (agent can act without review), supervised (agent acts, human reviews before merge), and escalated (human decides before agent acts). Assign every change type in your system to one of these categories. This is your governance policy. It doesn't need to be perfect. It needs to exist.
Implement governance as data
Codify your decision tiers in a config file that CI reads. Route PRs automatically: low-risk to auto-merge queue, high-risk to named reviewers, critical to approval queue. Measure override frequency. Every time someone overrides the routing, log why. That log becomes your policy improvement queue.
Build or deploy orchestration for one workflow
Pick your highest-volume agent workflow (likely feature development or bug triage). Define it as an explicit workflow: trigger, agent steps, verification gates, escalation rules, human touchpoints. Run it with full observability for 30 days. This is your pilot for broader rollout.
90-day milestone
Governance is systematic, not per-engineer. One governed workflow runs reliably.
Path C · 200+ engineers
Enterprise: from paper governance to working infrastructure
At enterprise scale, the governance mirage is the most dangerous failure mode. You have a policy. You have a platform team. You have executive sponsorship. And yet, on the ground, different teams are doing whatever works for them. The first 90 days are about finding the gap between stated policy and actual infrastructure, and closing it with evidence, not with better documentation.
Map the governance mirage
Who actually owns AI governance in your org today? Ask three different engineering leaders. If you get three different answers, that's your finding. Document the gap between your written policy and what's actually happening in CI. This is the data you need before making any investments.
Define the human authority boundary
At which stage gates do humans retain decision authority, regardless of how much AI is involved? Write these down explicitly: merge authority, architecture decisions, production access, compliance sign-offs. This isn't about limiting AI. It's about being clear about the governance model so you can build infrastructure around it.
Spec and pilot the control plane
Design the minimum viable control plane for one business unit: shared context layer, policy enforcement layer, audit trail. You don't need to build everything. Identify whether you're building, buying, or assembling open-source. Run one governed workflow end-to-end with this infrastructure for 30 days.
Instrument observability across one agent fleet
For one team's agent workflows, build full tracing: from task assignment through agent execution, PR creation, review, merge, and deployment. Measure the AI-attributed change failure rate for this fleet. This is your baseline for the rest of the org rollout.
90-day milestone
AI-driven changes flow through governed, observable, auditable infrastructure.
Principles across all paths
What the successful transformations have in common
Sequence
Context before governance, governance before automation
You can't govern what you can't see. You can't automate what you haven't governed. The sequence matters: shared context first, then policy, then automation. Skipping steps produces systems that look coordinated but aren't.
Measurement
Measure from day one, not day 90
The most common failure: starting the plan without a baseline. Measure AI PR acceptance rate, review queue depth, and deployment frequency before you start. You need the before number to tell whether the 90 days worked.
Scope
One workflow, done well
Every successful transformation we've seen started with one high-volume workflow, got it right, and then replicated. Every failed transformation tried to change everything at once. Pick your highest-volume workflow. Get it to work. Then expand.
Ownership
Someone owns the result
"The platform team is responsible" is not the same as "Priya owns the AI governance layer and reports on its health every sprint." Name a person. Define what they're responsible for delivering. This is the most boring advice in this playbook and also the most frequently ignored.
Week 1 specifics
What Monday looks like
The most common reason 90-day plans don't start: the first step is too abstract. Here's a concrete first week, regardless of which path you're on.
Run the Module 01 assessment with your platform lead. Compare scores. Note the gaps.
Output: Two assessments, one gap analysis
Pull your actual PR data: AI vs. human acceptance rates, review queue depth, time-to-merge by source. This is your baseline.
Output: Baseline metrics doc
Map who actually owns AI governance today. Not who should, who does, in practice. Interview three teams.
Output: Governance ownership map (it will surprise you)
Identify your highest-volume AI-assisted workflow. What task do engineers use agents for most? How many PRs per week does it produce?
Output: Target workflow identified
Write one paragraph: what does success look like in 90 days? What specific, measurable thing will be true that isn't true today?
Output: 90-day success definition (share with the team)
CO-BUILD PROGRAM
From playbook to production
We work directly with engineering leaders who are making this transition now. You bring the real constraints; we help you build the coordination layer around them.