Tab in full: predictions, jumps, and partial accept

Tab gets a lesson of its own because it’s the gesture you’ll fire more often than any other, 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, “Tab is Cursor’s AI-powered autocomplete. It suggests code as you type, based on your recent edits, surrounding code, and linter errors” (Tab completion docs, as of September 2026) - 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 behaviors are worth knowing by name, because each one changes what you stop typing.

Next-edit 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. Per the docs, “After you accept a Tab suggestion, press Tab again. Tab predicts your next editing location and jumps there.” On budgetcli - the course’s illustrative personal-finance API - rename acct to account in a 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). Because accepting is otherwise one keystroke, it’s easy to Tab through three suggestions on autopilot and look up at code you didn’t intend to write; partial accept is the antidote when the first few words of a suggestion are right and the tail is a plausible-but-wrong default - take the good part, type over the rest.

# Illustrative: partial accept on budgetcli. Tab offers the whole
# line; the field name is right, the default is wrong (you want 0):

  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

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.

Try it

Place your cursor inside a function and start typing a new variable name. Watch Tab suggest the next edit - accept with Tab, reject by typing. Try a partial accept (Cmd+→ / Ctrl+→) on a multi-line suggestion.

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: inline edit, the bounded local edit.