# Developer track: a reading path to agentic engineering

URL: https://developertoolkit.ai/en/start/developer/
Description: The developer reading path: from the autonomy ladder and your tool's quick start to specs, feedback loops and reviewing evidence instead of diffs.

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.

## How do you use the developer track?

1. Take the [Developer Scorecard](/en/scorecard/) first. Your answers show which steps you can skip, and the [answer key](/en/developer-scorecard-guide/) 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.

<TrackList role="developer" lang="en" />

## 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](/en/comparison/) first.

| | Cursor | Claude Code | Codex |
| --- | --- | --- | --- |
| Quick start | [Cursor quick start](/en/cursor-ide/quick-start/) | [Claude Code quick start](/en/claude-code/quick-start/) | [Codex quick start](/en/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 both release channels since `stable` reached v2.1.287 (checked 2026-10-12).

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

```text
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 (step 8 of this path, [protecting the oracle](/en/workflows/test/protect-the-oracle/)), 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**

```text
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](/en/ecosystem/models/) 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**

```text
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](/en/resources/troubleshooting/).

## Where to go from the developer track

- [Quick wins in your first 24 hours](/en/start/quick-wins/) — Techniques that pay off before you start the path
- [Start here](/en/start/) — Pick a different starting point: your tool's quick start or your role's section
- [The tech lead track](/en/start/tech-lead/) — The same shift for a whole team: harness, verification and review capacity
- [The human's job in agentic engineering](/en/ladder/the-humans-job/) — What stays with you at every rung of the ladder
