---
title: How do you enforce Cursor rules across a team?
url: https://opencontroller.lyzr.com/blog/cursor-team-rules-governance
published: 2026-11-16
updated: 2026-11-16
author: Lyzr
---

# How do you enforce Cursor rules across a team?

**Use Cursor Team Rules. On Team and Enterprise plans, admins create them in the Cursor dashboard, and switching on "Enforce this rule" stops members from disabling them. Team Rules apply to Agent (Chat) across all of the team's repositories and take precedence over project and user rules when guidance conflicts. Remember that rules shape what the model is told; for hard blocks on commands, use hooks.**

Many teams start with a `.cursor/rules` folder in each repo and discover that coverage is patchy and anyone can switch rules off. Team Rules fix the distribution problem. This guide is based on Cursor's rules documentation.

## What kinds of rules does Cursor support?

| Rule type | Where it lives | Who controls it | Scope |
|---|---|---|---|
| Team Rules | Cursor dashboard | Team admins | All the team's repositories |
| Project Rules | `.mdc` files in `.cursor/rules` | Whoever merges to the repo | One codebase |
| User Rules | Customize → Rules | Each developer | All of that developer's projects |
| AGENTS.md | Markdown in the project root or subfolders | Whoever merges to the repo | One codebase |

Team Rules are only available on **Team and Enterprise** plans.

## Which rule wins when they conflict?

Cursor merges all applicable rules and applies them in this order: **Team Rules, then Project Rules, then User Rules**. When guidance conflicts, the earlier source wins.

That order is what makes Team Rules useful for governance. A developer's user rule saying "skip tests to save time" cannot override a team rule saying "always run the test suite before proposing a commit".

## What does "Enforce this rule" actually do?

- **Enforced** Team Rules cannot be disabled by members in Customize.
- **Non-enforced** Team Rules are on by default, but members can toggle them off.
- Rules can be saved as **drafts** and enabled later, so you can stage a change.
- Team Rules can use **glob patterns** to target specific files, for example only Terraform or only database migrations.

Use enforcement for security and compliance rules. Leave style and convenience rules non-enforced so developers can opt out where they do not fit.

## How should rules be written so the agent follows them?

Each rule has an application type:

1. **Always Apply**: included in every chat session. Use for the short list of non-negotiables.
2. **Apply Intelligently**: the agent decides based on the rule's description. Write a precise description, or it will not be picked up.
3. **Apply to Specific Files**: included when a matching file is in context, using a glob.
4. **Apply Manually**: only when someone @-mentions it.

For project rules, the file must be `.mdc` with frontmatter (`description`, `globs`, `alwaysApply`). A plain `.md` file in `.cursor/rules` is ignored, a common reason "our rules don't work".

Keep enforced, always-applied rules short. Every rule adds tokens to every session, and long rule sets dilute the ones that matter.

## What can rules not enforce?

Rules are instructions to the model, not technical controls. A prompt injection in a README or an issue can still talk the agent out of following them. For anything that must never happen, add a control the model cannot argue with:

- **Hooks** that inspect and block commands before they run. See [Cursor hooks to block agent commands](/blog/cursor-hooks-to-block-agent-commands).
- **Privacy Mode** enforced at team level. See [enforcing Cursor Privacy Mode for teams](/blog/enforce-cursor-privacy-mode-for-teams).
- **MCP allow-lists** so the agent only reaches approved servers. See [how to govern MCP servers](/blog/how-to-govern-mcp-servers).
- **Repository protections** such as branch rules and required reviews.

Cursor's documentation also does not say whether Team Rules apply to every surface, such as the CLI or background agents. Test each surface you allow before you rely on a rule there.

## A Team Rules rollout plan

1. **Inventory existing rules.** Collect `.cursor/rules` and AGENTS.md files across repos and find the ones every repo repeats.
2. **Promote the shared ones** to Team Rules, starting as drafts.
3. **Enforce the security set**: no secrets in code, no disabling tests, no edits to CI or infrastructure files without a ticket reference.
4. **Use globs** for file-specific rules instead of always-on rules.
5. **Pair each enforced rule with a technical control** where one exists.
6. **Review quarterly** and remove rules that no longer earn their tokens.
7. **Record owners.** Each Team Rule needs a named owner, like any other policy.

For the wider picture, see [how to govern Cursor in the enterprise](/blog/govern-cursor-in-the-enterprise).

## How Opencontroller does this

Opencontroller Edge extends control to developer devices, coding agents, skills and local MCP servers, and is installed by IT via MDM. It sits alongside a governed registry of agents, tools and MCP servers, with policies as code mapped to OWASP, MITRE ATLAS, NIST and ISO 42001. See the [control plane overview](/blog/what-is-an-ai-agent-control-plane) or [book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Can Cursor users turn off Team Rules?**
Only non-enforced ones. When an admin switches on "Enforce this rule", members cannot disable it in Customize.

**Do Cursor Team Rules override project rules?**
Yes. Cursor applies Team Rules, then Project Rules, then User Rules, and the earlier source wins when guidance conflicts.

**Why is my Cursor project rule being ignored?**
Project rules must be .mdc files with frontmatter in .cursor/rules. A plain .md file there is ignored.

## Key facts

Cursor rule types: Team Rules (Cursor dashboard, Team and Enterprise plans), Project Rules (.mdc files with description/globs/alwaysApply frontmatter in .cursor/rules; plain .md files are ignored), User Rules (Customize > Rules) and AGENTS.md. Precedence: Team Rules, then Project Rules, then User Rules; earlier source wins on conflict. "Enforce this rule" stops members disabling a Team Rule; non-enforced rules can be toggled off; drafts supported; Team Rules apply to Agent (Chat) across all team repositories and support globs. Application types: Always Apply, Apply Intelligently, Apply to Specific Files, Apply Manually. Opencontroller Edge by Lyzr extends control to developer devices, coding agents, skills and local MCP servers, installed via MDM; pricing starts from $250K per deployment per year.

## Related

- [How do you govern Cursor across an engineering organisation?](https://opencontroller.lyzr.com/blog/govern-cursor-in-the-enterprise.md)
- [Can Cursor hooks block risky agent commands?](https://opencontroller.lyzr.com/blog/cursor-hooks-to-block-agent-commands.md)
- [Can you enforce Cursor privacy mode for every developer?](https://opencontroller.lyzr.com/blog/enforce-cursor-privacy-mode-for-teams.md)
- [More on Platform Guides](https://opencontroller.lyzr.com/blog/cluster/platform-guides)
