Daily workflow

By the time you reach this chapter you have, in your hands, every move Cursor makes on budgetcli. You inherited a friend’s weekend project — a small self-hosted budgeting API, lightly documented, holding your own money — and over the week you turned it into something you trust. You shipped a first reviewed change from the Agent sidebar, learned to switch posture with Shift+Tab, dialled the model up and down, wrote the project’s standing facts into rules, steered what the agent sees with @-tags and self-gathering retrieval, set the blast radius with the sandbox, fanned a single prompt across parallel worktrees, and pushed async work onto a Cloud Agent. The primitives are all learned. Nothing below is new.

What’s left is the gap between knowing a move and reaching for it without thinking. That gap is real, and it’s where most of the day-to-day friction of working with an agent actually lives. You know you should be in a read-only posture while you explore, but flipping the mode is a step, so you don’t, and one day the agent edits a shared module while you were only trying to understand it. You know Auto is the right default and a frontier model is for the hard call, but under time pressure you leave whatever was last selected and either overpay or under-think. The primitives were the hard part to learn. Making them automatic is the hard part to keep.

This chapter is about closing that last gap — turning the deliberate moves of the week into reflexes you don’t have to summon — and then looking back across the whole arc to see what the week actually taught.

The reflexes worth wearing in

A reflex is a primitive you’ve stopped narrating to yourself. Here are the ones that pay off most on a tool that lives in both a GUI editor and a terminal.

Shift+Tab: Plan, then build

The single highest-leverage reflex is the posture switch. You met it in the modes chapter: Shift+Tab from the chat input rotates the agent’s mode — Cursor’s own docs describe pressing Shift+Tab to rotate to Plan Mode — and the natural rhythm of one task is to climb the ladder of latitude — Ask to understand unfamiliar code, Plan to design the approach, then Agent to build it.

The reflex isn’t the keystroke — it’s reaching for it before you type, not after a run has already gone somewhere you didn’t want. The tell is the shape of the change in front of you. A contained fix in a file you own goes straight to Agent. A change that reaches past the file in front of you — a shared module, a schema, anything a half-dozen things depend on — gets Shift+Tab to Plan first, every time, without you deciding to. The person who’s merely installed Cursor leaves it in Agent and hopes. The person who’s good with it feels which detent the task is asking for and switches before the first word.

The split-model trick from the modes chapter is part of this reflex too: Cursor 2.0 lets you create the plan with one model and build it with another, so when a task is worth planning, plan it with a frontier reasoning model and hand the written-down plan to a faster one to build. The plan is an editable markdown artifact, so the builder needs the plan, not the planner’s reasoning context.

Tab vs Agent vs @-pin: three tools for three moments

You met all three early. The reflex is using the cheapest one that fits, without thinking about which.

• Tab is for the keystrokes you were already going to make. Inline completion that predicts your next edit and is accepted with the Tab key. When you already know exactly what you’re typing and just want it faster, you don’t open a chat — you let Tab finish the line.
• Agent chat is for the work you’d rather describe than type. When the outcome is clear but the keystrokes aren’t, you hand it a brief and review the diff.
• @-pinning is the exception, not the default. Since Cursor 2.0 the agent self-gathers context without needing you to manually attach it — it greps and reads to find what it needs, so you rarely have to point, with @-mentions still there as a manual override. The reflex is to let it self-gather first, and reach for an @-tag only when you can see it guessed wrong: it’s reading the wrong file, missing the one that matters, or working a large repo where retrieval lands somewhere unhelpful. Pin to correct a miss, not as a ritual before every prompt.

Model posture as a habit

The reflex from the models chapter is to default to Auto and reach for a frontier model only where the reasoning pays. Auto lets Cursor select models that balance intelligence, cost efficiency, and reliability, and it draws from the discounted “Auto + Composer” pool — the one with significantly more included usage. For the bulk of budgetcli work — a CRUD endpoint, a docstring, a fixture, a rename — Auto is the right call and you shouldn’t be thinking about model names at all.

You break that default deliberately, not by accident. The categorisation rules engine — the one piece of budgetcli where a wrong design call is expensive to undo — is where you hand-pick a frontier reasoning model and, where it helps, MAX Mode, which extends the context window to the maximum a model supports and bills that request on token-based pricing at the model’s API rate. The habit is: Auto for everyday, a frontier model plus MAX where reasoning genuinely pays, and back to Auto the moment the hard part is done. The failure mode isn’t picking wrong once; it’s leaving the expensive model selected for the next twenty trivial turns because you forgot to switch back. And don’t assume MAX is always a toggle you control: on request-based plans some frontier models require Max Mode, so it isn’t always an opt-in you can turn off per request.

Cost-awareness across the two pools

The reason the model habit matters in money terms is that Cursor meters usage across two different pools, and the reflex above keeps you in the cheaper one by default. The discounted “Auto + Composer” pool — where Auto and Cursor’s own Composer family live, with significantly more included usage — carries the bulk of your work. The separate API pool bills at each model’s standard API rate, and that’s where MAX Mode and the frontier models draw from.

You don’t need to do arithmetic in your head. The reflex is just directional: the everyday pool is cheap and you live there; the API pool is where the spend concentrates, so the moves that bill from it — MAX Mode, frontier models, long-context runs — are the ones you make on purpose for the work that earns it, not by leaving an expensive selection in place. To get a directional read rather than guess, the CLI has a /usage slash command that surfaces your usage stats and streaks — not an itemised per-token cost breakdown, but enough to see your habits instead of assuming them.

Choosing the surface: editor, CLI, multi-agent, Cloud Agent

Cursor is unusual among the tools in this course because it’s genuinely both a GUI and a CLI, plus two flavours of parallel agent. The reflex is matching the shape of the task to the shape of the surface, and you’ve now used all four:

• The editor (Agent sidebar) — for interactive work where you want to watch the diff form and stay in the loop. This is the default and where most of budgetcli got built. Reach for it when you’ll be reviewing closely and iterating.
• The CLI (agent) — for batch and scripted work. The same agent, headless, driven from the terminal or CI (the executable is agent; cursor-agent is the legacy alias you’ll still see in older forum threads). When the job is “run this prompt over a list” or “wire a check into the pipeline,” it belongs here, not in a chat window you have to babysit.
• Multi-agent worktrees — for parallel, competing attempts. From the Composer chapter: fan one prompt across several agents, each in an isolated git worktree, then merge the winner. Reach for it when an approach is genuinely uncertain and you’d rather see three real attempts than argue one in your head.
• Cloud Agent — for async, meeting-time work. A full agent in an isolated cloud VM that clones the repo to a separate branch, runs, and pushes results as a PR, reachable from Cursor Desktop, Cursor Web, Slack (@Cursor), or a GitHub PR/issue comment (@cursoragent there, not @cursor) — and that surface list keeps growing (Linear and an API are in there too). Reach for it when the task is well-specified, you don’t need to watch, and you’d rather come back to a branch than sit through the run.

Install the CLI with curl https://cursor.com/install -fsS | bash. The multi-agent worktree fan-out is a Cursor 2.0 capability — one prompt across several agents, each in its own isolated git worktree — and Cloud Agents are the renamed Background Agents, run in isolated VMs and pushed back as PRs.

The pattern underneath: interactive → editor, batch → CLI, parallel/uncertain → multi-agent, async/unwatched → Cloud Agent. Once that mapping is reflex, you stop defaulting everything into the sidebar and start putting work where it runs best.

Rules, skills, and commands: the muscle memory written once

The reflexes above are about you. The next layer is muscle memory you write into the project so you stop re-typing it. You built all three earlier in the week:

• Rules (.cursor/rules/*.mdc and AGENTS.md) — the standing facts the agent reads every session. On budgetcli: money is integer cents, never float; the category taxonomy; dates stored in UTC. Written once, applied every time.
• Skills — a packaged procedure the agent invokes on its own. The per-bank CSV import — a different shape for every bank, the same steps every time — is the canonical one.
• Commands (.cursor/commands/[command].md) — markdown templates for the chores you re-type. The monthly-report draft, the same “scan the importers for the date-parse pattern” sweep.

Each layer reads from a known place: project rules live in .cursor/rules as version-controlled .mdc files and AGENTS.md is supported natively as a simpler alternative; glob-based rules auto-attach when a matching file is in context. A skill is a folder containing a SKILL.md file (Skills landed in Cursor 2.4, with a built-in /migrate-to-skills to bring older procedures across). Commands are stored as .cursor/commands/[command].md, a convention that arrived in Cursor 1.6.

The reflex is the trigger for writing one: when you catch yourself typing the same convention into a third prompt, it belongs in a rule, not the prompt. When you run the same multi-step chore a third time, it belongs in a command or a skill. You don’t write these up front — you write them the moment the repetition makes itself felt, because only then do you know which chores actually repeat.

One caveat to carry: rules don’t fire as reliably as you’d hope. A glob-scoped rule only attaches when the matching file actually enters the agent’s context — pulled in by an @-mention or because the agent itself decided to read it — not merely by being open in your editor, which is a behaviour change from Cursor 1.x where having the file open was enough. So you can have a perfectly scoped rule, watch the agent edit a matching file, and still not get the rule, because that file never entered the agent’s working context. So treat globbed rules as strong defaults, not hard guarantees, and keep the load-bearing ones (the money-is-cents kind) in an always-on layer — an Always rule or a line in AGENTS.md — stated plainly.

A note on the temptation to bundle all of this into one shareable package: Cursor has no formal “plugin” abstraction that wraps rules + skills + hooks + commands together. Sharing a Cursor configuration today means sharing the relevant .cursor/* files directly. A community feature request for exactly such a bundle exists, but it is not a shipped surface — don’t build a workflow around one until it is.

Briefing the agent well

The reflexes set the posture and the surface. The brief is the steering — and on budgetcli a vague brief steers you somewhere you didn’t want to go.

Here’s the difference that catches people. In a chat, a vague question is cheap: you read the half-useful answer and ask again, a few seconds lost. With an agent, a single prompt can trigger a chain — read the categorisation rules, run the tests, edit four files, run them again — that grinds for minutes before it surfaces anything you can review. By the time an ambiguous instruction bites, the agent has already touched files on a guess. Vagueness didn’t cost a re-ask; it cost a run and a diff you now have to unpick. The skill is reducing ambiguity before execution, not correcting it after.

A brief the agent can’t misread carries the same four parts every time — no template, no headings, just don’t leave one out:

1. Goal — what done looks like in one concrete sentence, with an outcome verb. Not “look at the CSV importer,” but “add support for the Monzo statement format to the CSV importer.”
2. Context — the framework and an analogous bit of the codebase to copy. “Same service; follow the pattern in importers/barclays.py.” A pointer to real code is worth a paragraph — the agent reads the reference and matches it.
3. Constraints — what not to do. “No new dependencies, don’t touch the accounts schema, money stays integer cents.” The off-limits list is where most wrong-but-reasonable runs come from.
4. Completion criteria — a check it can actually run. “A Monzo export imports clean and pytest tests/importers/ exits zero.” Now it knows when it’s finished instead of when it’s tired.

Most of this only needs saying once. The durable stuff — money is cents, the taxonomy, the test command, the off-limits files — already lives in your rules, and the agent reads it at session start. Your per-task prompt carries only what’s specific to this task. If you catch yourself re-typing a convention, that’s the trigger from the last section: it belongs in a rule, not the prompt.

Stop and rewrite, don’t nudge

When a run heads somewhere wrong, the instinct is to nudge it back — “no, not like that, do it this way.” Sometimes that works. But when the run went wrong because your prompt had two valid readings and the agent picked the one you didn’t mean, nudging is the slow road: you’re correcting on top of a foundation built from the wrong interpretation, and each correction inherits the original ambiguity.

The faster move is to stop, throw the run away, and rewrite the brief so the reading you wanted is the only one left. Interrupt immediately — the longer a misread run goes, the more diff you discard. Then write a fresh prompt with the same four parts, the ambiguous one nailed down: “the running balance is per-account, not the sum across accounts” stated up front rather than discovered three corrections in. A clean restart from a sharper brief beats five rounds of “no, the other thing,” because the ambiguity was a bug in the prompt, not a failing of the agent.

This is also why the Ask and Plan postures earn their place. When you’re still figuring out what to ask for, explore in Ask — read-only, nothing can move while you learn — then drop to Plan or Agent once the brief is sharp enough to commit to. The cost of a misread is zero when nothing was changed.

A look back across the week

That’s the last of the friction. Before you close the course, look back at the week — because the shape of the arc 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 with a repo you didn’t write. budgetcli came to you as a friend’s weekend project — lightly documented, holding the promise of your own money but not yet trustworthy enough to do it. Over the chapters you turned it into something you’d actually run.

You installed Cursor — the VS Code you already knew, with AI bolted on — and shipped a first reviewed change, the CSV date-parse fix, so you’d seen one full turn of the loop before anything was at stake. You learned the four modes and the Shift+Tab ladder from Ask to Plan to Agent. You picked models with intent — Auto for the everyday, a frontier model where the categorisation engine’s design actually paid for the reasoning. You steered context — letting self-gathering retrieval find what it needed and @-pinning only to correct a miss. When Cursor kept reintroducing the float-money bug and the wrong taxonomy, you stopped re-explaining and wrote it down once in rules. You set the blast radius — the sandbox as the load-bearing control, the allowlist superseded by the sandbox into friction-reduction and the denylist deprecated. You fanned work across parallel worktrees and pushed async work onto a Cloud Agent, three flavours of more-than-one-agent that are not the same primitive in three hats. And in this last chapter you smoothed all of it into reflex — posture by instinct, model by habit, surface by task shape, briefs tight enough that runs go where you meant.

Where it mirrored the spine, and where it diverged

This course rides the same teach-by-doing spine as its siblings — one inherited repo, one week, each primitive introduced exactly when the work demands it — and budgetcli is the same project the Codex course runs on, on purpose, 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’re AGENTS.md or .cursor/rules/*.mdc. A read-only exploration posture is the same discipline whether it’s Cursor’s Ask mode or Codex’s read-only profile. Brief the agent the same four ways in either. 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 in an editor — Tab completions and an Agent sidebar, the most interactive surface there is — and the week moved outward toward autonomy: from watching every diff, to fanning parallel agents across worktrees, to handing a Cloud Agent a branch you’d review when you got back. The editor-first → agents → headless progression is Cursor’s own, and the two-pool cost model, the self-gathering context, the split-model planning, and the four-surface choice 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 taught one thing. AI coding agents are extraordinary at the general — broad, fast, fluent across languages — and blind to the particular: they don’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. Every move in this course was a way to hand the agent the context it was missing: rules that persist it, skills that package it, modes that bound it, briefs that aim it.

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. That’s the whole goal of a workflow chapter: to make the deliberate automatic. The reflexes are yours, worn in by your own week of corrections on a repo you’ve turned from someone else’s weekend project into a service you trust with your own money. 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 story 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.