Tab in full: predictions, jumps, and partial accept

Tab, in full: the signature primitive

Tab gets a lesson of its own because it’s the gesture you’ll fire more than every other one combined, and because it’s the thing Cursor does that a terminal agent structurally can’t: it lives at the cursor, predicting your keystrokes inside the file you’re already looking at. Per Cursor’s docs it’s “Cursor’s AI-powered autocomplete” that “suggests code as you type, based on your recent edits, surrounding code, and linter errors” - that last clause is the tell. Tab isn’t autocomplete reading a dictionary; it’s reading what you just did and guessing the next thing in that arc.

Four behaviours are worth knowing by name, because each one changes what you stop typing.

Next-edit / jump prediction. Tab doesn’t only complete where your cursor sits - it predicts the next location you’ll want to edit and offers to jump there. Accept a suggestion, and Tab can immediately point you at the next spot (“jump-in-file”): press Tab again and your cursor moves there with the next edit already staged. On budgetcli, rename acct to account in the type and Tab will walk you through the other use-sites in the function, jump by jump, each one a single keystroke - you’re not searching, you’re confirming.

Multi-line and coordinated edits. A suggestion isn’t capped at finishing the current line. Tab “can modify multiple lines, add missing import statements, and suggest coordinated edits across related code.” Add a field to budgetcli’s Account type and Tab can propose the matching change in the constructor below and pull in an import you now need - several lines at once, as one ghost-text block you accept or reject whole.

Cross-file completions. When an edit in one file implies an edit in another, Tab predicts it. Per the docs, “Tab predicts cross-file edits when changes in one file need updates in another. When a jump to another file is available, a portal window appears at the bottom of the editor.” Change a function signature in budgetcli’s src/importers/importer.ts and Tab can surface a portal to the call-site in src/report/report.ts that now needs updating - you jump across the file boundary without leaving the keyboard.

Partial accept. You don’t have to take the whole suggestion. When Tab offers more than you want, accept it word-by-word with Cmd+→ (macOS) or Ctrl+→ (Windows/Linux), taking the half you agree with and typing over the rest. This is the antidote to the autopilot problem the chapter intro warned about: when the first few words are right and the tail is a plausible-but-wrong default, partial-accept keeps the good part without committing to the guess.

# budgetcli - partial accept in action. Tab offers the whole line;
# the field name is right, the default is wrong (you want 0, not -1):

  const limit = account.overdraftLimit   ← Tab's full suggestion (ghost)
  const limit = account.overdraftLimit   ← Cmd/Ctrl+→ twice: take "const limit ="
                                            then type your own RHS

  result:  const limit = 0

Tab in the terminal. Cursor’s integrated terminal also has a one-chord, natural-language path: press Cmd+K (macOS) / Ctrl+K (Windows/Linux) in the terminal and describe the command in English - “run only the report tests” - and Cursor drafts the shell command for you to run.

When Tab beats inline edit and the Agent

Tab wins whenever the change is already legible in your hands - you know the next keystrokes, you just want them typed for you. The signal is that you’d have started typing anyway: a rename mid-edit, the symmetric half of a branch, the next field in a list, the call-site that obviously follows the signature you just changed. There’s no prompt to write because there’s no instruction to give; Tab reads the trajectory and finishes it.

It loses the moment you’d have to stop and describe the change. If the words “make it…” or “extract…” or “handle the case where…” form in your head, you’ve left Tab’s territory: a described-but-not-typed local edit is Cmd+K inline edit, and a described outcome that has to find its own files and run its own checks is the Agent. Tab also can’t be told anything - it has no prompt box - so any change that needs an instruction, however small, is already a rung up.

The cheap heuristic, course-wide: if your fingers already know the edit, Tab; if your words do, inline edit; if only the outcome does, the Agent. Tab is the floor of that ladder and where most of your day is spent - but only because most edits, on a repo you’re actively reading, are ones your fingers already know.

Tab covers every edit your fingers already know. The moment you’d have to stop and describe the change instead, you’ve stepped up one rung. Next: the bounded local edit.