Cursor has two brains: knowing when to Tab and when to delegate
Cursor writes code for me two different ways, and treating them as one feature with a volume knob is the quickest way to waste an afternoon in it. Tab is the fast one: inline, multi-line prediction where I stay the driver and it finishes the thought I already started. Composer is the slow one: an agent that takes a bounded task, edits across a few files, runs commands, and hands me a diff to read.
They sit right next to each other in the editor. They are actually two different jobs.
the mistake I keep re-making
The error I make most is reaching for the agent when the job wanted two keystrokes. One Tuesday night I carefully described a mechanical rename to Composer, watched it think, then reviewed a diff, for a change that Tab would have finished in three taps while my hands were already on the keys. I felt clever setting up the agent and slow every step after. The reverse bites too: staying in Tab, hand-editing my way across eleven files for a refactor that Composer should have simply owned, because I was in flow and did not want to stop and write a brief. Both mistakes come from the same place, picking the mode by habit instead of by the shape of the task in front of me.
how I actually decide mid-task
The question I have learned to ask is who should be holding the keyboard for the next minute. If I know the exact edit and my cursor is already there, that is Tab, and reaching for the agent just adds ceremony to something my hands could finish faster. If the change is bounded but spans files, and I would genuinely rather review than type it all out, that is Composer. The real tell is whether I can see the whole edit in my head. When I can, I drive. When I can only see the goal and not every keystroke to get there, I delegate and shift into reviewing.
Tab is a conversation with my own hands; Composer is a conversation with a fast junior who needs a clear brief and a careful read of the result.
the altitude you review at
The part people miss is that the two modes ask for completely different kinds of attention. Tab I review at the character level, inside the flow of typing, catching a wrong variable the instant it appears. Composer I review at the diff level, a different altitude entirely, and that is where the real risk lives: a plausible-looking diff is far easier to wave through than a wrong character sitting right under my cursor. That review discipline is the actual skill, and it is the same one I keep banging on about in designing the human in the loop. Get the altitude wrong and the agent's speed just helps you ship a mistake faster.
So I hold both modes in my hands at once now, the way you hold a pencil and an eraser, and the switch has stopped being a decision I even notice. It is the single habit that separates people who feel fast in Cursor from people who only feel busy in it, which is most of what I like about the editor and a fair bit of what I mean when I talk about coding with agents honestly.