Cursor – guía completa de capacidades y configuración de agentes IA

Mayo de 2026

Cursor es un editor de código construido sobre VS Code que desde 2023 ha revolucionado la forma en que los desarrolladores trabajan con la IA. A diferencia de los simples complementos para chatear con un modelo de lenguaje, Cursor trata a la IA como un participante de pleno derecho en el proceso de desarrollo de software – un agente que lee archivos, ejecuta comandos en el terminal, revisa errores, escribe y modifica código, e incluso abre pull requests en GitHub. Este artículo es una revisión detallada de lo que Cursor puede hacer y, más importante, cómo configurarlo para que los agentes trabajen mejor, de forma más eficiente y de acuerdo con tus expectativas.

Modos de trabajo con la IA

Cursor ofrece varios modos de interacción con el modelo:

Ask (Preguntar)

Modo de solo lectura. El agente puede explorar archivos, buscar en el código y responder preguntas, pero no realiza ningún cambio. Ideal para explorar una base de código desconocida, entender la arquitectura o explicar fragmentos de código.

Agent (modo de trabajo predeterminado)

Un agente completo con acceso a todas las herramientas: puede leer y escribir archivos, ejecutar comandos en el terminal, buscar en el código, instalar paquetes, clonar repositorios, abrir navegadores, invocar herramientas MCP y delegar tareas a subagentes. La gran mayoría del trabajo ocurre en este modo.

Plan (Planificar)

Modo de solo lectura diseñado para planificar soluciones antes de su implementación. Cuando una tarea es grande, multihilo o tiene compromisos arquitectónicos importantes, el modo Plan permite discutir el enfoque antes de que se cambie nada en el código.

Inline Edit

Edición rápida directamente en el editor – seleccionas un fragmento de código, presionas un atajo de teclado y describes el cambio. Ideal para refactorizar una función, corregir un error concreto o añadir comentarios.

Tab Completion

Autocompletado inteligente de código – Cursor predice lo que escribirás a continuación, teniendo en cuenta el contexto de todo el proyecto, no solo el archivo actual. Admite sugerencias multilínea y puede proponer el siguiente paso en una secuencia de cambios.

Contexto – el corazón del trabajo del agente

Un agente es tan bueno como el contexto que recibe. Cursor ofrece varios mecanismos para proporcionar contexto:

@-menciones

En la ventana de chat puedes hacer referencia a:
- @archivo.ts – un archivo concreto
- @carpeta/ – un directorio completo
- @Git – historial de commits
- @Docs – documentación externa (por ejemplo, React, Tailwind)
- @Web – búsqueda web en tiempo real
- @Codebase – búsqueda semántica en toda la base de código

Adjuntar archivos

Puedes arrastrar archivos a la ventana de chat o usar el botón de adjunto para que el agente tenga acceso a recursos específicos – como una captura de pantalla de un error, un archivo CSV con datos o un esquema de base de datos.

MCP – Model Context Protocol

MCP es un estándar abierto para integrar herramientas externas con agentes de IA. Cursor admite servidores MCP que amplían las capacidades del agente con acceso a sistemas externos.

Ejemplos de servidores MCP disponibles:
- Datadog – consultas de logs, métricas y trazas
- Linear – gestión de tickets y proyectos
- Sentry – exploración de errores e issues
- Slack – envío de mensajes, exploración de canales
- Databricks – consultas SQL, trabajo con datos
- Stripe – datos de suscripciones y pagos
- GitHub – pull requests, issues, revisión de código
- PostgreSQL / SQLite – consultas directas a la base de datos

MCP se configura en ~/.cursor/mcp.json (globalmente) o .cursor/mcp.json (por proyecto). Ejemplo de configuración:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..."
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"]
    }
  }
}

Canvas – artefactos interactivos

Canvas es una función más reciente de Cursor que permite al agente crear aplicaciones React en vivo abiertas directamente junto a la ventana de chat. En lugar de pegar una tabla de datos en markdown, el agente puede renderizar un dashboard interactivo, un gráfico, una línea de tiempo o una herramienta de exploración de datos.

Los canvas son ideales cuando:
- el resultado es un artefacto analítico independiente – un resumen de métricas, una auditoría de seguridad, un informe, una revisión de arquitectura
- los datos de MCP (Datadog, Databricks, etc.) son el producto principal, no un paso intermedio
- el resultado tiene muchas filas y se beneficiaría de un diseño visual

Un archivo canvas tiene la extensión .canvas.tsx y solo importa desde cursor/canvas – sin paquetes externos, sin fetch(). El agente lo crea automáticamente cuando el tema lo requiere.

Reglas (Rules) – configuración persistente del agente

Las reglas son uno de los mecanismos de configuración más potentes de Cursor. Permiten instruir al agente de forma persistente – establecer estándares de código, convenciones del proyecto y patrones arquitectónicos que el agente debe respetar.

¿Dónde almacenarlas?

Reglas de proyecto – en .cursor/rules/ (versionadas junto con el proyecto, compartidas por todo el equipo).

Formato del archivo

Los archivos de reglas tienen la extensión .mdc y contienen frontmatter YAML:

---
description: Estándares de TypeScript para este proyecto
globs: **/*.ts
alwaysApply: false
---

# Manejo de errores

Siempre registra los errores antes de volver a lanzar la excepción:

\`\`\`typescript
// ❌ MAL
try {
  await fetchData();
} catch (e) {}

// ✅ BIEN
try {
  await fetchData();
} catch (e) {
  logger.error('Error al obtener datos', { error: e });
  throw new DataFetchError('No se pudieron obtener los datos', { cause: e });
}
\`\`\`

Campos del frontmatter

Buenas prácticas

• Una regla debe tener un objetivo concreto – no metas todo en un solo archivo.
• Incluye ejemplos concretos (bien / mal) – el agente aprende mucho mejor con ejemplos que con descripciones abstractas.
• Mantén las reglas por debajo de 500 líneas – cuanto más conciso, mejor.
• Usa alwaysApply: true para reglas globales (p. ej. idioma de respuesta, estilo de commits).

Ejemplos de reglas útiles

Regla de idioma (el agente siempre responde en español):

---
description: Idioma de respuesta del agente
alwaysApply: true
---
Responde siempre en español, a menos que el usuario solicite explícitamente otro idioma.

Regla de estilo para React:

---
description: Patrones de componentes React
globs: **/*.tsx
alwaysApply: false
---
- Usa componentes funcionales, nunca de clase.
- Extrae la lógica a hooks propios (useXxx).
- Coloca los estilos junto al componente (CSS Modules o styled-components).
- Tipifica las props con interfaces, no con type aliases.

Regla de commits:

---
description: Formato de mensajes de commit
alwaysApply: true
---
Commits en formato Conventional Commits:
- feat: nueva funcionalidad
- fix: corrección de error
- refactor: refactorización sin cambio de comportamiento
- docs: documentación
- test: pruebas

Ejemplo: `feat(auth): añadir inicio de sesión con Google OAuth`

Habilidades (Skills) – conocimiento especializado del agente

Las habilidades son más que reglas – son conjuntos de instrucciones que describen cómo realizar tareas concretas. El agente carga una habilidad solo cuando el tema de la conversación lo indica (o cuando se lo pides). Esto evita que el contexto se llene de información irrelevante.

¿Dónde almacenarlas?

• ~/.cursor/skills/nombre-skill/ – habilidades personales, disponibles en todos los proyectos.
• .cursor/skills/nombre-skill/ – habilidades de proyecto, versionadas con el repositorio.

Nota: Nunca crees habilidades en ~/.cursor/skills-cursor/ – ese es el directorio interno de Cursor.

Estructura de una habilidad

mi-skill/
├── SKILL.md              # Obligatorio – instrucciones principales.
├── reference.md          # Opcional – documentación detallada.
├── examples.md           # Opcional – ejemplos de uso.
└── scripts/              # Opcional – scripts auxiliares.
    └── helper.py

Formato de SKILL.md

---
name: analisis-ventas
description: Analiza datos de ventas desde CSV, genera informes y gráficos. Úsalo cuando el usuario mencione ventas, ingresos, informes mensuales o archivos CSV.
---

# Análisis de datos de ventas

## Inicio rápido

1. Carga el archivo CSV con pandas.
2. Comprueba los tipos de columna y los valores faltantes.
3. Calcula agregados (suma, media, tendencia).
4. Genera un gráfico con matplotlib.

## Scripts auxiliares

\`\`\`bash
python scripts/validate_csv.py archivo.csv
# Devuelve: "OK" o una lista de problemas
\`\`\`

Principios clave para escribir habilidades

La descripción es fundamental – el agente la usa para decidir cuándo cargar la habilidad. Debe contener:
- ¿Qué hace la habilidad (capacidades)?
- ¿Cuándo usarla (escenarios de activación, palabras clave)?

Ejemplo de una buena descripción:

description: Revisa pull requests en cuanto a calidad, seguridad y conformidad con los estándares del equipo. Úsalo cuando revises un PR, inspecciones cambios en el código o el usuario solicite una revisión de código.

Concisión – el agente es inteligente; no expliques lo obvio. Escribe solo lo que el agente no sabría por sí mismo.

disable-model-invocation: true – opción predeterminada; la habilidad se carga solo cuando se invoca explícitamente o cuando el agente la selecciona según el contexto.

Ejemplos de habilidades útiles

• code-review – Estándares de revisión de código para tu proyecto, lista de verificación de seguridad.
• deploy – Pasos de despliegue (staging → producción), lista de cosas a comprobar.
• db-schema – Descripción de la estructura de la base de datos, relaciones entre tablas.
• commit-messages – Formato preferido, ejemplos de mensajes buenos y malos.
• api-conventions – Estándares de nomenclatura de endpoints, formatos de respuesta, manejo de errores.
• onboarding – Guía para nuevos desarrolladores sobre cómo ejecutar el proyecto localmente.

Hooks – automatización alrededor de los eventos del agente

Los hooks son una función avanzada que permite ejecutar tus propios scripts o consultas al modelo antes o después de eventos específicos en el trabajo del agente. Con ellos puedes:

• bloquear operaciones peligrosas (p. ej. rm -rf, comandos de red)
• formatear archivos automáticamente después de cada edición
• auditar lo que hace el agente
• inyectar contexto adicional tras la ejecución de una herramienta
• encadenar subagentes en bucles

¿Dónde almacenarlos?

• .cursor/hooks.json + .cursor/hooks/ – hooks de proyecto
• ~/.cursor/hooks.json + ~/.cursor/hooks/ – hooks de usuario (globales)

Formato de hooks.json

{
  "version": 1,
  "hooks": {
    "beforeShellExecution": [
      {
        "command": ".cursor/hooks/approve-network.sh",
        "matcher": "curl|wget|nc",
        "failClosed": true
      }
    ],
    "afterFileEdit": [
      {
        "command": ".cursor/hooks/format.sh"
      }
    ]
  }
}

Eventos disponibles

Ejemplo: bloqueo de comandos peligrosos

#!/bin/bash
# .cursor/hooks/approve-network.sh
input=$(cat)
command=$(echo "$input" | jq -r '.command // empty')

if <span class="text-amber-500/50" title="Nieznany link">[[&quot;$command&quot; =~ curl]]</span>; then
  echo '{
    "permission": "ask",
    "user_message": "Este comando puede enviar una solicitud de red. ¿Lo apruebas?",
    "agent_message": "El hook bloqueó el comando como una posible solicitud de red."
  }'
  exit 0
fi

echo '{ "permission": "allow" }'
exit 0

Ejemplo: autoformateo tras la edición

#!/bin/bash
# .cursor/hooks/format.sh
input=$(cat)
file=$(echo "$input" | jq -r '.path // empty')

if <span class="text-amber-500/50" title="Nieznany link">[[&quot;$file&quot; =~ \.(ts]]</span>; then
  npx prettier --write "$file" 2>/dev/null
fi

exit 0

Hooks de prompt

En lugar de un script, puedes usar un modelo de lenguaje para tomar una decisión:

{
  "version": 1,
  "hooks": {
    "beforeShellExecution": [
      {
        "type": "prompt",
        "prompt": "¿Este comando parece seguro? Permite solo operaciones de solo lectura. Comando: $ARGUMENTS",
        "timeout": 10
      }
    ]
  }
}

Los hooks de prompt son simples de configurar, pero los hooks de script son deterministas y auditables – elige según tus necesidades.

Línea de estado en CLI

Cursor tiene su propia interfaz CLI (cursor en el terminal) con soporte para una línea de estado personalizada sobre el prompt. Es un script que se ejecuta con cada actualización de la conversación y puede mostrar cualquier información.

Configuración en ~/.cursor/cli-config.json:

{
  "statusLine": {
    "type": "command",
    "command": "~/.cursor/statusline.sh",
    "padding": 2
  }
}

El script recibe por stdin un JSON con información de la sesión – modelo actual, porcentaje de uso de la ventana de contexto, directorio de trabajo, rama git activa, modo vim, nombre del worktree y más.

Ejemplo de script que muestra el modelo y la barra de contexto:

#!/usr/bin/env bash
input=$(cat)
MODEL=$(echo "$input" | jq -r '.model.display_name')
PCT=$(echo "$input" | jq -r '.context_window.used_percentage // 0' | cut -d. -f1)

BAR_WIDTH=10
FILLED=$((PCT * BAR_WIDTH / 100))
EMPTY=$((BAR_WIDTH - FILLED))
BAR=""
[ "$FILLED" -gt 0 ] && printf -v FILL "%${FILLED}s" && BAR="${FILL// /▓}"
[ "$EMPTY" -gt 0 ] && printf -v PAD "%${EMPTY}s" && BAR="${BAR}${PAD// /░}"

printf "\033[36m[%s]\033[0m ctx %s %s%%\n" "$MODEL" "$BAR" "$PCT"

Resultado: [Claude Sonnet 4.5] ctx ▓▓▓░░░░░░░ 30%

Subagentes y tareas paralelas

Cursor Agent puede crear subagentes – procesos especializados lanzados en paralelo para gestionar tareas complejas. Es especialmente útil para:

• explorar una base de código grande y desconocida (el agente "explore" busca en muchos lugares simultáneamente)
• ejecutar experimentos aislados en ramas git separadas (worktrees)
• análisis que requieren múltiples fuentes de datos independientes
• ejecutar pruebas, compilaciones o despliegues en segundo plano

Tipos de subagentes

Los subagentes se ejecutan en segundo plano y notifican al agente principal al finalizar.

Worktrees – entornos de trabajo aislados

Cursor admite git worktrees – la posibilidad de tener varias copias de trabajo del repositorio simultáneamente, cada una en una rama diferente. Los agentes pueden trabajar en worktrees separados de forma independiente, sin interferir entre sí.

Útil cuando:
- quieres comparar varias implementaciones del mismo problema
- ejecutas una compilación larga en segundo plano mientras trabajas en otra funcionalidad
- pruebas diferentes enfoques de refactorización

Babysitting de PR – agente que vigila pull requests

La habilidad babysit implementa un escenario en el que el agente supervisa de forma autónoma un PR hasta que esté listo para hacer merge. En un bucle:

1. Revisa los comentarios del PR (incluidos los de bots como Bugbot).
2. Corrige los que acepta; explica aquellos sobre los que no está seguro.
3. Resuelve conflictos de merge (solo cuando la intención de los cambios es obvia).
4. Corrige el CI en rojo.
5. Hace push de los cambios y vuelve a observar el CI.
6. Repite hasta conseguirlo.

Split to PRs – dividir trabajo grande en PRs pequeños

La habilidad split-to-prs ayuda a dividir una gran cantidad de trabajo no confirmado en varios pull requests pequeños y revisables. Procedimiento:

1. El agente analiza el estado del repositorio y el historial del chat para entender la intención.
2. Propone una división (normalmente el título del PR es suficiente).
3. Espera tu aprobación.
4. Crea ramas, hace commit solo de los archivos o hunks planificados, hace push y abre los PRs.
5. Guarda una copia de seguridad antes de cualquier operación git.

Configuración de los ajustes del editor

Cursor hereda la plena configurabilidad de VS Code. Los ajustes del usuario se encuentran en:

Ajustes populares específicos de Cursor:

{
  "cursor.cpp.enablePartialAccepts": true,
  "cursor.chat.showSuggestedFiles": true,
  "cursor.chat.smoothStreaming": true,
  "cursor.composer.shouldAutoScrollToBottom": true
}

Cómo unir todo – ejemplo de configuración de proyecto

Así podría verse un proyecto bien configurado:

mi-proyecto/
├── .cursor/
│   ├── rules/
│   │   ├── typescript-standards.mdc    # Estándares TS, alwaysApply: false, globs: **/*.ts
│   │   ├── react-patterns.mdc          # Patrones React, alwaysApply: false, globs: **/*.tsx
│   │   ├── commit-style.mdc            # Formato de commits, alwaysApply: true
│   │   └── spanish-responses.mdc       # Respuestas en español, alwaysApply: true
│   ├── skills/
│   │   ├── db-schema/
│   │   │   └── SKILL.md                # Esquema de base de datos de este proyecto.
│   │   └── deploy/
│   │       └── SKILL.md                # Procedimiento de despliegue.
│   ├── hooks.json                      # Automatizaciones de eventos del agente.
│   ├── hooks/
│   │   ├── format.sh                   # Autoformateo tras la edición.
│   │   └── approve-network.sh          # Preguntar antes de solicitudes de red.
│   └── mcp.json                        # Integraciones con herramientas externas.

A nivel de usuario (globalmente):

~/.cursor/
├── skills/
│   ├── code-review/
│   │   └── SKILL.md                   # Mi estilo personal de revisión de código.
│   └── git-workflow/
│       └── SKILL.md                   # Mi flujo de trabajo con git.
├── hooks.json                         # Hooks globales (p. ej. bloqueo de rm -rf).
├── hooks/
│   └── safety-check.sh
└── cli-config.json                    # Línea de estado de CLI.

Buenas prácticas al trabajar con el agente

Sé específico en las instrucciones

Cuanto más precisamente describes la tarea, mejor será el resultado. En lugar de "corrige el error", escribe "la función calculateTotal en cart.ts devuelve undefined cuando la lista de productos está vacía – corrígela para que devuelva 0".

Usa las @-menciones de forma consciente

Añade al contexto solo lo que sea relevante. Un agente con el contexto sobrecargado pierde eficiencia. Señala un archivo concreto en lugar de toda una carpeta si es suficiente.

Lee antes de aceptar

El agente comete errores. Revisa siempre los cambios propuestos antes de aprobarlos – especialmente al modificar archivos de configuración, bases de datos o scripts de despliegue.

Itera en pasos pequeños

En lugar de una tarea grande (que puede fallar), divide el trabajo en etapas más pequeñas. Después de cada etapa, comprueba el resultado, haz preguntas y ajusta la dirección.

Construye una base de reglas

Dedica tiempo a escribir buenas reglas y habilidades al inicio del proyecto. Es una inversión única que da frutos en cada conversación posterior con el agente.

Usa el modo Plan antes de cambios importantes

Antes de refactorizar un módulo grande, migrar una base de datos o reescribir lógica crítica – cambia primero al modo Plan, discute el enfoque y asegúrate de que el agente entiende las restricciones y los objetivos.

Novedades (2026)

Cursor CLI como agente de terminal autónomo

Cursor ya no es solo un editor. El CLI (cursor) permite ejecutar el agente directamente desde el terminal – sin abrir la interfaz gráfica. Ideal para automatización, scripts de CI/CD o trabajo en servidores remotos a través de SSH.

Best-of-N runner

El subagente best-of-n-runner ejecuta la misma tarea varias veces en worktrees aislados y devuelve el mejor resultado. Útil cuando una tarea tiene múltiples enfoques válidos y te importa la calidad de la solución, no solo la velocidad.

Hooks ampliados

Los nuevos eventos de hook ofrecen un control aún mejor sobre el comportamiento del agente: afterAgentResponse, afterAgentThought, preCompact (antes de la compresión del contexto). Es posible construir sistemas completos de auditoría y seguridad alrededor del agente.

Hooks de prompt – políticas descritas en lenguaje natural

En lugar de escribir un script bash para la validación, puedes describir una política de seguridad en lenguaje natural en un hook de prompt – Cursor invoca un modelo de lenguaje que decide si la acción está permitida. Especialmente útil para reglas de negocio no triviales.

Integración con tableros kanban y herramientas de gestión de proyectos

A través de servidores MCP, el agente ahora puede leer y modificar directamente tickets en Linear, Jira, Notion y herramientas similares – el contexto de la tarea llega al agente sin copiar y pegar.

Resumen

Cursor no es solo un "editor con IA" – es una plataforma para construir tu propio entorno de trabajo con un agente de IA adaptado a tus necesidades. Mecanismos de configuración clave:

Cuanto mejor sea la configuración, menos tiempo pasarás explicando el contexto al agente y más tiempo dedicarás al trabajo real. Un Cursor bien configurado es un agente que conoce tu proyecto, tu estilo y tus limitaciones – y trabaja en consonancia con ellos desde la primera palabra.

Artículo escrito en mayo de 2026. Cursor está en continuo desarrollo – algunas funciones pueden estar disponibles solo en planes o versiones específicas.

Fuentes y lecturas adicionales

1. Cursor Docs – documentación principal – descripción general de todas las funciones del agente, reglas, MCP, habilidades y CLI
   cursor.com/docs

2. Hooks | Cursor Docs – documentación completa del sistema de hooks: eventos, formato JSON, matchers, ejemplos de scripts
   cursor.com/docs/agent/third-party-hooks

3. Agent Skills | Cursor Docs – especificación de habilidades: estructura de SKILL.md, ubicaciones, frontmatter, invocación automática
   cursor.com/docs/context/skills

4. Model Context Protocol (MCP) | Cursor Docs – configuración de servidores MCP, transportes (stdio, SSE, HTTP), instalación desde Marketplace
   cursor.com/docs/context/mcp

5. Canvases | Cursor Docs – descripción del formato canvas.tsx, componentes del SDK, flujo de trabajo para crear artefactos interactivos
   cursor.com/docs/agent/tools/canvas

6. Cursor Marketplace – biblioteca de plugins, reglas y servidores MCP listos para instalar con un clic
   cursor.com/marketplace