GuideBeginner
Cursor Essentials
Learn to direct Cursor with judgment on a real repository, not just to know its buttons. Cursor is Anysphere's fork of Visual Studio Code that puts AI at the center of the editor — not as just another extension — and this guide teaches the mental model "familiar editor + an agent that acts inside the open project" across eight modules, all built on the same case: Reservo, a coworking room-booking backend. You go from Tab (predictive autocomplete) to Cmd-K (inline editing), to Agent mode and Plan mode (goal-driven multi-file editing), to the context an agent uses before it acts (@-mentions and project rules in `.cursor/rules`), to MCP inside Cursor as an external context source, to the discipline of reviewing production diffs, and close with a project that chains all seven surfaces together on a new, unsolved feature. Every claim about Cursor's behavior is verified against `cursor.com/docs`; all the code presented as a result actually runs, with Python 3.14.
- 64
- lessons
- 8
- modules
- English · Spanish
- available in
- Yes
- certificate
- Free
- access
Outcomes
What you'll be able to do
- Define what Cursor is, and why "AI at the center of the editor" is a distinct product category from "editor plus AI extension"
- Use Tab with judgment: recognize that it predicts your next edit — not just the next token — and decide when to accept, reject, or partially accept its multi-line and cross-file suggestions
- Use Cmd-K for targeted edits: select the exact block, describe the intent, read the diff before accepting it, and refine it with a follow-up instruction
- Tell Agent mode (executes directly) apart from Plan mode (investigates and proposes a reviewable plan) for multi-file tasks, and know when each one applies
- Give the agent context with one-off @-mentions and persistent project rules in `.cursor/rules/*.mdc`, with its four application patterns
- Connect MCP servers inside Cursor (`.cursor/mcp.json`) as a third source of context, understanding its three transports: stdio, SSE, and Streamable HTTP
- Apply a confidence gradient when reviewing a diff based on which file it touches, and tell Cursor's Checkpoints apart from git (a local safety net, not a replacement)
- Recognize when Agent mode is the wrong tool for a task — money, migrations, security — and when it's better to drop down to Cmd-K or do it by hand
- Chain Cursor's seven surfaces into a single production workflow, on a real feature with genuine business ambiguities
Before you start
What you need to bring
It's for you if...
- Developers who already use, or are about to use, Cursor and want to direct it with judgment, not just know its features
- Devs coming from VS Code who want to get more out of Cursor beyond basic autocomplete
- Teams that need a discipline for reviewing AI-generated diffs before merging to production
- Anyone who needs to decide, with judgment, when to use Tab, Cmd-K, Agent mode, or Plan mode depending on the task
Requirements and materials
- Having used some code editor: the idea of opening a folder, editing a file, and running a terminal
- Basic Python to run the Reservo case examples: reading a function, a `@dataclass` class, an import
- Cursor itself is not required: the product's actions are described and verified against the official documentation
Content
The syllabus, module by module
Open any of them to see its lessons.
- Module 1: What Cursor Is and Why It Matters to an Engineer
- What Cursor Is: an IDE with AI at the Center
- The Mental Model: Familiar Editor + Agent Inside the Project
- A First Look at the Core Surfaces
- Touring the Reservo Repository
- Running Reservo As-Is
- The Map: Which Task, Which Cursor Surface
- Mini-Project: Your First Orientation Session in Cursor
- Module 2: Tab — Predictive Autocomplete
- What Tab Predicts: the Next Edit, not the Next Token
- Multi-Line Edits in a Single Suggestion
- Jumping to the Next Edit Location After Accepting
- Cross-File Predictions: the "Portal" Window
- Accepting, Rejecting, and Partial Accepts
- The Judgment Table: When Tab, When Not
- Mini-Project: a Tab-Only Editing Session
- Module 3: Cmd-K — Inline Editing
- The Inline Edit Loop: Select, Describe, and Apply
- Reading the Colored Diff Before You Accept
- Refining a Diff with a Follow-Up Instruction
- Cmd-K's Question Mode: Explaining Without Editing
- Cmd-K vs. Tab: Who Decides the Scope
- Cmd-K vs. Agent Mode: One Block vs. a Goal
- Mini-Project: a Complete Cmd-K Editing Session
- Module 4: Agent Mode and Plan Mode — Multi-File Editing
- Agent Mode: Executing Without a Plan
- Plan Mode: Investigating Before Writing Code
- Switching Modes, and the "Composer" Naming Trap
- Planning the Cancellation Policy with Plan Mode
- Executing the Plan with Agent Mode
- Agent Mode vs. Everything Else: When the Task Truly Needs It
- Mini-Project: a Complete Agent Mode Workflow
- Module 5: Context — @-mentions and `.cursor/rules`
- The real set of context mentions today, and why the agent searches first
- @file and @folder: scoping search on purpose
- Terminal, chat, and git context: `@Terminals`, `@Chats`, `@Commit`, `@Branch`, `@Browser`
- The four patterns for applying an `.mdc` rule
- Writing Reservo's real rule, field by field
- User Rules vs. Project Rules, and the Cmd-K gap
- Mini-project: a context and rules session for Reservo
- Module 6: MCP inside Cursor
- Project `.cursor/mcp.json` vs. global `~/.cursor/mcp.json`
- The stdio transport: a server Cursor manages
- The remote transports: SSE and Streamable HTTP
- How MCP tools show up in the chat
- One-click installation from the Cursor Marketplace
- Applied to Reservo: the Agent queries the cancellation policy
- Mini-project: a complete `mcp.json` for Reservo
- Module 7: Production workflows and diff review
- The confidence gradient by surface touched
- Reading multi-file Agent mode diffs
- Checkpoints: a safety net, not version control
- The terminal sandbox by default
- When Agent mode is the wrong tool
- Five Reservo diffs: accept, adjust, or reject
- Mini-project: a complete production review session
- Module 8: Project — a complete Cursor workflow
- Starting right: mentions and rules already in context
- Plan mode investigates and queries MCP instead of asking you
- Reviewing and approving the plan
- Agent mode executes the plan across four files
- Tab and Cmd-K do the fine-tuning
- The full review before calling it done
- Project: the complete workflow and where to go next
Common questions
What people usually ask
No limit. It's a free guide: come in whenever you like, as often as you like.
No. Modules run from easier to harder, but you can jump to the one you need. Progress is saved per lesson.
Whatever is needed is listed under “What you need to bring”, above. If nothing is listed there, you can start from zero.
In the Club's WhatsApp group, and every two weeks there's a live with an instructor where questions get worked through.
Yes. It's issued automatically once you finish every lesson, with a verifiable code you can share on LinkedIn.
Start whenever you like
What students say
These reviews are from enrolled students who completed at least 50% of the course. We moderate reviews only on content grounds (spam, offensive language, personal data), never for being critical or negative.
No approved reviews yet.
Be the first to share your experience!