The daily edit loop

Day-to-day work in an editor is not one big delegated task after another. It is dozens of small turns - read what is there, make a change, review it, keep it - against a codebase you are actively reading and editing. The course’s illustrative repo, budgetcli - a small self-hosted personal-finance API that imports bank CSVs, tracks accounts, and flags overspend - stands in for exactly that work: it is full of the small, real, slightly-wrong things you keep finding in code you didn’t write. Most of them are too small to summon the Agent for and too fiddly to type by hand. The whole day-to-day of working in Cursor lives in that gap, and it lives there because Cursor is an editor and not a CLI. A terminal agent has one surface: the prompt. Cursor has the prompt and the cursor - the blinking one, in a file you’re looking at - and the skill this chapter builds is knowing, without thinking, which one a given edit wants.

That’s the through-line: not new capabilities, but a loop - read what’s there, propose a change, review the diff it produces, commit when it’s green - small enough to run dozens of times a day. Walked through once, slowly, it is a ceremony (the getting-started chapter does exactly that); run all day, it has to be a reflex, and the editor gestures in this chapter are what make each turn of it cheap.

The two daily surfaces

Everything you do all day routes to one of two surfaces, and they are not two flavors of the same thing. They’re two different tools for two different moments (feature names, shortcuts, and behavior as of September 2026; Tab documentation, Agent documentation).

• Tab - Cursor’s AI-powered autocomplete. As you type, it predicts the next edit and shows it as ghost text; you press Tab to accept it. It is not agentic - there’s no loop, no tool calls, no “it’ll figure it out.” But it’s no longer just finishing the rest of an identifier: Tab predicts multi-line edits, coordinated edits across files, and the next location you’ll want to jump to. It’s the descendant of the autocomplete you already know, grown into something that anticipates the keystrokes you were about to make across more than the line you’re on.
• The Agent sidebar - the chat panel where you describe a task in English and Cursor runs the read-propose-review loop: it reads and searches the codebase, proposes and applies edits across however many files it judges relevant, and runs terminal commands. You open it with Cmd/Ctrl+I. This is the surface for the work you’d rather describe than type.

The dividing line is worth saying plainly because getting it wrong is a reliable way to be slow in Cursor: Tab is for edits you can already see in your head; the Agent is for edits you’d have to think to write. Renaming a variable you’re already mid-typing, filling in the obvious other half of an if/else, adding the third field to a struct when the first two are right above - that’s Tab. “Make the CSV date parser handle DD/MM as well as MM/DD” is the Agent. Reaching for the Agent to do a Tab-sized edit is like opening a chat to rename a local; reaching for Tab to do an Agent-sized one just means you type the whole thing yourself while ghost text guesses badly at the end of each line.

Tab is a passenger, not a driver

One habit to set now: Tab predicts, it does not decide. It will confidently suggest a completion that compiles and is wrong - the right shape, the wrong field, a plausible default that isn’t your default. Read the ghost text before you accept it the same way you’d read a teammate’s suggestion. The cost of a wrong Tab isn’t that it breaks loudly; it’s that it slips in quietly, looking like something you typed.

The moves of this chapter

• Tab - inline completion that predicts your next edit, not just the rest of your line: multi-line and cross-file suggestions, next-edit jumps, and partial accept - Tab in full: predictions, jumps, and partial accept
• Inline edit - the bounded local change, scoped to a selection you drew yourself, for when you know which lines move but don’t want to type the new version - Inline edit: the bounded local change
• @ and / - the two characters under every prompt you’ll type in the sidebar: @ hands the agent something to look at; / fires something to run - Attach or run: the @ and / split
• Review and restore - the diff as your veto, keep and undo per change, and checkpoints as the undo that understands an agent run as a unit - Review the diff, checkpoints, and restore
• The loop - the four beats, read, propose, review, commit, worn into a reflex you run all day - The four beats of the daily loop

The order runs up the ladder of surfaces - Tab at the bottom, the Agent at the top - and then back down to rhythm. The first two lessons give you the gestures your fingers and your words reach for, smallest first, because learning to reach down a rung - not up - is the habit this chapter drills. The third hands you the grammar for the top rung, so a prompt to the Agent aims at the right files instead of hoping. The fourth flips your role from author to reviewer: from there on, nothing the agent proposes lands until you’ve read it, and a wrong turn costs you a restore rather than a debugging session. The fifth names the beat all of them are moves inside. Work through them in order; the chapter has done its job when reaching for the smallest gesture that fits stops feeling like a decision.