Tutorial de Cursor: programar con IA a otra velocidad

Cursor ha cambiado mi forma de programar. Y eso es algo que no digo a la ligera. Después de años usando VS Code con Copilot, pensaba que ya había alcanzado el techo de productividad con IA. Cursor me demostró que no.

No es simplemente "VS Code con ChatGPT pegado al lado". Es un editor diseñado desde cero para que la IA entienda tu proyecto completo: tu código, tu estructura, tus dependencias, tu estilo. Y eso marca una diferencia brutal.

En este tutorial te enseño a instalar Cursor, dominar sus funciones principales y usarlo de forma productiva. Seas junior o senior, vas a programar más rápido.

Un aviso antes de empezar: Cursor cambia de interfaz y de modelo de precios cada pocos meses. Este tutorial está actualizado a agosto de 2026 y lo he escrito de forma que siga siendo útil aunque muevan un botón: cuando un atajo no coincida con lo que ves, ábrelo desde la paleta de comandos con Cmd+Shift+P (Mac) o Ctrl+Shift+P (Windows) y busca el nombre de la función. Es la forma más robusta de trabajar con una herramienta que se reinventa cada trimestre.

Qué es Cursor (y por qué no es solo otro Copilot)

Cursor es un editor de código basado en VS Code que integra IA de forma nativa. Fue creado por Anysphere y ha crecido exponencialmente porque resuelve un problema real: los asistentes de código generan sugerencias genéricas porque no entienden el contexto de tu proyecto.

Cursor sí lo entiende. Indexa todo tu repositorio y usa ese contexto para darte sugerencias que encajan con tu código real.

Cursor vs GitHub Copilot

Característica	Cursor	GitHub Copilot
Base	Fork de VS Code (editor completo)	Extensión para VS Code y otros IDE
Contexto	Proyecto completo indexado	Archivo actual + archivos abiertos + repo indexado
Chat con código	Integrado, entiende todo el repo	Copilot Chat, contexto más limitado
Edición inline	Cmd+K edita directamente	Sugerencias inline y edición
Multi-archivo	El agente edita varios archivos a la vez	Modo agente, más conservador
Modelos	GPT-5.x, Claude 5, Gemini 3.x y Composer (modelo propio)	GPT-5.x, Claude y Gemini según plan
Precio	Gratis (Hobby) + Pro 20 $/mes	Gratis limitado + Pro 10 $/mes

La diferencia clave: Copilot te ayuda a escribir líneas de código. Cursor te ayuda a construir features completas. La contrapartida es que Cursor es bastante más caro en cuanto le das trabajo de verdad, y eso lo explico en detalle más abajo.

Paso 1: instalación y configuración

Instalar Cursor

1. Ve a cursor.com y descarga la versión para tu sistema operativo
2. Ejecuta el instalador (macOS, Windows o Linux)
3. Al abrir por primera vez, Cursor te pregunta si quieres importar tu configuración de VS Code
   • Di que sí. Importará extensiones, temas, atajos de teclado y configuración
   • Si no usas VS Code, puedes empezar desde cero
4. Inicia sesión con tu cuenta de Cursor (puedes usar GitHub, Google o email)

Pro tip: Si vienes de VS Code, Cursor es literalmente el mismo editor por debajo. Tus extensiones favoritas funcionan, tus atajos son los mismos. La transición es casi instantánea.

Configuración inicial recomendada

Ve a Settings (Cmd+, en Mac, Ctrl+, en Windows) y ajusta:

1. Indexación del código: asegúrate de que está activada. Es lo que permite que Cursor entienda tu proyecto completo. En repos grandes la primera indexación tarda unos minutos: déjala terminar antes de juzgar la calidad de las respuestas.
2. Autocompletado (Tab): actívalo para sugerencias inline automáticas.
3. Modelos: aquí eliges qué modelo usa el agente. La opción Auto deja que Cursor elija por ti el modelo más eficiente en coste, y en los planes de pago no consume de tu bolsa de crédito. Empieza siempre por Auto y sube a un modelo concreto solo cuando Auto no dé la talla.
4. Privacy Mode: si trabajas con código de cliente o de empresa, actívalo. Impide que tu código se almacene en los servidores de Cursor. Es lo primero que te pedirá tu responsable de seguridad, así que hazlo antes de que te lo pidan.

Error típico en el primer arranque: las respuestas del chat son genéricas y no conocen tu código. Casi siempre es porque la indexación no ha terminado o porque el proyecto está fuera de la carpeta abierta. Comprueba el estado de la indexación en los ajustes antes de dar por hecho que "Cursor no funciona".

Paso 2: las 4 funciones principales

Cursor tiene cuatro funciones principales que necesitas dominar. Cada una sirve para algo diferente.

Función 1: Tab (autocompletado inteligente)

Qué es: Sugerencias inline mientras escribes, como Copilot pero con contexto de todo tu proyecto. A diferencia de un autocompletado clásico, también te propone saltar a otra línea o a otro archivo para el siguiente cambio lógico.

Cómo usarlo:

1. Simplemente escribe código como harías normalmente
2. Cursor te muestra sugerencias en gris
3. Pulsa Tab para aceptar la sugerencia completa
4. Pulsa Ctrl+Flecha derecha para aceptar palabra por palabra
5. Pulsa Esc para rechazar

Cuándo brilla:

• Escribir funciones que siguen patrones de tu código existente
• Completar imports y boilerplate
• Escribir tests basados en tu código
• Código repetitivo con variaciones

Ejemplo práctico: Si tienes un modelo User con campos name, email, password y escribes un modelo Product, Cursor sugerirá una estructura similar adaptada a un producto (name, price, description, etc.) porque entiende el patrón.

Función 2: Cmd+K (edición inline)

Qué es: Seleccionas código y le pides a la IA que lo modifique directamente en su lugar.

Cómo usarlo:

1. Selecciona el código que quieres modificar (o no selecciones nada para generar código nuevo)
2. Pulsa Cmd+K (Mac) o Ctrl+K (Windows)
3. Escribe tu instrucción: "Añade manejo de errores" / "Optimiza esta función" / "Convierte a TypeScript"
4. Cursor te muestra un diff con los cambios propuestos
5. Acepta (Enter) o rechaza (Esc)

Cuándo usarlo:

• Refactorizar una función
• Añadir tipado a JavaScript
• Implementar manejo de errores
• Optimizar rendimiento
• Traducir entre lenguajes

Ejemplo práctico: Selecciona una función JavaScript y escribe: "Convierte a TypeScript con tipos estrictos y manejo de errores". Cursor reescribe la función completa con tipos, try/catch y todo.

Truco poco conocido: Cmd+K también funciona en el terminal integrado. Escribes en lenguaje natural lo que quieres hacer y te propone el comando. Para comandos de git o de Docker que nunca recuerdas, es oro.

Función 3: chat

Qué es: Un chat con IA que entiende tu proyecto completo. Como ChatGPT pero con contexto real de tu código.

Cómo usarlo:

1. Abre el panel lateral de IA. En las versiones actuales el atajo es Cmd+L o Cmd+I (Ctrl en Windows) según cómo tengas configurada la barra; si no coincide, búscalo en la paleta de comandos.
2. Escribe tu pregunta o petición
3. Puedes referenciar archivos con @ (ejemplo: @components/Header.tsx)
4. Puedes referenciar la selección actual seleccionando código antes de abrir el chat
5. La IA responde con código y explicaciones
6. Puedes aplicar el código directamente haciendo clic en "Apply"

Cuándo usarlo:

• Entender código que no escribiste tú
• Pedir explicaciones sobre errores
• Diseñar la arquitectura de una nueva funcionalidad
• Depurar problemas complejos
• Preguntar sobre dependencias y librerías

Referencias con @:

Referencia	Qué hace
@filename	Incluye un archivo específico como contexto
@folder	Incluye una carpeta entera
@codebase	Busca en todo el repositorio
@web	Busca información en internet
@docs	Busca en documentación específica
@git	Incluye contexto del historial de git

Pro tip: Usa @codebase cuando necesites que la IA encuentre dónde se define algo o cómo se usa una función en todo el proyecto. Es increíblemente útil para entender proyectos grandes. También es la referencia que más contexto consume: en un monorepo grande, apuntar a @folder concretas sale mucho más barato y suele dar mejores respuestas.

Función 4: el agente (antes Composer)

Qué es: La función más potente, y la que se ha convertido en el centro de Cursor. Genera o modifica código en múltiples archivos a la vez, ejecuta comandos en el terminal, lee la salida de errores y corrige hasta que funciona.

Si vienes de tutoriales antiguos: esto es lo que se llamaba Composer. En las versiones actuales la interfaz gira en torno al agente y el modo "Composer normal" ya no es la forma habitual de trabajar. Cursor tiene además un modelo propio para el agente, llamado Composer, cuya versión actual es la 2.5.

Cómo usarlo:

1. Abre el panel del agente (Cmd+I / Ctrl+I, o desde la paleta de comandos)
2. Describe lo que quieres construir con detalle
3. El agente planifica, genera o modifica múltiples archivos, ejecuta comandos y corrige errores
4. Revisa cada cambio en cada archivo
5. Acepta o rechaza archivo por archivo

Cuándo usarlo:

• Crear una feature completa (componente + API + tests)
• Refactorizar algo que afecta a muchos archivos
• Migrar una tecnología (por ejemplo, de REST a tRPC)
• Crear CRUD completos
• Implementar cambios de diseño en múltiples componentes

Ejemplo práctico: "Crea un endpoint de API en /api/products que soporte GET (listar con paginación), POST (crear), PUT (actualizar) y DELETE. Crea también el modelo de Prisma, los tipos de TypeScript y tests unitarios con Vitest."

El agente genera 4-5 archivos de golpe, todos coherentes entre sí, y si los tests fallan los arregla solo.

El error que comete todo el mundo la primera vez: lanzar el agente sobre un repositorio con cambios sin commitear. Si el resultado no te gusta, separar lo tuyo de lo suyo es un infierno. Haz commit antes de cada tanda del agente. Es la regla número uno y la que más disgustos evita.

Paso 3: workflow productivo con Cursor

Saber qué hace cada función es una cosa. Saber cuándo usar cada una es otra. Este es mi workflow diario:

Para tareas pequeñas (< 5 min)

Usa Tab + Cmd+K

• Tab para completado rápido mientras escribes
• Cmd+K para ediciones puntuales

Para tareas medianas (5-30 min)

Usa Chat

• Abre el chat, referencia los archivos relevantes con @
• Describe lo que necesitas
• Aplica las sugerencias directamente

Para tareas grandes (> 30 min)

Usa el Agente

• Describe la feature completa
• Deja que genere la estructura base
• Refina con Chat y Cmd+K

Mi regla personal

Siempre empiezo con la herramienta más simple que pueda resolver el problema:

Tab -> Cmd+K -> Chat -> Agente
(Simple)                (Complejo)

Si Tab no es suficiente, paso a Cmd+K. Si Cmd+K no alcanza, abro Chat. Solo uso el agente para cosas que realmente afectan a muchos archivos. Esto no es purismo: el agente consume muchísimo más crédito que las otras tres funciones juntas, y desde que Cursor cobra por consumo eso se nota en la factura.

Paso 4: tips avanzados que marcan la diferencia

1. Reglas del proyecto: usa .cursor/rules, no .cursorrules

Este es el punto donde más tutoriales están desfasados. El archivo .cursorrules en la raíz del proyecto está obsoleto. Cursor todavía lo lee por compatibilidad, pero no recibe funciones nuevas y —esto es lo importante— no se carga en el modo agente, que es justo donde más falta hace.

El formato actual son las Project Rules: archivos .mdc dentro de la carpeta .cursor/rules/. Son Markdown con cabecera YAML, lo que permite que cada regla se aplique solo a los archivos que le corresponden.

Crea .cursor/rules/general.mdc:

---
description: Convenciones generales del proyecto
alwaysApply: true
---

Este proyecto usa:
- Next.js con App Router
- TypeScript estricto
- Tailwind CSS
- Prisma como ORM sobre PostgreSQL

Convenciones:
- Nombres de componentes en PascalCase
- Funciones helper en camelCase
- Archivos de utilidad en /lib
- Componentes reutilizables en /components/ui
- No usar 'any' en TypeScript
- Usar 'const' por defecto, nunca 'var'
- Manejo de errores con try/catch en todas las funciones async
- Tests con Vitest, no Jest

Y una regla específica solo para los tests, en .cursor/rules/tests.mdc:

---
description: Cómo escribir tests en este proyecto
globs: ["**/*.test.ts", "**/*.test.tsx"]
---

- Un describe por función pública
- Cubrir siempre el caso feliz, el caso límite y el error
- Nada de mocks de librerías internas: usa las reales

Las tres claves de la cabecera:

• alwaysApply: true — la regla entra en todas las peticiones
• globs — la regla solo entra cuando se tocan archivos que encajan con el patrón
• description — el agente decide por sí mismo si la carga según lo que esté haciendo

Cursor también lee un archivo AGENTS.md en la raíz, que es el estándar que están adoptando varias herramientas de agentes. Si trabajas en equipo con gente que usa otros editores, ese es el sitio donde poner las convenciones comunes, y dejas en .cursor/rules/ lo específico de Cursor.

Cómo comprobar que tus reglas se están aplicando: pregúntale al agente "¿qué reglas de proyecto tienes cargadas ahora mismo?". Si no menciona las tuyas, están mal ubicadas o el glob no encaja. Es el fallo más común y se diagnostica en 10 segundos.

2. Documentación como contexto (@docs)

Puedes añadir documentación externa como contexto:

1. Ve a los ajustes de Cursor, sección de funciones y documentación
2. Añade URLs de documentación que uses frecuentemente (Next.js, Prisma, etc.)
3. En el chat, usa @docs para que Cursor consulte esa documentación al responder

Esto es brutal para frameworks que se actualizan rápido. En vez de sugerirte código de una versión antigua, Cursor consulta la documentación actual.

3. Conectar herramientas externas con MCP

Cursor soporta el Model Context Protocol, el estándar que permite conectar el agente a herramientas externas: tu base de datos, tu gestor de incidencias, tu documentación interna. Configurado, puedes pedirle cosas como "mira el esquema real de la base de datos antes de escribir la consulta" y deja de inventarse nombres de columnas.

Es, de largo, la mejora de calidad más grande que puedes hacerle al agente. Si no sabes de qué va, lo explico desde cero en la guía sobre qué es MCP (Model Context Protocol).

4. Generar tests desde código

Uno de los mejores usos de Cursor:

1. Abre el archivo con tu función o componente
2. Abre el Chat
3. Escribe: "@filename Genera tests unitarios completos para este archivo. Cubre edge cases, errores y happy path."
4. Cursor genera tests que realmente entienden tu código

Y el paso que casi nadie da: pide después "ejecuta los tests y arregla los que fallen". Ahí el agente entra en su bucle de ejecutar, leer el error y corregir, que es donde de verdad aporta.

5. Code review con IA

Antes de hacer commit:

1. Selecciona los cambios (o usa @git)
2. En Chat: "Revisa estos cambios. Busca bugs, problemas de rendimiento, vulnerabilidades de seguridad y oportunidades de simplificación."
3. Cursor analiza tus cambios con el contexto completo del proyecto

Paso 5: atajos de teclado esenciales

Memoriza estos. Van a acelerar tu flujo enormemente. Si alguno no coincide con tu versión, búscalo en la paleta de comandos: Cursor los ha movido más de una vez.

Atajo (Mac / Win)	Acción
Tab	Aceptar sugerencia inline
Esc	Rechazar sugerencia
Cmd+K / Ctrl+K	Edición inline con IA (también en el terminal)
Cmd+L / Ctrl+L	Abrir el panel de chat
Cmd+I / Ctrl+I	Abrir el panel del agente
Cmd+Shift+L	Añadir la selección al chat
@ en el chat	Referenciar archivo, carpeta, docs o web
Cmd+Shift+P	Paleta de comandos: tu red de seguridad cuando cambian la interfaz

Errores comunes y cómo evitarlos

Aceptar todo sin revisar. Cursor genera código muy bueno, pero no perfecto. Siempre revisa lo que aceptas, especialmente con el agente, que puede tocar muchos archivos.

Lanzar el agente sin commit previo. Si el resultado no te convence, separar tus cambios de los suyos es un dolor. Commitea antes de cada tanda.

Seguir usando .cursorrules. No se carga en el modo agente. Migra a .cursor/rules/*.mdc y dedícale diez minutos: es la mejora de calidad más barata que existe.

Prompts vagos. "Arregla esto" no es un buen prompt. "Esta función lanza un TypeError cuando el array está vacío. Añade una comprobación al inicio y devuelve un array vacío como fallback" sí lo es.

Ignorar el diff. Cuando Cmd+K o el agente te muestran cambios, léelos. Es la mejor forma de aprender y de detectar errores antes de que lleguen a producción.

Usar el agente para todo. Es potente pero caro y pesado. Para cambios en un solo archivo, Cmd+K es más rápido, más preciso y consume una fracción del crédito.

Dejar el modelo más caro fijado por defecto. Es la vía rápida para fundirte la bolsa mensual en dos semanas. Trabaja en Auto y sube de modelo solo cuando el problema lo pida.

Pro tip: Si el resultado de Cursor no te convence, pulsa Cmd+Z para deshacer y reformula tu prompt con más contexto. La calidad del prompt determina la calidad del resultado.

¿Merece la pena el plan Pro? Cómo funcionan los precios hoy

Aquí está el cambio más importante desde que se escribieron la mayoría de tutoriales de Cursor. Ya no se cuentan "peticiones rápidas" ni "500 usos premium al mes". Cursor pasó a un modelo de consumo: cada plan incluye una bolsa de crédito en dólares que gastas según el modelo que uses y los tokens que consumas.

Plan	Precio	Qué incluye
Hobby	0 $	Prueba limitada de las funciones de agente y un cupo corto de autocompletado
Pro	20 $/mes	20 $ de consumo de modelos incluidos + modo Auto sin límite práctico
Pro+	60 $/mes	60 $ de consumo incluidos
Ultra	200 $/mes	200 $ de consumo incluidos
Teams	40 $/usuario/mes	Bolsa por usuario, gestión centralizada y controles de privacidad
Enterprise	A medida	Facturación y seguridad corporativas

La facturación anual aplica un descuento en torno al 20%. Cuando agotas tu bolsa puedes activar el consumo bajo demanda, que se factura después: actívalo con un límite de gasto configurado o te llevarás un susto. Es la queja número uno de los usuarios de Cursor y es perfectamente evitable.

Dos matices que cambian mucho la ecuación:

• El modo Auto no consume de tu bolsa en los planes de pago. Cursor elige un modelo eficiente y tú no pagas por token. Para el 70% del trabajo diario es más que suficiente.
• El modelo propio de Cursor (Composer) es mucho más barato que los de terceros, del orden de céntimos por millón de tokens frente a los dólares que cuestan los modelos punteros de OpenAI, Anthropic o Google. Para tareas de refactorización y edición mecánica va sobrado.

Mi opinión, sin humo: si programas todos los días profesionalmente, el Pro se paga solo en la primera semana. Si programas por afición o estás aprendiendo, empieza en Hobby, luego una mensualidad de Pro trabajando en Auto, y mira el panel de consumo antes de decidir si subes. Y si tu perfil es más de "quiero construir algo sin ser programador", el enfoque cambia bastante: lo trato aparte en el artículo sobre qué es el vibe coding.

Si lo que quieres es comparar Cursor con el resto de opciones antes de comprometerte, en la mejor IA para programar en 2026 están todas puestas una al lado de otra.

Conclusión: Cursor como multiplicador

Cursor no programa por ti. Multiplica tu capacidad de programación. Si eres un buen programador, Cursor te hace excelente. Si estás aprendiendo, Cursor acelera tu aprendizaje porque puedes preguntar, experimentar y entender código en contexto real.

El flujo que te recomiendo para empezar:

1. Instala Cursor e importa tu configuración de VS Code
2. Crea tu carpeta .cursor/rules/ con las convenciones de tu proyecto
3. Empieza solo con Tab y Cmd+K durante la primera semana
4. Añade Chat en la segunda semana
5. Experimenta con el agente cuando te sientas cómodo, siempre con commit previo

No intentes dominar todo de golpe. Tab y Cmd+K ya te van a dar una mejora de productividad notable. El resto viene con la práctica.

Preguntas frecuentes

¿Cuánto cuesta Cursor al mes en 2026?

Cursor tiene plan gratuito (Hobby) y tres niveles individuales de pago: Pro por 20 $/mes, Pro+ por 60 $/mes y Ultra por 200 $/mes. Cada plan incluye una bolsa de consumo de modelos equivalente a su precio. El plan de equipos ronda los 40 $ por usuario y mes, y la facturación anual descuenta alrededor de un 20%.

¿Cursor es gratis? ¿Qué incluye el plan hobby?

Hay un plan Hobby gratuito, pero es una prueba, no una alternativa sostenible: incluye un cupo corto de autocompletado y un uso muy limitado del agente. Sirve para ver si te encaja el flujo de trabajo durante unos días. Si programas a diario, se te agota en la primera sesión seria.

¿Sigue funcionando el archivo .cursorrules?

Cursor todavía lo lee por compatibilidad, pero está obsoleto y, sobre todo, no se carga en el modo agente, que es donde más lo necesitas. El formato actual son archivos .mdc dentro de .cursor/rules/, con cabecera YAML que permite aplicar cada regla solo a los archivos que corresponden. Migrar cuesta diez minutos.

¿Qué modelos de IA usa Cursor?

Cursor da acceso a los modelos punteros de OpenAI, Anthropic y Google (las familias GPT-5.x, Claude 5 y Gemini 3.x) y además tiene su propio modelo, Composer, especializado en tareas de edición de código. El modo Auto elige el modelo por ti y, en los planes de pago, no descuenta de tu bolsa mensual.

¿Cursor o GitHub Copilot: cuál es mejor?

Copilot es más barato (plan gratuito y Pro por 10 $/mes) y se integra en el IDE que ya usas. Cursor es más caro pero su agente es claramente superior para trabajos que tocan muchos archivos a la vez. Regla práctica: si quieres autocompletado excelente sin cambiar de editor, Copilot; si quieres delegar features completas, Cursor.

¿Por qué se me agotan tan rápido los créditos de Cursor?

Casi siempre por dos motivos: tener fijado el modelo más caro en lugar de trabajar en Auto, y usar el agente para tareas que resolverías con Cmd+K. El agente lee mucho contexto y ejecuta muchos pasos, y cada uno cuesta tokens. Trabaja en Auto por defecto, usa @folder en vez de @codebase y reserva el agente para cambios multi-archivo de verdad.

¿Es seguro usar Cursor con código confidencial de mi empresa?

Cursor tiene un Privacy Mode que impide que tu código se almacene en sus servidores, y los planes de equipo y empresa añaden controles centralizados. Actívalo antes de abrir cualquier repositorio de cliente. Aun así, si trabajas con código sujeto a acuerdos de confidencialidad estrictos, consulta la política antes: el código sí viaja al proveedor del modelo para poder generar la respuesta.

¿Qué pasó con Composer? ¿Ya no existe?

Composer sigue existiendo, pero el nombre significa hoy dos cosas distintas. La función multi-archivo se ha integrado en el agente, que es el centro de la interfaz actual. Y "Composer" es ahora también el nombre del modelo propio de Cursor, cuya versión actual es la 2.5. Si un tutorial te habla de "abrir Composer" como algo aparte del agente, es anterior a 2025.

¿Cursor sirve si no sé programar?

Sirve para construir cosas, pero no para no entenderlas. Puedes llegar lejos describiendo lo que quieres, y el agente lo montará. El problema aparece cuando algo se rompe: sin saber leer un stack trace no vas a poder desatascarte, y el agente entra en bucles de "arreglo" que empeoran el código. Es una herramienta que multiplica lo que sabes, no que lo sustituye.

¿Cursor funciona sin conexión a internet?

Como editor sí, porque por debajo es VS Code. Pero todas las funciones de IA —Tab, Cmd+K, el chat y el agente— necesitan conexión, porque los modelos se ejecutan en la nube. No hay un modo local para las funciones de IA.