Understanding .clinerules

.clinerules is a configuration system that serves as the equivalent to Cursor's .cursor/rules directory, providing a structured way to define how AI tools should interact with your codebase. It's designed to enhance the AI's understanding of your project and improve the quality of its assistance.

Core Components

The .clinerules system consists of three essential files:

1. rules - Defines systematic workflows and development patterns
2. memory - Manages project documentation and context
3. directory-structure - Specifies project organization and file layout

Setting Up .clinerules

Basic Directory Structure

your-project/
├── .clinerules/
│   ├── rules
│   ├── memory
│   └── directory-structure
├── src/
├── tests/
└── ...

File Configuration

Each core file serves a specific purpose:

1. rules

The rules file defines your development workflow in five phases:

# Development Workflow

## 1. Requirements and Clarifications
- Precise requirement gathering
- Early bottleneck identification
- Scope definition

## 2. Exhaustive Search and Planning
- Solution exploration
- Approach optimization
- Design decisions

## 3. User Validation
- Assumption verification
- Design review
- Stakeholder approval

## 4. Implementation
- Iterative development
- Incremental testing
- Feature validation

## 5. Optimization
- Performance improvements
- Feature suggestions
- Security enhancements

2. memory

The memory file maintains project context:

# Project Memory Structure

## Core Documentation
- Product Requirements (PRD)
- Technical Specifications
- Architecture Plans

## Active Context
- Current Sprint Goals
- Active Tasks
- Known Issues

## Historical Context
- Past Decisions
- Lessons Learned
- Reference Materials

3. directory-structure

The directory-structure file maps your project organization:

# Project Structure

## Core Directories
/src        - Source code
/tests      - Test suites
/docs       - Documentation
/config     - Configuration files
/data       - Data resources

## Special Directories
/.clinerules - AI configuration
/tasks      - Active development tasks
/utils      - Utility scripts

Best Practices

1. Rule Organization

• Keep rules atomic and focused
• Use clear, descriptive names
• Group related rules logically
• Include examples for complex patterns

2. Memory Management

• Update documentation regularly
• Keep active context current
• Archive outdated information
• Link related documents

3. Structure Maintenance

• Follow consistent naming conventions
• Maintain clear separation of concerns
• Document directory purposes
• Keep structure flat when possible

Advanced Patterns

1. Context Chaining

Link related rules and documentation:

@reference: ./docs/architecture.md
@context: ./tasks/current-sprint.md
@rules: ./patterns/api-design.md

2. Conditional Rules

Apply rules based on file patterns:

[*.test.ts]
- Apply test-specific patterns
- Include testing utilities
- Enable test documentation

[src/api/*]
- Apply API design patterns
- Include API documentation
- Enable security checks

3. Memory Layers

Organize project memory in layers:

1. Immediate Context (Current Sprint)
2. Recent History (Last 3 Sprints)
3. Core Documentation (Always Available)
4. Historical Archive (On-Demand)

Integration with Development Workflow

1. Version Control

   • Commit .clinerules with your project
   • Review changes in pull requests
   • Document significant updates

2. Team Collaboration

   • Share best practices
   • Maintain consistent patterns
   • Regular configuration reviews

3. Continuous Improvement

   • Monitor AI effectiveness
   • Gather team feedback
   • Iterate on rules and patterns

Conclusion

.clinerules provides a robust framework for optimizing AI-assisted development. By carefully configuring your rules, memory, and directory structure, you can significantly enhance the quality and consistency of AI assistance in your development workflow. Remember to treat your .clinerules configuration as a living document that evolves with your project's needs.