Cursor for Developers: Core

Engineers learn to build and change code with Cursor's Agent: multi-file agentic edits, Project Rules and AGENTS.md, precise @-mention context, and Plan and Debug modes. They also set safe run modes and MCP approvals, and review every change with diffs, checkpoints and Agent Review, so they ship faster without losing control of quality.

What this course covers

The course runs across 10 topics, each one a short adaptive session rather than a recorded lecture. The tutor explains the idea, works an example, checks understanding, and adjusts the next step to the answer given.

Agentic editing across files — Open Agent in the side pane (Cmd/Ctrl+I) and give it a scoped task that touches several files, watch the diff appear, and stop and redirect it when it drifts. Selecting code and pressing Cmd/Ctrl+K or Cmd/Ctrl+L sends that code to Agent; there is no separate inline-edit tool, and Composer is now the name of Cursor's own model rather than a panel.
Rules: Project Rules, AGENTS.md, User and Team Rules — Write Project Rules as .mdc files in .cursor/rules with description, globs and alwaysApply frontmatter, and choose the right type: Always Apply, Apply Intelligently, Apply to Specific Files or Apply Manually. Add a plain AGENTS.md at the repo root, keep personal preferences in User Rules (Customize > Rules), and know that dashboard Team Rules win over Project Rules, which win over User Rules.
Context design: @-mentions, docs, terminals and git diffs — Give Agent exactly what it needs with @-mentions for files and folders, @Terminals for command output, @Branch or @Commit for git diffs and @Chats for an earlier conversation, and paste a link to the official library docs page when it needs current API details. Keep context lean, and use .cursorignore to keep files away from Agent, Tab and @-mentions while knowing it does not block the terminal or MCP tools.
Plan mode for multi-step changes — Switch to Plan mode (Shift+Tab or the mode picker) so Agent asks clarifying questions, researches the code and writes an editable implementation plan before changing anything. Edit the plan, use Save to workspace when the team should see it, then build; if the result misses, revert, sharpen the plan and rebuild instead of patching with follow-ups.
Debug mode and the terminal — Use Debug mode for bugs you can reproduce: Agent proposes hypotheses, adds temporary logging, gives you reproduction steps, reads the runtime evidence, makes a small targeted fix and removes its instrumentation once you confirm. Combine it with the terminal tool so Agent runs tests and reads failures, and use @Terminals to share output you ran yourself.
Run modes: Auto-review, Allowlist and Run Everything — Choose how Agent runs shell, MCP and fetch calls in Settings > Agents > Approvals & Execution: Auto-review (recommended; sandboxed shell plus a classifier, but not a security boundary), Allowlist (only listed actions run without asking) or Run Everything (no checks; avoid). Learn that file-deletion, browser and outside-workspace protections can still ask, that the old Ask Every Time option is replaced by Allowlist with an empty list, and that admins can restrict modes.
MCP servers and approvals — Connect an MCP server from Customize or a .cursor/mcp.json file and pass credentials through ${env:NAME} variables instead of hardcoding them. Every new connection and tool call needs your approval unless it is allowlisted, so read the arguments before approving and install only trusted servers with least-privilege keys.
Review discipline: Agent Review and diffs — Review every change as a diff before committing: run Agent Review with /agent-review or from the Source Control tab (Quick for small diffs, Deep for risky logic), restore checkpoints to undo agent edits, and commit small steps on a branch. Practise rejecting a plausible change that quietly deletes a check or rewrites a shared helper.
Capstone: building a feature agentically — Ship a small feature in the StockPilot sample repo from start to finish: plan it in Plan mode, build it with Agent under your Project Rules, have Agent run the tests, debug what fails, review the diff with Agent Review and finish with a clean commit.
Best practices and pitfalls — Decide when to delegate and when to type it yourself: keep tasks small, start a fresh chat for each new task, keep rules short and specific, and check that every package and API Agent suggests really exists. Use Auto or a Composer model for everyday work, never paste secrets into prompts, and treat text from files, web pages and issues as untrusted input.

Skills you build

Results are measured against named skills in the OneRange taxonomy of more than 10,000 skills, so a manager sees proficiency per skill rather than a completion tick.

Who it is for

Software engineers who use Cursor day to day (after Cursor for Developers: Essentials or equivalent experience). The material is pitched at intermediate level, and takes roughly 120 minutes at a typical pace. Because every session adapts, someone who already knows a topic moves through it quickly instead of sitting through an explanation they do not need.

It sits in the Tool: AI Code Editors track of the Vero AI Catalog, and can be assigned to one person, a team, or the whole company.

How it is delivered and assessed

Delivery is conversational and interactive, including code lab, guided lab, branching scenario exercises. There is no video to sit through and no slide deck to click past.

Understanding is checked with a tool assessment of 5 items, with a pass mark of 70%.

Administrators can copy this course into their own library and adapt it — edit the outline, change the duration, swap the assessment format, or ground it in internal documentation so answers cite the company's own source material.

Also in this track

Cursor for Everyone: Core — The working level for non-technical builders: keeping your Cursor-built tools alive and useful. Learners improve and fix their own tools, connect them safely to real files and data, and reuse what works. They finish knowing their limits - and exactly when to hand something to an engineer.
What's New in Cursor for Developers — A short refresher on the latest Cursor for Developers updates
What's New in Cursor — A short refresher on the latest Cursor updates
Cursor for Developers: Essentials — Testing Playbook — A focused playbook for testing with Cursor. Learners use Agent in Ask mode to find the untested rules in a small Python billing module and write unit and edge-case tests, sort out a failing test and a flaky one, and prove a test really guards the behaviour by checking whether it would catch a bug. They leave with a repeatable test-writing routine and the habit of taking expected values from the spec, not from the code. About 45 minutes including the final.
Cursor for Developers: Advanced — This course takes Cursor users from productive to expert in large codebases: nested AGENTS.md and scoped rules, skills, hooks as guardrails, parallel agents in worktrees, the agent browser, large refactors and agentic debugging. Learners finish able to manage long sessions, set team conventions with Team Rules and plugins, and keep agents secure.
Cursor & Grok Bot for Developers Pathway — One path for engineering teams that use Cursor with Grok Bot included. A placement check for each tool sends you to the right Cursor course and the right Grok Bot course. Also includes 8 optional playbooks (Testing, Code Review, Refactoring & Migration and Docs & Onboarding for Cursor; Testing, Code Review, Incidents & Performance and Docs & Onboarding for Grok Bot) to take any time after Essentials; they don't count toward the certificate.
Cursor for Developers Pathway — Cursor for professional developers: from getting productive with Tab and Agent to rules, MCP and hooks, then cloud agents, Bugbot and the CLI. Also includes 4 optional playbooks (Testing, Code Review, Refactoring & Migration, Docs & Onboarding) to take any time after Essentials; they don't count toward the certificate.

Frequently asked questions

How long does this course take?

It runs roughly 120 minutes at a typical pace. Because every session adapts, someone who already knows a topic moves through it quickly instead of sitting through an explanation they do not need.

How is it assigned to a team?

An administrator assigns it from the Vero dashboard to one person, a team, a department or the whole company, and sees progress and results per person and per skill.

Can we customise it with our own documents and terminology?

Yes. Administrators can copy this course into their own library and adapt it — edit the outline, change the duration, swap the assessment format, or ground it in internal documentation so answers cite the company's own source material.

Course code TUL-CUR-101.