Skip to main content

Cursor Tutorial 2026: Setup, Tab Model, and Shipping Real Features

Cursor tutorial for 2026: install it, import VS Code, write a rules file, use Tab, Inline Edit, Agent and Plan Mode, then review the diff and ship a change.

Founder of IImagined.ai

Published
Apr 9, 2026
Updated
Oct 13, 2026
Reading time
10 min read
Quick answer

This Cursor tutorial goes from a fresh install to a deployed change in eight steps: install and import your VS Code setup, have Agent explain the codebase, write one rules file, then use Tab, Inline Edit and Agent for progressively larger edits before you review the diff and push. Start on the Free plan. Rewritten in October 2026 for the current editor: Agent and Plan Mode, project rules in .cursor/rules, and usage-based plans.

This Cursor tutorial takes you from a fresh install to a deployed change in eight steps: install Cursor and import your VS Code setup, have Agent explain your codebase, write one rules file, then use Tab, Inline Edit and Agent for progressively larger edits, review the diff and push. Budget an afternoon, start on the Free plan, and use a real project of your own, because the tools only make sense against code you care about.

Steps, shortcuts and prices checked October 2026 against Cursor's quickstart, its docs on Tab, Inline Edit, Agent, Plan Mode, rules, review and models and pricing, the pricing page, and the help center pages on migrating from VS Code, keyboard shortcuts and privacy.

If you learned Cursor from an older guide, three things have moved. The multi-file tool those guides call Composer is now Agent, and Composer is the name of one of Cursor's own models. Rules live in a .cursor/rules folder, not a single root file. And plans are no longer sold as a count of fast requests: each paid plan carries a monthly usage allowance. For where Cursor sits among the other AI coding tools, start with our Claude Code complete guide, the hub for this topic, or the head-to-head in Claude Code vs Cursor.

Cursor AI tutorial for beginners: what you will have at the end

By the last step you will have Cursor installed with your old editor setup, one rules file that teaches it your conventions, and one real change merged and live. You will also know which of the four tools to reach for, which matters more than any single prompt.

The path this tutorial follows
  1. 01
    Install

    Download, import VS Code, sign in

  2. 02
    Orient

    Agent explains the codebase

  3. 03
    Rules

    One file with your conventions

  4. 04
    Small edits

    Tab and Inline Edit

  5. 05
    A feature

    Plan Mode, then Agent builds

  6. 06
    Ship

    Review, run checks, push

What you need before you start

None of this is exotic, but the Git items are not optional. Agent edits real files, and a clean branch is what makes every mistake cheap.

Pre-flight check
  • macOS 12 or later, Windows 10 or later, or Linux (apt, dnf or AppImage)
  • A project in a Git repository, with a clean working tree
  • A new branch for this session, so main stays untouched
  • A command that proves the project works: tests, a type check, a lint run or a local build
  • Secrets kept in .env files, which Cursor ignores by default
  • If you are moving from VS Code: the names of the extensions you cannot work without
  • A host that deploys from Git, if you want the last step to end in a live change

Cursor tutorial steps 1 to 3: install, import and orient

Setup takes about ten minutes. The third step is the one people skip, and it is the fastest way to see what Agent can do without risking a single file.

Steps 1 to 3: from download to a first answer
  1. 1
    Step 1: Install and sign in

    Download Cursor from cursor.com for your OS, open it and sign in. Expected result: an empty editor window and a signed-in account.

  2. 2
    Step 2: Import your VS Code setup

    Open Cursor Settings (Cmd+Shift+J, or Ctrl+Shift+J), go to General, then Account, and click Import under VS Code Import. Expected result: your theme, keybindings and extensions appear.

  3. 3
    Step 3: Open your project and ask for a tour

    Open the folder, press Cmd+I (Ctrl+I on Windows and Linux) and type "Explain this codebase". Expected result: Agent searches the repo, reads files and summarises the project.

Two things to do while you are in settings. First, check the extensions you rely on: Cursor installs from the Open VSX registry, not the VS Code Marketplace, so a few may be missing. Second, decide on Privacy Mode. It sits under General in Cursor Settings, and with it on, Cursor's help center says your code is never used for training by Cursor or the model providers. Prompts and code context are still sent to those providers to generate answers.

How to use Cursor AI: four tools, smallest to largest

Using Cursor well is mostly a matter of picking the smallest tool that can do the job. Small tools are faster, cheaper against your allowance and easier to review.

ToolShortcut (Mac / Windows and Linux)What it works onReach for it when
TabTab to accept, Esc to rejectThe next edit, while you typeFinishing code you have already started
Inline EditCmd+K / Ctrl+KThe code you selectedOne function or block, from a one-line instruction
AgentCmd+I / Ctrl+IThe whole projectChanges across files, plus terminal commands
Plan ModeShift+Tab in the Agent inputThe whole project, plan firstFeatures where the approach needs agreeing before code
Debug ModeShift+Tab, or the mode pickerA bug you can reproduceBugs you cannot explain from reading the code

Two more shortcuts earn their place on day one: Cmd+. or Ctrl+. opens the mode menu, and Cmd+/ or Ctrl+/ cycles between models. Everything else is a standard VS Code shortcut, since Cursor keeps those defaults.

Step 4: write one rules file

A rules file is how you stop repeating yourself. Project rules are .mdc files in .cursor/rules, committed with the code, and Cursor's docs are blunt about the extension: a plain .md file in that folder is ignored. The quickest way to make one is to type /create-rule in Agent and describe what you want, or open Customize, then Rules, then Add Rule.

---
description: House conventions for this app
alwaysApply: true
---

- TypeScript strict mode. No `any`.
- Server components by default. Add "use client" only when a hook needs it.
- Tailwind for styling. No new CSS files.
- Database access goes through src/lib/db.ts. Never query from a component.
- Run `npm run lint` and `npm test` before saying a task is done.

The frontmatter decides when the rule loads. alwaysApply: true puts it in every chat. Leave that off and add globs to attach the rule when a matching file is in context, or a description so Agent can pull it in when it looks relevant. For a small project, a plain AGENTS.md in the root does the same job with no metadata.

Keep it short. Cursor's own advice is to stay under 500 lines, point at files instead of pasting them in, and add a rule only when Agent keeps making the same mistake. Expected result: the rule is listed under Rules in Customize, and the next Agent task follows it without being told. One catch: rules you set globally as User Rules apply to Agent, not to Inline Edit.

Step 5: let Tab finish your edits

Tab is Cursor's autocomplete, and it does more than complete the current line. It can change several lines at once, add a missing import and suggest the matching edit in a related file. Open a file, start a change you would normally type out, and watch for the grey suggestion.

  • Accept with Tab. Reject with Esc, or keep typing.
  • Accept one word at a time with Cmd+Right Arrow, or Ctrl+Right Arrow.
  • Jump to the next edit by pressing Tab again after you accept. When the next edit is in another file, a small portal window appears at the bottom of the editor.

Expected result: rename one prop in a component and Tab offers the same rename at the next place it is used. If suggestions get in the way while you write prose or config, click the Tab indicator in the bottom-right corner to snooze it or switch it off for that file type.

Step 6: change one block with Inline Edit

Inline Edit is for a change you can describe in one sentence and point at with a selection. Select the code, press Cmd+K or Ctrl+K, type the instruction and press Return. Cursor applies the edit in place; if it is not quite right, add a follow-up instruction and press Return again.

Good first instructions are narrow: "add input validation and return a 400 with a message", "convert this to async/await", "handle the empty state". To ask about the code without changing it, press Opt+Return or Alt+Return inside the Inline Edit box to switch to question mode. When the change turns out to be bigger than the selection, press Cmd+L or Ctrl+L and the same selection opens in Agent. Expected result: one function changed, nothing else in the file touched.

Step 7: ship a feature with Plan Mode and Agent

Agent is the tool for work that crosses files. It searches the codebase, edits files, runs shell commands and can drive a browser to test what it built. For anything larger than a quick fix, make it plan first: the approach is far cheaper to correct in a plan than in a diff.

One feature, start to finish
  1. 1
    Switch to Plan Mode

    Press Shift+Tab in the Agent input. Describe the feature, the files you expect it to touch and what done looks like.

  2. 2
    Answer the questions

    Agent researches the codebase and asks what it cannot infer. Short, specific answers beat a longer first prompt.

  3. 3
    Edit the plan

    Read it like a pull request description. Cut scope, fix the order, name the tests. Save it to the workspace if you want it in the repo.

  4. 4
    Build

    Approve the plan and watch the diff view as Agent works. It creates a checkpoint before significant changes.

  5. 5
    Steer, do not wait

    If it heads the wrong way, stop it (Cmd+Shift+Backspace) and correct it. A message typed during a run is queued for when the task finishes.

An illustrative first feature for a small app: "Add a notes field to the task model, show it on the task page and cover it with a test." It touches the schema, one API route, one component and one test file, which is enough to show the workflow without burying you in review. Expected result: a diff across three or four files that you can read in ten minutes.

When a bug resists reading, switch to Debug Mode from the same mode picker. Agent proposes several causes, adds temporary logging, asks you to reproduce the bug, reads the logs and then makes a targeted fix before removing the instrumentation. And when you want Agent to reach your database or docs, connect them through MCP: our list of the best MCP servers for coding covers which are worth installing.

Step 8: review the diff, run the checks, push

A change is shipped when it has passed your checks and reached production, not when Agent says it is done. Cursor gives you two review passes before a human reads it: click Review, then Find Issues, after a task and Agent goes through the proposed edits line by line; or tag @Branch in a prompt to hand it the full diff of your branch.

Before you push
  • Read every changed file in the diff view, not only the summary
  • Ask Agent to run the tests, type check, linter and a local build, and read the output yourself
  • Run Review, then Find Issues, and resolve what it flags
  • Check that no secrets, debug logging or unrelated files are in the diff
  • Commit with a message that says why, then push the branch
  • Open the preview deployment and click through the feature before you merge

The last item depends on your host. If the repository is connected to one that deploys from Git, the push is the deploy: Vercel, for example, builds a preview deployment for every push and a production deployment when the change merges into the production branch, per its Git documentation. Expected result: your feature is live, and you can trace it back through one pull request, one plan and one rules file.

The editor is the easy half. Deciding what to build, modelling the data and charging for it is where most projects stall, and that is where our AI SaaS Builder program picks up: it sets up Cursor alongside Supabase and Vercel, then builds a full product with the Claude API and Stripe billing.

What does Cursor cost in 2026?

You can finish this tutorial on the free plan. The paid plans differ mainly in how much model usage is included each month.

PlanPrice (read 13 October 2026)What the pricing page lists
Free$0Limited agent requests and limited chat requests
Plus$8 a monthThe introductory plan, with Grok models only
Premium$30 a month4x the usage of Plus, cloud agents and automations, third-party models at API list price
Super$100 a month15x the usage of Plus, priority model access at peak times
Ultra$200 a month50x the usage of Plus
TeamsFrom $30 a user a monthCentral billing, a team marketplace for rules, SSO, team-wide privacy settings

Cursor's docs and help centre still listed the earlier line-up that day: a free Hobby plan, Pro at $20, Pro Plus at $60 and Ultra at $200, with Teams seats at $40 and $120. The pricing page also says third-party model usage is not included in the monthly price.

Under the earlier plan names, the docs split paid usage into two pools that reset each billing cycle. The Cursor Models pool covers Cursor's own Grok and Composer models. The Other Models pool covers models from Anthropic, OpenAI, Google and others, charged at each model's API price. When the allowance runs out you can add on-demand usage at the same rates or move up a plan, and Cursor says requests are never downgraded in quality or speed.

Cursor does not publish a dollar figure for each allowance. Its docs describe who fits instead: daily Tab users typically stay within the included usage, daily Agent users typically total $60 to $100 a month, and people running several agents often pass $200. Watch your usage dashboard for the first two weeks before you pick a tier. Our Cursor review goes deeper on who the editor suits, and the Windsurf guide covers the best-known alternative.

Troubleshooting

  • An extension is missing after the import. Cursor uses Open VSX, so search there. If it is not listed, look for a maintained fork or keep VS Code for that one task.
  • Tab suggestions never appear. Click the Tab indicator in the bottom-right corner. It may be snoozed, disabled globally or disabled for that file type. The rest of the settings are under Cursor Settings, then Tab.
  • Agent ignores your conventions. Check the rule is a .mdc file inside .cursor/rules and that its type is Always Apply, or that its globs match the file you are editing.
  • Agent cannot see a file. Cursor respects .gitignore and ignores .env files, .git/ and lock files by default. Anything in .cursorignore is blocked from Agent too.
  • Agent read something it should not. Add the path to .cursorignore, and remember the gap Cursor documents: terminal commands and MCP tools run outside its file access controls.
  • The change went sideways. Stop the run, restore the checkpoint from the chat timeline, tighten the plan and start again. Do not try to argue a bad diff into shape.
  • You ran out of included usage. Switch on on-demand usage, move up a plan, or use Tab and Inline Edit for the small edits you were sending to Agent.

Cursor tutorial: FAQ

Is Cursor free to use?

Cursor has a Free plan. Its pricing page lists limited agent requests and limited chat requests. The paid individual plans are Plus at $8 a month, Premium at $30, Super at $100 and Ultra at $200, as read on 13 October 2026, and Plus runs Grok models only. Start on Free for this tutorial and upgrade once the agent limit gets in your way.

Can I use my VS Code extensions in Cursor?

Mostly. Cursor imports your VS Code extensions, themes, settings and keybindings from Cursor Settings, under General, then Account, then VS Code Import. Cursor installs extensions from the Open VSX registry, not the VS Code Marketplace, so its help center warns that not every extension is listed or works exactly the same way. Check the two or three you depend on before you switch.

What is the difference between Tab, Inline Edit and Agent in Cursor?

They are three sizes of the same idea. Tab is autocomplete that suggests the next edit while you type. Inline Edit, opened with Cmd+K or Ctrl+K, rewrites the code you selected from a one-line instruction. Agent, opened with Cmd+I or Ctrl+I, works across the whole project: it searches files, edits several of them and runs terminal commands. Pick the smallest one that can do the job.

Does Cursor still use a .cursorrules file?

Cursor's current rules documentation does not mention a .cursorrules file. It describes project rules as .mdc files inside the .cursor/rules folder, and a plain AGENTS.md file in the project root as the simpler alternative. If an older tutorial had you create .cursorrules, move its contents into AGENTS.md or a project rule so you are on a format the documentation covers.

Which model should I pick in Cursor?

Start with Auto, which routes each request and has three modes: Cost, Balance and Intelligence. If you choose by hand, know which meter you are using. Cursor's own Grok and Composer models draw on the Cursor Models pool, while models from Anthropic, OpenAI, Google and others draw on the Other Models pool at the model's API price. Cmd+/ or Ctrl+/ cycles between models.

Does Cursor train on my code?

Not when Privacy Mode is on. Cursor's help center says code is then never used for training by Cursor or the model providers, although prompts and code context are still sent to providers to produce answers. Privacy Mode is on by default for team members. On an individual plan, open Cursor Settings, click General and switch Privacy Mode on.

What is Plan Mode in Cursor?

Plan Mode makes Agent plan before it edits. Press Shift+Tab in the Agent input to switch to it. Agent researches the codebase, asks clarifying questions, writes an implementation plan and waits for your approval before building. Plans are saved in your home directory by default, with a Save to workspace option. Use it for any change that touches more than a couple of files.

Free · no card needed

Start with the free Starter Kit.

A unit economics calculator from AI SaaS Builder, plus four more working files.

Starter Kit5 files · free
All Access · all four programs · $99/mo

Cursor is set up. Now build something worth charging for.

All Access includes AI SaaS Builder, which takes the same editor through a full product: a Supabase schema with row level security, a Claude API feature, deployment on Vercel and Stripe billing. The other three programs, live coaching and the private community come with it.

See All Access: $99/mo →30-day money-back guarantee
Free

Stuck on a step?

Ask in the free Discord. Post the prompt and the diff, and someone who uses Cursor daily will tell you where it went wrong.