BEGINNER · 8 MODULES · 64 LESSONS

Cursor Essentials

Direct Cursor with judgment on a real project: choose the right way to ask for each change and review what it does before you accept it.

For you if
You use Cursor, or soon will, and want to go beyond autocomplete.
By the end
You'll know when to use Tab, Cmd-K, or each agent mode, how to add context with rules, and when to edit by hand.
You need
Some experience with a code editor and the ability to read basic Python. You don't need Cursor installed.
  1. 01What Is Cursor And Why It Matters8 LESSONS
    1. Module 1: What Cursor Is and Why It Matters to an Engineer
    2. What Cursor Is: an IDE with AI at the Center
    3. The Mental Model: Familiar Editor + Agent Inside the Project
    4. A First Look at the Core Surfaces
    5. Touring the Reservo Repository
    6. Running Reservo As-Is
    7. The Map: Which Task, Which Cursor Surface
    8. Mini-Project: Your First Orientation Session in Cursor
  2. 02Tab Predictive Autocomplete8 LESSONS
    1. Module 2: Tab, Predictive Autocomplete
    2. What Tab Predicts: the Next Edit, not the Next Token
    3. Multi-Line Edits in a Single Suggestion
    4. Jumping to the Next Edit Location After Accepting
    5. Cross-File Predictions: the "Portal" Window
    6. Accepting, Rejecting, and Partial Accepts
    7. The Judgment Table: When Tab, When Not
    8. Mini-Project: a Tab-Only Editing Session
  3. 03Cmd K Inline Editing8 LESSONS
    1. Module 3: Cmd-K, Editing a Selected Block
    2. The Cmd-K Loop: Select, Describe, Review
    3. Reading the Agent's Diff Before You Accept
    4. Refining with a Follow-Up Instruction (and Rolling Back with a Checkpoint)
    5. Ask Mode: Explaining Without Editing
    6. Cmd-K vs. Tab: Who Decides the Scope
    7. Cmd-K vs. an Open Goal: Same Agent, Different Scope
    8. Mini-Project: a Complete Cmd-K Editing Session
  4. 04Agent Mode Multi File Editing8 LESSONS
    1. Module 4: Agent Mode and Plan Mode, Multi-File Editing
    2. Agent Mode: Executing Without a Plan
    3. Plan Mode: Investigating Before Writing Code
    4. Switching Modes, and the "Composer" Naming Trap
    5. Planning the Cancellation Policy with Plan Mode
    6. Executing the Plan with Agent Mode
    7. Agent Mode vs. Everything Else: When the Task Truly Needs It
    8. Mini-Project: a Complete Agent Mode Workflow
  5. 05Context Mentions And Rules8 LESSONS
    1. Module 5: Context, @-mentions and `.cursor/rules`
    2. The real set of context mentions today, and why the agent searches first
    3. @file and @folder: scoping search on purpose
    4. Terminal, chat, and git context: `@Terminals`, `@Chats`, `@Commit`, `@Branch`, `@Browser`
    5. The four patterns for applying an `.mdc` rule
    6. Writing Reservo's real rule, field by field
    7. User Rules vs. Project Rules, and where rules don't reach: Tab and Bugbot
    8. Mini-project: a context and rules session for Reservo
  6. 06Mcp Inside Cursor8 LESSONS
    1. Module 6: MCP inside Cursor
    2. Project `.cursor/mcp.json` vs. global `~/.cursor/mcp.json`
    3. The stdio transport: a server Cursor manages
    4. The remote transports: SSE and Streamable HTTP
    5. How MCP tools show up in the chat
    6. One-click installation from the Cursor Marketplace
    7. Applied to Reservo: the Agent queries the cancellation policy
    8. Mini-project: a complete `mcp.json` for Reservo
  7. 07Production Workflows And Diff Review8 LESSONS
    1. Module 7: Production workflows and diff review
    2. The confidence gradient by surface touched
    3. Reading multi-file Agent mode diffs
    4. Checkpoints: a safety net, not version control
    5. The terminal sandbox by default
    6. When Agent mode is the wrong tool
    7. Five Reservo diffs: accept, adjust, or reject
    8. Mini-project: a complete production review session
  8. 08Project A Complete Cursor Workflow8 LESSONS
    1. Module 8: Project, a complete Cursor workflow
    2. Starting right: mentions and rules already in context
    3. Plan mode investigates and queries MCP instead of asking you
    4. Reviewing and approving the plan
    5. Agent mode executes the plan across four files
    6. Tab and Cmd-K do the fine-tuning
    7. The full review before calling it done
    8. Project: the complete workflow and where to go next
Reviews

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!

SEC. 06 · THE STUDIO

Why this studio exists

For decades, building software belonged to technical profiles with years of training, and getting a digital product into the real world took companies months or years. No-code and AI have narrowed that gap, but the knowledge is still held by a few.

Tech Benders exists to open that knowledge up, so business teams and non-technical teams can put their ideas into production with the right technical decisions behind them. AI does what you ask of it. Without a technical base, what it builds may not scale with your company’s ecosystem, and its costs can run away over time.

The team knows the pains of large organizations and the speed at which they have to move. It brings solution architecture, data engineering, product built end to end from back end to front end, and daily work with AI. Software that solves what you need in days, not months, with the cost of AI kept in check.

Founders

The studioRead about Tech Benders →

Write to ushi@techbenders.io

Made with Wislab