Cursor Tutorial: Agent Mode, Bugbot, and 7 DevOps Workflows

Here is the practical version: setup, the mindset that keeps agent mode from wrecking your afternoon, seven workflows worth stealing, and the gotchas that matter before you point it at anything with real access.

What Cursor Actually Is

Cursor is a fork of VS Code with an AI reasoning layer wired directly into editing, terminal, and now cloud infrastructure. Agent mode is the core loop, you describe a task and it plans, edits multiple files, runs commands, and iterates until the task is done. Plan Mode sits next to it as the read-only sibling, Cursor explores and proposes a plan before touching anything, so you approve or redirect first.

The newer piece is Cloud Agents: background agents that run in isolated cloud VMs with their own terminal, browser, and desktop access, working across multiple repos in parallel and reporting results back to your editor asynchronously. That is the difference between “wait for the agent to finish” and “kick off three agents on three tickets, go to a meeting, come back to three diffs.”

Quick Setup

Download the desktop app from cursor.com for Windows, macOS, or Linux, sign in, and open a project. First session should be small: ask Cursor to explain the codebase, make one small edit, and review the diff before trusting it with anything bigger.

For terminal and CI use, install the CLI. On macOS, Linux, or WSL:

curl https://cursor.com/install -fsS | bash

On native Windows PowerShell:

irm 'https://cursor.com/install?win32=true' | iex

The CLI needs a Cursor account, it opens your browser to authenticate on first run. Once logged in, an interactive session looks like agent chat "find one bug and fix it", and a scripted, non-interactive run looks like agent -p "...".

The Mindset: Rules Are Your Onboarding Doc, Not A Suggestion

The principle that keeps Cursor useful instead of chaotic is writing your conventions down once, in .cursor/rules/, instead of repeating them in every prompt. Rules use an MDC format with frontmatter: alwaysApply: true fires every session, globs: src/**/*.tsx auto-attaches when matching files are touched, and a plain description lets the agent pull a rule in when it judges it relevant. The older single .cursorrules file still works, but scoped rules age better as a codebase grows.

Second principle: Plan Mode before Agent mode on anything with real blast radius. Reviewing a proposed plan costs you thirty seconds, undoing a bad multi-file edit across a production config does not.

Third, treat Background Agents like you would treat a contractor working unsupervised, scope the ticket tightly, and check the diff before merging, not after three more tickets have piled on top of it.

7 Cursor Workflows Worth Stealing

1. Agent mode for a scoped bug fix

Open the file or describe the symptom, switch to Agent mode, and give it a bounded task: “the health check endpoint returns 200 even when the database connection is down, find why and fix it, then add a test.” Agent mode reads, edits, and runs your test suite before handing back a diff.

2. Plan Mode for infrastructure changes

Anything touching Terraform, Kubernetes manifests, or CI config, start in Plan Mode. Ask “plan the changes needed to add a read replica to the staging database” and review the proposed steps before switching to Agent mode to execute them.

3. Background Agents for parallel ticket triage

Kick off two or three Cloud Agents on unrelated tickets at once, each in its own isolated VM. One works a flaky test, one investigates a memory leak, one drafts a dependency bump. Check back for three diffs instead of babysitting one terminal.

4. Scoped rules for security-sensitive directories

Write a rule with globs: infra/**, **/secrets/** that spells out “never modify Terraform state files directly, never print secret values, always request explicit confirmation before touching IAM policies.” The rule attaches automatically whenever the agent’s edit touches those paths.

5. MCP-connected context for real incidents

Configure MCP servers in ~/.cursor/mcp.json and Agent mode can query your database, read Sentry errors, or pull Slack threads inside a single task. Ask it to “check Sentry for the top error in the last hour, cross-reference recent deploys, and summarize a likely cause” without leaving the editor.

6. Bugbot for automated PR review

Link Bugbot to your GitHub org, choose which repos it reviews, and it scans every pull request diff for logic errors, race conditions, and injection-class vulnerabilities, leaving inline comments with suggested fixes. Trigger it manually on any PR by commenting bugbot run, and encode team-specific rules in .cursor/BUGBOT.md so it flags what your team actually cares about.

7. Headless CLI runs in CI

Drop the agent CLI into a pipeline step for non-interactive checks:

git diff main --name-only | agent -p "review these changed files for security issues"

Safety And Gotchas

Agent mode edits files and runs terminal commands on your behalf, so scope matters more than it feels like it should. Review the plan before switching from Plan Mode to Agent mode on anything touching production configs, credentials, or IAM policies, and never let auto-run execute destructive commands unsupervised.

Background and Cloud Agents run in isolated VMs with their own terminal, browser, and desktop access, which is powerful and also a bigger surface. Scope what each background agent can reach, and review its diff before merging, the same way you would review a contractor’s PR.

MCP servers are only as trustworthy as whoever wrote them. Before pointing ~/.cursor/mcp.json at a third party server, read what it actually does, the same scrutiny you would give a random npm package with access to your database credentials.

Enable privacy mode in settings or at the team admin level if your code cannot be used for model training under any circumstance. It is not the default for every plan tier, so check it explicitly rather than assuming.

Usage And Cost Tips

Hobby is free with limited Agent requests and Tab completions, enough to try it, not enough for daily work. Individual plans, Pro, Pro+, and Ultra, start around $16 a month on annual billing and add extended agent limits, frontier model access, MCPs, skills, hooks, and cloud agents. Cursor’s own guidance recommends Pro+ for daily agent users and Ultra for power users running agents constantly.

Teams pricing centers on standard and premium seats with centralized billing, a shared rules and skills marketplace, and SSO, and Enterprise adds pooled usage, invoice billing, and access controls on top. Confirm current numbers on the official pricing page before budgeting, since usage-based overage applies once included model usage runs out.

For CI usage through the headless CLI, treat it like any other metered API call, put a scope and timeout on the pipeline step so a stuck agent does not quietly burn usage on a job nobody is watching.

FAQ

Is Cursor free to use?

The Hobby tier is free with limited Agent requests and Tab completions. Paid Individual plans start around $16 a month on annual billing and remove most of those limits.

Does Cursor work outside the editor, like in CI?

Yes, through the Cursor CLI. Install it with the official install script, log in once, and run it headlessly with agent -p "..." inside scripts, pipelines, or GitHub Actions steps.

Can Cursor review pull requests automatically?

Yes, through Bugbot. Link it to your GitHub organization, choose which repositories it covers, and it reviews every PR diff automatically or on a manual bugbot run comment, with custom rules configurable in .cursor/BUGBOT.md.

Get Building

Start in Plan Mode on a low-stakes change so you can see how Cursor scopes work before handing it anything with real access. Write one rules file for your most sensitive directory, connect one MCP server, and try a single Background Agent on a ticket you would otherwise put off. For structured, hands-on practice pairing agent tools with the rest of your DevOps and security toolchain, check our DevOps and cybersecurity courses.