Core Features: Tips 16-30

You have Cursor installed and configured. YOLO mode 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
• The Bug Finder feature that catches regressions before your PR review

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.

Three modes are available:

• Agent: Autonomous editing across files, can run commands, iterate on errors
• Ask: Read-only, for questions and planning without modifying files
• Manual: Direct edits with explicit control, no autonomous behavior

Default to Agent mode for everything. Switch to Ask mode only when you explicitly want to discuss code without changing it.

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 YOLO mode enabled, 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:

• @filename.ts — Include a specific file
• @foldername — Include an entire directory
• @symbol — Reference a function, class, or variable by name
• @web — Let the agent search the web for documentation
• @docs — Reference indexed documentation
• @git — Reference git history and diffs

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.”

Tip 24: Navigate with Go To Symbol

Cmd+Shift+O opens Go To Symbol in the current file. Cmd+T opens Go To Symbol across the entire workspace. These are standard VS Code shortcuts that work identically in Cursor, and they are faster than scrolling or searching when you know the name of what you are looking for.

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: Use the Bug Finder Before Opening PRs

Access Bug Finder via Cmd+Shift+P and type “Bug Finder.” It compares your changes against the main branch and flags potential issues:

• Missing null checks
• Unhandled edge cases
• Inconsistent error handling
• Type narrowing gaps
• Off-by-one errors in loops

It does not catch everything, but it catches enough to be worth the 30 seconds it takes to run. Think of it as a free first pass of code review.

Daily Workflow Patterns

Tip 29: Use Ask Mode for Architecture Planning

Before starting a complex feature, switch to Ask mode and plan the implementation:

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.

Once you have the plan, start a new agent conversation and reference the plan as context. This two-step approach (plan in Ask mode, implement in Agent mode) 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).

Bug Finder produces false positives: It over-reports on intentional patterns like deliberately unused variables or deliberate type widening. Treat its output as suggestions, not requirements. Fix what is obviously correct and ignore the noise.

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.