Level 1–2: Assisted and Paired Coding
Level 1 and Level 2 on the autonomy ladder are assisted and paired coding: the agent writes snippets, tests and boilerplate inside one session while the developer reads every line before it lands. Dan Shapiro places about 90% of AI-native developers here, and the way up is a repeatable setup per tool: a context file, plan mode, and one verified quick-start workflow.
The agent is on, the diff is small, and the work still feels like yours. That is the exact texture of Level 2, and it is also why so few developers leave: nothing is broken, so nothing forces a change. The plateau is comfortable, well-tooled, and one setup away from the next rung.
What Levels 1 and 2 look like in a working day
Section titled “What Levels 1 and 2 look like in a working day”Shapiro’s names for the two rungs are the coding intern and the junior developer, and the distinction is who holds the important work. At Level 1, in his words, “You’re writing the important stuff, but you offload specific, discrete tasks to your AI intern.” A regex, a test fixture, a migration script, a component you have written twenty times. You still own the shape of the change.
Level 2 hands over the writing and keeps the reading. The agent works through a task while you watch it, and you catch the wrong turn in the moment rather than in review. Shapiro’s warning about this rung is the sentence worth pinning above the desk: “level 2, and every level after it, feels like you are done. But you are not done.” He puts it at “where 90% of ‘AI-native’ developers are living right now”.
Below both sits Level 0, which is not a level anyone chooses any more: “not a character hits the disk without your approval.”
The reading is what makes Level 2 safe, and the reading is already thinner than most teams assume. Sonar’s survey of over 1,100 professional developers, published 8 January 2026, found that “96% of developers do not fully trust AI-generated code, and only 48% always verify it before committing.” Half the population is running Level 2’s control while skipping Level 2’s check.
You are at Level 2 if all five of these are true
Section titled “You are at Level 2 if all five of these are true”- The agent gets whole tasks, not completions. You describe an outcome — add pagination to the orders endpoint — rather than accepting the tail of a line you were already typing.
- You are present for the whole run. The session is a conversation you watch, and you stop it when it drifts rather than discovering the drift afterwards.
- You read every line before it lands. The diff, not the summary. You would notice a renamed variable.
- The agent’s memory of the project is you. Conventions, commands and the paths it must not touch get typed again each session.
- Nothing runs while you are away. No scheduled run, no second agent in a second checkout, no job that opens a pull request on its own.
Five yeses is Level 2. Items four and five are the ones that keep you there, and both have a fix that takes an afternoon.
The setup each tool needs before it can climb
Section titled “The setup each tool needs before it can climb”Every tool has the same three-part starting kit, and the differences are in the file names and the flags. Read your tool’s quick start once, then the lessons and the tips for the parts that surprised you.
The one move that takes a repository to Level 3
Section titled “The one move that takes a repository to Level 3”Three things, in this order, and none of them is a new tool.
A context file the agent loads every session. Claude Code reads CLAUDE.md and accumulates learnings in auto memory; Codex “reads AGENTS.md files before doing any work”; Cursor’s rules “provide system-level instructions to Agent”. One file per tool, generated from the repository rather than from memory, covering the commands that must pass, the layout, and the paths that are off limits. This is the single change that stops you being the agent’s memory.
Plan mode as the default gate. Cursor’s Plan Mode “creates detailed implementation plans before writing any code”; Claude Code’s plan mode is one of its permission modes, switched with Shift+Tab; Codex exposes /plan among its developer commands. Reading a plan takes a minute and reading a wrong diff takes twenty.
One quick-start workflow you have verified end to end. Pick a real task class you repeat — a CRUD endpoint, a migration, a bug with a reproduction — and run it through the tool once with the context file and plan mode in place. That verified path is what you later hand to an agent you are not watching.
Why the climb out of Level 2 stalls
Section titled “Why the climb out of Level 2 stalls”The context file is aspirational. Written from memory, it lists conventions the repository does not follow. The agent obeys it, CI rejects the result, and the file gets blamed. Generate it from the repo and verify every command in it exits 0 before you commit it.
Reading quietly becomes skimming. Sonar’s 48% is the failure mode with a number on it. Dropping the line-by-line read is only a climb if something else takes over the checking; on its own it is Level 2 with the oracle removed.
One agent, one terminal. As long as the session is a conversation you attend, your calendar is the throughput limit. Level 3 begins the first time an agent’s work reaches you as a diff you did not watch being written.
The tool moved. Flags, permission modes and command names change monthly across all three tools. Re-verify against the quick start and the vendor’s own page rather than against a blog post, especially before you automate something.