The 5-level map: where you stand on the Claude Code creator's ladder
The ladder from Boris Cherny, creator of Claude Code: 5 levels of agent adoption, a 60-second self-check to find your level, and the one move that takes you up a level.

What you get
A map of 5 agent adoption levels, a 60-second self-check, and the one move that takes you from each level to the next
Who it is for
For developers, founders and agent operators who work with Claude Code and want to know where they really stand, and what breaks the next ceiling.
1. Why this ladder is worth your time
Boris Cherny, the creator and lead of the Claude Code team at Anthropic, published a 5-level ladder for organizational agent adoption in July 2026. His original name for it: Steps of AI Adoption. I'm calling them "levels" here instead of "steps," just to make them easier to talk about.
- The core idea is simple and uncomfortable: one employee is already multiplying their output 10x with Claude, and most of the organization is not there yet.
- The gap is not token volume. The gap is which blockers you already broke through and which safety guardrails you already built.
- Cherny reports that Anthropic itself is at level 3 and moving toward 4, and that he personally has already reached level 4.
- Both of those statements are his own self-report, not an official company statement. The ladder itself is worth using either way.
2. Step 1: find your level (60 seconds)
Go through the sentences in order. Your level is the last sentence that is true for you.
- Level 0, blocked. The organization blocks or restricts access to the powerful tools. You have no Claude Code at work, or only a neutered chat through an internal portal. Roughly zero agents.
- Level 1, paired. You work with one agent, side by side. You type, read every change, approve every action. One agent.
- Level 2, parallel. You run several agents in parallel on defined, separate tasks, but every run still waits for you at the end. Roughly 10 agents.
- Level 3, supervised. Agents manage agents. Continuous background runs with automatic gates, and you step in only for decisions. Roughly 100 agents.
- Level 4, the whole organization. Leadership gives direction, and a fleet of 1,000+ agents runs entire work domains. Control and verification at scale, not manual approvals.
- To keep this honest: those numbers are Cherny's description of organizational behavior at each level, not an official Claude Code spec. Don't rush to open 100 terminals tomorrow morning.
3. From level 0 to level 1: a fenced pilot
The bottleneck: approval and security processes, and cost-per-token thinking. The move up is always to break the bottleneck, not to "use it more."
- Don't fight for permissions for the whole company. Ask for one fenced pilot.
- One non-sensitive repo, limited permissions, one real task with a measurable result.
- Safety guardrails are what calm an organization down, not slide decks.
- One real result is worth more than ten discussions.
4. From level 1 to level 2: let the agent check itself
The bottleneck: your attention. You read every change, so you are the limit.
- Stop checking keystrokes, start checking results.
- Give the agent a way to verify its own work end to end: tests, lint, type checks, an actual run of the code.
- Once the agent proves it clears the gate, you can split into two or three agents in parallel on separate tasks.
- Each agent gets its own isolated environment, and you move between them.
5. From level 2 to level 3: automatic gates instead of manual approval
The bottleneck: reviewing and directing a lot of parallel streams. You become the approval bottleneck.
- Move approvals from you to gates.
- Automatic permissions for safe actions.
- Automatic code review and security checks by default on every run.
- Background runs and scheduled tasks that run even when you are not at the screen.
- You step in only when a real decision is needed.
6. From level 3 to level 4: intent instead of tasks
The bottleneck: trust and decision pace, and token efficiency.
- By Cherny's account, this is the transition Anthropic itself is still working on.
- Define direction and goals instead of individual tasks.
- Build control and verification that work at scale.
- I'm not there yet, so here I'm relaying his points, not personal experience.
7. Cherny's list: what actually moves a team up a level
These are the tools and mechanisms Cherny himself lists in the post as what moves teams up the ladder.
- The agent's ability to verify its own work end to end.
- An automatic mode for permissions.
- Automatic code review and security checks by default.
- One view across all agents: terminal, desktop and mobile.
- Loop runs and batch runs across many tasks.
- Isolated work environments for subagents.
8. The source
Boris Cherny's original post (July 2026):
https://x.com/bcherny/status/2077929379661844559How to use this now
This is how I work myself with Claude Code: parallel agents during the day, supervised overnight runs with check gates. That's exactly what puts me between level 2 and level 3. Find your level, identify the one bottleneck holding you down, and make only its move.