Cursor 2.0 - Full Tutorial for Beginners

One Sentence Summary

A practical guide to Cursor 2.0's AI-enhanced VS Code workflow, covering planning, multi-agent tasks, testing, and version control strategies today.

Main Points

• Cursor 2.0 adds AI on top of VS Code core features.
• Start projects by storing code in a dedicated folder.
• Composer model released for faster, multi-agent code generation.
• New UI redesign; understand editor vs agent views.
• Change themes via command palette and color themes.
• Panels are resizable/draggable; customize workspace.
• Agent pane vs editor pane have distinct roles.
• Use left/right panels and terminal toggle for layout.
• Before prompting, define project goals and outcomes.
• Multi-agent workflows enable parallel tasks and reviews.

Takeaways

• Plan project scope before asking AI to generate code.
• Use plan/agent/ask modes for safe, scalable automation.
• Rely on built-in review/diff to maintain code quality.
• Leverage the web-browser test feature to validate end-to-end flows.
• Iterate Markdown plan and to-dos; evolve with feedback.

---

1. Extended Summary

This tutorial explains how to use Cursor 2.0, an AI-powered code editor built as a fork of VS Code, to generate, edit, and manage code using AI agents. The core skill taught is building applications (e.g., a Tetris game) using agent-driven workflows, including planning, generating code, reviewing diffs, testing locally, and managing changes with Git. It emphasizes agent modes (Plan, Agent, Ask), multi-agent workflows, and safe iteration practices like reviewing diffs and using version control.

---

2. Detailed Step-by-Step Breakdown

Step 0: Prerequisites

• Install Cursor (from official website)

• Sign in to your account

• (Optional but recommended) Install:

  • Git
  • Live Server extension

---

Step 1: Open a Project Folder

1. Launch Cursor

2. Navigate:

   File → Open Folder
   

3. Create/select a project directory (e.g., demo2)

4. All generated code will be stored here

---

Step 2: Configure Editor (Optional)

• Open command palette:

  Ctrl + Shift + P  (Windows/Linux)
  Cmd + Shift + P   (Mac)
  

• Search:

  Preferences: Color Theme
  

• Select theme (e.g., Monokai)

---

Step 3: Understand Core UI Panels

• Editor View → file-based coding

• Agent View → AI agents + chat

• Toggle panels:

  • Left sidebar (agents/files)
  • Terminal
  • Right editor/chat pane

---

Step 4: Generate a Plan (Best Practice)

1. Switch to Plan Mode

2. Example prompt:

   Build a simple Tetris web app (MVP) with:
   - basic gameplay
   - scoring
   - browser-based
   

3. Press Enter

4. Output:

   • Markdown plan (.md)
   • Task list (e.g., 9 steps)

---

Step 5: Execute Plan (Build Phase)

1. Click:

   Build → Build Locally
   

2. Cursor:

   • Spawns AI agent
   • Executes steps
   • Generates files

---

Step 6: Review Generated Code (CRITICAL STEP)

1. Click:

   Review
   

2. Inspect diff view:

   • Shows all changes made

3. Key behavior:

   • Code is already written to disk

   • Options:

     • Keep All → accept changes
     • Undo All → revert

⚠️ Important:

• If you proceed without reviewing, changes persist
• Undo option may disappear later

---

Step 7: Test the Project

1. Switch to Ask Mode

2. Prompt:

   How do I run this project?
   

3. Likely output:

   • Install Live Server

4. Steps:

   Extensions → Search "Live Server" → Install
   

5. Run app:

   Right-click index.html → Open with Live Server
   

6. Verify functionality in browser

---

Step 8: Accept Changes

• If working:

  Keep All
  

• Otherwise:

  Undo All → Re-run agent with fixes
  

---

Step 9: Use Multiple Agents

• Create new agent for separate tasks:

  New Agent → Prompt
  

Example:

Create a landing page with a "Play" button linking to the game

• Run concurrently with other agents

---

Step 10: Use Agent Modes Correctly

---

Step 11: Make Targeted Edits

Inline Edit

• Highlight code

• Press:

  Ctrl + K
  

• Example:

  Add comments and clean up this function
  

Context Injection

• Reference code:

  Ctrl + L
  

• Or manually:

  @filename.js
  

---

Step 12: Enable Autocomplete

• Start typing code

• Press:

  Tab
  

• Accept AI suggestion

---

Step 13: Add Rules (Very Powerful)

1. Go to:

   Settings → Rules
   

2. Add project rule:

   Always generate docstrings for functions
   

3. Options:

   • Always apply
   • File-specific
   • Intelligent application

---

Step 14: Use Git (Version Control)

Prompt agent:

Initialize git and save project

Agent executes:

git init
git add .
git commit -m "initial commit"

Benefits:

• Rollback changes
• Track history
• Prevent catastrophic AI edits

---

Step 15: MCP (Advanced Integration)

• Add via:

  Settings → MCP Servers
  

• Enables:

  • API calls
  • Tool execution
  • External integrations

---

3. Key Technical Details

Core Software

• Cursor 2.0 (VS Code fork)

• Built-in Composer model (default AI model)

• Supports:

  • GPT
  • Claude
  • Gemini

Modes

• Plan, Agent, Ask

Commands / Shortcuts

• Command palette:

  Ctrl/Cmd + Shift + P
  

• Inline edit:

  Ctrl/Cmd + K
  

• Reference code:

  Ctrl/Cmd + L
  

File Types

• Plans stored as:

  .md (Markdown)
  

• Rules stored as:

  .mdc (Cursor rules file)
  

Extensions

• Live Server → local web testing

Version Control

• Uses:

  git
  

---

4. Pro Tips

• Always start with Plan Mode → reduces chaotic code generation

• Use Ask Mode before running anything → prevents unintended file changes

• Test BEFORE “Keep All” → avoids locking in broken code

• Use multiple agents for parallel work → faster development

• Use rules for consistency → avoids repeating instructions

• Reference specific files/functions → improves accuracy of edits

• Switch to smaller edits over time → more predictable results

---

5. Potential Limitations / Warnings

• ⚠️ Agent Mode can make large, unpredictable changes
• ⚠️ Diff view is confusing for beginners
• ⚠️ Undo option may disappear over time
• ⚠️ AI may generate unnecessary or bloated code
• ⚠️ Requires manual validation/testing
• ⚠️ Git knowledge is strongly recommended
• ⚠️ Plans may not always match expectations

---

6. Recommended Follow-Up Resources

• Learn Git fundamentals (critical for safety)

• Explore VS Code features (Cursor inherits them)

• Study:

  • Prompt engineering for dev tools
  • Frontend basics (HTML/CSS/JS)

• Experiment with:

  • MCP servers
  • Multi-agent workflows

---

7. Suggested Books (5)

1. Clean Code — Robert C. Martin

A foundational guide to writing readable and maintainable code. Helps you refine AI-generated code by understanding what “good code” actually looks like and how to improve structure, naming, and logic.

2. The Pragmatic Programmer — Andrew Hunt & David Thomas

Covers practical development workflows, debugging, and tooling strategies. Particularly useful for managing AI-assisted coding workflows and making smart engineering decisions.

3. You Don’t Know JS Yet — Kyle Simpson

Deep dive into JavaScript fundamentals. Essential for understanding and modifying frontend projects like the Tetris app generated in the tutorial.

4. Pro Git — Scott Chacon & Ben Straub

Comprehensive guide to Git. Directly supports the tutorial’s emphasis on version control, commits, and recovering from bad AI-generated changes.

5. Designing Data-Intensive Applications — Martin Kleppmann

While more advanced, this book builds strong architectural thinking. Helps when scaling beyond simple apps and using AI tools to build real-world systems with reliability and performance in mind.