Setup and Configuration: Tips 1-15

You installed Cursor, opened a project, typed a prompt, and got mediocre suggestions. You tried agent mode, it asked permission for every terminal command, and you gave up after the fifth confirmation dialog. The AI feels slow, the suggestions feel generic, and you are wondering what all the hype is about. The problem is not Cursor. The problem is that Cursor out of the box is configured for maximum safety, not maximum productivity. These 15 tips fix that.

What You Will Walk Away With

• A Cursor installation that imports your existing VS Code workflow without losing a single keybinding
• YOLO mode configured with a safe allow-list that lets the agent run tests and builds without asking
• Model selection tuned for the right cost-quality tradeoff across different task types
• Project rules that make AI-generated code match your team’s conventions on the first attempt
• Indexing and performance settings that keep Cursor responsive on large codebases

Installation and Migration

Tip 1: Install via Package Manager for Painless Updates

Do not download the .dmg or .exe from the website. Use a package manager so updates are a single command instead of a manual download-and-replace cycle.

macOS

brew install --cask cursor
# Updates: brew upgrade --cask cursor

Windows

winget install Anysphere.Cursor
# Updates: winget upgrade Anysphere.Cursor

Linux

# Download AppImage from cursor.com
chmod +x Cursor-*.AppImage
# For Ubuntu/Debian, FUSE is required:
sudo apt install libfuse2

Tip 2: Import VS Code Settings in One Step

Cursor is a VS Code fork, which means your extensions, keybindings, settings, and snippets transfer directly. On first launch, Cursor offers an import wizard. If you missed it:

1. Open Command Palette: Cmd+Shift+P (macOS) or Ctrl+Shift+P (Windows/Linux)
2. Type “Import VS Code Settings”
3. Select all categories (extensions, keybindings, settings, snippets)
4. Restart Cursor

Your muscle memory stays intact. The only new shortcuts you need to learn are Tab (accept suggestion), Cmd+K (inline edit), and Cmd+I (agent panel).

Tip 3: Install the cursor Shell Command

Without this, you cannot open projects from the terminal — and terminal-driven workflows are a huge part of using Cursor effectively.

# From Command Palette (Cmd+Shift+P):
# "Install 'cursor' command in PATH"

# Now you can:
cursor .                    # Open current directory
cursor src/api/routes.ts    # Open specific file
cursor -g src/app.ts:42     # Jump to line 42
cursor --diff file1 file2   # Compare two files
cursor -a ../shared-lib     # Add folder to current workspace

Quick project switching from terminal

# Add to ~/.zshrc or ~/.bashrc for instant project switching:
alias c="cursor"
alias cn="cursor -n"  # Force new window
alias cr="cursor -r"  # Reuse current window

Unlock Autonomous Workflows

Tip 4: Understand Why YOLO Mode Changes Everything

By default, Cursor’s agent asks for permission before running any terminal command. This makes sense for safety, but it destroys the autonomous workflow that makes agent mode powerful. Every npm test, every tsc, every mkdir triggers a confirmation dialog. You end up babysitting the agent instead of letting it work.

YOLO mode removes these interruptions for commands you trust. The agent can now write code, run tests, see failures, fix the code, and re-run tests — all without you clicking “Allow.”

Tip 5: Configure YOLO Mode with a Safe Allow-List

Go to Settings > Features > YOLO Mode and enable it. Then configure the boundaries:

Allow prompt (paste this directly):

YOLO mode allow prompt

any kind of tests are always allowed like vitest, jest, pytest, npm test, pnpm test, etc. Basic build commands like tsc, npm run build, pnpm build are always ok. Creating files and directories (touch, mkdir, cp) is always fine. Linting commands like eslint, prettier, biome are allowed. Git status and git diff are ok but not git push or git commit.

Deny list (commands YOLO mode should never auto-approve):

rm -rf, sudo, ssh, curl, wget, git push, git commit, npm publish, deploy

This gives you an agent that can iterate on code autonomously while keeping destructive operations gated behind manual approval.

Tip 6: Set Up Multi-Root Workspaces for Full-Stack Projects

If your project spans multiple repositories (frontend, backend, shared types), open them as a single workspace so the agent can edit across all of them.

// myproject.code-workspace
{
  "folders": [
    { "path": "frontend", "name": "Frontend (Next.js)" },
    { "path": "backend", "name": "Backend (Express)" },
    { "path": "shared", "name": "Shared Types" }
  ]
}

Open it with cursor myproject.code-workspace. Now when you tell the agent “add a new API endpoint and update the frontend to call it,” it can edit files in both repos within a single conversation.

Model Selection

Tip 7: Pick the Right Model for the Right Task

Cursor lets you switch models per conversation. Use this strategically instead of defaulting to the most expensive option.

Task Type	Recommended Model	Why
Complex architecture, difficult bugs	Claude Opus 4.6	Best agentic reasoning, highest accuracy on multi-step tasks
Everyday coding, feature implementation	Claude Sonnet 4.5	Strong performance at lower cost, fast responses
Large context analysis (10k+ lines)	Gemini 3 Pro	1M+ token context window
Quick iterations, simple edits	GPT-5.2	Fast responses, good for rapid prototyping

Switch models mid-session using the model picker in the bottom-left of the agent panel.

Tip 8: Use Max Mode Only When Context Demands It

Max Mode gives you extended context windows but burns through your quota faster. Enable it manually (not auto) and use it for:

• Analyzing files over 5,000 lines
• Cross-repository refactoring where the agent needs to hold multiple large files in context
• Understanding complex dependency chains across a monorepo

For everything else, standard context is sufficient and significantly cheaper.

Project Rules

Tip 9: Create a .cursorrules File for Every Project

This is the single highest-ROI configuration you can make. A .cursorrules file at your project root tells the AI your tech stack, conventions, and constraints. Without it, the AI guesses — and guesses wrong often enough to be annoying.

Copy-paste .cursorrules template for a TypeScript web project

This project is a TypeScript web application using Next.js App Router with React Server Components.

Tech stack:
- Next.js 15 with App Router
- TypeScript in strict mode
- Tailwind CSS for styling
- Drizzle ORM with PostgreSQL
- Vitest for testing
- pnpm as package manager

Code conventions:
- Use named exports, not default exports
- Prefer functional components with hooks
- Use server components by default, add "use client" only when client state is needed
- Error handling: always use try-catch for async operations with typed error responses
- Use zod for all input validation

When running commands, use pnpm instead of npm.
When searching the codebase, do at least 3 semantic searches and 3 grep searches.
Do not modify package.json dependencies directly -- ask first.

Tip 10: Graduate to .cursor/rules/ for Larger Projects

For projects with more than a few conventions, split your rules into focused files:

mkdir -p .cursor/rules

Create separate files for different concerns:

• .cursor/rules/architecture.md — Layer boundaries, dependency rules, file organization
• .cursor/rules/testing.md — Test framework, coverage expectations, test file conventions
• .cursor/rules/api-conventions.md — Request/response patterns, error formats, auth requirements
• .cursor/rules/styling.md — Component patterns, CSS conventions, accessibility requirements

Tip 11: Use Auto-Attach Rules for Context-Aware Guidance

Configure rules to apply automatically based on file patterns. This means the AI gets different instructions when editing test files versus component files versus API routes:

.cursor/rules/config.json

{
  "autoAttach": [
    { "pattern": "**/*.test.{ts,tsx}", "rules": ["testing"] },
    { "pattern": "**/components/**", "rules": ["styling", "architecture"] },
    { "pattern": "**/api/**", "rules": ["api-conventions"] },
    { "pattern": "**/*.sql", "rules": ["database"] }
  ]
}

Indexing and Performance

Tip 12: Configure File Exclusions Before First Index

Cursor indexes your codebase for semantic search. Without exclusions, it wastes time and memory indexing node_modules, build artifacts, and generated files.

Add to your workspace settings:

{
  "search.exclude": {
    "**/node_modules": true,
    "**/dist": true,
    "**/build": true,
    "**/.next": true,
    "**/coverage": true,
    "**/*.min.js": true,
    "**/package-lock.json": true,
    "**/pnpm-lock.yaml": true
  }
}

Tip 13: Prioritize Core Source Files for Indexing

Tell Cursor which files matter most by structuring your workspace so source code is prominent. If you have a monorepo, open the specific packages you are working on rather than the root:

# Instead of this:
cursor ~/projects/big-monorepo

# Do this:
cursor ~/projects/big-monorepo/packages/web ~/projects/big-monorepo/packages/api

Check indexing status in Settings > Indexing and Docs. A healthy project indexes in 1-5 minutes. If it takes longer than 15, your exclusions are too loose.

Tip 14: Enable Privacy Mode for Proprietary Code

If you work on code that cannot leave your machine, enable Privacy Mode before opening the project:

Settings > Privacy > Enable Privacy Mode

With Privacy Mode on:

• No code is stored or used for model training
• Processing happens in real-time without retention
• Logs are not sent to Cursor’s servers

This is a hard requirement for many enterprise teams and should be configured before any proprietary code is opened.

Tip 15: Set Global User Rules for Personal Preferences

Global User Rules apply across all projects. Use them for personal preferences that are not project-specific:

Settings > Cursor Settings > Rules > User Rules

Copy-paste global user rules

Prefer functional code over imperative where possible.
Use async/await instead of .then() chains.
When writing TypeScript, use strict types -- avoid 'any'.
For network requests, use fetch instead of axios.
Always handle errors explicitly, never silently swallow them.
When I ask you to fix something, explain what was wrong before showing the fix.

These rules sit at IDE level and vary per developer, so they should not replace project-level rules for team conventions. Think of them as your personal coding preferences that apply regardless of which project you open.

When This Breaks

YOLO mode runs a destructive command: This is why the deny-list exists. If you accidentally approve something dangerous, use Cmd+Z in the terminal or git checkout . to restore files. For extra safety, always commit before starting a large agent session.

Indexing is stuck or extremely slow: Usually caused by a missing exclusion pattern. Check if Cursor is trying to index node_modules, large binary files, or generated code. Clear the index cache via Settings > Advanced > Clear Index Cache and re-index with proper exclusions.

AI ignores your .cursorrules: Rules only apply if the file is in the project root (for .cursorrules) or in .cursor/rules/ with proper naming. Check that the file is not empty and does not have syntax errors. Also verify you are in Agent mode — Ask mode sometimes ignores project rules.

Model responses are slow or timing out: Switch to a faster model (Sonnet 4.5 instead of Opus 4.6) for routine tasks. If all models are slow, check your network connection and Cursor’s status page.

What is Next

With your environment properly configured, move to Core Features (Tips 16-30) to learn the shortcuts and navigation patterns that make daily coding faster. The setup you just completed is the foundation that makes every subsequent tip more effective.