How Promtior Is Using Cursor Rules to Build Smarter With AI

Among all the ideas shared at the Cursor Meetup in Montevideo (2025), one made its way straight into our daily workflow at Promtior: Cursor Rules. The session explained how this feature can transform AI from a “helpful assistant” into a true teammate that understands your project’s context without starting from 0 every time. That idea stuck with us, and back at Promtior, we’ve already started experimenting with it.

---

What Are Cursor Rules?

Cursor Rules are essentially persistent instructions for your AI Agent. Instead of explaining the same thing every time you ask the Agent to generate or edit code, you can write down your team’s standards once and let Cursor handle the rest. Every time you interact with the Agent, those rules are prepended to the context, acting as guardrails that keep outputs aligned with your project’s needs.

Rules can capture things like:

• Project structure (e.g., how services, components, or pipelines are organized)

• Styling and naming conventions (e.g., casing rules, file naming patterns)

• Library usage (e.g., preferred frameworks or validation tools)

• Templates and workflows (e.g., boilerplate for APIs, steps for adding configuration)

• Actions and tasks (e.g., run linters, add tests, execute the full suite, then review the commit)

This transforms the Agent from a “blank-slate coder” into a true collaborator that knows your project inside and out, and sometimes even runs parts of the workflow for you.

Rule Modes: How Rules Are Applied

One of the strengths of Cursor Rules is flexibility. You can decide when and how a rule should apply:

• Always apply: The rule is prepended to every request, no matter what.

• Apply to specific files: The rule is automatically applied when you’re working in files or folders that match the defined globs (like all Python files or a certain directory).

• Apply intelligently (Agent decides): The AI chooses to apply the rule if it recognizes that it’s relevant based on the description.

• Apply manually: You can invoke any rule explicitly by calling it with @rulename.

Even “Always” or “Intelligent” rules can be called manually if you want to ensure they’re active in a given task. This layered approach gives teams precise control over when the AI should follow specific instructions.

How Do They Work? The Syntax of Rules

At the technical level, each rule is written in Markdown with YAML front-matter. A typical rule file (.mdc) begins with metadata that tells Cursor where and how to apply it:

--- description: Enforce RPC service boilerplate globs: src/services/**/*.ts alwaysApply: false --- - Use our internal RPC pattern when defining services- Always use `snake_case` for service names

• description gives a short, human-readable summary.

• globs define which files or folders the rule applies to.

• alwaysApply controls whether the rule is applied everywhere, or only in specific contexts.

The body of the file then holds the actual instructions. This can be as simple as a few bullet points, or as detailed as code snippets (Cursor recommends less than 500 lines per rule), JSON, or even XML. Cursor passes the entire contents of the rule file directly to the Agent.

Another powerful feature: rules can reference other rules or even specific files. For example, including @filename.extor @other-rule.mdc inside a rule will pull that content into context automatically. This allows you to build a hierarchy of rules, where higher-level guidelines can bring in supporting details when needed.

---

How Promtior Uses Cursor Rules

At Promtior, we’ve started building a balanced set of rules that cover different aspects of our workflow. Right now, we’re running with a mix of project rules and user rules that help us enforce consistency, safety, and automation.

Some categories we use include:

• Code quality: Guidance to avoid bad practices (like hardcoding values) and write maintainable code.

• Configuration: Steps for safely adding environment variables or adjusting system settings.

• Architecture: Rules that encode high-level design patterns and ensure consistency in how services or pipelines are structured.

• Execution safety: Restrictions that prevent the AI from running code in unsafe environments.

• Change management: Asking the AI to explain why before applying code changes, adding transparency.

• Linting & testing: Automatically running checks when working on certain files, and even suggesting new tests.

• Pipelines: Guidelines for how complex workflows (like agent orchestration) should be implemented.

On top of that, we also maintain a couple of user rules that capture global preferences, things like communication style and how the AI should phrase or format its responses.

Why This Matters for Us

At Promtior, Cursor Rules aren’t just about style. They’re about embedding shared team knowledge directly into our tools. By doing so, we:

• Keep our standards consistent across projects and devs.

• Automate repetitive quality checks like linting and validation.

• Ensure code reviews focus on real problems, not formatting.

• Give new developers a head start, the AI itself helps them follow our practices.

The ability to encode even actions and workflows, from running tests to reviewing commits, means the AI isn’t just generating code; it’s actively participating in our development lifecycle.

From Meetup to Workflow

The Montevideo meetup gave us the spark. Listening to the talk on Cursor Rules showed us how powerful this feature can be for aligning AI with human teams. We came back inspired, and we’re already integrating these ideas into our daily development at Promtior.

Rules are still evolving, and so is our way of using them. But one thing is clear: they’ve already become a cornerstone of how we build smarter with AI.