Designing a Structured AI Collaboration Framework for Cursor IDE

Background

With the rise of AI‑assisted programming tools, Cursor IDE has become popular, but teams face a critical issue: how can AI truly understand project requirements and generate high‑quality, consistent code?

Problems with the Old Rules

Redundant and vague specifications that waste token usage and distract AI.

Conflicting role definitions and lack of rule priority, causing contradictory behavior.

Maintenance difficulties due to unclear file responsibilities and inter‑rule dependencies.

New Rules Design Philosophy

The new approach adopts a three‑layer architecture: Base Layer , Module Layer , and Workflow Layer , emphasizing layered structure , responsibility separation , and on‑demand invocation .

Three‑Layer Structure

Each layer has clear responsibilities and boundaries.

Base Layer

Splits the original monolithic MDC file into seven single‑purpose rule files, such as

basic.mdc

(project basics),

code-quality.mdc

(quality constraints),

ts.mdc

(TypeScript rules),

style.mdc

(CSS/LESS standards),

comment.mdc

(JSDoc),

code-names.mdc

(naming), and

lint.mdc

(ESLint/Prettier).

Module Layer

Follows a front‑end layered architecture, dividing the application into:

Presentation:

components.mdc

,

pages.mdc

Business Logic:

hooks.mdc

,

utils.mdc

Data Service:

service.mdc

,

constants.mdc

Routing:

route.mdc

Workflow Layer

Standardizes specific business scenarios, such as

curd-page.mdc

(CRUD page development),

log.mdc

(APM monitoring), and

send-buried.mdc

(data tracking).

Standardized Rule Format

# Rule Name
## Base Specification
- Clear technical requirements and implementation standards
## Mandatory Actions
- Actions that must be performed
## Prohibited Actions
- Actions that must never be performed
## Example Code
- Code snippets and best‑practice examples

AI Collaboration Execution Protocol

A concise prompt guides AI to apply the appropriate rules:

# AI Collaboration Execution Rules
## Rule Categories
- basic/ : universal rules, must be invoked
- modules/ : modular rules, invoked as needed
- workflow/ : workflow rules, invoked per scenario
## Execution Flow
1. Identify scenario → invoke relevant rules
2. Load example code as reference
3. Enforce mandatory/prohibited actions
4. Apply design principles (componentization, single responsibility, layered design)
## Quality Assurance
- All rules must be 100% enforced, focusing on mandatory and prohibited actions

Best Practices

Clear responsibilities: each file focuses on a single domain.

Easy maintenance: changes in one rule do not affect others.

Learning friendly: newcomers can understand each rule in isolation.

Quick Start

Create the base directory structure:

.cursor/rules/
├── ai.mdc                # AI collaboration overview
├── basic/                # Base specifications
│   ├── basic.mdc
│   ├── code-quality.mdc
│   ├── ts.mdc
│   ├── style.mdc
│   ├── comment.mdc
│   ├── code-names.mdc
│   └── lint.mdc
├── modules/              # Module specifications
│   ├── components.mdc
│   ├── pages.mdc
│   ├── hooks.mdc
│   ├── service.mdc
│   ├── constants.mdc
│   ├── utils.mdc
│   └── route.mdc
└── workflow/             # Workflow specifications
    ├── curd-page.mdc
    ├── log.mdc
    └── send-buried.mdc

Phased Implementation Plan

Phase

Goal

Key Activities

Pilot

Validate rule effectiveness

Select 1‑2 projects, collect feedback

Optimization

Refine rule content

Iterate based on feedback, develop tooling

Standardization

Establish team standards

Create team‑level standards, set up continuous improvement

Conclusion

By adopting a three‑layer, responsibility‑separated, on‑demand rule system, teams can ensure AI understands context accurately, enforce consistent code quality, and scale the collaboration framework across projects, turning AI‑assisted programming into a core competitive advantage.