How AI Adoption Progresses Inside Organizations
Each phase adds capabilities that let teams do more with AI until the next bottleneck appears.
In a recent X post, Claude Code creator Boris Cherny describes a pattern he keeps seeing: one engineer gets dramatically faster with Claude, while the rest of the organization may not move at the same pace.
His framework maps how that wider adoption tends to unfold. A new tool or practice lets a person or team run more AI work, often in parallel. That works until another constraint becomes binding. The bottleneck moves from access, to the engineer’s attention, to review, to trust, and finally to deciding what should be automated at scale.
These are not company-wide levels. Different people, teams, and workflows can move through them at different speeds. Boris’s evidence and examples are Claude-specific. I use the progression as a vendor-neutral heuristic that can also help teams reason about other coding agents. The agent counts in the image are scale cues, not targets.
With that in mind, let’s look briefly at what each phase means and what moves the work forward.
Gated: open an approved path
The first phase is about whether people can use AI on real company work at all.
Some organizations do not approve the latest models for company code. Others route access through an internal service that adds authentication, policy checks, and latency. A developer may be allowed to experiment locally but have no approved way to deploy what the agent produces. The work waits for security, data, procurement, and IT approval.
At this point, the AI adoption stack contains only a few things:
Claude.ai chat as the approved entry point.
SSO, SCIM, and role-based access so use is tied to company identities.
Organization budget caps, data-governance rules, and existing IAM and deployment controls around the work.
When the organization has an approved workflow that can use Claude and ship its output without requesting a policy exception each time, the gated phase has been passed. The next bottleneck is the engineer’s attention.
Assisted: one engineer and one agent
With access open, adoption moves into the developer’s daily workflow. One engineer works with one agent but still reviews nearly every response and code edit. AI makes the task faster, yet the work remains synchronous: while Claude works, the engineer watches.
The practical stack now expands from access to one bounded, self-checking task loop:
Claude Code in Desktop, CLI, or IDE, with Plan mode to review the approach before edits begin.
Tests, build, lint, type checks, and end-to-end tests in a real development environment so the agent can check its own work.
Auto mode to remove routine permission interruptions inside an approved policy.
For the organization, Claude Code Analytics, OpenTelemetry export, spend caps, and centrally managed settings keep this new path visible and bounded.
When the agent can close one bounded task and the engineer can begin another, attention stops being the immediate constraint. The work becomes parallel.
Parallel: one engineer and several agents
One engineer can now coordinate several agents. Each works in an isolated checkout, runs its checks, and returns a final diff. Output grows quickly. The review capacity of one person does not, so the bottleneck moves to review.
The new tools are built for concurrency:
Agent view keeps multiple sessions visible, while worktrees keep their edits from colliding.
Claude Code Review and Claude Security investigate code and security findings before human approval.
Claude Code on Mobile, cloud execution in Desktop, and Remote control let the engineer monitor work away from the terminal.
These sessions inherit the previous phase’s verification loop. The new guardrails are for concurrency: pre-approve common safe Bash and MCP commands in settings.json, isolate each task, and retain human merge and security approval. The Chrome extension or an iOS or Android simulator MCP can extend verification to end-to-end behavior.
The point is not to remove review. It is to stop reviewers spending attention on failures the agent could have found itself. This phase works when parallel sessions return evidence, not another pile of unchecked output.
Supervised autonomy: manage loops, not sessions
Once repeated parallel tasks become reliable, teams can turn them into loops. A person no longer needs to start and steer every session. Claude can gather context, delegate work, and begin scheduled or event-driven tasks.
Trust is now the bottleneck. A deep agent tree cannot be watched step by step, and scaling it before the loop has earned trust only multiplies failures, decisions, and token use.
This phase adds:
Subagents to delegate work into separate workers.
Routines,
/loop,/batch,/goal, and Dynamic workflows for scheduled, repetitive, or multi-agent work.Claude Tag to watch a channel, use the shared context, and start work proactively.
CLAUDE.mdand Skills to encode standards, plus agent sandboxing to limit filesystem and network access.
At this scale, operating cost becomes part of trust: a loop that is correct but wasteful will not scale. Boris calls out advisors, language servers, model selection, and moving large CLAUDE.md instructions into lazily loaded Skills to reduce token use.
The phase has been passed when a background loop can gather its context, check its result, and stop or return to a person predictably. The question then changes from “Can this run?” to “Which work should we automate at scale?”
AI-native: steer by intent
In the final phase, trusted loops become domain-specific automations: code migrations, fuzzing, feature building, or feedback remediation. Many agents may run, some started by other agents. People set the intent and monitor exceptions instead of assigning and inspecting every task.
The bottleneck is identifying valuable work to automate and choosing the right guardrails for each kind of work.
The product list is short:
Claude Agent SDK to build and schedule agents programmatically.
Cost controls and model selection for each automation.
One global autonomy policy will not fit every workflow. Each needs its own scope, checks, and cost ceiling. Human judgment becomes the bottleneck: deciding which work should run, what evidence is sufficient, and where a person must remain in the loop.
The takeaway
These phases describe a progression, but they are not a single company-wide maturity score or a mandatory linear path. They map what enables more AI work to happen in parallel and where each workflow waits next.
As technical constraints fall away, the bottleneck often moves into human attention, review, trust, or judgment. Find where the workflow waits. Add the smallest tool and guardrail that can remove that constraint. Then watch where the queue moves.
More tokens do not move a team through these phases. Better operating loops do.
Based on Boris Cherny’s X post and Steps of AI Adoption.