Curso de Cursor para Ingeniería del Software

Instalación y actualización de Cursor en Windows, macOS y distribuciones Linux compatibles.

Inicio de sesión, organización, equipo, licencia y selección del espacio de trabajo correcto.

Importación desde Visual Studio Code de extensiones, settings, themes y keybindings.

Compatibilidad con extensiones y análisis de aquellas que pueden afectar a privacidad, rendimiento o comportamiento del entorno.

Apertura de repositorios locales y conexión con sistemas de control de versiones.

Configuración global frente a configuración específica del workspace.

Gestión de terminales integrados, shells, variables de entorno y herramientas de desarrollo.

Selección del modelo predeterminado y cambio de modelo durante una conversación según la dificultad de cada fase.

Configuración de Agents, approvals, execution y herramientas habilitadas.

Auto-review, Allowlist y Run Everything como modelos actuales de ejecución de comandos y sus diferencias de riesgo.

Sandboxing de comandos para limitar acceso a filesystem y red.

Configuración de `.cursorignore` para excluir archivos o directorios del contexto del agente.

Uso de `permissions.json` y `sandbox.json` para separar revisión de acciones y límites efectivos del sandbox.

Configuración del repositorio para build, lint, tests, type checking y comandos de validación reproducibles.

Preparación de un entorno en el que el agente pueda cerrar el ciclo escribiendo, ejecutando y verificando el software.

Diferencias entre trabajar desde el IDE tradicional y utilizar Agents Window como espacio orientado a coordinación de agentes.

Agents Window para ejecutar y administrar simultáneamente múltiples tareas, repositorios y entornos.

Organización de conversaciones y agentes según feature, incidencia, investigación, refactorización o mantenimiento.

Ejecución de agentes locales sobre el workspace actual.

Worktrees como checkouts Git aislados para evitar conflictos entre tareas paralelas.

Creación de worktrees desde Agents Window y continuidad del trabajo dentro de una copia independiente del repositorio.

Configuración de worktrees mediante `.cursor/worktrees.json`.

Estrategia de una tarea por branch/worktree para facilitar revisión, comparación y descarte.

Diferencia entre Agent, subagent, worktree y Cloud Agent como niveles distintos de aislamiento.

Múltiples agentes trabajando en paralelo sobre áreas independientes de una misma aplicación.

Multi-repo workspaces para cambios coordinados entre frontend, backend, infraestructura y librerías compartidas.

Desarrollo mediante Remote SSH y trabajo sobre entornos remotos cuando forma parte de la arquitectura del equipo.

Handoff entre ejecución local y cloud para trasladar tareas de larga duración sin perder el flujo de trabajo.

Artifacts como screenshots, vídeos, logs y otras evidencias producidas por agentes para facilitar la revisión.

Criterios para coordinar múltiples agentes sin multiplicar conflictos, consumo, duplicidad de trabajo o complejidad de integración.

Agent Mode para tareas complejas que requieren búsqueda, edición de varios archivos, terminal y validación.

Ask Mode para explorar y comprender el código sin permitir modificaciones automáticas.

Plan Mode para diseñar la solución, aclarar requisitos y ordenar el trabajo antes de implementar.

Debug Mode como proceso basado en hipótesis, instrumentación, reproducción, evidencia en runtime, corrección y verificación.

Diferencias entre pedir directamente una implementación y comenzar mediante análisis o planificación.

Custom Modes para mantener una habilidad o conjunto de instrucciones durante toda una sesión.

Conversión de Skills en modos especializados para workflows recurrentes.

Herramientas de lectura, búsqueda semántica, edición, terminal, web, browser, MCP y subagents disponibles según el modo.

Control de autonomía a través de permisos sobre cada familia de tools.

Steering del agente durante una ejecución sin necesidad de interrumpir completamente su trabajo.

Uso de `/goal` para objetivos persistentes y tareas que requieren múltiples iteraciones cuando la funcionalidad está disponible.

División de grandes features en unidades verificables y dependencias explícitas.

Diseño previo de criterios de aceptación para que el agente conozca qué significa completar realmente una tarea.

Verificación obligatoria de tests, build, linting y comportamiento antes de aceptar una implementación.

Estrategia Ask → Plan → Agent → Debug → Review para cambios de especial complejidad.

Prompting para ingeniería: objetivo, restricciones, arquitectura, criterios de aceptación, pruebas y definición explícita de lo que no debe modificarse.

Diferencia entre describir una solución concreta y proporcionar suficiente contexto para que el agente proponga alternativas.

Contexto procedente del repositorio, archivos abiertos, búsqueda semántica, historial, herramientas, Rules, Skills y MCP.

Indexación y exploración semántica para localizar implementaciones relevantes en repositorios de gran tamaño.

Control del tamaño de contexto y eliminación de información irrelevante o desactualizada.

Resumen de conversaciones largas para conservar decisiones importantes reduciendo consumo de contexto.

Project Rules almacenadas en `.cursor/rules` y versionadas junto al código.

Archivos `.mdc`, descripciones, patrones de archivos y aplicación permanente o contextual de reglas.

User Rules para preferencias individuales aplicadas entre proyectos.

Team Rules para estándares distribuidos y administrados a nivel de organización en planes compatibles.

`AGENTS.md` como alternativa Markdown sencilla para transmitir instrucciones persistentes al agente.

Reglas por directorio para adaptar convenciones a backend, frontend, tests, infraestructura u otras áreas del repositorio.

Memorias persistentes y criterios para diferenciar conocimiento estable de contexto temporal.

Prevención de reglas contradictorias, excesivamente largas, redundantes o imposibles de verificar.

Diseño de un sistema de instrucciones como parte del repositorio y sujeto a revisión de ingeniería igual que el código.

Agent Skills como capacidades especializadas que encapsulan conocimiento, instrucciones, workflows y recursos.

Estructura de una Skill mediante `SKILL.md`, metadata, documentación y recursos asociados.

Skills de proyecto y capacidades compartidas entre desarrolladores.

Skills integradas para automatización, creación de hooks, rules, revisión, seguridad, SDK y otras tareas actuales.

Diferencia entre Rule, Skill, Command y Subagent y criterios para utilizar cada mecanismo.

Subagents como asistentes especializados con su propia ventana de contexto para investigación, ejecución o revisión independiente.

Subagents integrados Explore, Bash y Browser y su función para aislar contextos especialmente ruidosos.

Custom Subagents definidos en `.cursor/agents/` con instrucciones, modelo, tools y comportamiento especializado.

Subagents foreground y background y utilización del paralelismo en trabajos independientes.

Aislamiento de subagents mediante worktrees o entornos cloud cuando varios agentes modifican código simultáneamente.

Hooks como scripts ejecutados antes o después de etapas del agent loop para observar, bloquear o modificar comportamiento.

Uso de Hooks para formatters, detección de secretos, validación de PII, políticas de seguridad y restricciones sobre operaciones peligrosas.

Commands reutilizables para encapsular acciones o prompts invocables mediante `/`.

Plugins como paquetes capaces de distribuir Rules, Skills, Agents, Commands, MCP Servers y Hooks.

Marketplace, plugins internos de equipo y estrategia para estandarizar prácticas de ingeniería sin copiar manualmente configuraciones entre repositorios.

Cursor Tab como sistema de next-action prediction que va más allá del autocomplete de una única línea.

Utilización del contexto de la sesión, cambios recientes y archivos relacionados para anticipar ediciones.

Generación de bloques multilínea y modificaciones estructuradas mientras se programa.

Predicción de la siguiente posición de edición y navegación rápida entre cambios relacionados.

Ediciones coordinadas entre distintos puntos del código.

Generación de funciones, clases, componentes, endpoints y estructuras repetitivas desde intención y contexto.

Uso de Tab para implementaciones locales y de Agent para tareas que requieren investigación, herramientas y cambios amplios.

Desarrollo incremental para mantener pequeñas las unidades de cambio y facilitar la revisión.

Refactorización asistida mientras se modifica código existente.

Generación de documentación inline, tipos y comentarios cuando aportan valor real.

Prevención de aceptación mecánica de sugerencias que introducen código duplicado o patrones inconsistentes.

Comprobación de imports, dependencias, tipos y convenciones después de aceptar cambios.

Uso del lenguaje natural como complemento del código y no como sustitución del conocimiento de la tecnología.

Combinación Tab + Agent para alternar velocidad de edición y autonomía.

Revisión periódica del diff para impedir que pequeñas sugerencias acumuladas oculten desviaciones arquitectónicas.

Exploración inicial de un repositorio desconocido mediante Ask, Agent y subagents especializados.

Localización de entry points, módulos, servicios, capas, dominios y componentes críticos.

Análisis de flujos desde interfaces hasta lógica de negocio, persistencia e integraciones.

Identificación de relaciones entre archivos, funciones, clases, módulos y paquetes.

Comprensión de dependencias internas y externas antes de modificar contratos.

Uso de búsqueda semántica cuando no se conoce la terminología exacta utilizada por el proyecto.

Identificación de convenciones existentes antes de generar nuevos patrones.

Análisis de deuda técnica, duplicidades, responsabilidades mezcladas y acoplamiento excesivo.

Refactorización de funciones y clases preservando comportamiento observable.

Refactorización multiarchivo mediante Agent con tests y criterios de aceptación.

Migración progresiva entre bibliotecas, frameworks, versiones de APIs o arquitecturas.

Introducción de tipos, validaciones, límites de dominio y abstracciones manteniendo compatibilidad.

Evaluación del impacto de una modificación sobre consumidores, tests y código downstream.

Generación y actualización de documentación arquitectónica a partir del repositorio.

Uso de IA como apoyo a decisiones arquitectónicas sin sustituir ADR, revisión técnica ni análisis de trade-offs.

Estrategia de testing antes de solicitar generación automática de pruebas.

Generación de unit tests alineados con comportamiento, límites y casos de error.

Integration tests para validar colaboración entre módulos, persistencia, APIs y servicios.

End-to-end tests para comprobar workflows completos desde la perspectiva del usuario.

Generación de mocks, fixtures, factories, stubs y datos de prueba mantenibles.

Identificación de tests superficiales que reproducen la implementación sin verificar comportamiento.

Debug Mode para bugs reproducibles, race conditions, regresiones, memory leaks y problemas de rendimiento.

Análisis de stack traces, logs, excepciones, estados intermedios y diferencias entre resultado esperado y real.

Instrumentación temporal añadida por Debug Mode y eliminación posterior después de verificar la causa raíz.

Browser integrado para navegación automática, formularios, responsive testing y validación de workflows.

Acceso del agente a console logs y network traffic para investigar fallos de aplicaciones web.

Capturas de pantalla como evidencia visual para detectar problemas que no aparecen en tests funcionales.

Design Mode para seleccionar elementos visuales directamente y transmitir contexto espacial al agente.

Auditorías básicas de accesibilidad y validación de estados, mensajes de error y comportamiento de interfaces.

Cierre de cada ciclo mediante tests, build, lint, type checking y verificación del comportamiento ejecutado.

Integración de Cursor con Git para revisar estado, ramas, commits y diferencias del repositorio.

Generación asistida de mensajes de commit manteniendo convenciones del proyecto.

Explicación de diffs mediante lenguaje natural antes de aceptar cambios complejos.

Estrategia de commits pequeños y reversibles cuando el código ha sido producido por agentes.

Preparación de Pull Requests con descripción, impacto, tests realizados, riesgos y decisiones técnicas.

Agent Review para revisar cambios locales dentro de Cursor antes de enviarlos al repositorio remoto.

Review Quick frente a Deep y selección según tamaño, criticidad y sensibilidad del cambio.

Bugbot para analizar Pull Requests buscando bugs, regresiones, problemas de seguridad y calidad.

`BUGBOT.md` y reglas específicas del repositorio para proporcionar contexto adicional a la revisión.

Bugbot Autofix para lanzar Cloud Agents capaces de proponer reparaciones de findings detectados.

Security Agents para revisar Pull Requests y analizar vulnerabilidades en el código base.

`/review`, `/review-bugbot` y `/review-security` como mecanismos de revisión antes de realizar push.

Resolución asistida de comentarios de revisión y fallos procedentes de CI.

Separación entre revisión generada por IA y aprobación formal requerida por la organización.

Diseño de un flujo Agent → tests → Agent Review → Security Review → Pull Request → revisión humana → merge.

Model Context Protocol como mecanismo estandarizado para conectar Cursor con herramientas y fuentes externas.

Arquitectura cliente-servidor de MCP y separación entre el agente, servidor MCP y sistema final.

Tools y recursos externos accesibles mediante servidores MCP.

Gestión de MCP desde Customize y configuración declarativa mediante `mcp.json`.

Configuración de servidores específicos de proyecto en `.cursor/mcp.json`.

Configuración global mediante `~/.cursor/mcp.json`.

Transporte `stdio` para servidores ejecutados localmente.

Servidores remotos mediante HTTP y compatibilidad con mecanismos remotos admitidos por Cursor.

OAuth para servidores MCP que requieren autorización y gestión de redirect URIs.

Variables de entorno e interpolación para evitar credenciales hardcoded.

Integración con GitHub, bases de datos, observabilidad, gestores de proyectos, documentación, APIs y servicios internos.

Desarrollo de MCP Servers propios en Python, JavaScript, Go u otros lenguajes compatibles con los transportes del protocolo.

Principio de mínimo privilegio aplicado a las tools que un servidor expone al agente.

Riesgos de prompt injection procedente de información externa y necesidad de validar acciones antes de ejecutarlas.

Gobierno empresarial de servidores MCP, scopes, autenticación, secrets y herramientas permitidas.

Cursor CLI para trabajar con agentes directamente desde terminal sin abrir el editor.

Instalación, autenticación mediante login o API key y configuración del entorno.

Sesiones interactivas para explorar, modificar y revisar código.

Agent, Plan, Ask y Debug disponibles desde línea de comandos según el workflow.

Reanudación, bifurcación y administración de sesiones.

Worktrees desde CLI para ejecutar cambios en checkouts temporales aislados.

Ejecución no interactiva mediante print mode para scripts y pipelines.

Structured output para integrar respuestas en otras herramientas.

Utilización de CLI en CI/CD para revisión, documentación, mantenimiento y automatizaciones internas.

Riesgo adicional del modo no interactivo al disponer de capacidad de escritura y necesidad de limitar permisos.

MCP disponible también desde la experiencia CLI.

Cursor SDK para invocar programáticamente el runtime de agentes desde aplicaciones propias.

SDK oficiales actuales para TypeScript y Python y SDK Bridge para otros lenguajes.

Construcción de workflows programáticos con modelos, subagents, MCP, Skills y ejecución local o cloud.

Diferenciación entre Cursor como IDE, CLI para automatización terminal y SDK como infraestructura de agentes embebible.

Cloud Agents como agentes que trabajan en máquinas virtuales aisladas con repositorio, dependencias, secrets, comandos y acceso de red.

Diferencias entre Agent local, Cloud Agent y Cloud Subagent.

Configuración de entornos mediante snapshots, Dockerfile y `.cursor/environment.json`.

Importancia de replicar dependencias y servicios para que el agente pueda ejecutar y verificar sus cambios.

Desarrollo multi-repo cuando una feature afecta simultáneamente a varias bases de código.

Artifacts de Cloud Agents: logs, capturas y vídeos utilizados como evidencias de validación.

Control remoto del desktop del agente para revisar manualmente el comportamiento del software.

Cloud Subagents mediante `/in-cloud` para descargar trabajo pesado sin bloquear la sesión principal.

`/autopilot` para mantener un Pull Request activo frente a feedback, conflictos o fallos de CI.

Subagents paralelos con contexto independiente para investigación, testing, documentación o revisión especializada.

Automations ejecutadas por calendario o eventos procedentes de GitHub, GitLab, Slack, webhooks, Linear y otras fuentes.

Automatizaciones para revisión de PR, triage, mantenimiento, vulnerabilidades, documentación y tareas recurrentes.

Memories persistentes de Automations para conservar contexto entre ejecuciones y riesgos de contaminar memoria mediante entradas no confiables.

Computer Use dentro de determinadas ejecuciones cloud para interactuar con navegador y aplicaciones.

Diseño de workflows autónomos con límites de tiempo, coste, permisos, herramientas, revisión humana y criterios explícitos de finalización.

Modelo de responsabilidad compartida entre Cursor y la organización que utiliza la plataforma.

Flujo de prompts y contexto hacia proveedores de modelos y necesidad de conocer qué información abandona el entorno local.

Privacy Mode y garantías asociadas sobre uso del código para entrenamiento cuando está habilitado.

Diferencias de tratamiento entre peticiones LLM normales y Cloud Agents que necesitan conservar temporalmente una copia del repositorio.

Protección de repositorios especialmente sensibles mediante blocklists y políticas organizativas.

`.cursorignore` como control para excluir archivos del contexto del agente.

Run Modes y aprobación de acciones sensibles.

Sandbox local para limitar filesystem, directorios protegidos y conectividad de comandos.

Network egress allowlists para Cloud Agents y reducción del riesgo de exfiltración.

Runtime Secrets para mantener credenciales fuera del transcript, tool output y commits.

Build secrets, OIDC y credenciales temporales para evitar secretos estáticos de larga duración.

Seguridad de MCP Servers, Plugins, Skills, Hooks y otros mecanismos capaces de ampliar los permisos del agente.

Hooks deterministas para impedir SQL destructivo, detectar secretos o aplicar controles propios antes de ejecutar acciones.

Signed commits y trazabilidad de cambios generados mediante Cloud Agents.

Team Rules, modelos permitidos, Privacy Mode forzado, SSO, repositorios autorizados y controles adicionales de Teams/Enterprise.

Human-in-the-loop, branch protection, CI, Security Agents y code review como capas complementarias antes de permitir despliegues.

Definición del proyecto y requerimientos funcionales

Preparación del repositorio y entorno de desarrollo

Creación de Rules y contexto específico del proyecto

Planificación de la solución mediante Plan Mode

Desarrollo de funcionalidades utilizando Agent y Cursor Tab

Integración de APIs o herramientas mediante MCP

Generación de tests y resolución de errores

Revisión de código, Git y preparación de Pull Requests

Automatización y ejecución de tareas mediante agentes

Documentación, presentación y evaluación final del proyecto