Rules for AI

[Haraven]

Hello,

I would like to request a feature I've seen in the other IDE I use, Cursor. Namely, I want to request giving Zed users the ability to define rule files that refine how the AI behaves and generates code.

In Cursor, they've implemented a feature whereby you can define project-specific rules that are automatically fed to the AI when discussing and composing code. Here is their docs for how Cursor does it.

Essentially, you create individual .mdc files in a specific folder (i.e., .cursor/rules/) which dictate how the AI should behave. There's generally available rules, like prompting the AI to behave like a senior developer with experience using X, Y and Z tools, or telling it to be concise when proposing solutions to the problems you prompt it with. There's also specific rules that you can define, like naming conventions inside .js files or how to structure future .mdc rule files. The AI automatically takes in specific rules depending on the context in which you're invoking it (e.g., depending on the files in which you're prompting it to make code changes, or on the files you are attaching to the AI panel).

The great thing about this feature is you can create a positive feedback loop for having the AI update existing rules or generate new rules for situations that pop up as you work with it to write code. Found a solution pattern to an issue with code generated by the AI? Tell it to remember it in a rule file so it keeps that in mind next time. For example, I have an app whose name is written either as a full name or as an abbreviation; there were specific contexts in my codebase where I needed the AI to generate code using the abbreviated app name and other contexts where I needed it to generate code using the full name. I simply told it to remember that naming rule in a new rule file.

Here is a sample rule file for generating rule files in the correct directory:

---
description: Cursor Rules Location
globs: *.mdc
---
# Cursor Rules Location

Rules for placing and organizing Cursor rule files in the repository.

<rule>
name: cursor_rules_location
description: Standards for placing Cursor rule files in the correct directory
filters:
  # Match any .mdc files
  - type: file_extension
    pattern: "\\.mdc$"
  # Match files that look like Cursor rules
  - type: content
    pattern: "(?s)<rule>.*?</rule>"
  # Match file creation events
  - type: event
    pattern: "file_create"

actions:
  - type: reject
    conditions:
      - pattern: "^(?!\\.\\/\\.cursor\\/rules\\/.*\\.mdc$)"
        message: "Cursor rule files (.mdc) must be placed in the .cursor/rules directory"

  - type: suggest
    message: |
      When creating Cursor rules:

      1. Always place rule files in PROJECT_ROOT/.cursor/rules/:
         ```
         .cursor/rules/
         ├── your-rule-name.mdc
         ├── another-rule.mdc
         └── ...
         ```

      2. Follow the naming convention:
         - Use kebab-case for filenames
         - Always use .mdc extension
         - Make names descriptive of the rule's purpose

      3. Directory structure:
         ```
         PROJECT_ROOT/
         ├── .cursor/
         │   └── rules/
         │       ├── your-rule-name.mdc
         │       └── ...
         └── ...
         ```

      4. Never place rule files:
         - In the project root
         - In subdirectories outside .cursor/rules
         - In any other location

examples:
  - input: |
      # Bad: Rule file in wrong location
      rules/my-rule.mdc
      my-rule.mdc
      .rules/my-rule.mdc

      # Good: Rule file in correct location
      .cursor/rules/my-rule.mdc
    output: "Correctly placed Cursor rule file"

metadata:
  priority: high
  version: 1.0
</rule>

(example taken from here)

---

Please consider adding this Rules for AI feature to Zed. In my opinion, it would add a lot of value to the AI side of things. It helps you gain more control over how code is generated and transformed by the AI, and it lets the AI improve over time depending on your specific needs, rather than having to keep repeating the same instructions whenever the same issues arise.

[a3lem]

Some related discussion here #14559, where I also mentioned .cursorrules as a possible source of inspiration.

Bear in mind, .cursorrules is just content that's inserted into the system prompt. So nothing's stopping you from including them in your own prompt with /file .cursor/rules/ – at least when using the chat assistant, which, unlike Cursor, isn't an agent in the sense that it edits your files.

Asking as someone who hasn't used Cursor, does Cursor use .cursorrules for inline completions as well?

[Haraven]

Some related discussion here #14559, where I also mentioned .cursorrules as a possible source of inspiration.

When I say rules for AI, I'm more specifically talking about individual rule files, not the .cursorrules file per se. My understanding is that Cursor is migrating away from having one single .cursorrules file where you dump all possible rules you want the AI to follow, in favor of individual .mdc rule files, so that it's easier to separate concerns, maintain rule files, and reuse specific rules across projects. If Zed should have a feature like this, I would recommend using smaller individual files, rather than one giant rule file.

Bear in mind, .cursorrules is just content that's inserted into the system prompt. So nothing's stopping you from including them in your own prompt with /file .cursor/rules/ – at least when using the chat assistant, which, unlike Cursor, isn't an agent in the sense that it edits your files.

I did consider just including my existing rule files into Zed's prompts, but that's not as elegant as having the AI automatically pick up rules for the specific context it's being prompted in. Cursor still lets you attach rule files in the AI panel as an extra way to enforce their application, but the AI should also automatically pick them up. In my experience, the AI even explicitly references the defined rules when reasoning about how to approach problems, without you having to tell it to use any kind of rule.

Asking as someone who hasn't used Cursor, does Cursor use .cursorrules for inline completions as well?

Good question. The rules apply to inline edits/transformations for sure (see this). Not sure about inline completions; based on what I've seen in my own code, it seems to follow the rules there too.

[a3lem]

I was curious how Zed behaves. After a few simple experiments I can conclude that the content of the assistant chat panel (right) is used as context for both inline completions ('tab to accept') and inline edits ('inline assist').

For example, I added the system prompt "you are a 15th century pirate that's also an expert python programmer. write your code in pirate speak". Both inline edits and inline completions starting using pirate speak, e.g. def hello_world_ye_lubbers()....

Next, I moved the same simple instruction to a file and included it in the system message with /file. No more pirate speak, sadly. When I expand the file content, though, the instruction gets picked up again.

Small digression, sorry. Just sharing in case anyone else is curious.

---

would recommend using smaller individual files

Yeah, for sure.

AI automatically pick up rules for the specific context it's being prompted in

Most naive approach is to lump everything into the system prompt with the added instructions: "You must follow these rules" and "You must refer to these rules in your reasoning". That gets you quite far, with the obvious downside that as your rules grow so too does the cost of each model request, since you're submitting more input tokens. This is what Zed more or less lets us do today. I personally like it because it hides nothing from the end-user. There is no hidden system prompt or extra model call performed behind the scenes.

More sophisticated approaches are to make rules searchable and have an actual code agent decide when to include them. That brings you into so-called 'agentic' AI territory. Amazing things can happen there, as Cursor demonstrates; however, because it's a fair amount more complex, it's harder to make the process transparent to users.

[a3lem]

Quick update after another test: just doing /file rules.md is enough for the inline assistant to pick up on its contents. No need to expand it as I wrote previously.

You can even move the rules file to a separate directory – e.g. .cursor/rules/ – and_ use that directory as the argument to /file: e.g. /file .cursor/rules/. Really cool!

[Haraven]

Quick update after another test: just doing /file rules.md is enough for the inline assistant to pick up on its contents. No need to expand it as I wrote previously.

You can even move the rules file to a separate directory – e.g. .cursor/rules/ – and_ use that directory as the argument to /file: e.g. /file .cursor/rules/. Really cool!

That's indeed very neat! It's a good workaround for now, though it's pretty costly. From what you're saying, I understand that you have to manually include each applicable rule file, and this will cost extra tokens.

Not only that, but you need to have a kind of mental map of all of the rules you've set up and the different contexts in which they apply. In my Cursor-based projects, I have quite a few individual rule files (in my current project I have 13 rule files). I try to make them atomic and generally applicable so that I can reuse them in other projects. I would have to keep track of which rules apply to which context and then to continuously attach them and/or switch them around. Very tedious. Although it does improve the AI's accuracy.

[nicholaswmin]

isn't that what the prompt library supposed to do?

i got all my styleguides in there, I always include a foundational* and a task specific via /prompt