Cursor Getting Started — The Mental Shift That Unlocks Real Productivity

Chapter 1: Cursor Getting Started — The Mental Shift That Unlocks Real Productivity

Most people's first week with Cursor: they use it as better autocomplete, see limited gains, and wonder why everyone raves about it. The real shift happens when you stop treating it as a tool and start treating it as a collaborator — you describe intent, it writes code, you review decisions. This chapter helps you skip that week of confusion.

The Mental Model: From Autocomplete to Collaborative Development

The fundamental difference between Cursor and GitHub Copilot isn't features — it's the interaction model.

Copilot is reactive: you write code, it guesses what you want on the next line, and completes it. You're still the driver; it's an accelerator.

Cursor is active: you describe what you want, it writes a complete implementation, and you review and adjust. The roles are reversed — AI is the executor, you are the decision-maker.

This reversal requires an adjustment period. Many people use Cursor for a week and still use it in "autocomplete" mode — the equivalent of buying a car and riding it like a bicycle.

The core mental shift: Stop asking "how do I write this code?" Start asking "how do I tell AI what I need?"

Cursor's Three Modes and When to Use Each

Mode 1: Inline Edit (Cmd/Ctrl+K)

Triggers at the cursor position, best for:

• Modifying the currently selected code
• Generating a single function
• Comments, renaming, simple refactoring

Use when: you already know what you want to change and just need AI to write it.

Mode 2: Chat (sidebar)

Conversational interface with file references, best for:

• Understanding unfamiliar code ("what does this function do?")
• Exploring design approaches ("what are the options for implementing user auth?")
• Debugging reasoning ("why would this code have a race condition?")

Use when: you need AI to give advice or explain, before you've reached the writing-code stage.

Mode 3: Composer (Cmd/Ctrl+I)

Multi-file editing, best for:

• Implementing new features that span multiple files
• Large-scale refactoring
• Generating complete modules or components

Use when: the task involves multiple files, or you need AI to autonomously plan the implementation path.

Codebase Vector Indexing: Why Cursor Understands Your Project

When Cursor starts, it indexes your codebase and stores code as vectors locally. This is what lets it actually search your code when you ask "where does this project handle user login?" — instead of guessing.

Indexing takes time. Large projects may need a few minutes. You can see progress in the bottom right corner. After indexing, @Codebase references in Chat become accurate.

Practical significance: Before indexing, AI only knows the file you have open. After indexing, AI knows the entire project structure, can give more accurate suggestions, and can find relevant code snippets.

Your First Effective Conversation: Use the "Context + Goal + Constraints" Structure

Many people's first Cursor experience: "help me write a login feature" → AI gives generic code that doesn't match your project style at all.

The problem isn't that AI is bad — it's that the prompt gave AI no context.

An effective first-conversation structure:

Context: @src/auth/session.ts — this is our existing Session management code, using JWT.

Goal: I need to implement an authorization check on the /api/users/:id route, ensuring users can only modify their own data.

Constraints:
- Implement as Express middleware for reusability
- Error response format must match existing code (see @src/utils/errors.ts)
- Don't introduce new dependencies

This prompt gives AI:

1. Project context (using @ to reference relevant files)
2. A clear goal
3. Implementation constraints

The resulting code will fit your project closely, not be a generic template.

Chapter Key Points

1. The mental shift is a prerequisite: Switch from "code-writing tool" to "collaborative development partner." You are the decision-maker, AI is the executor.
2. Three modes for three scenarios: Inline Edit for local modifications, Chat for exploration and understanding, Composer for cross-file development.
3. Wait for indexing to complete: In large projects, @Codebase accuracy depends on index quality. Give it a few minutes on first use.
4. Use the Context + Goal + Constraints structure: This is what makes AI output fit your project. Later chapters go deep on this.
5. Review is mandatory, not optional: You must read, understand, and approve every line AI writes before accepting it. Blind acceptance is the root of problems, not efficiency.