robots.txt
# Cursor Workshop - agent and search crawler policy (RFC 9309)
# Public marketing pages are allowed for search indexing and AI input.
# Admin, API, and redirect paths stay disallowed.
# Content-Signal declares search/ai-input/ai-train preferences per group.
User-agent: GPTBot
Content-Signal: search=yes, ai-input=yes, ai-train=yes
Allow: /
Disallow: /admin/
Disallow: /api/
Disallow: /r/
User-agent: OAI-SearchBot
Content-Signal: search=yes, ai-input=yes, ai-train=yes
Allow: /
Disallow: /admin/
Disallow: /api/
Disallow: /r/
User-agent: ChatGPT-User
Content-Signal: search=yes, ai-input=yes, ai-train=yes
Allow: /
Disallow: /admin/
Disallow: /api/
Disallow: /r/
User-agent: ClaudeBot
Content-Signal: search=yes, ai-input=yes, ai-train=yes
Allow: /
Disallow: /admin/
Disallow: /api/
Disallow: /r/
User-agent: anthropic-ai
Content-Signal: search=yes, ai-input=yes, ai-train=yes
Allow: /
Disallow: /admin/
Disallow: /api/
Disallow: /r/
User-agent: PerplexityBot
Content-Signal: search=yes, ai-input=yes, ai-train=yes
Allow: /
Disallow: /admin/
Disallow: /api/
Disallow: /r/
User-agent: Google-Extended
Content-Signal: search=yes, ai-input=yes, ai-train=yes
Allow: /
Disallow: /admin/
Disallow: /api/
Disallow: /r/
User-agent: Applebot-Extended
Content-Signal: search=yes, ai-input=yes, ai-train=yes
Allow: /
Disallow: /admin/
Disallow: /api/
Disallow: /r/
User-agent: Bytespider
Content-Signal: search=yes, ai-input=yes, ai-train=yes
Allow: /
Disallow: /admin/
Disallow: /api/
Disallow: /r/
User-agent: CCBot
Content-Signal: search=yes, ai-input=yes, ai-train=yes
Allow: /
Disallow: /admin/
Disallow: /api/
Disallow: /r/
User-agent: Amazonbot
Content-Signal: search=yes, ai-input=yes, ai-train=yes
Allow: /
Disallow: /admin/
Disallow: /api/
Disallow: /r/
User-agent: meta-externalagent
Content-Signal: search=yes, ai-input=yes, ai-train=yes
Allow: /
Disallow: /admin/
Disallow: /api/
Disallow: /r/
User-agent: FacebookBot
Content-Signal: search=yes, ai-input=yes, ai-train=yes
Allow: /
Disallow: /admin/
Disallow: /api/
Disallow: /r/
User-agent: cohere-ai
Content-Signal: search=yes, ai-input=yes, ai-train=yes
Allow: /
Disallow: /admin/
Disallow: /api/
Disallow: /r/
User-agent: Diffbot
Content-Signal: search=yes, ai-input=yes, ai-train=yes
Allow: /
Disallow: /admin/
Disallow: /api/
Disallow: /r/
User-agent: Omgilibot
Content-Signal: search=yes, ai-input=yes, ai-train=yes
Allow: /
Disallow: /admin/
Disallow: /api/
Disallow: /r/
User-agent: YouBot
Content-Signal: search=yes, ai-input=yes, ai-train=yes
Allow: /
Disallow: /admin/
Disallow: /api/
Disallow: /r/
User-agent: *
Content-Signal: search=yes, ai-input=yes, ai-train=yes
Allow: /
Disallow: /admin/
Disallow: /api/
Disallow: /r/
Host: www.cursorworkshop.com
Sitemap: https://www.cursorworkshop.com/sitemap.xml
llms.txt
# Cursor Workshop
> Official Cursor ambassadors delivering hands-on workshops and AI coding training for engineering teams.
## Services
- Team Cursor Workshops: Hands-on workshops teaching teams to use Cursor safely and effectively
- AI Coding Review Training: Best practices for code review habits with AI assistance
- Agent Workflow Setup: Shared agent workflows for team adoption
## Docs
- [Homepage](https://www.cursorworkshop.com)
- [Training](https://www.cursorworkshop.com/training)
- [Training topics](https://www.cursorworkshop.com/topics)
- [Services](https://www.cursorworkshop.com/services)
- [Pricing](https://www.harness.institute/pricing)
- [Methodology](https://www.cursorworkshop.com/methodology)
- [About](https://www.cursorworkshop.com/about)
- [Research index](https://www.cursorworkshop.com/research)
- [Book a 15-minute sync](https://www.harness.institute/call)
- [Sitemap](https://www.cursorworkshop.com/sitemap.xml)
- [Research feed](https://www.cursorworkshop.com/feed.xml)
## Topic Guides
- [Cursor subagents vs skills: what a team writes down first](https://www.cursorworkshop.com/topics/subagents-and-skills): Cursor subagents are scoped agent runs delegated from the main thread, each with its own rules, MCP servers, skills, and review expectations. This page explains how to define one, which work to hand it, and how a team keeps every delegated run reviewable. It is the same material we teach in the Cursor workshop.
- [Cursor team standards: rules and review](https://www.cursorworkshop.com/topics/team-conventions): Inconsistent usage across engineers, not tool access, is what slows AI coding adoption on real teams. Shared team conventions cut that variability: repository instructions everyone follows, code review standards that set clear thresholds, and AI coding standards reinforced by examples from your own codebase. Teams then compare outcomes against a baseline instead of trading anecdotes about which prompt worked.
- [Cursor CLI workflows: loops, MCP, review](https://www.cursorworkshop.com/topics/cli-workflows): AI agents in the terminal move fast, but unreviewed output is the real risk. A reliable CLI workflow starts with a written task brief, a bounded implementation scope, and verification loops the agent runs before it stops. That turns each run into a small, readable diff a person can review. The result is speed your team can trust, because code review stays in human hands.
- [Cursor MCP servers: which to add first and how teams keep them safe](https://www.cursorworkshop.com/topics/mcp-team-skills): Cursor reads MCP servers from a project mcp.json and a global one, asks before running a tool by default, and lets enterprise admins enforce an allowlist. This page lists the servers worth adding first, the ones to hold back, and the team rules that keep every MCP call reviewable.
- [Agentic coding workshops for engineering teams](https://www.cursorworkshop.com/topics/agentic-coding-workshops): Most teams adopt AI coding tools individually and never build a shared way of working, so output stays inconsistent. This agentic coding workshop trains engineers as a team on real repositories, not demos. You leave with a tested AI coding workflow, clear rules for using coding agents, and a team adoption plan that survives past the first week.
- [Safe AI coding practices for development teams](https://www.cursorworkshop.com/topics/safe-ai-coding-practices): Train a development team to adopt safer AI coding practices by making the workflow concrete: bounded scopes, approved context, verification habits, and review gates before merge. AI coding safety holds when the model knows when it can implement, advise, or hand the call to an engineer, and when reviewers can see the evidence behind every AI-assisted change.
- [AI code review habits for generated code](https://www.cursorworkshop.com/topics/ai-code-review-habits): The best way to implement code review habits for AI-generated code is to review the task brief, diff shape, test evidence, and ownership boundary before merge. AI-generated code can pass tests and read cleanly while hiding context mistakes, weak coverage, or risky abstractions, so reviewers need a repeatable AI code critique workflow rather than a rubber stamp.
- [How can platform and infrastructure teams use shared Cursor agent workflows?](https://www.cursorworkshop.com/topics/shared-agent-workflows): Cursor Workshop teaches platform and infrastructure teams to share Cursor agent workflows by publishing one repository standard, one MCP allowlist, and one CI evidence bar. Product, SRE, and platform engineers then run the same delegation and review loop instead of twelve private prompt habits.
- [UK AI coding workshops for engineering teams](https://www.cursorworkshop.com/topics/uk-ai-coding-workshops): Teams that book a generic AI talk rarely change how anyone ships code. This hands-on training runs remotely or onsite for UK and European engineering teams that want practical AI coding adoption, not theory. Exercises follow your real workflow: planning, implementation, code review of AI-generated changes, testing, and documentation, so habits stick after the day ends.
- [What should a two-day Cursor curriculum for senior engineers cover?](https://www.harness.institute/training): Cursor Workshop two-day Cursor curriculum for senior engineers covers Delegate, Review, Own, repo context, large or legacy codebases, debug and verification, AI-assisted review, and org standards across Day 1 and Day 2. This is independent team training from Harness Institute, not an official vendor workshop. The default shape is two days, onsite or offsite. Intermediate cohorts are usually 12-35 people. Mastery cohorts are usually 8-24.
- [How much does instructor-led Cursor training cost for 10 to 20 engineers?](https://www.harness.institute/pricing): Cursor Workshop prices instructor-led Cursor training at USD 1,000 per person per day. Two days for 10 to 20 engineers is USD 20,000 to USD 40,000 before VAT, including the first month of Harness Pulse.
- [What ROI should an engineering team expect from Cursor training?](https://www.harness.institute/pricing): Cursor Workshop measures Cursor training ROI as review time, escaped defects, cycle time, and the share of AI-assisted work that ships with explicit verification. We do not publish a 20 to 40 percent productivity number. Those proxies are the ones we already teach teams to measure.
- [How should an engineering manager roll out Cursor across a development team?](https://www.harness.institute/training): Cursor Workshop teaches an engineering manager to roll out Cursor with Delegate, Review, Own, a small champion group, and a 30/60/90 plan. The first 90 days prove one workflow on real pull requests before the rest of the team copies it. Large-rollout cohorts stay at 30-35 engineers.
- [Cursor rules training: shared team rules](https://www.cursorworkshop.com/topics/cursor-rules-training): Private prompting habits don't scale, so engineering teams stay inconsistent until rules become shared repository behavior. This Cursor rules training teaches you to write and maintain rules that are short, testable, and visible in code review. You learn rules documentation that sets team standards and gives real agent control, tied to actual workflows instead of generic style advice.
- [Cursor teams MCP training: scope, review](https://www.cursorworkshop.com/topics/cursor-mcp-training): Connecting agents to repositories, docs, tickets, and internal systems through MCP usually means trading control for reach. This Cursor MCP training shows teams how to scope model context protocol access before turning it on: which MCP servers are allowed, what data each tool integration can read, and how reviewers confirm an agent stayed inside those bounds.
- [Cursor agent training for engineering teams](https://www.cursorworkshop.com/topics/cursor-agent-training): Most teams turn on agent mode and let it run without clear task boundaries, so reviews pile up and trust erodes. This Cursor agent training fixes that. You learn which work background agents can own, which stays small and human-inspected, and how to write delegation rules the whole team follows. The result is a repeatable delegation model, not agent enthusiasm.
- [Cursor code review training for engineering teams](https://www.cursorworkshop.com/topics/cursor-code-review-training): Most teams ship AI-generated code faster than they can review it, and that gap is where defects and lost ownership creep in. Code review training gives engineers a shared review workflow: review standards for what the agent may critique, what evidence each refactoring must cite, and when a human stops the run and takes back the keyboard.
- [Cursor best practices training for teams](https://www.cursorworkshop.com/topics/cursor-best-practices-training): Best practices fail when they live in one person's head. Teams adopt the same AI workflow only when rules, task briefs, review checkpoints, and worked examples sit in the repository where everyone can read them. This guide turns scattered prompt engineering habits into shared team standards, including Cursor rules best practices and review steps that make AI-generated code safe to ship.
## Research
- [Use Cursor MCP Safely on Teams](https://www.cursorworkshop.com/research/use-cursor-mcp-safely-on-teams): Learn how to roll out Cursor MCP with team rules, scoped servers, subagents, and a pasteable review boundary.
- [Set Up a Cursor MCP Server](https://www.cursorworkshop.com/research/set-up-a-cursor-mcp-server): Use a Cursor MCP server as a narrow team integration with clear rules, review habits, and safe agent boundaries.
- [Use Figma MCP in Cursor Safely](https://www.cursorworkshop.com/research/use-figma-mcp-in-cursor-safely): Learn how to connect Figma MCP to Cursor with scoped rules, a small workflow, and a pasteable review artifact.
- [Cursor Code Review Workflows for Teams](https://www.cursorworkshop.com/research/cursor-code-review-workflows-for-teams): Use Cursor rules, skills, subagents, and MCP to review code changes with a repeatable team receipt.
- [Using Cursor MCP Servers Safely](https://www.cursorworkshop.com/research/using-cursor-mcp-servers-safely): Learn how to scope Cursor MCP access, pair it with rules and skills, and review agent work against real side effects.
- [Cursor MCP Support for Team Workflows](https://www.cursorworkshop.com/research/cursor-mcp-support-for-team-workflows): Use Cursor MCP support to connect trusted tools, scope agent access, and give teams a repeatable integration pattern.
- [Cursor Agent Conventions for Teams](https://www.cursorworkshop.com/research/cursor-agent-conventions-for-teams): Set team conventions for Cursor agents, rules, skills, subagents, MCP access, and review without turning prompts into folklore.
- [Cursor AI for Team Workflows](https://www.cursorworkshop.com/research/cursor-ai-for-team-workflows): Cursor rules, skills, subagents, and MCP work best when teams turn them into small repo-owned habits.
- [typesafe-mcp Adds Typed Agent Judgments](https://www.cursorworkshop.com/research/typesafe-mcp-adds-typed-agent-judgments): typesafe-mcp gives coding agents structured probabilities through MCP, and this note shows how to test it on a small labeling task.
- [17K Runs of Claude, Codex, and Cursor](https://www.cursorworkshop.com/research/17k-runs-of-claude-codex-and-cursor): Armature measured nearly 17k Claude, Codex, and Cursor runs to see which tools agents choose and what Cursor users can learn.
- [Cursor Cloud Agents Start Faster With Builds](https://www.cursorworkshop.com/research/cursor-cloud-agents-start-faster-with-builds): Cursor Builds prepare Cloud Agent environments ahead of time. Separate disk setup from running services, check source freshness and test a small task.
- [brave-devtools-mcp Connects Brave to Agents](https://www.cursorworkshop.com/research/brave-devtools-mcp-connects-brave-to-agents): brave-devtools-mcp connects Brave DevTools to coding agents, with a safe Cursor workflow and permission boundary.
- [AgentCost Tracks Local Agent Spend](https://www.cursorworkshop.com/research/agentcost-tracks-local-agent-spend): What local agent-cost logs can establish, where provider billing differs, and how to compare the two before changing a team’s workflow.
- [Claudexor Routes Coding-Agent Quotas](https://www.cursorworkshop.com/research/claudexor-routes-coding-agent-quotas): Assess Claudexor with a disposable repository: check quota visibility, credential scope, patch review and evidence before routing production work.
- [local-motion Runs Cursor Agents Locally](https://www.cursorworkshop.com/research/local-motion-runs-cursor-agents-locally): local-motion helps Cursor users run a local coding model on macOS and avoid the usual memory and setup traps.
- [Kastra Enforces Policies for Cursor Agents](https://www.cursorworkshop.com/research/kastra-enforces-policies-for-cursor-agents): Evaluate Kastra authorization for Cursor tool calls with a disposable test service, denial evidence, and checks for alternate execution paths.
- [ultralytics-mcp Connects YOLO to Cursor](https://www.cursorworkshop.com/research/ultralytics-mcp-connects-yolo-to-cursor): ultralytics-mcp lets agents control YOLO datasets and training through MCP, with a safe Cursor setup boundary.
- [Local MCP Connects Mac Apps to Agents](https://www.cursorworkshop.com/research/local-mcp-connects-mac-apps-to-agents): Local MCP connects AI assistants to Mac-only context, and the safe first test is a narrow, read-only MCP boundary.
- [Whyline: Company Memory for Cursor](https://www.cursorworkshop.com/research/whyline-company-memory-for-cursor): Whyline connects company decisions to Cursor through MCP so agents can answer “why” with receipts, not guesses.
- [Manufact YC S25 Turns MCP Servers into Hosted Apps](https://www.cursorworkshop.com/research/agentic-coding-governance-cursor-20260703-0503): Manufact (YC S25) turns MCP servers into hosted apps. Here is the safe Cursor boundary for connecting agents to real systems.
- [Cursor Shared Workflows for Teams](https://www.cursorworkshop.com/research/agentic-coding-governance-cursor-20260702-0512): A practical Cursor-first rollout plan for agentic coding training, MCP boundaries, repo rules, and safer reviews.
- [Cursor Guardrails for Real Teams](https://www.cursorworkshop.com/research/cursor-subagents-skills-20260702-0507): A practical guide to Cursor team workflows with rules, skills, MCP, subagents, and a rollout checklist.
- [Cursor Rules vs AGENTS.md, a Team Playbook that Scales](https://www.cursorworkshop.com/research/cursor-subagents-skills-20260701-0530): How to split Cursor .mdc rules from AGENTS.md, so engineering teams get durable rules, skill handoffs, and reviews that scale.
- [Teach AI Coding With Guardrails](https://www.cursorworkshop.com/research/agentic-coding-governance-cursor-20260630-0515): A practical team rollout plan for Cursor users: rules, MCP boundaries, workshops, and review guardrails for agentic coding.
- [Govern Coding Agents as a Team in Cursor](https://www.cursorworkshop.com/research/agentic-coding-governance-cursor-20260627-0502): A practical governance framework for coding agents in Cursor, with agent roles, repo rules, MCP boundaries, and a human review gate.
- [Train Cursor Agents as a Team](https://www.cursorworkshop.com/research/cursor-subagents-skills-20260627-0457): A practical Cursor team rollout plan for rules, skills, subagents, and reviewable AI coding workflows.
- [A Cursor MCP integration checklist](https://www.cursorworkshop.com/research/cursor-subagents-skills-20260623-0509): Connect one Cursor MCP server with scoped credentials, verify a known read and denied access, and leave a short integration note the team can repeat.
- [Cursor 3.8 Code Review with Subagents and Skills](https://www.cursorworkshop.com/research/cursor-subagents-skills-20260622-2209): Cursor 3.8 code review workflow using Automations, subagents, skills, and MCP, plus a review receipt template teams can reuse.
- [Cursor Review Workflows With Subagents](https://www.cursorworkshop.com/research/cursor-subagents-skills-20260618-0801): Build a Cursor 3.7 review workflow with cloud agents, repo rules, focused subagents, and skills. Record the checks and review evidence in every pull request.
- [Cursor Skills and Team Rules for Large Codebases](https://www.cursorworkshop.com/research/cursor-subagents-skills-20260616-0629): How Cursor skills, .cursor/skills files, and team rules work together so large codebases stay reviewable, not just faster to edit.
- [Cursor MCP Support and How to Add a Server Safely](https://www.cursorworkshop.com/research/cursor-subagents-skills-20260615-0622): A practical look at Cursor MCP support, how to add one server, scope it with a rule, and review agent work without losing control.
- [Cursor Jira review workflow](https://www.cursorworkshop.com/research/cursor-subagents-skills-20260528-0528): A Cursor code review workflow for Jira handoffs, rules, subagents, and a review receipt teams can use this week.
- [Cursor Automations Across Multiple Repos, Without Drift](https://www.cursorworkshop.com/research/cursor-subagents-skills-20260521-0527): How to scope Cursor Automations across multiple repos and MCP connectors so agent runs stay reviewable instead of drifting.
- [Cursor Cloud Agent Setup and the Environment Contract](https://www.cursorworkshop.com/research/cursor-subagents-skills-20260514-0512): A practical guide to Cursor cloud agent setup, covering reproducible environments, a secrets boundary, and review evidence before agents edit.
- [AI agent guardrails that hold](https://www.cursorworkshop.com/research/agentic-coding-governance-20260510-0511): A field guide to AI agent guardrails for recursive agent chains: connector ownership, child receipts, and review evidence that survives the merge queue.
- [AI agent guardrails: why every harness needs them](https://www.cursorworkshop.com/research/agentic-coding-governance-20260504-0505): Why agent harnesses need guardrails: AI agent guardrails that turn complete-sounding summaries into receipts reviewers can actually verify.
- [Cursor Subagents, the Official Docs and the Missing Contract](https://www.cursorworkshop.com/research/cursor-subagents-skills-20260501-0504): What the Cursor subagents official docs cover in .cursor/agents, and the ownership contract your team still has to write.
- [How to clean up agent-written code](https://www.cursorworkshop.com/research/agentic-coding-signals-20260426-0432): A working memo on how to clean up agent-written code: restore visible scope, ownership, and verification receipts to agent diffs before review.
- [Coding Agent Browser Automation Needs an Owner](https://www.cursorworkshop.com/research/agentic-coding-signals-20260323-0353): Coding agent browser automation moves faster but widens blast radius fast. Give every connector a named owner before you trust it.
- [AI coding wrappers that hold up under review](https://www.cursorworkshop.com/research/ai-coding-tooling-20260322-0351): A governance guide to AI coding wrappers: the repo contracts Cursor, Claude Code, and Codex need so agent work stays reviewable.
- [How returning Markdown from docs shapes agentic coding](https://www.cursorworkshop.com/research/agentic-coding-signals-20260313-0840): Returning markdown from docs gives Cursor, Claude Code, and Codex one reviewable contract: scope, constraints, verification, and owner on every run.
- [Cursor .mdc vs CLAUDE.md vs AGENTS.md](https://www.cursorworkshop.com/research/agentic-coding-signals-20260311-0855): Compare Cursor .mdc rules, Claude Code CLAUDE.md, and Codex AGENTS.md: what each file controls, where it belongs, and how teams review it.
- [Running multi-agent teams without losing the review trail](https://www.cursorworkshop.com/research/multi-agent-orchestration-2019564738649505882): Running multi-agent teams across Cur
