Cursor 101

Cursor 101 Webinar — Tech Concepts & Product Features

Session structure (how the webinar is run)

• Interactive Zoom session: attendees are encouraged to use Zoom chat to share where they’re calling from.
• During demos: questions are submitted via the Q&A panel; host/moderators handle questions live and later.
• Feedback encouraged: participants are encouraged to share feedback on the demo/product.

---

What Cursor is (foundational positioning)

• Cursor is a standalone AI-native IDE, not just a plugin to an existing editor.
• It’s built from a VS Code fork, so it includes familiar:
  • editor ergonomics
  • hotkeys
  • extension ecosystem
• It includes:
  • a CLI
  • coding agents
  • code review capabilities
  • a context engine
• Context engine / indexing approach:
  • Cursor uses vector embeddings to index the codebase (via a vector database)
  • The goal is to produce more relevant AI outputs for the current task and repository.

---

Core AI features highlighted throughout

1) Tab (next-action prediction)

• Predicts the “next action” in code and shows inline translucent suggestions.
• Accept/reject is integrated directly into the editor flow (e.g., accept with Tab).
• Uses multiple context sources:
  • Local context: surrounding code in the current file
  • Global indexed context: embeddings over the codebase
  • User feedback loop: accepts/rejects improve later suggestions
• Best suited for structured/repetitive work, such as:
  • API development
  • nested loops
  • switch/case patterns
  • templated code
• Can be guided by comments to steer outputs toward a specific implementation.
• Demonstrated workflow: iteratively generate a new filter function via a few accept presses.

---

2) Command K (quick edit / targeted edits)

• Applies a user prompt to selected code.
• Produces a diff (line-by-line change preview) that can be accepted or rejected.
• Diff semantics:
  • Red = changes that will be overwritten
  • Green = net-new changes
• Demonstrated scenario: refactoring two similar endpoints into a more general function (e.g., consolidating color filter endpoints into a single dynamic endpoint).

Additional modes/behavior for Command K (from the demo)

• Auto model selection is used by default.
• You can apply edits to the selection, or alternatively:
  • Quick question: research-oriented; uses global indexed context
  • Send to chat / open agent: for broader multi-step work

---

3) Agents (multi-file, multi-step coding)

• Designed for general-purpose changes across a project:
  • can reason over a codebase
  • perform multi-step changes
  • complete tasks end-to-end

Agent architecture (as described)

• LLM for coding/reasoning
• Orchestration (“agent harness”):
  • conversation management
  • memory handling
  • caching
  • system prompt construction
  • evaluation optimizations
• Tools layer enabling model interaction with the IDE/environment:
  • edit/read/create/delete files
  • run shell commands
  • semantic search via embeddings
  • code retrieval (including substring-based tooling like “GPS”)
  • optional integration with MCPs for external context

Demonstrated scenario

• After refactoring the backend, the agent updates the front-end UI to add a dropdown/controls for the new filter system.

---

Agent workflow in practice (context & safety)

• Agents use successive tool calls guided by:
  • the prompt
  • provided context
• Best practice for large/legacy repos:
  • provide explicit context upfront (specific files/folders) to avoid pulling irrelevant code
• Agents are described as non-deterministic, so tighter guidance/context helps reduce irrelevant retrieval.

---

Agent operating modes and planning

Modes mentioned

• Plan mode (released feature)
• Background agent mode
• Ask mode
• Custom modes can enable/disable tool types (e.g., edit/delete).

Plan mode behavior

• The agent first asks clarifying questions.
• Then generates a markdown plan (editable) containing:
  • a task list/contract
• The user reviews/audits the plan before the agent “builds,” then proceeds sequentially.
• Demo example: create an animated warp effect with parameters; Plan mode produced the implementation plan before coding.

---

Context management (for long chats)

• A context meter indicates context-window usage.
• When the context window fills:
  • Cursor summarizes prior messages
  • starts a new context window within the same chat
• Context rot concept:
  • Near capacity, if the chat shifts to a new task, irrelevant earlier context can pollute responses, increasing hallucinations/misalignment.

Mitigation strategy

• Split work into separate chats when tasks diverge.
• Chats can run in parallel and are visible in the agent management area.
• Earlier context can be reused by pulling in summaries from past chats.
• Live Q&A guidance for when to start a new window/chat:
  • heuristic: if you’re near ~90% but still aligned with the current task, finish it
  • if you veer into separable work or things go wrong, fork/reset using previous checkpoints

---

Checkpoints / “U-turn” for reverting agent history

• A U-turn control lets you revert to a previous code state from earlier chat messages.
• Described as:
  • in-session “version control”
• Not a replacement for Git, which is still recommended.

---

Context sources beyond files

Cursor context management can include:

• Files and folders (folders provide directory trees)
• Code snippets (e.g., function signatures or specific lines)
• Documentation via built-in web scrapers (example: FastAPI docs)
• Public documentation URLs (scraped into Cursor docs)
• Git diffs / PR review context
  • agents can review colleague changes using diffs against the main branch and ask PR-review questions (test coverage, style issues, etc.)
• Past chats (reuse prior work)
• Cursor rules (metaprompts for repeated workflows)
• Web search (agents can fetch information)

---

Cursor CLI (agentic coding outside the IDE)

• Cursor provides a CLI to run the same agentic workflow in other editors (e.g., JetBrains/IntelliJ).
• CLI supports:
  • indexing the codebase similarly to the IDE
  • agent patterns to generate code changes
  • terminal-first actions like running shell commands for context
  • headless mode for automation scripts

---

Enterprise adoption / validation claims (non-review, but metrics)

• Cursor claims:
  • 89% of the Fortune 1000 use Cursor
  • 100,000+ enterprises using Cursor
  • users reportedly write 1B+ lines of enterprise code per month
• Mentions customer/industry logos (e.g., OpenAI, Vercel, Shopify, plus more).

---

Main speakers / sources

• Kevin — Go-to-market, Cursor; hosts/moderates
• Ryan — Field engineering, Cursor; leads the “Cursor 101” demo
• Denzel — Go-to-market, Cursor; onboarding/adoption focus; answers questions during the session