Cursor Tips and Tricks

Quick answer

Fifteen concrete techniques that turn a casual Cursor user into a fast one. Each tip has a one-sentence why and a direct how. Keep this page open the first week you use Cursor and pick up two tips per day. By the end of the week the habits are muscle memory. None of the tips require the Business plan; most work on free and all work on Pro.

The fifteen

1. Use @Codebase before you start writing

Before writing code for any refactor, open Chat (Cmd+L) and ask @Codebase where is authentication handled? The index search returns every file that touches the topic. You now know the blast radius before the first keystroke. This saves far more time than any autocomplete trick.

2. Checkpoints in Composer let you experiment safely

Every Composer turn creates a checkpoint. When an agent run goes sideways, click the checkpoint marker in the chat to revert just that step's file edits. Reverting a single step is much faster than a full git reset, and you keep the good earlier work from the same session.

3. Add Think step by step as a global rule

Create ~/.cursor/rules/global.mdc with a single line: Think step by step before writing code. The rule applies to every project on your machine. On complex tasks the agent's first message becomes a plan instead of a code dump, which almost always produces better final output.

4. Cmd+K beats Composer for single-file fixes

If the change is in one file and takes under 20 lines, Cmd+K on the selection is 5x faster than opening Composer. The prompt is inline, the diff is inline, the accept or reject is one key. Use Composer only when the task actually spans files.

5. Notepads hold design tokens the AI keeps forgetting

Create a Notepad called Design Tokens and paste your color palette, spacing scale, and font stack. When you prompt Cmd+K or Composer on UI work, mention @Notepads/design-tokens. The model now uses the actual tokens instead of inventing #333 every time.

6. Multi-file rename through Composer

A prompt like rename userId to accountId everywhere in src/ is faster than any IDE's rename refactor when the rename crosses type boundaries, comments, test names, and doc files. Composer reads each file, proposes the rename, and you accept the batch in one pass.

7. Paste the last error through @Terminal

In Cursor's integrated terminal, a command failed. Open Chat, type @Terminal and ask fix this error. Cursor grabs the last terminal output as context. No more copying stack traces between windows.

8. Use a fast model for Tab, a deep one for Composer

In Settings > Models, set Tab to Cursor Small or another fast model, and set Composer to Claude Opus or GPT-4o. Typing should feel instant. Agent work should think hard. Mixing them costs nothing extra on Pro and removes the subjective lag on autocomplete.

9. Write a .cursorignore at the repo root

Exclude node_modules, build artifacts, lockfiles, and anything containing secrets. Indexing is faster, context is cleaner, and the agent stops trying to edit generated code. A minimal file:

node_modules/
.next/
dist/
.env*
*.lock

10. Agent mode plus YOLO scaffolds projects in minutes

For a fresh project, open Composer with YOLO mode on and prompt set up a Next.js 15 project with Tailwind and a ds folder containing Button and Card components. The agent runs npx create-next-app, installs deps, writes the components, and starts the dev server. What was 30 minutes of typing is now 3 minutes of supervision.

11. Index internal docs with @Docs

In Settings > Features > Docs, add your internal design system docs, API reference, or company style guide by URL. The agent can now cite them correctly. For a private-repo design system, host the docs on a shared URL or run the docs locally and point Cursor at localhost.

12. Background agents review PR diffs

Before pushing, open Composer and ask review the uncommitted diff as if you were a senior engineer. The agent reads git diff, flags risks, and suggests improvements. Catches silly bugs before CI does, and occasionally finds a real issue you missed.

13. Let the Source Control panel write your commit message

Stage your changes, open Source Control, and click the sparkle icon next to the commit message box. Cursor reads the staged diff and drafts a commit message. Edit if needed, then commit. Saves 20 seconds per commit and produces more descriptive history.

14. Chain keyboard shortcuts for a full edit loop

The classic flow: Cmd+I to open Composer, type the task, Cmd+Enter to submit, review the diff, Cmd+Enter again to accept, Cmd+W to close the Composer panel. Four keys for a full feature. Once the rhythm clicks, you stop reaching for the mouse.

15. A security rule that blocks secret suggestions

In ~/.cursor/rules/security.mdc add: never suggest code that logs environment variables or prints API keys. The rule catches the common failure where a quick debug statement sneaks an AWS key into a git history. Cheap to add, high value the one time it fires.

How to adopt these tips

Nobody picks up 15 habits at once. A week-long ramp that works:

• Day 1: tips 1, 2, 4. Get comfortable with the big three edit surfaces.
• Day 2: tips 3, 15. Add the two rules. They apply to every session after.
• Day 3: tips 5, 11. Set up Notepads and @Docs.
• Day 4: tips 6, 8. Try a cross-file rename and set up per-surface models.
• Day 5: tips 7, 9. .cursorignore and @Terminal.
• Day 6: tips 10, 13. Scaffolding with YOLO and AI commit messages.
• Day 7: tips 12, 14. Review-before-push and the full shortcut chain.

By the end of the week, most of these become reflex. The ones that do not stick usually do not match your workflow, which is fine.

Which tips give the biggest speedup

If you can only pick three to start, the ranking by practical time saved:

1. Tip 4 (Cmd+K for single-file fixes): largest single speed win because small edits are the most common task.
2. Tip 2 (Composer checkpoints): biggest risk reduction. Removes the fear of agent runs.
3. Tip 3 (step-by-step rule): largest quality win on complex prompts, free to enable.

The other twelve are incremental. Useful, worth learning, but the first three move the needle most.

Common traps

A short list of mistakes people make while trying these tips:

• Using Composer for 3-line edits out of habit. Cmd+K is the right tool there.
• Forgetting to add .cursorignore until the index has already bloated. Clean it out once, then commit the file.
• Writing 50-line rules files. The model respects short rules better than long ones. Keep each rule under 10 lines.
• Running YOLO mode scaffolding in a dirty git tree. Always commit or stash first.
• Using @Docs on URLs that change often. Point at stable versioned docs, not the latest branch.

Avoid the traps and the 15 tips above become a steady productivity lift rather than a source of new problems.

A small daily habit worth keeping

At the end of each day, ask yourself: what did I type today that Cursor could have typed for me? The answer usually points at an untaken shortcut. That question is itself the 16th tip. Over a few weeks it turns an average Cursor user into one of the fast ones in the team.

Bonus tips that did not make the list

A handful of smaller habits that are worth knowing even if they did not earn a top-15 slot:

• Pin important files in Composer context by dragging them into the chat box before you type the task. The agent treats pinned files as must-read rather than optional retrieval.
• Use Cmd+Shift+P command palette for anything you only do occasionally. Toggle word wrap, change the theme, run a task. Muscle memory from VS Code works unchanged in Cursor.
• Switch models mid-session from the Composer header. Start with a cheap fast model for a draft, bump to Opus for the final polish on tricky parts of the same task.
• Clear Composer context between unrelated tasks. A stale conversation thread confuses the model on a fresh task. New chat button, fresh start.
• Keep a prompt snippets note in a Notepad with the three or four task templates you use weekly. Paste-and-modify beats writing the prompt from scratch every time.
• Use @Git to ask questions about recent commits like @Git what did we change in the last 10 commits to the auth folder? The answer doubles as standup prep.
• Run Composer against a stash by having it read git stash show -p output through @Terminal when you want to revive old experimental work.
• Disable telemetry if your workplace requires it through Settings > Privacy. The privacy mode toggle on Business plans does this automatically, but individual users can opt in manually.

Each is a 10-second habit that compounds across a year of daily use.