Hand your agent the whole change: migration, model, handler and test.

A backend change rarely sits in one file: a schema, a migration, a handler and its tests move together. That is the shape an agent handles in a single pass and an autocomplete cannot, because the agent can run the test suite and correct itself. The recipes below cover eight language stacks plus API and database patterns.

$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
11
Steps on the reading path
16
Questions in the free scorecard
25
By-role data last updated
2026-08-17

Pages: API patterns, SQL patterns, Node.js recipes, Python recipes, Go recipes, Rust recipes, Java recipes, PHP recipes, Elixir recipes, Serverless recipes, Migration patterns.

One change, two ways to work.

One backend change, drawn two ways: a migration, the model it alters, the handler that reads it and the test that covers it.

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

With autocomplete

Four context switches.

A migration, the model it alters, the handler that reads it and the test that covers it: you carry the change from one file to the next.

  1. Migration You write
  2. Model You write
  3. Handler You write
  4. Test You write

As one agent task

One change, one loop.

The same four are one task. An agent that runs the test suite and iterates until it passes hands you a diff that already compiles.

Spec

spec.md

Every requirement has an acceptance criterion that a test can check.

You write and read

One task for the agent

  • Migration
  • Model
  • Handler
  • Test

Runs the test suite and corrects itself until it passes.

Agent writes, checks read

Evidence bundle

Evidence, then a code reader

The test report and the spec delta. A data migration is an escalation class: its owner reads the migration code.

You read

The unit of work moves from a function to a change. A migration, the model it alters, the handler that reads it and the test that covers it are one task for an agent, and four separate context switches for a person with autocomplete. The review burden moves with it. An agent that runs the test suite and iterates until it passes hands you a diff that already compiles — which makes the remaining question "is this the right change" rather than "does this work".

Drawing
One change, two ways to work.
Source
Drawn from the by-role text for backend developers, last updated 2026-08-17; the spec line is from the artifact chain guide, the migration rule from reading evidence instead of code.
Note
An illustration of the by-role data, not a measurement

The failures your tests do not catch.

Each recipe opens with the failure it exists to prevent. Here are 5, in the recipes’ own words, with the page that fixes them.

  1. The scene
    “Your POST /orders charges a customer twice when the mobile app retries on a weak connection. Your ‘next page’ skips an order whenever two orders share a created_at.”

    The page that fixes it API patternsPrompts for Claude Code, Codex, and Cursor that build idempotent POSTs, keyset pagination, and a drift-proof OpenAPI spec, plus the checks that prove them.

    Open API patterns 2026-09-26

  2. The scene
    “… the tests passed, and at 2 p.m. Postgres took an ACCESS EXCLUSIVE lock to rewrite a 40-million-row table. Every checkout query queued behind it.”

    The page that fixes it Migration patternsZero-downtime Postgres migrations with Claude Code, Codex, and Cursor, proven by a Squawk lint gate, a parity query, and a rollback plan for each phase.

    Open Migration patterns 2026-10-12

  3. The scene
    “Your Express API passes every test the agent wrote, then the first deploy drops in-flight requests, two customers buy the last item in stock at the same moment, and a refresh token shows up in plain text in your log search.”

    The page that fixes it Node.js recipesPrompts and gates for agent-written Node.js services on Express 5: clean shutdown, validation, token rotation, Prisma transactions, queues, and safe logs.

    Open Node.js recipes 2026-10-12

  4. The scene
    “… the first load test freezes the event loop because a handler calls requests.get(), an async query raises MissingGreenlet on a relationship nobody loaded, and a retried Celery task charges a customer twice.”

    The page that fixes it Python recipesPrompts and gates for agent-written Python backends: FastAPI lifespan, Pydantic v2, async SQLAlchemy 2.1, Celery, httpx, structlog, and Django tenant scoping.

    Open Python recipes 2026-09-26

  5. The scene
    “The per-request goroutines never exit, the pgx pool starves because a rows.Close() is missing, and a downstream call with no deadline piles up until the pod is OOM-killed.”

    The page that fixes it Go recipesPrompts and gates for agent-written Go services — graceful shutdown, bounded goroutines, sized pgx pools, and race and leak checks you can trust.

    Open Go recipes 2026-10-12

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 work that ends in a migration and a test. 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 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.

  4. Step 6 of 16 Toolkit

    Executable acceptance criteria: from story to failing test

    Acceptance criteria written as failing tests are the contract the agent works to.

    Done whenA story whose criteria exist as tests before the agent starts.

  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

Recipes for your stack.

Each recipe is a set of prompts for Claude Code, Codex and Cursor, plus the gate that proves the result. Pick the stack you ship.

Descriptions: the pages themselves, with the date each was last updated. The pages are documentation pages and come with the Toolkit.

Where your backend 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 backend 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 backend changeThe migration, model, handler and test are one task. You write the spec, the agent works until the suite passes, and you read the evidence bundle. The migration’s owner still reads its code: a data migration is an escalation class.

    Where the toolkit points
  2. 3

    The developer

    “Your life is diffs.”

    One backend changeThe agent writes the change and you read the whole diff, migration included.

    The valley, levels 2 and 3
  3. 2

    The junior developer

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

    One backend changeYou and the agent build the handler together, a step at a time, and you check each step.

  4. 1

    The coding intern

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

    One backend changeYou hand over one function or one query, and you paste the result into your own change.

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 backend 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 a ticket that touches a migration, a handler and its tests. Write intent.md and spec.md, have the agent draft plan.md and accept it before any code changes, let the agent build and stop on the tests, then read the evidence bundle. The migration’s owner reads its code.

  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 is best for backend work?

All three edit many files autonomously, run commands and self-correct by running tests, so none is disqualified. They differ in where they run: Claude Code and Codex start from a terminal CLI with an editor extension beside it, Cursor is the editor itself, and each has a cloud option (Claude Code web sessions, Codex cloud, Cursor Cloud Agents).

Can an agent write the migration and its test in one pass?

That is the case they are built for. Autonomous multi-file editing, command execution and self-correction by running tests are core capabilities in all three tools, which is why a schema change and the test covering it are one task rather than four.

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.

Hand over the change. Check what passed.

Within the 30-day refund window, ship one migration-sized change this way on your own repository: the evidence bundle, and a named reader for the migration’s code.

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