English for Cursor IDE

Cursor is a fork of VS Code built around AI as a first-class feature rather than an add-on, and describing your workflow in it precisely means distinguishing its several distinct AI interaction modes, which teammates often conflate.

Key Vocabulary

Inline edit (Cmd+K) — Cursor’s feature for describing a change in natural language directly at a specific location in the code, which then generates and applies a targeted diff at that spot, without opening a separate chat window. “I used an inline edit right on this function instead of opening chat — I described the change I wanted at that exact spot, and it generated a diff scoped to just this function, which was faster than explaining the whole context in chat.”

Agent mode — Cursor’s autonomous mode where the AI can read multiple files, make edits across the codebase, and run terminal commands to complete a multi-step task, with the developer reviewing and approving the result rather than writing each change manually. “This refactor touched twelve files, so I used agent mode rather than doing it manually — I described the goal, and it explored the codebase, made the changes across all the affected files, and I reviewed the diff before accepting it.”

Codebase-aware chat — Cursor’s chat feature that can reference and search across the actual project’s files for context, rather than only knowing what’s pasted into the conversation, letting you ask questions about code you haven’t manually included. “I didn’t have to paste in the relevant files — codebase-aware chat found the authentication logic on its own when I asked how login currently works, since it can search the actual project instead of relying only on what’s in the conversation.”

Context window — the amount of code and conversation history the AI model can consider at once when generating a response, which limits how much of a large codebase or long conversation can be factored into a single answer. “The suggestion missed an important detail because it fell outside the context window — for a codebase this large, I need to be more deliberate about pointing it at the specific files that actually matter for this task.”

Diff review — the step of examining exactly what a Cursor-generated change modifies before accepting it, especially important with agent mode, since multi-file autonomous changes can include unintended edits alongside the intended ones. “Always do a careful diff review before accepting an agent mode change — it got the main task right, but it also reformatted an unrelated file it happened to open, which I don’t want included in this commit.”

Common Phrases

• “Would an inline edit be faster here, or does this need agent mode across multiple files?”
• “Is codebase-aware chat finding the right files, or should I point it at specific ones directly?”
• “Is this suggestion missing context because of the context window limit?”
• “Have you done a diff review before accepting that agent mode change?”
• “Should we scope this task down before handing it to agent mode?”

Example Sentences

Choosing the right interaction mode: “For a change this contained, I’d just use an inline edit rather than agent mode — agent mode is better suited to multi-file refactors, and using it for a one-line fix is more overhead than it’s worth.”

Explaining a limitation to a teammate: “The AI didn’t account for that edge case because it was outside the context window it had for this request — it’s worth pointing it explicitly at the relevant validation file next time instead of relying on it to find everything.”

Setting expectations about review: “I don’t just accept agent mode changes wholesale — I always do a diff review first, since it sometimes makes a reasonable but unintended edit alongside the actual task, and I want to catch that before it’s in the commit.”

Professional Tips

• Reach for an inline edit for small, localized changes, and reserve agent mode for genuinely multi-file or multi-step tasks — using agent mode for trivial edits adds unnecessary review overhead.
• Rely on codebase-aware chat for exploratory questions about how existing code works, but be ready to point it at specific files directly when the automatic search misses relevant context.
• Keep the context window in mind for large tasks — breaking a huge request into smaller, more targeted ones often produces better results than one sprawling prompt.
• Never skip diff review on agent mode changes — treat AI-generated multi-file diffs with the same scrutiny you’d give a colleague’s pull request, not less.
• Describe your intended change precisely regardless of mode — vague prompts produce vague diffs, whether through inline edit or agent mode.

Practice Exercise

1. Explain when you’d choose an inline edit over agent mode.
2. Describe why diff review matters more for agent mode changes than for inline edits.
3. Write a sentence explaining how codebase-aware chat differs from pasting code into a normal chat window.