Cursor Rules

Sistema de Rules para personalizar IA

El sistema de Rules de Cursor IDE representa una de las funcionalidades más avanzadas para personalizar el comportamiento de la inteligencia artificial según las necesidades específicas de cada proyecto o desarrollador. Este sistema permite definir instrucciones precisas que la IA seguirá durante la generación de código, estableciendo patrones, estilos y restricciones que se aplicarán de forma consistente.

Arquitectura del sistema de Rules

Cursor implementa un sistema jerárquico de reglas que opera en diferentes niveles de aplicación. Las reglas se organizan en una estructura que permite desde configuraciones globales hasta especificaciones muy concretas para proyectos individuales.

El sistema distingue entre Project Rules y User Rules, cada una con su propio ámbito de aplicación y prioridad. Las Project Rules se almacenan dentro del directorio del proyecto y afectan únicamente a ese contexto específico, mientras que las User Rules se aplican globalmente a todos los proyectos del usuario.

# Ejemplo de estructura de directorios con rules
mi_proyecto/
├── .cursor/
│   └── rules
├── src/
│   └── main.py
└── requirements.txt

Project Rules: configuración específica del proyecto

Las Project Rules se definen mediante un archivo llamado rules ubicado en el directorio .cursor/ dentro de la raíz del proyecto. Estas reglas tienen precedencia sobre las configuraciones globales y permiten establecer convenciones específicas para el contexto de trabajo actual.

La creación de Project Rules es muy útil cuando trabajamos en equipos de desarrollo, ya que garantiza que todos los miembros del equipo reciban sugerencias de código consistentes con los estándares establecidos para el proyecto.

# Ejemplo de código que seguiría project rules específicas
class DataProcessor:
    """Procesador de datos siguiendo convenciones del proyecto."""
    
    def __init__(self, config_path: str) -> None:
        self._config = self._load_config(config_path)
        self._logger = self._setup_logger()
    
    def _load_config(self, path: str) -> dict:
        """Carga configuración desde archivo JSON."""
        # Implementación específica del proyecto
        pass

Jerarquía y precedencia de reglas

El sistema implementa una jerarquía clara donde las Project Rules tienen prioridad sobre las User Rules. Esta estructura permite mantener flexibilidad personal mientras se respetan las convenciones específicas de cada proyecto.

Cuando Cursor genera código, evalúa primero si existen Project Rules aplicables. En caso de no encontrarlas, recurre a las User Rules del usuario. Si ninguna regla específica está definida, la IA utiliza sus patrones predeterminados.

# La IA aplicará diferentes estilos según las rules activas
def procesar_datos(datos: list) -> dict:
    """
    Función que se adapta al estilo definido en las rules.
    El formato de docstrings, naming conventions y estructura
    dependerán de las reglas configuradas.
    """
    resultado = {}
    
    for item in datos:
        # El estilo de procesamiento seguirá las rules establecidas
        clave = item.get('id')
        valor = item.get('valor')
        resultado[clave] = valor
    
    return resultado

Beneficios del sistema de Rules

La implementación de un sistema de reglas personalizado ofrece ventajass en el desarrollo de software. Permite mantener consistencia en el estilo de código a lo largo de todo el proyecto, reduce la necesidad de revisiones manuales de código y facilita la integración de nuevos desarrolladores al equipo.

Además, el sistema de Rules mejora la productividad al automatizar decisiones de estilo que tradicionalmente requerían discusión y documentación manual. La IA aprende y aplica estas convenciones de forma automática, liberando tiempo para enfocarse en la lógica de negocio y arquitectura del software.

La flexibilidad del sistema permite desde reglas simples de formato hasta instrucciones complejas sobre patrones arquitectónicos, manejo de errores o convenciones de nomenclatura específicas del dominio del proyecto.

Tipos de rules y formato MDC

El formato .mdc (Markdown Components) constituye el estándar para definir reglas en Cursor IDE. Los archivos .mdc combinan metadatos (frontmatter) con contenido de reglas, proporcionando una sintaxis estructurada para personalizar el comportamiento de la IA. Este formato combina la simplicidad del markdown con extensiones específicas que Cursor interpreta para personalizar el comportamiento de generación de código.

Estructura básica del formato MDC

Las reglas se escriben utilizando sintaxis markdown estándar, donde los encabezados definen categorías de reglas y el contenido describe las instrucciones específicas. El formato MDC permite organizar las reglas de manera jerárquica, facilitando tanto la lectura humana como el procesamiento por parte de la IA.

# Convenciones de código Python

## Nomenclatura
- Usar snake_case para variables y funciones
- Usar PascalCase para clases
- Constantes en MAYÚSCULAS

## Documentación
- Incluir docstrings en todas las funciones públicas
- Usar type hints en parámetros y valores de retorno

Tipos de reglas por categoría

El sistema de rules admite diferentes categorías de instrucciones que abarcan desde aspectos sintácticos hasta patrones arquitectónicos complejos. Cada categoría se enfoca en un aspecto específico del desarrollo de software.

Reglas de estilo y formato:

# Estilo de código

## Formato
- Líneas máximo 88 caracteres
- Usar comillas dobles para strings
- Espacios alrededor de operadores

## Imports
- Imports estándar primero
- Imports de terceros después
- Imports locales al final

Reglas de patrones y arquitectura:

# Patrones de diseño

## Clases
- Implementar __str__ y __repr__ en clases de datos
- Usar properties para atributos calculados
- Aplicar principio de responsabilidad única

## Funciones
- Máximo 20 líneas por función
- Un solo nivel de abstracción por función
- Evitar efectos secundarios en funciones puras

Reglas específicas para Python

Dado el enfoque en desarrollo con Python, las reglas pueden incluir especificaciones detalladas sobre el uso de características específicas del lenguaje, bibliotecas comunes y patrones idiomáticos.

# Especificaciones Python

## Manejo de datos
- Usar pandas para manipulación de datasets
- Implementar validación con pydantic
- Aplicar list comprehensions cuando mejoren legibilidad

## Machine Learning
- Usar scikit-learn para algoritmos estándar
- Implementar pipelines para preprocesamiento
- Documentar hiperparámetros en configuración

Reglas condicionales y contextuales

El formato MDC permite definir reglas condicionales que se aplican únicamente en contextos específicos, proporcionando flexibilidad para adaptar el comportamiento de la IA según el tipo de archivo o funcionalidad que se esté desarrollando.

# Reglas contextuales

## Para archivos de testing
- Prefijo "test_" en nombres de función
- Usar pytest fixtures para setup
- Un assert por test cuando sea posible

## Para scripts de análisis
- Incluir logging detallado
- Guardar resultados en formato pickle
- Generar visualizaciones con matplotlib

Sintaxis avanzada del formato MDC

El formato admite elementos avanzados como ejemplos de código, plantillas y referencias cruzadas que enriquecen las instrucciones proporcionadas a la IA.

# Plantillas de código

## Clase base para procesadores
    ```python
    class BaseProcessor:
    def __init__(self, config: dict):
    self.config = config
    self.logger = self._setup_logger()

    def process(self, data):
    raise NotImplementedError
    ```

## Patrón de factory
- Usar cuando se necesiten múltiples implementaciones
- Registrar tipos en diccionario de factories
- Validar parámetros antes de crear instancias

Reglas de validación y restricciones

Las reglas pueden incluir restricciones específicas que la IA debe respetar durante la generación de código, estableciendo límites y validaciones que garanticen la calidad y consistencia del código generado.

# Restricciones de código

## Seguridad
- No usar eval() ni exec()
- Validar inputs de usuario
- Usar secrets para datos sensibles

## Performance
- Evitar loops anidados profundos
- Usar generadores para datasets grandes
- Implementar caching cuando sea apropiado

Organización y mantenimiento de rules

La organización efectiva de las reglas requiere una estructura lógica que facilite el mantenimiento y la evolución del sistema. Las reglas deben agruparse por funcionalidad y mantenerse actualizadas conforme evoluciona el proyecto.

# Estructura recomendada

## Core (reglas fundamentales)
## Styling (formato y presentación)  
## Architecture (patrones y estructura)
## Domain (específicas del dominio)
## Testing (reglas para pruebas)

El formato MDC proporciona la flexibilidad necesaria para crear sistemas de reglas sofisticados que evolucionan junto con las necesidades del proyecto, manteniendo siempre la claridad y facilidad de mantenimiento que caracterizan a las mejores prácticas de desarrollo de software.