Developer track: a reading path to agentic engineering

The developer track is the ordered reading path for developers who use Cursor, Claude Code or Codex. It starts with a free baseline, the Developer Scorecard, then climbs the autonomy ladder from a first real task to reviewing evidence instead of every diff. Each step ends in an artifact that proves it is done.

You already use an agent. Some days it saves an afternoon; other days you spend the afternoon reading what it wrote, because nothing tells you whether to trust it. The path below puts the habits that fix that in the order they pay off.

What the developer track gives you

• An order that compounds. Each step assumes the one before it: an instructions file makes the feedback loop reliable, and the feedback loop makes parallel agents safe.
• A “Done when” criterion per step. You move on when an artifact exists, not when the reading feels finished.
• One branch per tool where the tools differ, and one shared step where they do not.
• A clear free boundary. Every step is marked Free or Subscribers.

How do you use the developer track?

1. Take the Developer Scorecard first. Your answers show which steps you can skip, and the answer key maps each question to the page that moves it.
2. Read steps 1 to 3 in order. Everything later assumes an installed tool and a reviewed instructions file.
3. After step 3, skip any step whose “Done when” artifact you already have.
4. Re-take the scorecard after four weeks and compare the sections.

Steps that are still being written are hidden and appear here when they are published. The list grows toward the end of the path, where it moves from reviewing diffs to reviewing evidence.

Baseline first

Take the Developer Scorecard before step 1: about 8 minutes, free.

Start the scorecard · Answer key: every question mapped to its page

1. 1 The Autonomy Ladder: Which Level Is Your Workflow At? Free

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

   Done when: You can name your level and the one habit that keeps you on it.

2. 2 Your tool's quick start: Cursor · Claude Code · Codex Subscribers

   Why now: Get one tool installed, configured and through a first real task in your repository.

   Done when: A merged change the agent wrote, with the tests it ran.

3. 3 AGENTS.md and CLAUDE.md — concise repository context Subscribers

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

   Done when: A reviewed CLAUDE.md or AGENTS.md under 150 lines with the real test commands.

4. 4 Permissions, sandboxes and approval modes across Claude Code, Codex and Cursor Subscribers

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

   Done when: A committed permission policy and a sandbox for anything with network or secrets.

5. 5 The artifact chain Subscribers

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

   Done when: One change shipped from an accepted intent.md, spec.md and plan.md.

6. 6 Executable acceptance criteria: from story to failing test Subscribers

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

   Done when: A story whose criteria exist as tests before the agent starts.

7. 7 Test: give the session a feedback loop Subscribers

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

   Done when: The agent runs the loop and reports exit status on every task.

8. 8 Protecting the oracle: checks the agent cannot edit Subscribers

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

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

9. 9 Run parallel agents in isolated worktrees Subscribers

   Why now: Parallel agents need isolated checkouts, ports and state before they need more tokens.

   Done when: Two agents on two tasks in two worktrees without a collision.

10. 10 Skills, MCP servers or plugins: which one, and where each lives Subscribers

    Why now: Choose between a skill and an MCP server by the job, not the hype.

    Done when: One capability added in the right layer, with a reason you can state.

11. 11 Model routing by evidence, not brand Subscribers

    Why now: Start on the default model, tune effort, and switch only when your own evals say so.

    Done when: A routing rule for your repository backed by a before-and-after run.

12. 12 Agentic development frameworks compared Subscribers

    Why now: See which named frameworks exist and what each prescribes.

    Done when: You know whether any framework fits your next change.

13. 13 Reading evidence instead of code Free

    Why now: The turn of the whole path: what you read instead of the diff, and when you still read code.

    Done when: A change approved on its evidence bundle without reading every line.

14. 14 Reviewing an agent's pull request without reading every line Subscribers

    Why now: Review an agent pull request by risk class and evidence, with a short escalation list.

    Done when: A review checklist the review agent runs and you only escalate from.

15. 15 From issue to pull request with no hands on the keyboard Subscribers

    Why now: Once the gates hold, let a well-shaped issue become a pull request without you.

    Done when: One issue closed by a pipeline run you did not start by hand.

16. 16 Your craft and career when agents write the code Free

    Why now: What your craft becomes when agents write the code, and how to show it.

    Done when: A written plan for the skills you will keep sharp and the ones you hand over.

Further reading

• Quick Wins in Your First 24 Hours
• Power-user tips for Cursor, Claude Code and Codex

Which tool branch should you take?

Step 2 branches by tool; the rest of the path is shared, and each linked page shows all three tools where they differ. If you have not chosen a tool, read the tool comparison first.

	Cursor	Claude Code	Codex
Quick start	Cursor quick start	Claude Code quick start	Codex quick start
Instructions file (step 3)	Rules	CLAUDE.md	AGENTS.md
Read-only planning	Plan Mode	claude --permission-mode plan or /plan	/plan
Parallel work	Worktrees	claude -w <name>	codex --worktree
Headless checks	Cursor CLI print mode (-p)	claude -p	codex exec

Claude Code and Codex commands were checked on 26 September 2026 against Claude Code 2.1.283 and Codex CLI 0.157.1. Cursor features were last verified on 28 August 2026. Claude Code reads AGENTS.md when a project has no CLAUDE.md, from v2.1.277 on the latest release channel only.

Copy-paste prompt: turn this path into a plan for your repository

I am following a learning path for agentic engineering. Read this repository and tell me:
1) whether it has an agent instructions file (CLAUDE.md, AGENTS.md or Cursor project rules) and what is missing from it,
2) the single command that runs the tests, lint and type checks, or that there is none,
3) which of these is weakest here: instructions file, feedback loop, test coverage, parallel-work setup.
Recommend the one step to work on first and the evidence that would show it is done. Do not change any files.

How do you prove a step is done without reading every line?

The exit criteria are built so that a check, not your reading, answers “is it done”. Three rules keep them honest:

• One command decides. From the feedback-loop step on, every task ends with the agent running the repository’s single test, lint and type-check command and reporting its exit status. A zero exit on a command you trust is the evidence; the agent’s summary is not.
• The agent cannot weaken the checks. Tests the agent can edit prove nothing. Lock the checks it must not weaken with a hook or a CI rule (the path’s protect-the-oracle step, which appears when published), and let CI re-run the same command on every pull request.
• You read the contract, not the diff. From the artifact-chain step on, you review the intent, spec and plan before the agent writes code, and after it finishes you check the evidence against them. You still read code line by line where a change is high-risk or the evidence is missing.

Copy-paste prompt: collect the evidence for one finished task

You just finished the task. Do not change any code. Produce an evidence report:
1) the acceptance criteria you worked to, quoted from the spec or issue,
2) for each criterion, the test that covers it and whether it passed,
3) the exact command you ran for tests, lint and type checks, with its exit status,
4) every test file you added, changed or deleted, and why,
5) anything you could not verify.
If any criterion has no test, say so first.

When does the developer path stall?

Four blockers repeat, and each has a fast recovery:

• The agent reads the wrong files. Build output and generated files drown the context in large repositories. Name the files and directories that matter in your prompt, and record the ones to ignore in your instructions file.
• An MCP server will not connect. A missing environment variable is the usual cause. Run the server on its own first, confirm the token is exported, then restart the agent; in Claude Code, claude --debug "mcp" prints the connection failure, and /mcp shows each server’s status.
• Quality drops suddenly. Check the active model and effort before anything else: /model in Claude Code and Codex, the model picker in Cursor. Start on the tool’s default model, raise effort before you switch models, and switch only when your own evals say so. The models hub keeps the current defaults.
• Headless runs hang. A run in CI waits on an approval prompt nobody will answer. In Claude Code, pre-approve the tools the job needs with --allowedTools or the project settings. In Codex, pass the approval policy before the subcommand, as in codex -a never exec …, inside a sandboxed runner.

Copy-paste prompt: find out why the agent keeps missing the point

Your last three attempts did not do what I asked. Before trying again:
1) restate the goal and the acceptance check in one sentence each,
2) list the files you read and the ones you did not open,
3) name the instruction in CLAUDE.md / AGENTS.md / project rules that you followed, if any.
Then tell me what context you are missing. Do not edit anything yet.

For the full catalog of error messages and fixes, see the troubleshooting guide.

Where to go from the developer track

Quick wins in your first 24 hours Techniques that pay off before you start the path

Start here Pick a different starting point: your tool's quick start or your role's section

The tech lead track The same shift for a whole team: harness, verification and review capacity

The human's job in agentic engineering What stays with you at every rung of the ladder