Essential Configuration

Master Cursor’s essential configurations in 15 minutes. We’ll enable power features, select optimal AI models, generate project rules, and ensure your setup is ready for serious development.

Power Features Overview

Yolo Mode

Auto-execution of safe operations

Lets AI run tests, create files, and execute build commands without constant approval

Max Mode

Extended context windows

Increases context from 128k to 1M tokens for complex operations (slower but more capable)

Privacy Mode

Enterprise-grade security

Ensures zero code retention and no training on your data

Model Selection

Strategic AI model usage

Choose the right model for each task - balance speed, cost, and capability

Enable Yolo Mode (Auto-Execution)

Tip

Yolo mode dramatically speeds up development by allowing the AI to execute safe operations automatically. Essential for the PRD → Plan → Todo workflow.

What Yolo Mode Does

• Auto-runs tests: npm test, pytest, cargo test
• Creates files/directories: mkdir, touch
• Executes builds: npm run build, tsc
• Runs linters: eslint, prettier
• Git read operations: git status, git diff

Enable and Configure

1. Open Settings: Cmd/Ctrl + Shift + J

2. Navigate to Agent

3. Enable “Auto-run” (Yolo Mode)

4. Configure Allow List:

   # Recommended Yolo Mode Prompt:
   Any kind of tests are always allowed like vitest, npm test,
   nr test, etc. Also basic build commands like build, tsc, etc.
   Creating files and making directories (like touch, mkdir, etc)
   is always ok too. Git read operations are safe.

5. Add Custom Allow Rules:

   • Test runners: jest, mocha, cypress
   • Build tools: webpack, vite, rollup
   • Linters: black, rubocop, golint
   • Package managers: npm install, yarn add

Security Configuration

Development

More permissive for rapid development:

{
  "allow": [
    "npm test",
    "npm run build",
    "npm install",
    "git status",
    "git diff",
    "mkdir -p",
    "touch",
    "ls -la"
  ]
}

Production

Restricted for safety:

{
  "allow": [
    "npm test",
    "git status"
  ],
  "deny": [
    "rm -rf",
    "git push",
    "npm publish"
  ]
}

Configure Max Mode (Extended Context)

Note

Max Mode is powerful but costs more. Use it strategically for complex tasks requiring deep understanding of large codebases.

When to Use Max Mode

Use Max Mode

• Large refactoring (100+ files)
• Cross-module analysis
• Architecture planning
• Complex debugging

Skip Max Mode

• Simple file edits
• Small bug fixes
• Documentation updates
• Routine coding

Enable Max Mode

1. Open Settings: Cmd/Ctrl + Shift + J
2. Navigate to Models
3. Toggle “Max Mode” on
4. Understand the impact:
   • Normal: 128k tokens (~10,000 lines)
   • Max: 1M tokens (~80,000 lines)
   • Cost: ~8x more expensive
   • Speed: 30-50% slower

Model-Specific Context Windows

Model	Normal Context	Max Context	Best For
Claude 4 Sonnet	128k	200k	Daily development
Claude 4 Opus	128k	200k	Complex reasoning
Gemini 2.5 Pro	128k	1M	Large codebase analysis
GPT 4.1	128k	1M	Versatile tasks
o3	128k	200k	Deep problem solving

Model Selection Strategy

Primary Development Models

Claude 4 Sonnet

The Workhorse (Default)

Speed: Fast
Cost: $3/million tokens
Strengths:
  - Excellent code generation
  - Fast responses
  - Cost-effective
  - Great instruction following
Use for:
  - Daily coding tasks
  - Feature implementation
  - Bug fixes
  - Code reviews

Claude 4 Opus

The Architect

Speed: Moderate
Cost: $15/million tokens (5x Sonnet)
Strengths:
  - Superior reasoning
  - Complex problem solving
  - Architecture design
  - Deep code understanding
Use for:
  - System design
  - Complex refactoring
  - Algorithm optimization
  - Technical planning

OpenAI o3

The Problem Solver

Speed: Slow
Cost: Variable (usage-based)
Strengths:
  - Exceptional debugging
  - Complex logic puzzles
  - Mathematical reasoning
  - Edge case handling
Use for:
  - Difficult bugs
  - Algorithm design
  - Performance optimization
  - Complex business logic

Gemini 2.5 Pro

The Context Master

Speed: Fast
Cost: $7/million tokens
Strengths:
  - 1M token context
  - Excellent for large codebases
  - Strong multimodal support
  - Good cross-file understanding
Use for:
  - Large codebase navigation
  - Multi-file refactoring
  - Documentation generation
  - Cross-module analysis

Configure Default Model

1. Open Settings: Cmd/Ctrl + Shift + J
2. Navigate to Models
3. Set Chat Model: Claude 4 Sonnet (recommended)
4. Set Tab Model: Keep default (optimized for completions)
5. Enable Auto Model Selection: Off (maintain control)

Model Selection Decision Tree

graph TD A[Task Type] --> B{Complexity?} B -->|Simple| C[Claude 4 Sonnet] B -->|Complex| D{What Kind?} D -->|Architecture| E[Claude 4 Opus] D -->|Debugging| F[o3] D -->|Large Context| G[Gemini 2.5 Pro] H[Context Size] --> I{Lines of Code?} I -->|< 10k| C I -->|10k - 50k| J[Enable Max Mode] I -->|> 50k| G

Generate Project Rules

Tip

Project rules are your AI’s instruction manual. Well-crafted rules ensure consistent, high-quality code generation aligned with your standards.

Quick Rule Generation

1. Open Command Palette: Cmd/Ctrl + Shift + P
2. Type and select: “Generate Cursor Rules”
3. Cursor analyzes your project and creates initial rules
4. Review generated .cursor/rules/ directory

Manual Rule Creation

1. Open Command Palette: Cmd/Ctrl + Shift + P
2. Select: “New Cursor Rule”
3. Choose rule type:
   • Always: Applied to every AI interaction
   • Auto-attached: Applied based on file patterns
   • Agent Requested: AI decides when to use
   • Manual: Only when explicitly referenced

Essential Rule Templates

Code Style

---
description: Code style and formatting standards
alwaysApply: true
---

## Code Style Guidelines

- Use TypeScript with strict mode enabled
- Prefer const over let, never use var
- Use async/await over callbacks
- Destructure imports and parameters
- Include JSDoc comments for public APIs
- Follow ESLint configuration
- Use 2 spaces for indentation

## Naming Conventions

- Components: PascalCase
- Functions/variables: camelCase
- Constants: UPPER_SNAKE_CASE
- Files: kebab-case
- Interfaces: prefix with 'I'

Architecture

---
description: Architecture patterns and principles
globs: ["src/**/*.ts", "src/**/*.tsx"]
---

## Architecture Principles

- Follow Domain-Driven Design
- Use Repository pattern for data access
- Implement dependency injection
- Keep business logic in services
- Controllers should be thin
- Use custom errors for domain exceptions

## File Structure

src/
  domain/      # Business entities
  application/ # Use cases
  infrastructure/ # External services
  presentation/   # UI components

Testing

---
description: Testing standards and practices
globs: ["**/*.test.ts", "**/*.spec.ts"]
---

## Testing Requirements

- Write tests for all new features
- Maintain 80% code coverage
- Use descriptive test names
- Follow AAA pattern (Arrange, Act, Assert)
- Mock external dependencies
- Test edge cases and error scenarios

## Test Structure

describe('ComponentName', () => {
  describe('methodName', () => {
    it('should handle specific scenario', () => {
      // Test implementation
    });
  });
});

Rule Organization

.cursor/rules/
├── always/
│   ├── code-style.mdc
│   └── security.mdc
├── backend/
│   ├── api-patterns.mdc
│   └── database.mdc
├── frontend/
│   ├── components.mdc
│   └── state-management.mdc
└── testing/
    └── test-patterns.mdc

Privacy and Security Configuration

Enterprise Requirements

These settings are critical for corporate environments with strict data policies.

Privacy Mode Verification

1. Open Settings: Cmd/Ctrl + Shift + J
2. Navigate to Privacy
3. Ensure Privacy Mode shows: ✓ Enabled
4. Check telemetry settings:
   • Disable usage analytics
   • Disable crash reporting
   • Disable feature tracking

Data Handling Configuration

Maximum Privacy

{
  "privacy": {
    "mode": "enabled",
    "telemetry": false,
    "crashReports": false,
    "usageData": false,
    "codeSnippets": false
  },
  "security": {
    "httpsOnly": true,
    "certificateValidation": true
  }
}

Team Sharing

{
  "privacy": {
    "mode": "enabled",
    "shareWithTeam": true,
    "shareContext": ["rules", "memory"],
    "excludePatterns": [
      "**/*.env",
      "**/*secret*",
      "**/credentials/**"
    ]
  }
}

Optimize for Your Workflow

Performance Settings

Indexing

Settings → Indexing

• Enable incremental indexing
• Set update interval: 5 minutes
• Exclude: node_modules, dist

Auto-complete

Settings → Tab

• Trigger delay: 100ms
• Multi-line completions: On
• Partial accept: Enabled

Keyboard Shortcuts

Essential shortcuts to configure:

Action	Default	Recommended
Inline Edit	Cmd/Ctrl + K	Keep default
Open Chat	Cmd/Ctrl + I	Keep default
Accept Suggestion	Tab	Keep default
Trigger Suggestion	Alt + \	Customize if needed
Open Composer	Cmd/Ctrl + Shift + I	Keep default

Verify Configuration

Run this checklist to ensure everything is configured:

1. Test Yolo Mode:

   # In Chat, type:
   "Create a test file and run npm test"
   # Should execute without prompts

2. Test Model Selection:

   • Switch to o3 model
   • Ask a complex question
   • Verify slower but deeper response

3. Test Rules:

   • Create a new file
   • Ask AI to write a function
   • Verify it follows your style rules

4. Test Privacy:

   • Check Settings → Privacy
   • Ensure “Privacy Mode: Enabled”

Configuration Complete!

Tip

Cursor is now configured for maximum productivity. You have power features enabled, optimal models selected, and project rules in place.

Next Steps

Continue to Model Selection

Now let’s dive deeper into when and how to use each AI model effectively.

Model Selection →

Time: 10 minutes

Tip

Pro Tip: Save your configuration by exporting settings. Use Cmd/Ctrl + Shift + P → “Export Settings” to create a backup you can share with your team.