Core Features: Tips 16-30

You have Cursor installed and configured. Auto-Run is on, project rules are committed, indexing is complete. But you are still using Cursor like VS Code with a chat sidebar — typing code by hand, running commands manually, and occasionally asking the AI a question. That is like buying a sports car and only driving it in first gear. These 15 tips cover the features that make Cursor fundamentally different from a normal code editor.

What You Will Walk Away With

• The three keyboard shortcuts that handle 80% of your AI interactions (Tab, Cmd+K, Cmd+I)
• Terminal AI commands that eliminate memorizing obscure CLI flags
• Navigation techniques that let you jump to any symbol, file, or concept in seconds
• A commit message workflow that writes itself
• How Bugbot reviews your pull requests and catches bugs before a human reviewer does

The Three Shortcuts That Matter Most

Tip 16: Master the Tab Key for AI Completions

Tab in Cursor is not regular autocomplete. It is multi-line, context-aware prediction that understands your project structure. The key behaviors to internalize:

• Single Tab: Accept the full suggestion
• Escape: Dismiss the current suggestion
• Alt+] / Alt+[: Cycle through alternative suggestions
• Tab after Tab: Cursor sometimes chains suggestions — after accepting one, it immediately offers the next logical edit

The confusing part for new users is that “Tab” sometimes completes code and sometimes jumps you to the next edit location. This is intentional. Cursor predicts not just what you will type, but where you will type next. Trust the flow and you will find yourself navigating through a chain of related edits without touching the mouse.

Tip 17: Use Cmd+K for Targeted, Single-File Edits

Cmd+K (macOS) or Ctrl+K (Windows/Linux) opens inline edit mode. Its behavior changes based on context:

• With code selected: Rewrites the selection based on your instruction
• With cursor on an empty line: Generates new code at that position
• With cursor inside a function: Understands the surrounding context for more accurate edits

The key advantage over agent mode is speed. Cmd+K knows it only needs to modify the selected code, so it responds faster and with more precision. Use it for surgical edits where you can point at exactly what needs to change.

Cmd+K prompt for adding error handling to a function

Select the function body, then press Cmd+K and type:

Add try-catch error handling. Log the error with the function name as context, then re-throw with a descriptive message. Use the project’s existing error logging pattern if visible in nearby files.

Tip 18: Use Cmd+I to Open the Agent Panel

Cmd+I (macOS) or Ctrl+I (Windows/Linux) opens the agent/chat panel. If you have code selected when you press it, that code is automatically included as context. This is the entry point for multi-file operations.

Four modes are available, and you rotate through them with Shift+Tab (or the mode dropdown):

• Agent (default): Autonomous editing across files, can run commands, iterate on errors
• Ask: Read-only, for questions and exploration without modifying files
• Plan: Researches the codebase, asks clarifying questions, and produces an editable plan before building it
• Debug: Generates hypotheses and instruments code with log statements to pin down tricky, hard-to-reproduce bugs

Default to Agent mode for everyday work. Reach for Plan mode on complex, multi-file features, Ask mode when you only want to discuss code, and Debug mode for regressions and race conditions.

Terminal Superpowers

Tip 19: Use Cmd+K in the Terminal for AI Commands

This is one of the most underused features. Press Cmd+K while your cursor is in the integrated terminal, and Cursor gives you an AI prompt for terminal commands. You describe what you want in English; it generates the command.

# Instead of remembering:
git log --oneline --graph --all --decorate -20

# Type in the Cmd+K terminal prompt:
# "show my last 20 git commits as a graph with branch names"

# Instead of looking up:
find . -name "*.ts" -not -path "*/node_modules/*" | xargs grep "TODO"

# Type:
# "find all TODO comments in TypeScript files, excluding node_modules"

This is not a toy feature. Senior engineers report saving 10-15 minutes per day on command lookups alone. Stop memorizing git flags and Docker CLI arguments.

Tip 20: Let the Agent Fix Build Errors Automatically

After a coding session, instead of manually hunting down TypeScript errors, let the agent handle it:

Copy-paste prompt for fixing build errors

Run tsc —noEmit to see all TypeScript errors. Fix each error, then run tsc again. Keep iterating until the build passes cleanly. Do not change any public API signatures — only fix internal type issues.

With Auto-Run enabled (formerly called YOLO mode), the agent runs tsc, reads the errors, fixes them, re-runs tsc, and repeats until zero errors remain. This works with any build tool — npm run build, cargo check, go vet, pytest.

Tip 21: Create a Pre-PR Validation Prompt

Keep a reusable prompt for the final check before opening a pull request:

Copy-paste pre-PR validation prompt

Run these commands in sequence and fix any issues found:

1. pnpm run typecheck
2. pnpm run lint
3. pnpm run test

Fix all errors from each step before moving to the next. Do not modify test assertions — only fix the source code that causes failures. After all three pass, give me a summary of what changed.

Save this as a .md file in your project and reference it with @ whenever you are ready to submit a PR. Some developers call this their “ship it” prompt.

Navigation and Search

Tip 22: Use Semantic Search Instead of Text Search

Cursor’s search understands meaning, not just strings. In the agent panel, describe what you are looking for in natural language:

Where is the function that handles user authentication and generates JWT tokens?

This finds the right code even if the function is named createSession or issueToken — terms you would never match with a text search for “authentication.”

For precision, combine semantic and text search. The agent can run grep for exact matches while using its own understanding for conceptual matches.

Tip 23: Use @ References for Precision Context

In any agent conversation, type @ to reference specific context:

• @Files & Folders — Include a specific file or an entire directory (type @ then the name)
• @Code — Reference a precise function, class, or snippet rather than a whole file
• @Docs — Reference indexed documentation (built-in libraries or your own added docs)
• @Past Chats — Pull in context from an earlier conversation

The more specific your context, the more accurate the response. Instead of “fix the auth bug,” try “fix the auth bug in @src/middleware/auth.ts — the token validation on line 42 is not checking expiration.”

For web and git context, you no longer attach a token. Cursor 2.0 removed the explicit @Web and @Git mentions; the agent now self-gathers both from plain-language requests — ask it to “search the web for the latest tRPC v11 router syntax” or to “review the changes on my branch,” and it fetches docs or runs git on its own.

Tip 24: Navigate with Go To Symbol

Cmd+Shift+O opens Go To Symbol in the current file. From the editor, Cmd+T opens Go To Symbol across the entire workspace — a standard VS Code shortcut that works the same in Cursor, and faster than scrolling or searching when you know the name of what you are looking for. One gotcha: when your focus is in the chat input, Cmd+T opens a new chat tab instead, so run the symbol search from the editor pane.

Tip 25: Use Quick Open to Jump Between Files

Cmd+P opens Quick Open, the fastest way to switch files. Start typing the filename and it fuzzy-matches instantly. Add : followed by a line number to jump directly to a specific line: Cmd+P then auth.ts:42.

Safety and Version Control

Tip 26: Understand the Checkpoint System

Every time the agent makes changes, Cursor creates an automatic checkpoint. This is your safety net for aggressive experimentation. If the agent goes off track:

1. Look at the checkpoint indicator in the agent panel
2. Click “Restore” on any previous checkpoint to roll back all changes since that point
3. Adjust your prompt and try again from a known-good state

Checkpoints are faster and more granular than git stash or git checkout. Use them liberally. The mental shift is important: with checkpoints, you can tell the agent “try this risky approach” knowing you can undo it in one click.

Tip 27: Generate Commit Messages Automatically

In the Source Control panel (the git sidebar), click the sparkle icon next to the commit message input. Cursor reads your staged changes and generates a commit message. It is not always perfect, but it is a solid starting point that you can edit in 5 seconds instead of writing from scratch.

For better results, stage your changes incrementally (smaller, focused commits) rather than staging everything at once. The AI generates better messages when the diff tells a coherent story.

Tip 28: Let Bugbot Review Your Pull Requests

The old local “Bug Finder” command was replaced by Bugbot, Cursor’s automated PR reviewer for GitHub and GitLab. Once enabled at cursor.com/dashboard, Bugbot reviews each pull request and leaves inline comments flagging real issues:

• Missing null checks and unhandled edge cases
• Inconsistent error handling and type-narrowing gaps
• Security problems and off-by-one errors in loops

Each finding comes with Fix in Cursor and Fix in Web links so you can jump straight to a fix. You can trigger a review on demand by commenting cursor review or bugbot run on the PR, and steer it with project rules in .cursor/BUGBOT.md files (checked into the repo, applied per directory). Think of it as a free first pass of code review before a teammate looks.

If you want a pre-PR check on your local changes instead, ask the agent to review your branch directly, or run Debug mode for a tricky bug — both work before anything is pushed.

Daily Workflow Patterns

Tip 29: Use Plan Mode for Architecture Planning

Before starting a complex feature, switch to Plan mode (Shift+Tab) and let Cursor research the codebase, ask clarifying questions, and produce an editable plan you can then build with one click. For a lighter-weight, read-only pass where you just want to discuss an approach without Cursor offering to build it, Ask mode works too. The same planning prompt fits either mode:

Copy-paste architecture planning prompt

I need to add real-time notifications to this application. Look at @src/lib/ and @src/api/ to understand the current architecture. Suggest an implementation plan that:

1. Lists the files that need to change
2. Defines the data flow from event source to UI
3. Identifies potential issues with the current architecture
4. Recommends which parts should use server-sent events vs WebSockets

Do not make any code changes. Just give me the plan.

In Plan mode you click to build the plan directly; in Ask mode, start a new agent conversation and reference the plan as context. Either way, this plan-then-build approach produces dramatically better results than jumping straight to implementation.

Tip 30: Use Images as Context for UI Work

Cursor supports image input in the agent panel. Drag and drop a screenshot, a Figma export, or a mockup, and the agent can use it as a reference for generating UI code.

This is particularly powerful when combined with a .cursorrules file that specifies your design system. The agent will attempt to map the visual design to your project’s actual components, spacing tokens, and color variables — not generic CSS.

Paste screenshots of bugs too. Instead of describing “the button overlaps the card on mobile,” drop a screenshot and say “fix this layout issue using the project’s existing responsive breakpoints.”

When This Breaks

Cmd+K generates wrong code: The most common cause is insufficient context. If you select a function body but the function depends on imports or types defined elsewhere, Cmd+K does not see those dependencies. Solution: include the relevant imports in your selection, or switch to agent mode which can read the full file.

Terminal Cmd+K generates a wrong command: The AI does not know your shell configuration. If it generates npm commands when you use pnpm, add “use pnpm for all package manager commands” to your global user rules (Tip 15).

Bugbot produces false positives: It can over-report on intentional patterns like deliberately unused variables or deliberate type widening. Treat its inline comments as suggestions, not requirements — fix what is obviously correct and resolve the noise. Encode your intentional patterns in a .cursor/BUGBOT.md rules file so future reviews stop flagging them.

Checkpoint restore leaves files in a weird state: If a checkpoint restore seems incomplete, check that all relevant files were tracked. Files that the agent created (rather than modified) sometimes need to be manually deleted after a restore.

What is Next

You now have the core feature set down. Move to Tab Autocomplete (Tips 31-45) to learn how to push Tab completion from “nice to have” to “types half my code for me.” The tab experience improves dramatically once you understand the prediction model and learn to guide it.