Glossary

Plain-English definitions for the enterprise and Cursor terms used across every track. Every term here also appears as a hover tooltip wherever it shows up in a lesson, so you never have to leave the page to look one up.

123 of 123 terms

.cursorignore: A file listing paths Cursor must never index or read, kept separate from .gitignore.
.mdcMarkdown-Cursor rule file: The file format for a Cursor rule; set always_apply to false and scope it so the rule only fires on the files that need it instead of burning context every request.
@browser: A prompt invocation that runs your built app in a browser pane inside Cursor; the agent can then take control of it to click, scroll and test the UI itself.
ACPAgent Client Protocol: The protocol that lets other editors, such as JetBrains IDEs, drive Cursor's agent.
ACPAgent Client Protocol: An open standard that lets any IDE host any coding agent; Cursor uses it to run inside JetBrains/IntelliJ and Android Studio.
ADRArchitecture Decision Record: A short doc capturing one architecture decision and the reasoning behind it.
Agent Client Protocol: An open standard that lets any IDE host any coding agent; Cursor uses it to run inside JetBrains/IntelliJ and Android Studio via the Cursor CLI bridge.
Agent layout: Cursor's agent-first window: the agent chat sits center, history on the left and the codebase on the right, with a toggle back to the classic editor. Often called the Agents window.
Agent mode: Cursor's full-capability mode: the AI can read the codebase, write and edit files, move them and run terminal commands. Contrast with Ask mode, which is read-only.
Agent SDK: A programmatic interface for running Cursor agents from your own scripts, services or CI, locally or in the cloud.
Agent Skills: Reusable, model-invoked instructions (a SKILL.md with a name, description and steps) the agent loads only when its description matches the task.
Agents Window: Cursor's surface listing your agent runs; open a run to read its diff and search transcripts from the command palette.
AI-first PRD: A product spec kept as a file in the repo — covering the PR breakdown, stages and architecture — so the agent can treat it as a source of truth and you can run code review on the spec itself.
ASC 606: The US revenue-recognition standard; cited as the canonical judgment-heavy accounting work to keep human-led rather than hand to an agent, because facts and circumstances vary deal to deal.
ask clarification tool: A Plan-mode tool that lets the agent pause and ask you for direction before building; it surfaces on vague prompts or when you invoke it explicitly.
Ask mode: A read-only mode for asking questions about a codebase without changing files; the safe way to explore unfamiliar or legacy code.
Auto Install: A step where a prior Cursor model sets up each training repo's environment, proposing install commands and writing tests until the build verifiably works.
Auto mode: A router that reads your prompt and picks a model for you, defaulting to Composer; you steer it with cues like "quickly" or "carefully".
Auto-Run: The Cursor Settings > Agents setting that decides which commands the agent runs automatically and which wait for your approval, via allow and block lists.
barrel-shaped engineer: An engineer who keeps deep expertise in one area while becoming genuinely capable across several others, broadening the T into a barrel.
best-of-N: Sampling a model N times and keeping the best answer; a rising best-of-16 score shows training isn't collapsing the model to a single solution.
blast radius: How much breaks if a change goes wrong; the scope of potential damage.
Bugbot: Cursor's automated PR reviewer that posts inline findings and can push fix commits from isolated VMs.
Bugbot Autofix: Bugbot's option to push a fix commit for an issue it found, instead of only flagging it for a human.
CABChange Advisory Board: A group that reviews and signs off on higher-risk production changes before they ship.
characterization test: A test written to pin down current behavior before a refactor, so you notice if the behavior changes.
CI/CDContinuous Integration / Continuous Delivery: The automated pipeline that builds, tests and ships code so changes reach production safely and often.
CISOChief Information Security Officer: The executive who owns security; usually the hardest and most important person to win over.
Cloud Agents: Agents that run in a Cursor-managed virtual machine, check out the repo, do the work and open a pull request, then shut down, with no load on your laptop.
code half-life: How long code survives in the codebase before it has to change; a maintainability signal that counters 'more lines means more value'.
Composer: Cursor's own fast coding model, tuned for the editor and priced well below frontier models; the recommended day-to-day model for executing a plan.
Composer 2: Cursor's in-house agentic coding model: frontier-level coding quality at high speed and low cost, built as a software-engineering specialist rather than a general-purpose model.
Composer 2.5: The current Composer release, better at long-running tasks and at judging when a job needs a light touch versus deep work.
context compaction: Automatic compression of earlier conversation when the context window fills up; it can read like lost context while still costing tokens.
context rot: The quality drop that happens when one chat accumulates unrelated tasks or tangents, burying the signal the model needs in a haystack of stale context.
continued pre-training: An extra large-scale training stage that raises a model's code-domain knowledge: short-context pre-training, then long-context extension, then fine-tuning on agent-like data.
control/data separation: The security principle, missing in today's LLMs, that a system should distinguish trusted instructions from untrusted input; its absence is why prompt injection works.
Conversation Insights: A Cursor analytics view that passively categorises what agents are doing (new features, bug fixes, refactors) so leaders can see where engineering time goes.
critical path: The longest end-to-end chain of dependent work in a plan; it sets the realistic timeline no matter how parallel everything else looks. A slip on the critical path moves the date; a slip on a task with slack does not.
Cursor 3: Cursor's agent-forward interface (also called the agent window or Glass), built to run and supervise many agents at once rather than edit one file.
Cursor Artifacts: Proof of work a cloud agent returns with its pull request, such as a screen recording, screenshots, type-checks or test results.
Cursor Automations: A cloud agent set to run on a schedule or an event trigger; each one is a trigger plus an instruction plus the tools it may use.
Cursor Blame: An augmented git blame that records line-level human and agent co-authorship, so you can trace which code was written by AI versus a person.
Cursor Canvas: A surface that renders visual outputs (such as a coverage or accessibility report) that aren't plain Markdown or diagrams.
Cursor CLI: Cursor's command line: the full agent, all modes and models, in the terminal and pipeable into scripts and CI.
Cursor Foundry: A prototype software factory that chains specialised agents (plan, design, build, review) with clean handoffs, built on the Agent SDK.
Cursor harness: Cursor's hosted layer around each model (context selection, caching, retries) that makes the same model run better and cheaper than calling it directly.
Cursor Hooks: Small scripts Cursor runs at fixed points in an agent's lifecycle (such as before a prompt or before a file write) to enforce policy deterministically.
Cursor Tab: Cursor's original autocomplete: multi-line, edit-aware suggestions you accept with the Tab key.
CursorBench: Cursor's internal benchmark that scores models on both task performance and token efficiency, not accuracy alone.
DASTDynamic Application Security Testing: Probing a running application for vulnerabilities from the outside, the way an attacker would. Complements SAST, which reads the code instead of poking the app.
de-slop skill: A shared Cursor skill that strips typical AI-generated tells (filler comments, vague names, over-engineering) and applies house style.
Debug mode: A mode that diagnoses a failure: it reproduces the issue, adds instrumentation and watches the logs, rather than reviewing a pull request.
demos, not memos: The shift from writing a text spec to building a live, clickable prototype to convey product intent; what gets cheap to make moves the leverage to vision and taste.
Design Mode: A way to point at an element in Cursor's built-in browser and change it directly, instead of describing it in words.
dev-to-feature ratio: How many engineers it takes to ship a feature; AI tooling is compressing it from roughly 10:1 toward 1:1 and beyond.
DORADORA metrics: Four widely-used delivery measures: deployment frequency, lead time for changes, change failure rate and time to restore service.
DPAData Processing Agreement: The contract spelling out exactly how a vendor may process your data: purposes, subprocessors, retention and breach duties. The document privacy reviews actually read.
dynamic context discovery: The agent pulling only the relevant parts of files, tools and MCP servers into context as needed, instead of loading everything up front.
egress control: Network policy for where agents may send traffic: an allowlist that auto-runs, a denylist that's always blocked and default-deny for everything else, plus DNS filtering and an HTTP proxy.
expand/contract: A safe migration pattern: add the new thing, migrate to it, then remove the old, so you can roll back at each step.
feature-completion velocity: How fast a team moves through its roadmap; the hardest delivery metric to measure but the closest to real customer value.
fork chat: Branching a new conversation off the current one so the new thread inherits the relevant context without carrying the whole bloated history.
Forward Deployed Engineer: An engineer who embeds inside a customer's own engineering org to scope ambiguous problems and ship production-grade Cursor workflows a senior engineer keeps using after they leave.
Grind mode: Letting a cloud agent keep working autonomously for hours on long jobs like migrations or building something from scratch.
harness lab: Cursor as a model-neutral test bed: frontier labs send their newest models to Cursor pre-release to tune them inside the same agent harness every model shares.
IaCInfrastructure as Code: Managing servers and cloud resources through version-controlled config files (e.g. Terraform).
IC Plus pricinginterchange-plus pricing: Card-processing pricing that passes the underlying network and issuing-bank cost through to you with a fixed markup on top, giving full visibility into cost — unlike a blended sticker rate.
integrated browser: Cursor's built-in browser, driven by Playwright under the hood, so the agent can navigate, click, screenshot and capture each action's metadata while you watch.
ITGCIT General Controls: The baseline IT controls auditors check: who can change what, how changes get approved and how systems are run.
ITSMIT Service Management: The tooling and process for change and incident records, e.g. ServiceNow.
Kimi K2.5: The open base model Cursor continued-trained into Composer 2 (1T parameters, 32B active, 256K context), chosen mainly for how well it fit Cursor's serving infrastructure.
L2/L3 interchange data: Extra Level 2 / Level 3 transaction metadata that can qualify certain US card transactions for cheaper interchange or scheme fees; supplying it correctly is a real cost-optimization lever.
length penalty: A training reward that discourages a model from being too verbose or too terse, so easy tasks finish fast and hard tasks get more room.
long-horizon RLlong-horizon reinforcement learning: Training a coding agent by running many rollouts on real problems and reinforcing the ones that succeed; a single rollout can reach 200K tokens and hundreds of tool calls.
MCPModel Context Protocol: A standard that lets an AI agent pull in context from outside the repo, like Jira tickets or internal docs.
MSAMaster Service Agreement: The overarching contract between customer and vendor that everything else (order forms, DPAs, SLAs) hangs off. Negotiated once so each later purchase doesn't restart legal review.
MTTRMean Time to Restore: How long it takes to recover service after a failed change or incident.
Multitask mode: Sending one prompt that fans out into several agents working on independent tasks at the same time.
OIDCOpenID Connect: The modern single sign-on standard, built as an identity layer on top of OAuth 2.0. Where SAML is XML and enterprise-legacy, OIDC is JSON and what newer tools implement first.
PIIPersonally Identifiable Information: Data that can identify a person (names, emails, SSNs); regulated and sensitive.
Plan mode: A mode that makes no edits: it researches the codebase and produces an editable plan you review before any code changes.
plugin: A Cursor marketplace package that bundles MCP servers and skills (sometimes sub-agents and hooks); one click installs all of it into your Cursor instance.
PR velocity: How quickly pull requests are merged; the easiest delivery metric to measure, though it sits furthest from the customer outcome.
PRDProduct Requirements Document: The spec describing what to build, for whom and why, before implementation starts. Increasingly the artifact you hand an AI agent as the source of truth for a feature.
Privacy Mode: Cursor's setting that guarantees code data is not used for training by Cursor or its model providers, and that an admin can enforce org-wide; data-retention terms are a separate, contractual layer.
private workers: Cloud-agent machines that run inside your own network so they can reach internal systems; the model inference still calls external providers.
PrivateLink: An AWS feature that keeps traffic to a service on your private network instead of the public internet.
progressive disclosure: How skills load: the agent boots knowing only each skill's name and description, then pulls a skill's full instructions into context only at the moment it decides to use it.
Project Rules: Version-controlled instructions in the repo that every Cursor agent interaction inherits, so standards are encoded once.
RAIDRisks, Assumptions, Issues, Dependencies: A living program-tracking log: Risks (might go wrong), Assumptions (treated as true but unverified), Issues (a risk that already materialized), Dependencies (work blocked on someone else) — each with a single named owner.
RBACRole-Based Access Control: Granting permissions by role rather than configuring each person individually.
reasoning effort: A model dial (high / medium / low) for how hard the model thinks before responding, set separately from which model and how fast it runs.
RFCRequest for Comments: A written design proposal circulated for feedback before anything gets built.
ROIReturn on Investment: The value gained versus what it cost, the language an economic buyer funds deals in.
SAFeScaled Agile Framework: A framework for coordinating many agile teams at enterprise scale, common in regulated orgs.
SAMLSecurity Assertion Markup Language: The XML-era enterprise standard that powers single sign-on: your identity provider vouches for you to each app. Older than OIDC but still what many enterprise tools speak.
Sandbox Mode: An isolated agent execution mode that contains the blast radius: file access scoped to the workspace, network off by default and git restricted to read-only, enforceable org-wide.
SASTStatic Application Security Testing: Scanning source code for vulnerabilities without running it. In AI-heavy workflows it is the automated gate that reads every generated diff before a human does.
SBOMSoftware Bill of Materials: A list of every component and dependency in a build, like an ingredients label for software.
SCASoftware Composition Analysis: Scanning third-party dependencies for known vulnerabilities and license problems.
SCIMSystem for Cross-domain Identity Management: A standard for automatically creating and removing user accounts when people join or leave.
self-hosted cloud agents: Cloud agents whose infrastructure runs inside your own VPC, keeping more of the environment under your control and offering configurable retention.
self-summarization: A model summarizing its own work at a trigger point and continuing from that summary, so it can keep working past its context limit.
separation of duties: No single person can author, approve and deploy the same change. The core control AI autonomy has to respect.
slash commands: Saved multi-step prompts you trigger from the / menu, such as run tests, fix CI or open a pull request.
SLSASupply-chain Levels for Software Artifacts: A framework for proving how a piece of software was built and that it wasn't tampered with.
SoDSeparation of Duties: Short for separation of duties: the rule that authoring, approving and deploying a change never sit with one person. Auditors use the acronym; the control is the same.
SOXSarbanes-Oxley Act: A US law that forces companies to keep auditable controls over any system that affects their financial reporting.
SRESite Reliability Engineering: The team and practice that keeps production reliable: monitoring, on-call and incident response.
SSOSingle Sign-On: One company login (usually via SAML or OIDC) instead of a separate password per tool.
sub-agent: A child agent a main agent spawns to work in parallel with its own context window, handing results back so the parent's context stays clean.
T-shaped engineer: An engineer broad across many areas but deeply expert in only one or two; the profile AI is widening into a barrel shape.
TCOTotal Cost of Ownership: The full cost of a tool over time, not just the sticker price (seats + enablement + overhead).
Team Rules: Rules promoted to apply across a whole organisation and shared consistently between the Cursor IDE, Agent and Bugbot.
Teams Marketplace: An organisation's private catalogue for distributing rules, skills, sub-agents, commands, MCP servers and hooks to its developers.
thinking model: A reasoning model (shown with a brain icon in Cursor's picker) that spends extra compute before answering; reach for it on complex, nuanced work and a standard model for fast, simple tasks.
time-to-market: How fast a feature actually reaches customers; the outcome metric the velocity and quality pillars ultimately serve.
value stream: The end-to-end path a change takes from idea to running in production.
voice mode: Dictating context to the agent by speaking instead of typing, used to dump everything in your head into the prompt faster than your fingers can.
WIPWork in Progress: How many tasks are in flight at once; Kanban deliberately limits it to improve flow.
Xcode MCP: An MCP server Apple maintains inside Xcode that exposes the simulator, build logs and debugging to Cursor, so the agent can run and iterate on iOS apps it writes.
ZDRZero Data Retention: A contractual guarantee that the model provider won't store your code or train on it.