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.

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
Contexto	Proyecto completo indexado	Archivo actual + archivos abiertos
Chat con código	Integrado, entiende todo el repo	Copilot Chat, contexto limitado
Edición inline	Cmd+K edita directamente	Sugerencias inline
Multi-archivo	Composer edita varios archivos a la vez	Un archivo a la vez
Modelos	GPT-4o, Claude, modelos propios	GPT-4o, Claude (limitado)
Precio	Gratis + Pro 20$/mes	10$/mes individual

La diferencia clave: Copilot te ayuda a escribir líneas de código. Cursor te ayuda a construir features completas.

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. Cursor > General > Codebase indexing: Asegúrate de que está activado. Esto permite que Cursor indexe tu proyecto completo.
2. Cursor > General > Auto-complete: Actívalo para sugerencias inline automáticas
3. Cursor > Models: Elige tu modelo preferido (recomiendo GPT-4o o Claude Sonnet para uso general)

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.

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+Right Arrow 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.

Función 3: Chat (Cmd+L)

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. Pulsa Cmd+L (Mac) o Ctrl+L (Windows) para abrir el panel de chat
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.

Función 4: Composer (Cmd+I)

Qué es: La función más potente. Genera o modifica código en múltiples archivos a la vez.

Cómo usarlo:

1. Pulsa Cmd+I (Mac) o Ctrl+I (Windows)
2. Describe lo que quieres construir con detalle
3. Cursor genera o modifica múltiples archivos simultáneamente
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 Jest."

Composer genera 4-5 archivos de golpe, todos coherentes entre sí.

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 Composer

• Describe la feature completa
• Deja que Composer 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 -> Composer
(Simple)                (Complejo)

Si Tab no es suficiente, paso a Cmd+K. Si Cmd+K no alcanza, abro Chat. Solo uso Composer para cosas que realmente afectan a muchos archivos.

Paso 4: Tips Avanzados que Marcan la Diferencia

1. Reglas del proyecto (.cursorrules)

Crea un archivo .cursorrules en la raíz de tu proyecto para definir cómo debe comportarse la IA:

Este proyecto usa:
- Next.js 14 con App Router
- TypeScript estricto
- Tailwind CSS
- Prisma como ORM
- 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

Cursor lee este archivo y ajusta TODAS sus sugerencias para seguir tus convenciones. Es como darle un manual de estilo a la IA.

2. Documentación como contexto (@docs)

Puedes añadir documentación externa como contexto:

1. Ve a Settings > Cursor > Features > Docs
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. Modo "Agent" en Composer

El Composer tiene un modo Agent que no solo escribe código, sino que también:

• Ejecuta comandos en terminal
• Lee la salida de errores
• Corrige los errores automáticamente
• Instala dependencias si hace falta

Para activarlo, en el Composer selecciona el modo "Agent" en lugar de "Normal". Es como tener un programador junior que escribe, ejecuta, falla, corrige y repite hasta que funciona.

4. Generar tests desde código

Uno de los mejores usos de Cursor:

1. Abre el archivo con tu función/componente
2. Abre Chat (Cmd+L)
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

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:

Atajo (Mac / Win)	Acción
Tab	Aceptar sugerencia inline
Esc	Rechazar sugerencia
Cmd+K / Ctrl+K	Edición inline con IA
Cmd+L / Ctrl+L	Abrir chat
Cmd+I / Ctrl+I	Abrir Composer
Cmd+Shift+L	Añadir selección al chat
@ en chat	Referenciar archivo/carpeta
Cmd+Enter en chat	Enviar con contexto de codebase

Errores Comunes y Cómo Evitarlos

Aceptar todo sin revisar. Cursor genera código muy bueno, pero no perfecto. Siempre revisa lo que acepta, especialmente en Composer que puede tocar muchos archivos.

No usar .cursorrules. Sin reglas de proyecto, Cursor hace suposiciones. Con reglas, sigue tus convenciones exactas. Dedica 5 minutos a crear el archivo, te ahorrará horas de correcciones.

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" es un buen prompt.

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

Usar Composer para todo. Composer es potente pero pesado. Para cambios en un solo archivo, Cmd+K es más rápido y preciso.

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?

Cursor tiene un plan gratuito que incluye:

• 2000 completados (Tab)
• 50 usos de modelos premium (GPT-4o, Claude)
• Modelos propios ilimitados

El plan Pro (20$/mes) incluye:

• Completados ilimitados
• 500 usos de modelos premium/mes
• Modelos propios ilimitados
• Acceso prioritario

Mi opinión: si programas todos los días, el Pro se paga solo en la primera semana. Los 50 usos del plan gratuito se agotan rápido si usas Chat y Composer con frecuencia.

Si estás empezando, prueba el plan gratuito durante una semana para ver si encaja con tu workflow. Si al tercer día ya te has quedado sin usos premium, tienes tu respuesta.

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 .cursorrules 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 Composer cuando te sientas cómodo

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.