Cursor 2 Tutorial for Beginners: Composer, Chat, and Agent Mode

Introduction

Cursor is the most popular agentic AI code editor in 2026 — a fork of VS Code with AI bolted into every surface. Same keymaps, same extensions, same look. What’s different is that you can generate entire files, projects, or features with natural language, run multiple agents in parallel, and switch between AI-managed and hand-coded workflows fluidly.

Cursor 2.0 changed the UI substantially — the agent pane is now the center of gravity, the review flow is new, and Cursor finally has its own first-party model called Composer that runs four times faster than the equivalent third-party models on the same hardware. This is a complete beginner’s tour: install, layout, planning, agent modes, reviewing diffs, version control, rules, and MCP.

📚 Table of contents

Install and open your first folder

Download from cursor.com, install, sign in. First step inside Cursor is always the same: File → Open Folder. Create a new empty directory on your desktop, open it. Everything Cursor generates lands here. Skip this step and the model creates files in arbitrary places — don’t.

What changed in Cursor 2.0

• Composer model — Cursor’s in-house model, roughly 4× faster than comparable third-party models for code edits. New default in 2.0.
• Multi-agent in parallel — run several agents at once on different tasks in the same workspace.
• Redesigned UI — the agent chat moved to a top-level Agents view alongside Editor view. Diffs now group by file in a dedicated review pane.
• Cloud build option — offload the build step to Cursor’s cloud instead of running locally.
• Browser tool — agents can drive a real browser to test the app they just wrote.

The UI tour: Editor vs Agents views, toggles, settings

Two primary views in 2.0:

• Editor view — classic VS Code-like file editing with optional AI chat pane.
• Agents view — the list of running agents, their plans, their pending diffs.

Toggle each side panel with the buttons at top-left and top-right. Move tabs around like Chrome tabs. Pin, split, and reorder freely — everyone’s layout looks slightly different.

Change theme with Ctrl/Cmd + Shift + P → type “theme,” pick whatever. Settings wheel at top-right opens Cursor settings with sections for models, rules, MCP, tabs, privacy, telemetry.

Plan it before you build it

The single biggest determinant of agent quality is the prompt. Before you type a word into the agent pane, get clear on:

• Medium — web app, mobile, CLI, backend service?
• Visual reference — wireframe, screenshot, design mockup if it’s a UI?
• Feature list — what does v1 actually need?
• Tech stack — or are you fine letting the model pick?

Vague prompts produce wild output. Specific prompts produce useful output.

The three modes: Plan, Agent, Ask

The mode selector in the agent pane controls how aggressively the AI acts:

Composer and the model picker

Composer is Cursor’s in-house default. For most edits it’s fast and good. Switch to Claude, GPT-5, or Gemini from the model picker at the bottom of the agent pane when you want:

• Claude Sonnet/Opus — for complex refactors, long context, careful code generation
• GPT-5 — for tricky reasoning and architecture decisions
• Composer — for fast iterative edits in a tight feedback loop

Different models suit different tasks. Default to Composer and switch deliberately when the task warrants it.

Multi-agent workflow

Open a second agent for a separate task. Right rule: same context = same agent; different task = new agent.

Concrete example: agent one builds the Tetris game. Agent two builds a landing page that links to the game. Different scopes, different files mostly, different contexts — new agent.

All agents share the workspace, so they see each other’s files, but they don’t inherit each other’s chat history. Run them in parallel and check back when each one reaches “awaiting review.”

Reviewing diffs safely — the gotcha to know

The recommended review flow:

1. Switch to Editor view — the diff list is hard to scan but Editor view shows files normally.
2. Open the project and actually run it. Live Server for static sites, npm run dev for Node apps.
3. If it works, go back to Agents view and hit Keep All.
4. If it doesn’t, ask the same agent to fix the specific problem you found.
5. If it’s catastrophically broken, hit Undo All while you still can.

Don’t blindly Keep All. The Undo All button gets harder to reach the further you go.

Targeted edits, inline AI, autocomplete

Three other AI surfaces beyond the agent pane:

• Inline edit — highlight code, press Ctrl/Cmd + K, describe the change. Perfect for “rename this variable everywhere it’s used,” “add docstrings,” “extract this into a helper.”
• Add to chat — highlight code, press Ctrl/Cmd + L, the code becomes context for an Ask-mode question. Great for “what does this do,” “why isn’t this working.”
• Autocomplete — while typing, Cursor predicts the next lines. Hit Tab to accept. Faster than waiting for the agent for tiny additions.

Reference specific files in chat by typing @filename. Reference whole folders, your terminal output, or external docs the same way.

Project rules and user rules

Rules let you teach the agent house style without repeating yourself. Settings → Rules, Memories, Commands. Two scopes:

• User rules — apply globally across every project.
• Project rules — stored as .mdc files in .cursor/rules/ in the project. Version-controllable with the rest of the repo.

Examples worth setting:

• “Always generate docstrings for functions.”
• “Use TypeScript strict mode. Never use any.”
• “Write tests for every new function in tests/.”
• “Don’t modify migration files without explicit permission.”

Rules support targeting: always-apply, intelligent-apply, file-pattern-apply. Use file-pattern for “never touch *.prod.ts.”

Version control with Git (let the agent do it)

Git is non-negotiable for agent-driven work. The model will eventually do something destructive. Without commits, your only recovery is Undo All — which expires.

Easiest setup: tell the agent. “Use git to save this work,” or “initialize a git repo, commit everything, and use feature branches for new tasks going forward.” Cursor will run git init, stage files, commit, and continue. The source control panel (Ctrl/Cmd + Shift + G) shows your history.

Habit worth building: commit after every successful agent run. Two clicks. Saves you when the next agent run goes sideways.

MCP servers for external tools

Settings → Tools & MCP. Add servers that connect Cursor agents to external services — Postgres, Tiger Data, your company API, anything that speaks the Model Context Protocol.

Examples worth installing first:

• Postgres / database MCP — let the agent query your dev database when writing data-handling code.
• Browser MCP / Playwright — let the agent actually test the app it built.
• GitHub MCP — agent can open PRs, list issues, comment.
• Documentation MCP — pull official docs for libraries directly into context.

❌ Common mistakes

💡 Pro tips

Conclusion

Cursor 2.0 is still VS Code at heart, but the AI is no longer bolted on — it’s the point. The shape of effective work is: plan in Plan mode, build in Agent mode, review diffs deliberately, commit to Git, refine with inline edits and Ask. The editors that win in 2026 give you that loop with as little friction as possible.

Two weeks of using it deliberately is more valuable than reading any documentation. Build a small project end-to-end, get past the “wow this is fast” phase, and you’ll start forming the judgment that separates effective Cursor users from people who let the agent run wild.

Related reading: Claude Code hands-on deep dive — Claude Code vs Cursor AI comparison — Cursor AI full review — Neo AI browser deep dive