No reviewer? Make the guardrails structural.

Building alone changes what an AI coding agent has to be good at. There is no reviewer, so the checks an agent runs on itself are the only checks, and the guardrails have to be structural rather than social: a config file the agent always reads, hooks it cannot skip, tests it must pass.

$59.99 once for 12 months of access. Nothing renews on its own. 30-day refund on a first purchase.

Pages picked for this work
5
Steps on the reading path
16
Questions in the free scorecard
25
By-role data last updated
2026-08-17

Pages: Quick wins in your first 24 hours, Writing a project context file, Using plan mode well, Hooks as guardrails, What the tools cost.

One change, two ways to work.

One change, drawn two ways: on a team, and alone with an agent.

  • Written by you
  • Read by you
  • Agent and checks

On a team

A reviewer at the pull request.

On a team, a second person catches what you missed, and standards spread through code review.

  1. You write A person
  2. Pull request A person
  3. A reviewer reads A person

Alone, with an agent

The review moves before the code.

A plan you read before any code is written is the review that would otherwise have happened at the pull request.

Instructions

CLAUDE.md or AGENTS.md

The only place your standards exist at all, and a file the agent always reads.

You write and read

One task for the agent

  • A plan you read
  • Hooks it cannot skip
  • Tests it must pass

Works inside the guardrails you set once.

Agent writes, checks read

Evidence

The plan and the test report

The checks an agent runs on itself are the only checks, so they have to be structural. For the escalation classes you are the named reader.

You read

Nobody catches what you and the agent both miss. That makes the project config file — CLAUDE.md, AGENTS.md or .cursor/rules — the first thing worth writing, because it is the only place your standards exist at all. It also makes plan mode worth the extra step more often than it would be on a team. A plan you read before any code is written is the review that would otherwise have happened at the pull request.

Drawing
One change, two ways to work.
Source
Drawn from the by-role text for solo builders, last updated 2026-08-17.
Note
An illustration of the by-role data, not a measurement

Where it goes wrong first.

Each guide opens with the situation it exists to fix. Here are 4, in the guides’ own words, with the page that fixes them.

  1. The scene
    “You have a standup in an hour, a module nobody has tested, and a stack trace from last night’s deploy.”

    The page that fixes it Quick wins in your first 24 hoursTen first-day techniques for Claude Code, Codex and Cursor, each with a copy-paste prompt and a check that proves the result without reading every line.

    Open Quick wins in your first 24 hours 2026-10-12

  2. The scene
    “You changed the test command from npm test to pnpm test:unit last sprint. CLAUDE.md got the edit, AGENTS.md did not, and today a Codex session ran the old command, saw it fail, and ‘fixed’ the failure by rewriting a test.”

    The page that fixes it Writing a project context fileWrite one short AGENTS.md core, wire Claude Code, Codex and Cursor to it, and prove with /context and codex debug prompt-input which rules each agent loaded.

    Open Writing a project context file 2026-10-17

  3. The scene
    “You ask for a partial-refund endpoint and get back a 900-line diff. It edits the frozen v1/ package, bumps a dependency the platform team owns, and tests only the happy path. A five-minute read of a plan would have caught all three, but there was no plan, only the diff.”

    The page that fixes it Using plan mode wellTurn an accepted spec.md into a committed plan.md in read-only plan mode, then implement in an isolated worktree behind hooks and a self-check.

    Open Using plan mode well 2026-10-12

  4. The scene
    “… your CLAUDE.md says ‘never edit src/generated/’ and ‘run the tests before you finish’, the agent follows both for a week, and then a long session edits a generated client, reports ‘all done’, and leaves a failing test and an API key in the diff.”

    The page that fixes it Hooks as guardrailsFour layered hooks for Claude Code and Codex: protect paths, block risky commands, lint each edit, and refuse to stop with secrets or failing tests.

    Open Hooks as guardrails 2026-09-26

Scenes are the opening scenarios of the pages and are written as examples, not as reader reports. Quotations are trimmed. The pages are documentation pages and come with the Toolkit.

Your reading path, in the order it pays off.

From the 16 steps on the developer path, 6 picked for working alone: the instructions file, a plan you read, and checks the agent cannot weaken. The numbers are each step’s place in the full path, and each one says what you can show when it is done.

  1. Step 1 of 16 Free

    The Autonomy Ladder: Which Level Is Your Workflow At?

    Place your current workflow on the ladder, so every later step is a move up one rung.

    Done whenYou can name your level and the one habit that keeps you on it.

  2. Step 3 of 16 Toolkit

    AGENTS.md and CLAUDE.md — concise repository context

    The instructions file is the cheapest lever on output quality; write it before you scale use.

    Done whenA reviewed CLAUDE.md or AGENTS.md under 150 lines with the real test commands.

  3. Step 4 of 16 Toolkit

    Permissions, sandboxes and approval modes across Claude Code, Codex and Cursor

    Decide what the agent may run without asking before you let it run longer.

    Done whenA committed permission policy and a sandbox for anything with network or secrets.

  4. Step 5 of 16 Toolkit

    The artifact chain

    Intent, spec and plan are what you review instead of every line the agent writes.

    Done whenOne change shipped from an accepted intent.md, spec.md and plan.md.

  5. Step 7 of 16 Toolkit

    Test: give the session a feedback loop

    A single-command feedback loop lets the agent prove its own work before you look.

    Done whenThe agent runs the loop and reports exit status on every task.

  6. Step 8 of 16 Toolkit

    Protecting the oracle: checks the agent cannot edit

    Tests the agent can edit are not evidence; lock the checks it must not weaken.

    Done whenA hook or CI rule that fails when protected tests change.

Steps and “done when” lines: the developer reading path, 16 steps and 2 further reading, last updated 2026-10-12. The ladder pages are free; every other step is marked.

Read the whole path

Where your solo work sits on the ladder.

Dan Shapiro’s levels describe how much of the work you hand to an agent. Each row shows what one change looks like at a rung the scorecard can place you on.

Not sure which row is yours?

The AI Dev Score asks 25 questions in about 8 minutes, scores 6 sections and gives you a 30/60/90-day plan for the next rung. Free.

Take the AI Dev Score

No account, no card. An email only at the end, and only if you want the full playbook.

  1. 4

    The engineering team

    “leave for 12 hours, and check to see if the tests pass”

    One changeYou write the spec and accept the plan, the agent works until the tests pass behind hooks it cannot skip, and you read the evidence. For authentication, money, schema and migrations, and changes to the tests themselves, you read the code: you are the named reader.

    Where the toolkit points
  2. 3

    The developer

    “Your life is diffs.”

    One changeThe agent writes the change and you read the whole diff yourself: you are the only reviewer.

    The valley, levels 2 and 3
  3. 2

    The junior developer

    “feels like you are done. But you are not done”

    One changeYou and the agent build the feature together, a step at a time, with nobody to catch what you both miss.

  4. 1

    The coding intern

    “you offload specific, discrete tasks to your AI intern”

    One changeYou hand over one function, and you paste the result into your own project.

Level names and quotations: Dan Shapiro, “The Five Levels: from Spicy Autocomplete to the Dark Factory”, 2026-01-23 (opens in a new tab). The ladder runs from Level 0 to Level 5 and the scorecard places you on 1 to 4. The “One change” column is our illustration.

Your first week, planned.

  1. Day 1

    Generate your Setup Pack.

    Answer 9 questions about your stack and tools, including language, framework, package manager and test runner. Your agent runs INSTALL-PROMPT.md and checks each setting against what you have installed. About 20 minutes. The Setup Pack is included in the Toolkit.

  2. Days 2 to 5

    Hand over one real change.

    Pick one real feature. Write the instructions file first, then intent.md and spec.md, have the agent draft plan.md and accept it before any code changes, let the agent build behind your hooks and tests, then read the plan and the report.

  3. By day 30

    Decide with evidence.

    You have one change done the new way. If it did not change how you work, ask for a refund before day 30.

Buy the Toolkit

The Toolkit includes the guides, the Setup Pack and all eight books, for 12 months. $59.99 once for 12 months of access. Nothing renews on its own. 30-day refund on a first purchase.

Questions about this work.

Something else? Write to support@developertoolkit.ai.

Which tool should I start with?

The one already included in a subscription you pay for: Claude Code comes with Claude Pro, Max and Team plans, Codex with ChatGPT Plus, Pro, Business, Edu and Enterprise (pricing analysis, 2026-09-26). If neither applies, start from where you want to work: an editor points to Cursor, a terminal to Claude Code or Codex.

What should I set up first?

The project config file — CLAUDE.md, AGENTS.md or .cursor/rules depending on the tool. Working alone, it is the only place your standards exist, so it is the one artefact that keeps paying back on every session.

What do I read instead of the diff?

The evidence the change carries: the spec delta, the acceptance results, the strength of the oracle and runtime signals from a running build. A named person still reads the code for authentication, money, schema and migrations, changes to the tests themselves, and anything no check covers.

I only use one of the three tools.

That works. Where Claude Code, Codex and Cursor differ, the guides and recipes show a tab for each, so you read the one for your tool.

Write the guardrails once. Let them check every change.

Within the 30-day refund window, set up one repository this way and ship one change through it.

$59.99 once for 12 months of access. Nothing renews on its own. 30-day refund on a first purchase.