Qué es Cursor AI y cómo usarlo (2026): el editor con IA (fork de VS Code), de Tab al Agente

¿Qué es Cursor AI? Un editor de código con IA nativa (fork de VS Code de Anysphere)

Cursor AI es un editor de código con IA nativa: un fork de VS Code creado por Anysphere. Como parte de VS Code, tus extensiones, temas y atajos de teclado se conservan, así que no tiras a la basura la configuración que ya conoces. Lo manejas por cuatro superficies de IA: Tab (autocompletado predictivo), Cmd+K (edición en línea), Cmd+L (chat) y Cmd+I (el Agente para trabajo multiarchivo en todo el proyecto). En la práctica, esas cuatro teclas son el 90% del trabajo diario.

La diferencia con instalar una extensión de IA sobre VS Code normal es que aquí la IA está integrada en el editor: entiende tu proyecto completo porque lo indexa (más sobre esto abajo), no solo el archivo abierto. Según cursor.com, reportó más de 500,000 desarrolladores a inicios de 2026.

Instala Cursor desde cursor.com — tus extensiones, temas y atajos se conservan

Descarga el binario desde cursor.com, instálalo y ábrelo. La primera vez te ofrece importar tu configuración de VS Code — extensiones, temas, keybindings y settings.json — con un clic. Acéptalo y tu entorno queda idéntico al que ya usabas, solo que con las superficies de IA encima.

Si vienes de la terminal, Cursor también instala el comando cursor para abrir carpetas desde tu shell:

cursor .
cursor ~/proyectos/mi-api

Tab: autocompletado predictivo multilínea y smart rewrites

Tab es el autocompletado con esteroides. A diferencia del autocompletado clásico que sugiere una palabra, Tab predice bloques enteros de varias líneas a partir de lo que estás escribiendo y del contexto del archivo. Escribes la firma de una función y te propone el cuerpo completo; aceptas con la tecla Tab.

Además hace smart rewrites: si escribes una línea con un typo o un error menor (un nombre de variable mal, un paréntesis fuera de lugar), Tab no solo completa hacia adelante, también sugiere corregir lo que ya escribiste. Es la superficie con la que más interactúas sin darte cuenta: no abres nada, solo escribes y presionas Tab cuando la sugerencia gris es correcta. Si no lo es, sigues tecleando y la sugerencia se recalcula.

Cmd+K / Ctrl+K: la barra de edición en línea

Cuando quieres generar o modificar código en un punto exacto, coloca el cursor ahí (o selecciona un bloque) y presiona Cmd+K en macOS o Ctrl+K en Windows/Linux. Aparece una barra de prompt en línea: escribes la instrucción en lenguaje natural y Cursor edita el código en el lugar, mostrándote un diff que aceptas o rechazas.

Ejemplos reales de lo que le pides a Cmd+K sobre una selección:

Convierte esta función a async/await y maneja el error con try/catch
Añade validación de tipos con zod al body de este endpoint
Extrae este bloque a una función pura y ponle nombre descriptivo

Cmd+K es quirúrgico: opera sobre lo que tienes seleccionado o donde está el cursor, no sobre todo el proyecto. Es la herramienta correcta para refactors puntuales dentro de un archivo.

Cmd+L / Ctrl+L: el panel de chat con IA

Cmd+L (o Ctrl+L) abre el panel de chat. Es conversacional e iterativo: preguntas, la IA responde con contexto de tu código, tú repreguntas. Úsalo para entender código ajeno (“explícame qué hace este módulo”), para diseñar antes de escribir (“¿cómo estructurarías el manejo de webhooks de Stripe aquí?”), o para depurar pegando un stack trace.

La diferencia con Cmd+K es de intención: Cmd+K edita el código directamente; Cmd+L conversa y te muestra bloques que puedes aplicar cuando decidas. Para explorar y planear, chat; para aplicar un cambio concreto en el punto del cursor, inline edit.

Cmd+I / Ctrl+I: el Agente (Composer) para trabajo multiarchivo en todo el proyecto

Cmd+I (o Ctrl+I) abre el Agente, también conocido como Composer: una superficie unificada que puede editar a través de varios archivos y ejecutar tareas en todo el proyecto. Aquí es donde Cursor deja de ser un autocompletado y se vuelve un agente de verdad. Le describes un objetivo de alto nivel y el Agente localiza los archivos relevantes, propone los cambios en todos ellos y te presenta un diff conjunto para revisar.

Ejemplo de instrucción de nivel de proyecto:

Agrega un endpoint POST /webhooks/stripe que verifique la firma,
registre el evento en la tabla events y responda 200. Crea el handler,
la migración y actualiza el router.

El Agente toca varios archivos a la vez —handler, migración, router— sin que tú saltes entre ellos manualmente. Si quieres entender la línea que separa este flujo del de un agente de terminal, lo cubro en Claude Code vs Cursor. Y si aún no tienes claro qué distingue a un agente de un simple script, empieza por qué es un agente de IA.

Dale contexto con símbolos @: @file, @folder, @codebase

La IA no adivina bien si no sabe a qué te refieres. Por eso en cualquiera de las superficies de texto (Cmd+K, Cmd+L, Cmd+I) puedes escribir símbolos @ para apuntar el contexto de forma explícita:

@file src/lib/stripe.ts       apunta a un archivo concreto
@folder src/routes/           incluye toda una carpeta
@codebase                     busca semánticamente en todo el proyecto

• @file para cuando sabes exactamente qué archivo importa.
• @folder cuando el cambio abarca un módulo entero.
• @codebase cuando no sabes dónde vive algo y quieres que Cursor lo encuentre por significado, no por nombre.

Usar @ bien es la diferencia entre una respuesta genérica y una que respeta cómo está construido tu proyecto. Es el mismo principio que aplicas al conectar un agente de IA a tus datos con MCP: el modelo solo es tan bueno como el contexto que le das.

Indexado del código: cómo los vector embeddings hacen funcionar @codebase

Cuando abres un proyecto, Cursor construye un índice de tus archivos usando vector embeddings. En lugar de guardar el texto tal cual, convierte fragmentos de tu código en vectores numéricos que capturan su significado. Cuando escribes @codebase "dónde validamos el RFC del cliente", Cursor no hace un grep literal de la palabra “RFC”: busca por similitud semántica sobre ese mapa vectorial y trae los fragmentos relevantes aunque la función se llame validateTaxId.

Eso es lo que hace que @codebase funcione en repos grandes: la IA parte de un mapa real de tu código, no de una suposición. En proyectos con datos sensibles vale la pena recordar qué se envía al modelo — si manejas datos personales, revisa cómo ocultar PII mexicano (CURP, RFC, CLABE) antes del LLM antes de indexar todo a ciegas.

Rules: codifica los estándares de tu equipo para no repetirte

Si te descubres escribiendo “usa TypeScript estricto, nada de any, tests con Vitest” en cada prompt, eso es señal de que necesitas Rules. Cursor te deja definir reglas de proyecto que persisten, de modo que la IA sigue los estándares de tu equipo sin que los repitas cada vez. Las escribes una vez en el proyecto y aplican a todas las superficies.

Un ejemplo de reglas de proyecto:

- Usa TypeScript en modo estricto; prohibido el tipo any.
- Los endpoints validan el body con zod antes de tocar la base de datos.
- Errores de dominio como clases, nunca strings sueltos.
- Cada handler nuevo trae su test en Vitest.
- Los montos en centavos (enteros), nunca en flotante.

Las Rules son el equivalente en Cursor a un CLAUDE.md: convierten tus convenciones en algo que la IA respeta por defecto. Es la misma filosofía de encapsular estándares que aplicas al construir un agente con n8n y Claude, donde el contexto fijo hace que cada corrida sea consistente.

Elegir modelo: multiproveedor (Claude, GPT y más)

Cursor es multiproveedor: tú eliges el modelo. Soporta modelos de Claude y de GPT, entre otros, y cambias entre ellos desde el selector en cada superficie. Las versiones exactas cambian seguido, así que no las fijes en tu cabeza — revisa el selector.

En la práctica: modelos más capaces para el Agente en tareas de refactor grande, modelos más rápidos para el chat exploratorio. Si además consumes modelos por API en tu propio backend, el patrón de selección es el mismo que explico en cómo usar la API de Claude: eliges el modelo por la relación capacidad/costo de cada tarea, no uno para todo.

Tu primera tarea real: un flujo completo en Cursor

Un flujo típico de principio a fin, agregando un endpoint a una API:

# 1. Abre el proyecto desde la terminal
cursor ~/proyectos/mi-api

1. Explora con Cmd+L. Pregunta @codebase "¿dónde registramos las rutas?" para ubicar el router sin buscar a mano.
2. Lanza el Agente con Cmd+I. Instrucción: @folder src/routes/ agrega POST /clientes que valide el body con zod y persista en la tabla clientes. Revisa el diff multiarchivo.
3. Ajusta con Cmd+K. Selecciona el handler y pide añade manejo de error 409 si el RFC ya existe.
4. Termina con Tab. Al escribir el test, Tab autocompleta los casos a partir de la firma.

Ese ciclo —chat para ubicar, Agente para construir, Cmd+K para pulir, Tab para rematar— es el ritmo real de trabajo. No es una superficie; es saber cuál usar en cada momento. Para entender cuándo un agente conviene más que una herramienta de automatización tradicional, compara en agentes de IA vs herramientas de automatización.

Precios: Free, Pro $20, Pro+ $60, Ultra $200, Teams $40 (usage-credit)

Cursor usa un modelo de usage-credit: la cuota mensual incluye una bolsa de créditos de uso, y los excedentes se cobran después. Confirma los números vigentes en cursor.com/pricing, pero al momento de escribir esto los planes son:

Para uso individual serio, Pro a $20/mes es el punto de entrada; Pro+ a $60 y Ultra a $200 amplían la bolsa de créditos para quienes viven en el Agente todo el día. Teams cuesta $40 por usuario y agrega administración. La bolsa de créditos importa: si abusas del Agente con modelos caros, la consumes rápido — por eso elegir modelo (sección anterior) también es una decisión de costo.

Cursor vs Claude Code — y cómo correr Claude Code dentro de Cursor

Cursor y Claude Code no son estrictamente un “esto o lo otro”. Cursor es un editor con IA integrada; Claude Code es el agente de terminal de Anthropic. Y son complementarios: Claude Code publica una extensión para Cursor, así que puedes correr Claude Code dentro de Cursor y usar ambos en el mismo repo — el editor para la edición asistida en el punto del cursor, el agente de terminal para tareas autónomas de mayor alcance.

Si quieres el desglose completo de cuándo conviene cada uno, léelo en Claude Code vs Cursor, y si aún no conoces el agente de terminal, empieza por qué es Claude Code y cómo usarlo. Para el panorama de agentes en general, el hub de agentes de IA reúne todo lo demás.

La regla práctica: empieza con Cursor por sus cuatro superficies (Tab, Cmd+K, Cmd+L, Cmd+I), aprende a dar contexto con @ y Rules, y cuando necesites un agente que trabaje solo por más tiempo, súmale Claude Code sin salir del editor. Documentación oficial en cursor.com/docs.