Tutorial

How to use Cursor IDE effectively in 2026: rules, prompts, MCP and the workflows that actually ship

Cursor is the most-used AI IDE on earth in 2026, and 80% of users are still treating it like fancy autocomplete. This guide unpacks the workflow that actually doubles your throughput — rules, MCP, Composer, Agent, and the prompt patterns we use daily.

May 20, 202613 min readCruxBit Team

We've been on Cursor since the early-2024 beta. It's gone from "interesting fork of VS Code" to the default AI IDE for most working engineers we know in 2026. But most users are still leaving 70% of its capability on the table — using Cursor like fancy autocomplete and never touching the workflows that compound. This guide walks through what we've standardised on internally at CruxBit, the prompts we keep in our team library, and the small habits that take you from "using Cursor" to "shipping with Cursor."

Before you read on

If you've never installed Cursor, do that first (cursor.com → download). This is a workflow guide, not an installation guide. You should have at least 30 minutes of typing-in-Cursor experience before any of this will click.

1. Know the three modes (this is the most-missed thing)

Cursor isn't one tool. It's three, sharing an editor. Knowing which mode to invoke is half the productivity gain.

  • Tab — inline completion as you type (Tab to accept). Best AI tab-completion in the category. Use it for the 90% of typing where you basically know what you want
  • Inline edit (Cmd+K) — highlight code, describe the change, get a diff. Best for surgical edits in one file: rename, refactor a function, convert a callback to async/await
  • Chat / Agent (Cmd+L) — multi-turn conversation with context, can do multi-file edits, runs commands when in Agent mode. Best for tasks that span files or require iteration
When to use which mode
   Tab          Cmd+K            Chat / Agent
   ───          ─────            ────────────
   typing       single-file      multi-file
   line-level   refactor         feature
   < 1 sec      seconds          minutes
   no review    quick review     deep review
   ───────────────────────────────────────────
   ~70% of      ~20% of          ~10% of
   your work    your work        your work
                                 (but the biggest wins)

The pro move: stop opening Chat for things Cmd+K can do faster. Cmd+K is a low-friction surgical knife; Chat is a chainsaw.

2. Set up a .cursorrules / .cursor/rules.md file (today)

Without a rules file, every chat starts from zero. With one, the model loads your conventions, libraries, and gotchas on every call. The single biggest "why does my AI do dumb things" fix is writing one.

.cursor/rules/main.md
markdown
---
description: Project-wide rules for AI agents
alwaysApply: true
---

# Project context
- Next.js 16 (App Router, Turbopack). Read node_modules/next/dist/docs
  for breaking-change notes; never assume Next 13/14 patterns work.
- TypeScript strict mode. No `any` without a comment explaining why.
- Tailwind CSS v4. Use canonical classes (`leading-normal`, not
  `leading-[1.5]`).

# Style rules
- Prefer named exports; default exports only for page/layout/route files.
- Server components by default; mark `"use client"` explicitly only when
  needed (state, effects, browser APIs).
- No try/catch around code that can't actually throw.

# Patterns we use
- Data fetching: server components + `fetch()`. No useEffect for data.
- Forms: react-hook-form + zod resolver.
- Tests: vitest + testing-library. Co-locate as `*.test.tsx`.

# Things NOT to touch
- `src/lib/seo.ts` (manually tuned, requires explicit ask)
- Migrations in `/migrations` (only edit via the migration generator)
- Anything in `.next`, `node_modules`, `public/og-images`

Two-file pattern that scales

Keep .cursor/rules/main.md short and global. Add per-area rules in .cursor/rules/auth.md, .cursor/rules/db.md with `globs: src/auth/**` so they only load when the model is working in that area. Token budget stays tight, context stays relevant.

3. Add MCP servers — the unfair advantage

[[mcp-explained-2026|MCP]] support landed in Cursor in early 2025 and matured through the year. Wiring a few MCP servers means the model can query your database directly, look at your GitHub issues, read your Linear tickets — without you copy-pasting context.

~/.cursor/mcp.json
json
{
  "mcpServers": {
    "postgres-dev": {
      "command": "npx",
      "args": [
        "-y", "@modelcontextprotocol/server-postgres",
        "postgresql://localhost:5432/myapp_dev"
      ]
    },
    "linear": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-linear"],
      "env": { "LINEAR_API_KEY": "lin_api_xxx" }
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_TOKEN": "ghp_xxx" }
    }
  }
}

Restart Cursor. Check Settings → Features → MCP — each server should show a green dot. Now you can ask things like "summarise the open Linear tickets in the \"Billing\" project and propose a sequencing" and the model will actually pull live data.

4. The prompt patterns we keep reaching for

Pattern 1: The "spec-first" prompt

Don't say "add a logout button." Say:

text
Add a logout button to the user menu.

- Trigger: click the user menu, click "Log out"
- Behaviour: POST /api/auth/logout, clear session cookie, redirect to /
- Existing patterns to match:
  - Use the Button component from @/components/ui/button (variant="ghost")
  - Wire mutation via the existing useAction() hook in @/lib/actions
- Out of scope: don't refactor the user menu component itself
- Verification: clicking the button should land on / with no session

Five extra lines, ten minutes saved. See the [[spec-driven-development-with-ai-2026|spec-driven post]] for the full loop.

Pattern 2: The "read first, then propose" prompt

text
Before writing any code, read these files and tell me back what you
think the contract is between them:

- @src/lib/queue.ts
- @src/workers/email.ts
- @src/api/notifications/route.ts

Don't propose changes yet. I'll confirm or correct your understanding,
then we'll plan the change.

Forces the model to load and summarise context before generating. Catches misunderstandings before they become bad diffs.

Pattern 3: The "diff review" prompt

text
Review the staged diff (run `git diff --cached`) like a senior
reviewer. Look for:

- Bugs / off-by-one / null-safety
- Convention violations vs .cursor/rules/main.md
- Anything out of scope for the stated task
- Missing or weak tests

Output: a numbered list. Mark each item as [must-fix] or [nit].

5. Composer vs Agent — when to use which

Cursor's Composer is the "plan + multi-file edit in one shot" mode. Agent is the "autonomous loop, runs commands, iterates" mode. They sound similar; they're not.

  • Composer — you stay in the driver's seat. Good for changes you understand and just don't want to type. Predictable, fast
  • Agent — the model takes the wheel. Good for tasks where iteration is the point ("make tests pass", "debug this failing build", "port this file to TypeScript and verify by running it"). Slower, but does work you'd otherwise babysit

6. The settings worth changing on day one

  1. 1Model: default to Claude 4.x Sonnet for cost-effective general work; switch to Opus for complex reasoning; GPT or Gemini for second opinions
  2. 2Privacy mode: turn ON if you work on client code. Prevents code from being used for training
  3. 3Codebase indexing: enable. Without it, the model can't find files it hasn't seen in this session
  4. 4Auto-run mode (Agent): leave OFF until you trust your rules file. Otherwise the agent will run commands you didn't expect
  5. 5Notepads: discover them in the sidebar. Scratch space to keep architectural notes the model can reference via @-mention

7. Keyboard shortcuts that pay rent

text
Cmd+K          Inline edit (selection or new code)
Cmd+L          Open Chat / Agent
Cmd+I          Open Composer
Cmd+/          Toggle inline comment
Cmd+Shift+L    Add selection to chat as context
Tab            Accept inline suggestion
Esc            Reject inline suggestion
Cmd+Enter      In chat: apply the last code block to the editor
@             In chat: mention a file, symbol, doc, or web URL

8. Daily habits that separate fast users from slow ones

  • Re-read the diff before accepting. Even when you trust it. Especially when you trust it
  • Keep the rules file fresh — every time the model does something wrong twice the same way, that's a rule it's missing
  • Don't fight a bad chat session — start a new one. Long conversations drift
  • Use @docs for libraries the model doesn't know well (Cursor will fetch and ground on real docs instead of hallucinating APIs)
  • Pair Cursor with a separate Claude Code session for big terminal-driven refactors — Cursor for in-editor, Claude Code for cross-cutting CLI loops. They complement, they don't compete

9. Common mistakes we still see in 2026

  1. 1Opening Chat for everything. Cmd+K is faster for ~60% of edits
  2. 2No rules file. Every conversation reinvents your conventions, badly
  3. 3Letting the agent run shell commands you didn't sanity-check. Auto-run is convenient until it isn't
  4. 4Stuffing the chat with 20 files via @. Token budget matters; pick the 3 most relevant
  5. 5Not using MCP. Live data > stale paste

TL;DR

  • Know the three modes — Tab, Cmd+K, Chat/Agent — and use the lightest one that does the job
  • Write a .cursor/rules/main.md today. Update it whenever the model gets your conventions wrong
  • Add 2–3 MCP servers (Postgres, GitHub, Linear are the cheapest wins)
  • Prefer spec-first prompts; force the model to read before it writes
  • Composer for predictable multi-file edits; Agent for tasks that need iteration
  • Keep chats short, rules tight, diffs reviewed

Rolling Cursor out to a team and want a starter rules file plus a prompt library? Drop us a paragraph about your stack and we'll send back a tailored bundle, free.

#Cursor#AI Coding#Tutorial#Productivity#Workflow
Back to all posts

Up next

AI

Vibe coding in 2026: what it's actually good for (and where it bites)

Half the engineers we know vibe-code their way through a Saturday side project and half their Monday standup. Here's where vibe coding earns its keep in 2026 — and the failure modes nobody wants to admit on Twitter.

AI

Spec-driven development: how teams actually ship AI-written code in 2026

"Vibe coding" got us all to a demo. Shipping production software with AI needs something stronger — a spec-first loop with executable checks. Here's the workflow we've standardised on in 2026.

Tutorial

How to use Google Antigravity: a hands-on guide to the new agentic IDE

Google Antigravity launched in November 2025 and the search volume hasn't slowed since. Here's a hands-on guide: install, run your first agent, wire it to your project, and use the Inspector the way it's meant to be used.

Have a project?

Building something we've just written about?

Drop us a line. We respond within 24 hours with a candid, no-pressure take on whether we're the right partner.

Start a conversationRead more posts