rules_template

The memory files (located in clinerules/memory and cursor/rules/memory.mdc) create a persistent documentation system for the AI assistant and the project. This system is organized into Core Files (required) and Context Files (optional).

Core Files (Required)

• product_requirement_docs.md (docs/product_requirement_docs.md): The PRD or SOP. Defines project purpose, problems solved, core requirements, and goals. Acts as the source of truth for scope.
• architecture.md (docs/architecture.md): System Architecture Document. Outlines design, component relationships, and dependencies.
• technical.md (docs/technical.md): Technical Specifications. Details the dev environment, technologies, design patterns, and constraints.
• tasks_plan.md (tasks/tasks_plan.md): Task Backlog. Tracks progress, current status, and known issues.
• active_context.md (tasks/active_context.md): Current focus, active decisions, recent changes, and next steps.
• error-documentation.mdc (.cursor/rules/error-documentation.mdc): Reusable fixes for known mistakes and resolutions.
• lessons-learned.mdc (.cursor/rules/lessons-learned.mdc): A journal capturing patterns, preferences, and project intelligence.

Context Files (Optional)

• docs/literature/: Research directory. Can contain research papers (e.g., .tex files).
• tasks/rfc/: Request for Comments (RFC) directory. Stores detailed specifications and discussions for specific functionalities.

The template operates on two pillars: Software Engineering Best Practices and Software Development Documentation. By using comprehensive documentation (PRDs, architecture plans, technical plans, and RFCs) as context, the AI assistant gains the necessary knowledge to follow structured workflows.

The system relies on six crucial file types that shape AI behavior:

1. rules: Houses generic rules and custom workflows.
2. plan: Defines a chain of thinking workflow involving exhaustive searching, optimal planning, rigorous reasoning, and user validation.
3. implement: Defines an implementation workflow based on separation of concerns, modular design, and incremental development. Testing is mandatory after significant implementations.
4. debug: Defines rules for breaking out of loops or handling hard debugging, including web searching and reviewing previously solved errors.
5. memory: Acts as the project's persistent context, containing PRDs, architecture plans, technical plans, and RFCs.
6. directory-structure: A simple file defining the project layout to ensure modularity across code, tests, configs, and data.

The template uses rules files (located in clinerules/rules and cursor/rules/rules.mdc) to enforce a systematic five-phased workflow for any development task. This workflow ensures software engineering best practices are applied regardless of task granularity.

The Five-Phased Workflow:

1. Requirements and Clarifications: Start by making requirements precise and verbose. Ask as many clarifying questions as possible to anticipate bottlenecks and avoid redoing work later.
2. Exhaustive Searching and Optimal Plan: Search all possible directions for a solution. Find the optimal approach (which may be an amalgamation of different methods) and reason rigorously about why it is the best choice.
3. User Validation: Validate the proposed plan with the user. Clearly state all assumptions, design decisions, and the reasoning behind them.
4. Implementation: Implement the plan iteratively. Take one functionality at a time, test it exhaustively across all cases, and then build the next piece to ensure a robust, incremental system.
5. Further Suggestions: After implementation, suggest possible optimizations or additional features for security and functionality.

The template uses a standardized directory structure to ensure all aspects of project development (code, tests, configuration, data, and rules) are handled modularly. This structure serves as the organizational foundation for both human developers and AI coding assistants.

Key directories include:

• .cursor/rules/: Custom rules for Cursor
• .clinerules/: Custom rules for CLINE
• docs/: Project documentation, architecture, and reference materials
• tasks/: Task plans, active context, RFCs, and general to-do items
• src/: Main source code
• test/: Testing suite
• utils/: Utility scripts or libraries
• config/: Configuration files
• data/: Data resources

flowchart TD
    Root[Project Root]
    Root --> Docs[docs/]
    Root --> Tasks[tasks/]
    Root --> Cursor[.cursor/rules/]
    Root --> CLINE[.clinerules]    
    Root --> SourceCode[src/]
    Root --> Test[test/]
    Root --> Utils[utils/]
    Root --> Config[config/]
    Root --> Data[data/]
    Root --> Other[Other Directories]

To save tokens and optimize performance in RooCode, create three custom modes. For each mode, go to Prompts (book icon), click + in the Modes section, and configure as follows:

1. Chat Mode

• Name: Chat
• Slug: chat
• Save Location: Global
• Role Definition: Think Comprehensively in full depth.
• Available Tools: NONE
• Custom Instructions: Use the content from .roo/system-prompt-chat.

2. Write Mode

• Name: Write
• Slug: write
• Save Location: Global
• Role Definition: Create and Edit files and directories. A dedicated mode for all Read/Write operations and running commands.
• Available Tools: Read Files, Edit Files, Run Command
• Custom Instructions: Use the content from .roo/system-prompt-write.

3. MCP Mode

• Name: MCP
• Slug: mcp
• Save Location: Global
• Role Definition: Using MCP servers connected.
• Available Tools: Use MCP
• Custom Instructions: Use the content from .roo/system-prompt-mcp.

To use this template, place the specific rule files into the directory corresponding to your AI coding assistant. The template provides a uniform rule set across different platforms by using these specific file names.

For Cursor

Place files in .cursor/rules/ using the .mdc extension:

• .cursor/rules/rules.mdc
• .cursor/rules/plan.mdc
• .cursor/rules/implement.mdc
• .cursor/rules/debug.mdc
• .cursor/rules/memory.mdc
• .cursor/rules/directory-structure.mdc

For CLINE

Place files in .clinerules/:

• .clinerules/rules
• .clinerules/plan
• .clinerules/implement
• .clinerules/debug
• .clinerules/memory
• .clinerules/directory-structure

For Windsurf

Add the files directly into .windsurfrules.

# Cursor setup example
.cursor/rules/rules.mdc
.cursor/rules/plan.mdc
.cursor/rules/implement.mdc
.cursor/rules/debug.mdc
.cursor/rules/memory.mdc
.cursor/rules/directory-structure.mdc

# CLINE setup example
.clinerules/rules
.clinerules/plan
.clinerules/implement
.clinerules/debug
.clinerules/memory
.clinerules/directory-structure