Chapter 1 · 6 lessons
The AI Developer Workstation
Cursor, Claude Code, Codex, and Copilot — what each surface is for, how agent loops work, and the daily habits that separate fast from reckless.
Cursor · Claude Code · OpenAI Codex · GitHub Copilot
Show all 6 lessonsHide list
Lesson 1 of 6
What a Coding Agent Actually Does
Every modern coding agent runs the same loop: read context, decide on a tool call (search, read file, edit, run shell, call MCP), observe the result, and repeat until it believes the task is done. The model is the planner; the harness (Cursor, Claude Code, Codex, Copilot) decides which tools exist, what context is preloaded, what needs approval, and what gets logged.
┌──────────── context ────────────┐
│ system + repo memory + skills │
│ + your prompt + prior turns │
└───────────────┬─────────────────┘
▼
┌──────────┐ tool call ┌──────────────┐
│ model │ ────────────▶ │ harness tool │
│ (planner)│ ◀──────────── │ read/edit/sh │
└──────────┘ observation └──────────────┘
│ (repeat until done or budget hit)
▼
diff + summary → YOU review- Quality is bounded by context: wrong files in, wrong code out
- Speed is bounded by approvals: every prompt-for-permission is a round trip to you
- Safety is bounded by the harness: sandbox, permission rules, and hooks — not by asking nicely
- The summary is a claim, the diff is the evidence
Signal
Describe agents in terms of loop, context, tools, and guardrails. Candidates who only talk about 'which model is smartest' miss that the harness decides most outcomes.
Lesson 2 of 6
Editor vs CLI vs Cloud Agent
The same model behaves differently depending on the surface. Pick the surface for the shape of the task, not out of habit.
| Surface | Examples | Best for | Cost of misuse |
|---|---|---|---|
| In-editor agent | Cursor Agent, Copilot agent mode | Iterating on code you are actively reading | Context fills with chat; you babysit long tasks |
| Terminal agent | Claude Code, Codex CLI, Cursor CLI, Copilot CLI | Repo-wide tasks, scripts, headless CI runs | Harder to review visually; needs good permissions |
| Cloud / background agent | Cursor cloud agents, Copilot cloud agent, Codex cloud | Parallel, well-scoped tickets that end in a PR | Vague tickets produce confident, wrong PRs |
| Review bot | Copilot code review, Cursor Bugbot | A second pass on every PR | Noise if rules are not tuned |
Rule of thumb
If you would want to watch it, use the editor. If you would hand it to a junior with a checklist, use a cloud agent. If it must run the same way every time, script it and let the agent call the script.
Lesson 3 of 6
Tool-by-Tool Map
| Tool | Repo memory | Extension points | Signature strength |
|---|---|---|---|
| Cursor | .cursor/rules/*.mdc, AGENTS.md | Skills, MCP, hooks, plugins, subagents | Plan mode + fast edit/review in the IDE; cloud agents |
| Claude Code | CLAUDE.md | Skills, slash commands, subagents, hooks, plugins, MCP | Deep agentic runs, rich hook events, headless mode |
| Codex | AGENTS.md chain (global, then root → cwd) | Skills, MCP, plugins, profiles | Explicit sandbox_mode + approval_policy |
| Copilot | .github/copilot-instructions.md, *.instructions.md, AGENTS.md | Custom agents, prompt files, skills, MCP | Issue → cloud agent → PR inside GitHub |
The convergence is the real story: Agent Skills (SKILL.md), AGENTS.md, and MCP now work across most of these tools. Invest in portable assets first, tool-specific config second.
- Also worth knowing: Gemini CLI, Windsurf, Cline, Continue, OpenCode — same primitives, different defaults
- Model choice is a setting, not a religion: route cheap models to search/summarize, strong models to design and hard debugging
Lesson 4 of 6
Plan, Ask, Agent, Debug — Using Modes Deliberately
Most harnesses expose modes that change which tools the agent may use. Treat them as guardrails you choose per task.
| Mode | Tools | Use when |
|---|---|---|
| Ask / read-only | Search and read only | Understanding unfamiliar code without risk of edits |
| Plan | Read + write a plan, no code edits | Changes spanning many files or with design tradeoffs |
| Agent | Full edit + shell (within permissions) | Clear task, clear done-criteria |
| Debug | Instrument, reproduce, then fix | Bugs where you need runtime evidence, not guesses |
Common failure
Jumping straight to Agent mode on a vague ask. The agent will pick an interpretation and implement it confidently. A two-minute plan review is cheaper than reverting forty files.
Lesson 5 of 6
The Daily Loop of a Strong AI Developer
- Spec: goal, constraints, done-criteria, and what is out of scope
- Context: let repo memory carry conventions; attach only task-specific files and skills
- Execute in a box: sandbox or permission mode sized to the task
- Review: read the diff, run tests, ask a clean-context reviewer to hunt for bugs
- Capture: turn repeated explanations into rules/skills and repeated checks into hooks
Portfolio signal
Show a repo where the agent setup is visible: a concise AGENTS.md, two or three focused skills, a test-gate hook, and PRs where agent output was reviewed and corrected. That is stronger evidence than 'I use Cursor every day.'
Lesson 6 of 6
Worked Example: Adding Rate Limiting
Task: add per-user rate limiting to the public API. Same developer, same model, two approaches.
you: add rate limiting to the api
agent: (edits 14 files, adds express-rate-limit, new Redis client,
changes 3 unrelated handlers, updates package-lock)
agent: Done! Rate limiting added and all tests pass.
you: (merges) → prod: health checks rate-limited, deploy rolls backyou: [Plan mode] Add per-user rate limiting to /api/public/*.
Use the existing Redis client in lib/redis.ts. 100 req/min.
Exclude /health. Done = tests for limit, reset, and /health bypass.
agent: Plan: middleware in lib/rate-limit.ts, wire in api/public/router.ts,
3 tests. No new deps. Risk: shared IP behind proxies → key on user id.
you: approve (adds: return Retry-After header)
agent: (edits 3 files, adds 4 tests, runs suite: 212 passed)
you: reads diff, runs tests, merges- Spec had scope (which routes), constraints (existing client, no deps), and done-criteria (named tests)
- Plan mode surfaced a real risk (proxy IPs) before any code was written
- The diff shrank from 14 files to 3 — and the review took two minutes
Takeaway
The model did not get smarter between runs. The input and the review loop did.