How to Set Up Cursor: A Practical Guide

TL;DR

• Cursor is an AI-first code editor built on VS Code, with inline generation, chat mode, and multi-file editing.
• Install in 2 minutes (brew install --cask cursor or download from cursor.com).
• Key workflows: Tab for completions, @ for chat, Cmd+L (macOS) to edit multiple files at once.
• Gotchas: Some VS Code extensions don’t work; AI can hallucinate—always review code.

1. Installation and Setup

Install Cursor

Cursor supports Windows, macOS (Apple Silicon/Intel), and Linux (x86_64/ARM).

Option A: GUI Install (Recommended)

1. Download the installer for your OS:
   • Windows (.exe)
   • macOS (.dmg)
   • Linux (.AppImage/.deb/.rpm)
2. Run the installer and open Cursor.

Option B: CLI Install (macOS/Linux)

# macOS (Homebrew)
brew install --cask cursor

# Linux (Snap)
sudo snap install cursor --edge

Expected output:

cursor was successfully installed!

Copy

1. Launch Cursor and sign in with GitHub, GitLab, or Google.

First-Run Setup

1. Select a theme (Cursor uses VS Code themes by default).
2. Enable AI features:
   • Click "Enable AI" in the welcome prompt.
   • Choose between:
     • Hosted model (default, free tier: 50 requests/day).
     • Self-hosted (requires API keys for OpenAI/Anthropic/Ollama).
3. Install VS Code extensions (optional):
   • Cursor supports 90% of VS Code extensions. Install them via the Extensions sidebar (Cmd+Shift+X).

Gotcha: Some extensions (e.g., certain debuggers) may not work. Check the compatibility list.

Verify Installation

Run this in the Cursor terminal to check the version:

cursor --version

Expected output (as of March 2026):

Cursor 0.12.0

Copy

2. Tab Completion and Inline Suggestions

Cursor’s AI autocomplete works like GitHub Copilot but with deeper context awareness.

Basic Usage

1. Start typing code. Cursor will suggest completions inline (gray text).
2. Press Tab to accept a suggestion.
3. Press Esc to dismiss.

Example: Python Function

Type this in a Python file:

def calculate_ta

Cursor will suggest:

def calculate_tax(subtotal, tax_rate):
    """Calculate the total tax amount."""
    return subtotal * tax_rate

Press Tab to accept.

Multi-Line Completions

Cursor can generate entire blocks of code. Example:

1. Type a docstring or comment describing what you want:

   # Write a function to fetch user data from an API and cache it
   

   Copy
2. Press Tab. Cursor may generate:

   import requests
   from functools import lru_cache
   
   @lru_cache(maxsize=128)
   def fetch_user_data(user_id):
       response = requests.get(f"https://api.example.com/users/{user_id}")
       response.raise_for_status()
       return response.json()
   

   Copy

Pro Tip: Use # TODO: or # Fix: to guide the AI.

Force a Suggestion

If Cursor isn’t suggesting anything:

1. Press Cmd+K (macOS) or Ctrl+K (Windows/Linux) to trigger a suggestion.
2. Or type // (any language) and describe what you need.

Common Issues

3. Chat Mode vs Composer Mode

Cursor offers two AI interaction modes:

Chat Mode (@)

Use inline chat to ask questions without leaving the editor.

1. Type @ in your code:

   @how do I optimize this SQL query?
   SELECT * FROM users WHERE status = 'active';
   

   Copy
2. Cursor will reply with suggestions inline:

   # Try adding an index on `status` and limiting columns:
   SELECT id, name, email FROM users WHERE status = 'active' LIMIT 1000;
   

   Copy

Pro Tip: Use @doc to generate docstrings or @test to create unit tests.

Composer Mode (Cmd+L)

Edit multiple files at once with natural language.

1. Press Cmd+L (macOS) or Ctrl+L (Windows/Linux).
2. Describe your edit:

   Update all API base URLs from "api.old.com" to "api.new.com" in JavaScript and Python files
   

   Copy
3. Cursor will show a preview of changes across files. Press Enter to apply.

Example Output:

Files to be modified:
- src/api/client.js (2 changes)
- backend/services.py (1 change)

Copy

4. Cursor Rules (.cursorrules)

.cursorrules lets you define custom AI behaviors for your project.

Create a .cursorrules File

1. Add a file named .cursorrules to your project root.
2. Define rules in YAML format.

Example: Enforce Code Style

# .cursorrules
rules:
  - name: "Python Type Hints"
    description: "Always add type hints to Python functions"
    language: "python"
    pattern: "def (\\w+)\\(.*\\):"
    action: "Add type hints to parameters and return value"
    severity: "high"

  - name: "No Console Logs"
    description: "Replace console.log with proper logging"
    language: "javascript"
    pattern: "console\\.log\\(.*\\)"
    action: "Replace with logger.info()"
    severity: "medium"

Predefined Rules

Cursor ships with default rules for common patterns. View them with:

cursor rules list

Expected output:

1. "Add Error Handling" (Python, JavaScript)
2. "Optimize SQL Queries" (SQL)
3. "Add Docstrings" (Python)

Copy

Disable Rules

To ignore a rule for a file, add this comment:

# cursor: disable=No Console Logs
console.log("This won't trigger a warning")

5. Model Selection and API Keys

Cursor supports:

• Hosted models (default, free tier).
• Self-hosted models (OpenAI, Anthropic, or local LLMs via Ollama).

Switch Models

1. Open Settings (Cmd+,).
2. Navigate to AI > Model.
3. Choose from:
   • cursor-gpt-4.5 (default, hosted).
   • openai-gpt-4 (requires OpenAI API key).
   • anthropic-claude-3 (requires Anthropic API key).
   • ollama-local (for local models like codellama).

Add API Keys

1. Get your API key from:
   • OpenAI
   • Anthropic
2. Add it to Cursor:

   cursor config set openai.api_key "sk-..."
   

   Copy
3. Verify:

   cursor config get openai.api_key
   

   Copy

   Expected output:

   sk-...
   

   Copy

Use Local Models (Ollama)

1. Install Ollama:

   brew install ollama
   

   Copy
2. Pull a model (e.g., codellama):

   ollama pull codellama:13b
   

   Copy
3. Configure Cursor to use Ollama:

   cursor config set ai.model "ollama-codellama"
   

   Copy

Gotcha: Local models are slower but keep data on-device.

6. Multi-File Editing Workflows

Cursor’s Composer Mode (Cmd+L) excels at cross-file edits.

Example: Refactor a Database Schema

1. Press Cmd+L and describe the change:

   Update all database models to use the new 'users_v2' table.
   Replace 'users.id' with 'users_v2.user_id' in Python and SQL files.
   

   Copy
2. Cursor will preview changes across files. Press Enter to apply.

Example: Add Logging

1. Press Cmd+L and type:

   Add debug logging to all functions in src/utils.py and src/api.py.
   Use the format: logger.debug("Entering function_name")
   

   Copy
2. Review and apply.

Gotchas

7. Tips for Maximizing Productivity

Keyboard Shortcuts

Custom Snippets

Add AI-aware snippets to .vscode/cursor-snippets.json:

{
  "Python Class": {
    "prefix": "pclass",
    "body": [
      "class ${1:ClassName}:",
      "    \"\"\"${2:Docstring}\"\"\"",
      "    def __init__(self, ${3:args}):",
      "        ${4}",
      "",
      "    @classmethod",
      "    def from_dict(cls, data: dict):",
      "        \"\"\"Create instance from dict.\"\"\"",
      "        return cls(${5})"
    ],
    "description": "Python class with type hints and from_dict"
  }
}

Trigger with pclass + Tab.

Collaboration

• Real-time pair programming: Click "Share" in the top-right to invite teammates.
• Conflict resolution: Use cursor git lock to prevent overwrites.

What's Next?

1. Try Composer Mode: Press Cmd+L and refactor a small feature in your codebase.
2. Set up .cursorrules: Add 2–3 rules for your team’s coding standards.
3. Experiment with local models: Install Ollama and test codellama for offline use.

For teams scaling AI workflows, Hyperion Consulting helps implement tools like Cursor with custom rules and model fine-tuning.