The look back: the whole job

Briefing well is the last of the friction. Before the course closes, stand back from the arc itself - because the shape of the progression is the actual lesson, and it’s a deliberately different shape than the one this course’s siblings walk.

The arc, in one breath

You started in an editor, on a repo you were still learning. Getting started went from nothing installed to a first reviewed change - the CSV date fix in the course’s illustrative budgetcli personal-finance API - so one full turn of the read-propose-review loop happened before anything was at stake. The daily edit loop made that loop cheap: Tab (the inline-completion key) for the edits you could already see in your head, the bounded inline edit, the diff as your veto, and the four beats - read, propose, review, commit - worn into rhythm. Modes named the latitudes - the built-ins Agent, Ask, Plan, and Debug (as of September 2026) - and the judgment of matching posture to stakes. Context showed what the agent sees: a local search index, self-gathering retrieval, and @-pinning (fixing files into its context with @-mentions) held back for the moments a wrong guess would be expensive. Models put a meter on the engine - Auto for the everyday, a stronger model where reasoning pays, billing read off the plan rather than assumed. Rules stopped the re-teaching: conventions written once into .cursor/rules/*.mdc and AGENTS.md, loaded every session. Permissions set the blast radius on purpose - the OS-enforced sandbox as the wall, allow/deny lists as policy, instructions as guidance. Parallel & remote agents multiplied the work safely: worktree fan-outs, delegated subagents, Cloud Agents off your machine. Extending gave the agent reach and structure - MCP servers past the repo, skills and commands for what repeats, hooks as the gate that runs whether or not the model cooperates. And the CLI, headless & CI took the whole thing out of the editor: agent -p in scripts, a read-only check gating CI, Cloud Agents spawned over the API, Bugbot reviewing every pull request. That is the editor-first → headless progression this course was built around - and this last chapter smoothed it into reflex: posture by instinct, surface by shape, briefs that can’t be misread.

Where it mirrored the spine, and where it diverged

This course rides the same teach-by-doing spine as its siblings - one carried example project, each primitive introduced exactly when the work demands it - and the Codex course runs a project of the same name and shape (a Python one there, TypeScript here), so you can read the two side by side and see the primitive underneath the tool’s spelling of it. Rules are rules whether they live in AGENTS.md or .cursor/rules/*.mdc. A read-only exploration posture is the same discipline whatever the tool calls it. The four-part brief - goal, context, constraints, completion criteria - travels unchanged. Learn the discipline once and you carry it across all of them.

Where Cursor diverged from that spine is worth naming, because it’s the reason this course was written at all. The other tools in this family are terminal-first; Cursor is a GUI editor that grew a CLI, and that inverts the arc. You started on the most interactive surface there is - Tab completions and an Agent sidebar - and moved outward toward autonomy: watching every diff, then fanning agents across worktrees, then handing branches to Cloud Agents, then gating CI on an unattended run. The moves that inversion forced - Auto routing on a plan-dependent billing structure, self-gathering context, planning with one model and building with another, the four-surface choice (editor, CLI, worktrees, or cloud) - are moves a terminal-first tool simply doesn’t have to make. The discipline mirrored the spine; the surface of it was Cursor’s alone.

The whole job

Strip away the tool and every chapter was teaching one move under four principles. The agent is extraordinary at the general - broad, fast, fluent across languages and frameworks - and blind to the particular: it doesn’t know your codebase, your conventions, your domain, or that on budgetcli money is integer cents and never a float. You are the inverse - slower, narrower, but you know all of that cold. Capability is what the agent brings to that gap; context is what it is missing; control is how you bound what it does with both; cost is what every attempt spends while you do it. Every move in this course was one of the four: rules, briefs, and skills feed it context; modes, permissions, and hooks bound it with control; model choices spend capability exactly where it changes the answer - and the meter runs the whole time.

That’s the discipline. Not a keystroke, not a clever command - closing the gap between what you know and what the agent knows, on purpose, every time. By now none of the moves should feel like steps; making the deliberate automatic was the point of a workflow chapter. The reflexes are yours, worn in by your own corrections on real code. Now go close the gap somewhere it matters.

---

For the spec-level other half - the exhaustive “what is this primitive and every option it takes” view this course stayed deliberately light on - see the per-tool reference pages and Cursor’s own docs at cursor.com/docs. This course taught you the practice; that’s the reference.