Cursor for developers: complete guide for 2026

Cursor is the AI-native fork of VS Code that has become the default editor for most professional engineers in 2026, and this guide takes you from install to power-user in one read. We cover daily shortcuts, when to reach for Composer vs Agent, the real model picks (Claude Sonnet 4.6, Opus 4.7, GPT-4o), .cursorrules examples that actually constrain output, MCP setup, and the cost levers that keep your monthly bill from spiking.

If you have used Cursor as a smarter Tab key for six months, you are paying for about 5% of what it does. The shift from "AI autocomplete" to "AI workflow surface" is the entire point of the editor, and most engineers never make it.

Install and first 10 minutes

Download Cursor from cursor.com. It is a fork of VS Code, so your existing extensions, keybindings, themes, and settings.json import in one click on first launch. Sign in, accept the codebase indexing prompt (it builds a local Merkle-tree index plus remote embeddings via Turbopuffer), and turn on Privacy Mode in Settings if your code cannot leave your machine in identifiable form.

Five settings to change before you write a line of code:

1. Privacy Mode: on, unless you want prompts and snippets retained for training.
2. Codebase indexing: on, with .gitignore respected.
3. Auto-run mode for Agent: off until you trust it. Default is "ask before running terminal commands."
4. Default model: Claude Sonnet 4.6 for general work. We will tune this later.
5. Rules for AI: blank for now. We add .cursorrules per-project.

That is the install. The next 1,500 words are about how to actually use it.

The four interaction modes (and when to use each)

Cursor exposes four AI surfaces. Knowing which one to reach for is the single biggest skill gap between casual and power users.

Mode	Shortcut (Mac)	Shortcut (Win/Linux)	Use it for
Tab	Tab	Tab	Inline predictive completion, multi-line. The thing you already use.
Inline Edit	Cmd + K	Ctrl + K	Single-file surgical edits: rename, extract, fix this function.
Chat (Ask)	Cmd + L	Ctrl + L	Read-only Q&A over your codebase. Never writes a file.
Composer	Cmd + I	Ctrl + I	Multi-file edits, refactors, new features across the repo.
Composer Full	Cmd + Shift + I	Ctrl + Shift + I	Composer in a full-screen panel for big tasks.
Add to Context	Cmd + Shift + L	Ctrl + Shift + L	Pin a file, folder, or selection to the current chat.
Terminal AI	Cmd + K (in terminal)	Ctrl + K (in terminal)	Generate a shell command from a description.

A working rule of thumb: if the change touches one function, use Cmd + K. If it touches three to ten files, use Composer. If it touches the whole repo or needs to run tests in a loop, switch Composer into Agent mode.

Ask vs Composer vs Agent

These three confuse new users every week.

• Ask reads your code and answers. It cannot edit. Use it when you are debugging, exploring an unfamiliar codebase, or planning before you build.
• Composer edits multiple files in one coherent diff. You review, accept, or reject. It does not run commands.
• Agent is Composer with a longer leash: it can read files, write files, run terminal commands, run tests, and iterate until the task is done. You toggle Agent mode inside Composer.

Agent mode is where Cursor stops being an editor and becomes a pair programmer. It is also where it can quietly cost you $40 in API credits if you let it run on a fuzzy prompt. We will get to cost.

Daily workflows that compound

The engineers shipping 3-5x more in Cursor share four habits. They are unglamorous and they work.

Habit 1: Prompt-as-spec

A bad Composer prompt: "add login."

A good Composer prompt:

Implement POST /api/auth/login:
- Input: { email: string, password: string }, validated with Zod
- Reference @user_model.ts and @auth_service.ts for the existing patterns
- Use bcrypt.compare for password check
- Return { token: string, expiresAt: number } on success
- Return error format matching @errors.ts on failure
- Add a Vitest test in tests/auth/login.test.ts covering: valid login, wrong password, missing fields, unknown email

The @ syntax pins specific files into context. The model now has a function signature, three references, an error contract, and a test contract. This is the same artifact a senior engineer would hand a junior. Prompt-as-spec is what separates engineers who get good output from those who blame the model.

Habit 2: Checkpoint before Agent

Before any Agent run that touches more than two files, commit. git commit -am "checkpoint before agent". This is not paranoia: Cursor's Agent mode has shipped at least one revert bug in the past year where file-locking conflicts silently undid edits. A checkpoint commit gives you git reset --hard HEAD as your eject button. Cost: 4 seconds. Saves: 40 minutes of "where did my changes go."

Habit 3: Read every diff

Composer and Agent surface diffs in a review pane. Read them. Not skim, read. The single most common failure mode of AI-assisted engineering is accepting a diff that "looks right" and shipping a subtle behavior change. Cadence's voice interview specifically scores for this verification habit (we cover the rubric in our piece on what AI-native engineering actually means) because it predicts shipping quality more than any other signal.

Habit 4: Use Ask before Composer in unfamiliar code

When you open a repo you have not touched in three months, do not jump to Composer. Open Ask (Cmd + L), pin the relevant folder with Cmd + Shift + L, and ask "explain how authentication flows through this codebase, file by file." Two minutes of grounding turns a 40-minute Composer session into a 12-minute one.

.cursorrules: the file that fixes 80% of your complaints

Most "Cursor produces bad code" complaints disappear once the user writes a .cursorrules file. Drop it in the repo root. Cursor automatically prepends it to every prompt as a system message.

Here is a real .cursorrules for a Next.js + TypeScript + Postgres project:

You are a senior TypeScript engineer working on a Next.js 15 (App Router) + Drizzle ORM + Postgres project.

CODE STYLE
- TypeScript strict mode. No `any`. No `as` casts unless justified in a comment.
- Functional React components with hooks. No class components.
- Tailwind for styling. No CSS modules, no styled-components.
- Server Components by default; "use client" only when the component needs interactivity.

ARCHITECTURE
- Route handlers in app/api/**/route.ts. Business logic in lib/services/*.
- Database access only through Drizzle queries in lib/db/. Never inline SQL in routes.
- Validation with Zod at the API boundary. Never trust client input.

TESTING
- Every new lib/services function gets a Vitest unit test in tests/services/.
- Use msw for HTTP mocking, not jest.fn().

OUTPUT RULES
- Output FULL file content. No "// rest of file unchanged" placeholders.
- If you are unsure about an existing pattern, search the codebase first; do not invent one.
- When you finish, list every file you changed.

That single file removes most of the friction. The "Output FULL file content" line alone fixes the most common complaint about Cursor (truncated diffs that break apply).

For larger projects, Cursor 3.x supports .cursor/rules/*.mdc files: scoped rules that apply only when matching globs. Example: .cursor/rules/api.mdc with globs: ["app/api/**/*"] applies only when the model is editing API routes. This keeps the system prompt small and relevant.

Picking the right model for the right task

Cursor 2026 routes to multiple frontier models. The Pro plan ($20/month) gives you a generous allotment, then meters by request. Picking the wrong model wastes money and slows you down.

Task	Model	Why
Tab autocomplete	Cursor's custom model	Tuned for low-latency in-editor completion; included unmetered.
Inline Edit (Cmd+K)	Claude Sonnet 4.6	Fast, accurate, cheap. The default for 80% of edits.
Multi-file Composer	Claude Sonnet 4.6	Strong at following file-by-file diffs without hallucinating paths.
Architecture and design	Claude Opus 4.7	Best at multi-step reasoning over large codebases. Use sparingly: it is expensive.
Long-context exploration	Gemini 2.5 Pro	1M+ token window for "explain this 800-file repo."
Debugging tricky bugs	Claude Opus 4.7 or GPT-4o	Cross-check: if Sonnet missed it twice, escalate.
Cheap bulk refactors	DeepSeek V4 Pro or GPT-4o-mini	When the task is mechanical and you have 200 files to touch.

A practical heuristic: start with Sonnet 4.6. If it fails twice on the same task, switch to Opus 4.7. If you find yourself reaching for Opus more than once a day, your prompts probably need work, not your model.

MCP: connecting Cursor to your real tools

Model Context Protocol (MCP) is the 2025 standard for letting AI assistants call external tools. Cursor supports it natively. With MCP servers configured, your agent can query your Postgres schema in real time, read tickets from Linear, fetch docs from Notion, or call your own internal APIs without you pasting context.

A minimal mcp.json in ~/.cursor/:

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/myapp_dev"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_TOKEN": "${env:GITHUB_TOKEN}" }
    }
  }
}

Now Composer can answer "what columns are on the users table?" by querying live Postgres, and "summarize the last five PRs that touched auth/" by calling the GitHub server. Practical limit: keep total tools under 40 per session. Cursor's tool selection degrades past that.

Cost optimization: keeping the bill under control

Cursor Pro at $20/month is one of the best price-to-value deals in dev tooling. Most engineers who complain about cost are on Pro+ ($60) or Ultra ($200), running Opus 4.7 by default and Agent on every task. Three levers:

1. Default to Sonnet 4.6. Reserve Opus for the 10% of tasks where reasoning depth matters.
2. Use .cursorrules aggressively. A tight system prompt cuts back-and-forth, which cuts requests, which cuts spend.
3. Use Ask before Agent. A 30-second Ask query is one request. The same answer extracted from a confused 8-step Agent run is fifteen.

Founders evaluating whether to add Cursor seats for a contract team should check our breakdown of what it actually costs to integrate AI into a product, since the dev-tool spend and the production AI spend are usually conflated in early budgets.

What to do this week

If you take one thing from this guide:

1. Today: write a .cursorrules for your main project. Even 15 lines beats none.
2. This week: do one Composer task per day (not Inline Edit) so the muscle memory builds.
3. Next week: configure one MCP server, ideally Postgres or GitHub, and run one task through it.
4. Within a month: you will know whether your team needs the Pro+ or Ultra tier, because you will have data.

If you are a founder hiring engineers and want every booking to come pre-vetted on this exact tooling fluency, every engineer on Cadence is AI-native by default: the voice interview specifically scores Cursor (Composer, Agent, .cursorrules), Claude Code, and Copilot habits before bookings unlock. There is no non-AI-native option on the platform. If you would rather get a Build / Buy / Book recommendation on a specific feature before hiring at all, our decide tool gives one in 90 seconds.

Try Cadence: book a junior at $500/week or a senior at $1,500/week, get a 48-hour free trial, replace any week with no notice. The voice interview is the gate, not the hiring loop.

FAQ

Is Cursor worth it over GitHub Copilot in 2026?

For most professional engineers, yes. Copilot is excellent at inline completion and is cheaper at $10/month. Cursor wins on multi-file edits, Composer, Agent mode, and codebase-wide context, which is where the real productivity delta lives. If you only want autocomplete, stay on Copilot. If you want the editor to do refactors and feature work, switch to Cursor. We covered the full trade-off in our Cursor vs Copilot vs Claude Code piece.

What is the difference between Composer and Agent in Cursor?

Composer edits multiple files in one diff that you review and accept. Agent is Composer with permission to run terminal commands, run tests, and iterate autonomously until a task is done. Use Composer when you want to keep your hands on the wheel; use Agent when the task has a clear "done" condition (tests pass, build succeeds, lint clean).

Which model should I use in Cursor by default?

Claude Sonnet 4.6 for 80% of work: edits, Composer, Chat. Escalate to Claude Opus 4.7 for architecture, hard debugging, and complex refactors. Use Gemini 2.5 Pro when you need to feed in a 500K-token codebase. Tab completion uses Cursor's own model and is included.

Does Cursor read my whole codebase?

It indexes it locally (Merkle tree), then sends embeddings to Turbopuffer for semantic search. With Privacy Mode on, code snippets are not retained by model providers. For sensitive code, use the local-only models or run Cursor in Privacy Mode with a self-hosted MCP setup.

Can a non-technical founder evaluate whether their engineer is using Cursor well?

Yes. Three signals: (1) they have a .cursorrules file in the repo, (2) they describe edits in terms of "I asked Composer to..." not "I wrote...," and (3) they checkpoint with git before Agent runs. Our piece on evaluating AI-native engineering covers the full rubric, and our voice-interview writeup explains how Cadence scores it at the platform gate.