Module 01
2 exercises
Basics
Get productive in Cursor fast — the core edit loop and shortcuts.
2 lessons
Start module
Anysphere · Course
Learn Cursor.
Cursor is an AI-first code editor built on VS Code. Its edge is working *inside* a real codebase: indexing, rules, and agentic edits across files. This hub breaks Cursor down by intent — pick what you're doing, then drill into tested knowledge cards.
Course syllabus
A practical path through Cursor.
Move through the modules in order, or return to the part of your work that needs attention now.
Module 02
3 exercises
Coding
Generate, debug, and refactor code across a real project in Cursor.
3 lessons
Start module
Module 03
1 exercise
Workflows
Multi-step, agentic development loops in a real repo.
1 lesson
Start module
Module 04
3 exercises
Hidden Features
Capabilities most people miss — Rules, Agents, and Indexing.
3 lessons
Start module
Module 05
1 exercise
Advanced
Context control and model selection for power users.
1 lesson
Start module
Module 06
1 exercise
Mistakes
The common errors that make Cursor work against you — and how to avoid them.
1 lesson
Start module
How to use Cursor well
What makes Cursor different from a chat assistant
Cursor is an AI-first code editor built on top of VS Code, so it feels instantly familiar — same layout, same extensions, same keybindings. The difference is where the AI lives. Instead of copying code out to a chat window and pasting answers back, Cursor works inside your real codebase: it indexes your project, edits across multiple files, and runs an agent that can plan and apply changes while you watch. That in-editor context is the whole point. A general chatbot only knows what you paste; Cursor can see the surrounding code, your conventions, and how the pieces connect.
If you are coming from VS Code, start with the fast wins: inline edit to change the code under your cursor in place, and tab-completion that understands the file you are in. These cost nothing to learn and immediately show why an AI editor beats round-tripping through a separate window.
The two features that make or break results: rules and indexing
Two Cursor features do most of the heavy lifting, and both are about context. Rules are persistent instructions Cursor applies to every request — your stack, your conventions, the patterns you want and the ones you have banned. Written well, rules stop you from re-explaining your project in every prompt and keep generated code consistent with what already exists. Indexing is how Cursor understands a codebase it has never been told about explicitly: it builds a searchable map of your files so the agent can pull in the right modules on its own.
Get these two right and everything else improves. The most common reason Cursor produces off-target edits is not a weak model — it is thin context: no rules, a stale index, or a prompt that never pointed at the relevant files. Manage context deliberately (the advanced cards go deep on this) and the quality jumps.
Working with the agent instead of fighting it
Cursor's agent can take a goal, plan a set of edits across files, apply them, and iterate — the agent loop. Used well it is genuinely fast; used carelessly it sprawls. The reliable pattern is to give it a scoped task with clear acceptance criteria, let it propose a plan, review the diff before accepting, and keep changes small enough to verify. For debugging, point it at the actual error and the failing path rather than describing the symptom, and for refactoring, name the safe steps you want rather than asking for a vague 'clean this up'.
Treat the agent like a fast junior engineer who has read your whole repo: brilliant at the mechanical work, but it still needs a clear brief and a review before merge.
Where to go next
The fastest way to level up in Cursor is to fix your context foundation first — write real rules, keep the index fresh, and be deliberate about what the agent can see. Pick the intent below that matches what you are doing and drill into the tested knowledge cards underneath.
Frequently asked
Is Cursor free?
Cursor has a free tier that covers basic usage and a paid Pro plan that raises limits and unlocks heavier use of the strongest models and the agent. For trying it out and light work the free tier is fine; if Cursor becomes your daily editor and you lean on the agent, the paid plan quickly pays for itself.
Is Cursor better than GitHub Copilot?
They solve overlapping problems differently. Copilot is an assistant layered into your existing editor; Cursor is a full AI-first editor built around codebase indexing, project rules, and a multi-file agent. If you mostly want smart autocomplete, Copilot is enough. If you want the AI to understand and edit across your whole project, Cursor's deeper context integration is the reason people switch.
Can Cursor use my existing VS Code setup?
Yes. Cursor is built on VS Code, so it imports your extensions, themes, keybindings, and settings, and it feels like the editor you already know. That familiarity is deliberate — the learning curve is almost entirely about the AI features (inline edit, rules, indexing, and the agent), not the editor itself.
What are Cursor rules?
Rules are persistent instructions Cursor applies to every AI request — your tech stack, coding conventions, preferred patterns, and things to avoid. They mean you stop re-explaining your project in each prompt and get output that matches your existing codebase. Well-written rules are the single biggest quality lever in Cursor.
Why does Cursor sometimes make bad edits?
Almost always it is a context problem, not the model. The usual causes are missing or vague rules, a stale codebase index, or a prompt that never pointed the agent at the relevant files. Tighten the context — real rules, a fresh index, and a scoped request that references the right code — and the quality of edits improves sharply.
What is the Cursor agent?
The agent takes a goal, plans a set of changes across your files, applies them, and iterates toward the result — the agent loop. It works best on scoped tasks with clear acceptance criteria: let it propose a plan, review the diff before accepting, and keep each change small enough to verify rather than handing it a sprawling, open-ended request.
Course checkpoint
Cursor Master Quiz
Eight questions spanning everything Cursor — the inline edit loop, @-context, Rules, agents, indexing, and the context mistakes that produce confident edits in the wrong file. Take it as a diagnostic: whatever you miss tells you which topic to read next. No sign-up, instant score, and you can share how you did.