AI AI Tools Guidebook
AI Tool Tutorials

Cursor Beginner Guide: From Install to First Real Edit

Cursor's real learning curve isn't install — it's knowing when to use Tab, Inline edit (Cmd-K), Composer (Cmd-I), Chat (Cmd-L), or Agent mode. Five surfaces, four real edits, with June 2026 pricing and models.

Published: Updated: Author: AI Productivity Guide Team 🌐 查看中文版本

TL;DR

Cursor is VS Code with five AI surfaces bolted on. The install takes two minutes; the skill is matching the surface to the task. Use Tab to finish the line you are typing, Inline edit (Cmd-K) to rewrite a selected block, Composer (Cmd-I) for reviewable multi-file changes, Chat (Cmd-L) to ask questions without touching code, and Agent mode when you want Composer to run terminal commands and fix its own errors without stopping for approval. The free Hobby tier is enough to evaluate Cursor; Pro is $20/month (as of June 2026). This guide gets you from a fresh install to four real edits in about an hour.

What this covers

Cursor markets itself as “VS Code with AI inside,” but the actual learning curve is figuring out which AI surface to use when. Tab completion, Inline edit, Composer, Chat, and Agent each have a real sweet spot and a real failure mode. This guide walks through install, the first indexing run, the model picker, and four real edits — one per AI surface — so by the end of an hour you know which keystroke to reach for.

Who this is for

Developers who want AI inside their editor rather than in a separate chat tab. Coming from plain VS Code or JetBrains, the transition is friction-free — Cursor is a fork of VS Code, so your extensions, themes, and keybindings come across. If you want a wider walk-through (Inline vs Composer vs Chat, indexing, @Files, rollback), start with Cursor for beginners — 30 minutes to a working loop.

The five surfaces at a glance

Cursor 3 (current as of June 2026) reorganized the AI features into an agent-first layout, but the five surfaces below are still the ones you reach for by keystroke. Here is the decision table to keep open while you learn:

SurfaceShortcut (macOS / Win-Linux)What it doesReach for it when
TabTabPredicts the next edit, often across multiple lines or your next jumpYou are mid-line and the next token is obvious
Inline editCmd-K / Ctrl-KRewrites the selected block in place with a prompt barOne function or one block needs changing
ComposerCmd-I / Ctrl-IEdits many files at once, then shows a unified diff you step throughA change spans several files and you want to review each hunk
ChatCmd-L / Ctrl-LAnswers questions; does not edit unless you apply a suggestion”Why does this code do X?” or planning before editing
Agent modeinside Composer / Agents WindowComposer without per-step approval — reads files, writes code, runs terminal commands, reads stdout, fixes errors, and loopsA larger task you are willing to let run, then review at the end

One common point of confusion: Composer was not renamed to Agent. Composer is the panel; Agent is the mode inside it that drops the per-step approval gate and lets Cursor run commands on its own. In Cursor 3 you can also open Cmd-Shift-P → "Agents Window" to see every running agent (local and cloud) in one sidebar.

Before you start

  • Have a real repository to test in — not a fresh npm create. Cursor’s value shows up at scale, where it can use surrounding code as context.
  • Know your project conventions: lint rules, formatter, test command. Cursor produces cleaner output against a clean baseline.
  • Pick a small, low-risk, reversible task for the first AI edit.
  • Decide your model strategy. The free Auto model (which routes to Composer 2.5 and cheaper models) is fine for most edits; you can switch to a named frontier model per request from the picker.

Step by step

  1. Install Cursor from cursor.com. The first launch offers to import VS Code settings, extensions, and keybindings — accept; the import is non-destructive and leaves your VS Code install untouched.
  2. Open a project. Indexing starts automatically and can take 30 seconds to a few minutes depending on repo size — it builds a local embedding index so Cursor can pull relevant files into context. Add a .cursorignore for node_modules, build output, and large data files before the first index. If the repo is new to you, run a guided AI codebase tour in Chat while indexing finishes.
  3. Open the model picker (the model name in the bottom-right of any AI panel). Leave it on Auto to start — Auto balances cost and capability and draws from the same usage pool as Composer 2.5 at lower prices. Pin Claude Sonnet 4.6 or Opus 4.7 for harder agent runs, GPT-5.5 for terminal-heavy work, and Composer 2.5 for fast inline edits.
  4. Try Tab completion first. Type a function signature, pause, accept the suggestion with Tab. Tab is the lowest-stakes surface and the one you will use a hundred times a day. It predicts not just the rest of the line but often your next edit elsewhere in the file.
  5. Try Inline edit (Cmd-K / Ctrl-K). Select a function, hit the shortcut, describe a change: “convert this to async/await and preserve error handling.” Knowing when to use agents vs autocomplete keeps you from reaching for Composer on a one-line tweak.
  6. Try Composer (Cmd-I / Ctrl-I) for multi-file edits. Describe the task in two or three sentences with explicit file scope: “In src/api/, replace every call to request.json() with await request.json(). Do not touch tests.” Step through each diff before accepting.
  7. Try Chat (Cmd-L / Ctrl-L) for explanations and exploration. Chat does not edit code by default — it answers, and you decide what to apply. Highlight buggy code and press Cmd-Shift-L / Ctrl-Shift-L to drop the selection straight into Chat.

First-run exercise

  1. Pick a small, isolated task: rename a variable across a few files, add a missing prop type, or add JSDoc to one module. Reversible and low-risk.
  2. Do one variant with Inline edit and one with Composer. Compare the experience directly.
  3. Note which surface fit which task. The pattern is stable: single-function change → Inline; cross-file change → Composer; “why does this code do X?” → Chat; “finish this line” → Tab.
  4. Commit between AI edits. Rollback is far easier when each step has its own commit and you can git diff exactly what Cursor touched.

Cursor pricing, as of June 2026

You can learn every surface on the free tier before paying anything. Here are the current individual and team plans from cursor.com/pricing:

PlanPrice (USD/month)AnnualWho it’s for
HobbyFree—Evaluation; limited Tab completions and Agent requests, no card required
Pro$20~$16/mo billed annuallyDaily individual use; extended Agent limits, $20 of frontier-model credits, MCPs and cloud agents
Pro+$60—Heavier agent usage with more included credits
Ultra$200—Power users running long agent sessions all day
Teams (Business)$40 per seat—Centralized billing, SSO, team-wide privacy mode, Bugbot code reviews

In June 2025 Cursor moved from request-based to usage-based billing: a fixed monthly fee with included dollar credits, plus pay-as-you-go charges if you exceed them. The free Hobby tier hits its Tab and Agent caps quickly under daily use; for most working developers Pro pays for itself within the first week.

Which model to pick

Cursor exposes its own models and the frontier providers through one picker. As a starting point (June 2026):

ModelBest forCost note
Auto / Composer 2.5Fast inline edits, refactors, everyday agent runsCheapest; Composer 2.5 runs at roughly a tenth the per-token cost of the frontier models
Claude Sonnet 4.6Long agent runs that need stronger judgmentMid; 1M-token context
Claude Opus 4.7Hard architectural calls, design opinions (87.6% on SWE-bench Verified)Highest; reserve for the genuinely difficult tasks
GPT-5.5Terminal-heavy work (leads Terminal-Bench 2.0 at 82.7%)High
Gemini 3.1 ProRead-heavy review passes, large-context reasoningLower per-token

Composer 2.5 shipped on May 18, 2026 and matched Opus 4.7 and GPT-5.5 on two of three public benchmarks at roughly one tenth the per-token cost, which is why Auto is a sensible default for most of your edits. Spend the expensive models on the genuinely hard work.

Quality check

  • Review every Composer diff. Cursor will sometimes touch a file you did not intend; reject those hunks.
  • Run your full test suite after multi-file edits. Cursor catches type errors but not behavioral regressions.
  • Confirm your .cursorignore excludes what you expect. Indexing private data or build output is both slow and a privacy risk.
  • Verify the model is the one you selected. Under load, Auto may route to a cheaper model than you want for a hard task — pin a named model when it matters.

Common mistakes

  • Letting Composer or Agent mode run on a dirty working tree. If something goes wrong you cannot tell what Cursor changed versus what you changed. Commit first.
  • Skipping .cursorignore. Indexing node_modules is slow and pollutes context with irrelevant files.
  • Letting initial indexing run for hours without checking why (why indexing never completes).
  • Editing a file in another window while Cursor still has a stale view of it (IDE state out of sync).
  • Layering project, workspace, and user rules files on top of each other and getting silent contradictions (Cursor config conflict).
  • Using Composer for a one-line change. It is overkill, and the diff review takes longer than the edit. Use Inline edit instead.

How to reuse this workflow

  • Keep a .cursorignore template you reuse across projects: node_modules/, dist/, *.log, large data files, secrets.
  • Add a project rules file (.cursor/rules/ in current Cursor) with your team’s coding conventions. Cursor reads them as standing context for every AI request.
  • Save common Inline edit prompts as snippets: “convert to async/await,” “add types,” “extract to helper.”
  • Re-check the surfaces after major Cursor releases. Cursor ships fast — Composer 2.5 and the Agents Window both landed in 2026 — and keystrokes occasionally shift.

FAQ

  • Is Cursor different enough from VS Code to justify switching?: If you write code daily, the five AI surfaces alone are worth it. Everything else is VS Code with your existing extensions, themes, and keybindings carried over by the import on first launch.
  • How does Cursor compare to Claude Code or Codex?: Cursor is editor-first; Claude Code and Codex are agent-first (terminal). Cursor wins for the IDE workflow and Tab completion; the others win for hands-off, long-running task execution. See Cursor vs Claude Code.
  • Do I need a paid plan?: No — the free Hobby tier is enough to learn every surface. But daily use hits the Tab and Agent caps quickly, and Pro at $20/month (as of June 2026) tends to pay for itself within a week.
  • Which model should a beginner use?: Start on Auto. It routes to Composer 2.5 and cheaper models, which handle most inline edits and refactors well. Switch to Claude Opus 4.7 or GPT-5.5 only for genuinely hard tasks.
  • What is the difference between Composer and Agent mode?: Composer edits multiple files and shows you a diff to approve. Agent mode is Composer without the per-step approval — it also runs terminal commands, reads the output, and fixes its own errors until the task is done. Use Agent mode only on a committed, clean repo.
  • Will Cursor work offline?: The editor works offline; the AI features need a network connection. The codebase index itself lives locally.

Tags: #AI coding #Tutorial #Cursor

Related Articles