Level 1–2: Assisted and Paired Coding

Level 1 Concept Updated 2026-09-26

Levels 1 and 2 of the autonomy ladder are assisted and paired coding: the agent takes discrete tasks or writes most of the change, and the developer reads every line before it is committed. Dan Shapiro estimates 90% of ‘AI-native’ developers sit at Level 2. Leaving Level 2 takes a context file, a plan gate and one verified task loop.

This page is for developers who use Claude Code, Codex or Cursor every day and still type the same conventions into every session. Tech leads can use the five-point test to see where each repository sits. The agent is on, the diff is small, and the work still feels like yours. Nothing is broken, so nothing forces a change, and that is why so few people leave this rung.

What you get from the Level 2 setup

A five-point test that tells you whether you are at Level 1, Level 2 or already past it.
A context file generated from your repository, with every command in it proven to exit 0.
Plan mode as the default gate: configured in Claude Code, a fixed habit before every edit in Codex and Cursor.
Two copy-paste prompts: one that writes the context file and one that runs a task to a checked stop condition.
The four ways the climb stalls, and how to recover from each.

What do Levels 1 and 2 look like in a working day?

Shapiro’s article “The Five Levels: from Spicy Autocomplete to the Dark Factory” (23 January 2026) names the two rungs the coding intern and the junior developer. The difference is who holds the important work.

At Level 1, in Shapiro’s 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 20 times. You still own the shape of the change. Level 1, like Level 0 below it, sits at the light end of AI-assisted coding, the umbrella name for any use of AI to help write software.

Level 2 hands over the writing and keeps the reading. The agent works through a task while you watch, and you catch the wrong turn during the run rather than in review. On this ladder, Level 2 matches AI pair programming, the phrase GitHub Copilot popularised in 2021. Shapiro puts this rung at “where 90% of ‘AI-native’ developers are living right now”, and he adds the warning worth remembering: “level 2, and every level after it, feels like you are done. But you are not done.”

Below both sits Level 0, which few developers choose any more: “not a character hits the disk without your approval.”

The reading is what makes Level 2 safe, and it 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.” About half of the respondents do not always run the one check that Level 2 depends on.

Are you at Level 2? The five-point test

The agent gets whole tasks, not completions. You describe an outcome, such as adding pagination to the orders endpoint, instead of accepting the end of a line you were typing.
You are present for the whole run. The session is a conversation you watch, and you stop it when it drifts.
You read every line before it is committed. You read the diff, not the summary, and you would notice a renamed variable.
You are the agent’s memory of the project. You type conventions, commands and forbidden paths again in each session.
Nothing runs while you are away. No scheduled run, no second agent in a second checkout, and no job that opens a pull request on its own.

Five yeses is Level 2. If item 1 is a no, you are at Level 1. Items 4 and 5 are the ones that keep you on this rung, and item 4 has a fix you can finish today: Step 1 below.

How do you set up a repository to leave Level 2?

Three changes, in this order. None of them is a new tool, and each one produces something you can check.

Step 1: Give the agent a context file it loads every session

The context file ends item 4 of the test: you stop being the agent’s memory. Generate it from the repository, not from memory, and keep it to what is true today: the commands that must pass, the layout, the conventions reviewers enforce, and the paths the agent must not touch. For the layering rules and what belongs in each file, see layered context with CLAUDE.md and AGENTS.md.

Run /init in the repository to generate a starter CLAUDE.md, then /memory to edit it and to turn auto memory on or off. Claude Code also reads AGENTS.md when the project has no CLAUDE.md: from v2.1.277 in first-party sessions and from v2.1.281 on Bedrock, Google Cloud and Microsoft Foundry, both on the latest release channel only as of 26 September 2026. So a team that shares one file with Codex can keep a single AGENTS.md.

Run /init in the Codex prompt to create an AGENTS.md file. Codex “reads AGENTS.md files before doing any work” (OpenAI’s Codex docs, checked 28 August 2026). Since codex-cli 0.150.0, an untrusted project does not supply project-level AGENTS.md instructions, so the file is silently ignored until you trust the repository. Accept the trust prompt Codex shows when you first open it; the Codex quick start covers the trust setting.

Read this repository and write the context file you load every session
(CLAUDE.md for Claude Code, AGENTS.md for Codex, a project rule for Cursor).
Use only what is in the repo. Include:
- the package scripts that actually run, and roughly how long each one takes;
- the test, typecheck and lint commands;
- the directory layout, one line per top-level folder;
- the three conventions a new contributor gets wrong, found by reading the
  last 50 commits and their review comments;
- the paths an agent must never edit (generated files, migrations already
  applied, vendored code, secrets).
No aspirational rules, no generic advice, nothing you cannot point at a file
for. Finish with a "Verify before you finish" block listing the exact commands
that must exit 0. Then run each of those commands now and report the exit
code of each one. If any command fails, fix the file, not the repository.

How you know it worked: every command in the “Verify before you finish” block exits 0 on a clean checkout, and a fresh session answers “how do I run the tests here?” correctly without you typing anything.

Step 2: Make plan mode the default gate

Reading a plan is far cheaper than reading a wrong diff. Plan mode makes the agent research and propose before it edits, so you catch the wrong approach before any code exists.

Press Shift+Tab to cycle to plan mode, or prefix a prompt with /plan. To start every terminal session in this project in plan mode, add this to .claude/settings.json:

{
  "permissions": {
    "defaultMode": "plan"
  }
}

When the plan is ready, choose Yes, manually approve edits if you want to approve each edit as it happens.

With v2.1.283 (latest channel), auto mode is the built-in starting mode for interactive terminal and VS Code sessions on every plan and provider (Pro, Max and Team since 14 August 2026). claude -p, sessions whose settings set disableAutoMode, and models auto mode does not support start in Manual. A defaultMode in your settings, like the plan above, replaces the built-in start. In auto mode a classifier, not you, reviews each action. That is fine for Level 2 as long as you still read the diff before you commit. To keep per-action approval instead, start with claude --permission-mode manual.

Type /plan in the Codex prompt before a change of more than a few lines. To keep edits inside the repository and let the model ask before it goes further, start the session with:

codex --sandbox workspace-write --ask-for-approval on-request

Codex writes to the working tree, so your Level 2 read happens at git diff before you commit. For permission profiles and sandbox choices, see permissions and sandboxing for agents.

For how the plan becomes the contract for the build, see the build stage of the lifecycle.

Step 3: Run one task class end to end with a stop condition

Pick a task class you repeat: a CRUD endpoint, a migration, or a bug with a reproduction. Run it once with the context file and plan mode in place, and write the acceptance criteria before the agent starts. The agent’s job ends at a stop condition it can check itself, not when it says it is done. That verified path is what you later hand to an agent you are not watching.

Task: add cursor-based pagination to GET /orders (query params: limit, cursor;
default limit 50, max 200).

Before you edit anything, write a plan that lists:
1. every file you will change and why;
2. the acceptance criteria as testable statements, including limit=0,
   limit=201, an invalid cursor, and the last page;
3. the tests you will add for each criterion.
Stop and wait for my approval of the plan.

After approval, implement it. You are done only when:
- each acceptance criterion has a test that fails without your change and
  passes with it (show me both runs);
- the test, typecheck and lint commands in the context file all exit 0;
- you have not edited any existing test, fixture or CI file.
Finish with a short evidence summary: criterion -> test name -> result, plus
anything you were unsure about. Do not summarise the diff.

How do you check the agent’s work without reading every line?

At Level 2 you still read every line; that is the definition of the rung. Kent Beck’s augmented coding keeps that same care for the code while the agent types. The point of the setup is to build, next to your reading, the checks that will replace it at the next level. Treat each run as a trial of those checks:

Check	Where it comes from	What it proves
Command gate	“Verify before you finish” block in the context file	The change builds, types and passes the existing suite
Acceptance tests	Criteria written in the plan, before the code	The new behaviour exists, and the test could have failed
Protected oracle	“Do not edit existing tests” in the prompt	The agent did not make the check easier to pass
Evidence summary	Last lines of the agent’s run	Which criterion maps to which passing test

Then compare the evidence with your own read of the diff. Each time your reading finds a problem the checks missed, add a check for it. When a task class goes several runs without your reading adding anything, that class is ready for Level 3, where the agent’s work reaches you as a diff you did not watch being written. You still sign off every commit at Level 2; the checks earn the right to take over later. For what a human reads once the diff is no longer the unit of review, see reading evidence instead of code.

Why the climb out of Level 2 stalls, and how to recover

What should a tech lead check across a team at Level 2?

A team is not at one level; each repeatable loop is. For each repository, check three things: whether a context file is committed and its commands pass in CI, whether plan mode is the configured default, and whether at least one task class has written acceptance criteria and a stop condition. A repository with all three is ready for its first unattended loop. To place teams and loops on one grid, see one map for the ladder, the lifecycle and the factory stations.

Where to go next from Level 2

Level 3: You Review the Diffs Parallel agents, review automation, and the review ceiling they hit.

Reading evidence instead of code What a human reads once the diff stops being the unit of review.

Developer track The reading order from this rung to running agents unattended.

The autonomy ladder All six levels, and a test to place each of your loops.

Claude Code quick start Configuration, MCP and the terminal workflow.

Codex quick start Setup across the app, CLI, IDE and cloud.

Cursor quick start Rules, MCP and model selection in one sitting.

Find your level Twenty-five questions that place your workflow on the ladder.

Frequently asked questions

What is Level 2 on the autonomy ladder?

Level 2 is paired coding. The agent does whole tasks inside one session while the developer watches the run and reads every line before it is committed. Dan Shapiro calls it the junior-developer level and places "90% of 'AI-native' developers" there.

What is the difference between Level 1 and Level 2?

Who writes the important code. At Level 1 the developer writes it and hands the agent discrete tasks such as a regex, a fixture or a migration script. At Level 2 the agent writes most of the change and the developer keeps the reading.

How do I move a repository from Level 2 to Level 3?

Three changes, in order: a context file the agent loads every session, generated from the repository and proven by running its commands; plan mode as the default gate before any edit; and one repeated task class run end to end with a stop condition the agent checks itself.

Is it safe to stop reading every line at Level 2?

Only when something else does the checking. Sonar's January 2026 survey found that only 48% of developers always verify AI-generated code before committing. Dropping the read without adding command gates and a written evidence summary is Level 2 with the check removed, not Level 3.