{
  "title": "Un año con Cursor: Cómo mi flujo de trabajo evolucionó de Agente a Arquitecto",
  "excerpt": "Mi viaje con Cursor refleja la maduración de la propia herramienta: de un simple agente a un socio arquitectónico sofisticado. Este post detalla cómo evolucionó mi flujo de trabajo a través de @ mentions, MCP, Plan Mode y comandos personalizados.",
  "content_html": "<p>Ha pasado más de un año desde que hice de Cursor mi IDE principal, y es difícil exagerar el impacto que ha tenido en mi trabajo. Como ingeniero de aprendizaje automático que construye plataformas de IA conversacional en Dylog y experimenta con infraestructura agéntica en mis proyectos personales, he vivido la evolución del desarrollo nativo de IA. Mi viaje con Cursor refleja la maduración de la propia herramienta: de un simple agente a un socio arquitectónico sofisticado.</p>\n<p>Este post es una reflexión sobre ese viaje, detallando cómo evolucionó mi flujo de trabajo y cómo he llegado a depender de una poderosa combinación de Plan Mode, comandos personalizados e ingeniería de contexto para construir más rápido, de manera más inteligente y con mayor claridad.</p>\n<h2>Fase 1: El Agente Toma el Volante</h2>\n<p>Cuando comencé, mi uso era simple. Trataba a Cursor como un autocompletado sobrealimentado. Escribía un comentario, presionaba <code>Cmd+K</code> y dejaba que el agente generara el código. Era mágico, pero también era una caja negra. Yo era un pasajero y el agente conducía.</p>\n<p>Luego llegaron las <strong>@ mentions</strong>. Esta fue mi primera experiencia de darle al agente contexto real. En lugar de esperar que entendiera mi código, podía decirle explícitamente qué mirar:</p>\n<ul>\n<li><code>@file</code> para referenciar un archivo específico</li>\n<li><code>@folder</code> para incluir un directorio completo</li>\n<li><code>@codebase</code> para que buscara en todo el proyecto</li>\n<li><code>@web</code> para obtener documentación externa</li>\n<li><code>@docs</code> para referenciar documentación oficial de bibliotecas</li>\n</ul>\n<p>Esto fue un gran avance. De repente, el agente no estaba adivinando; estaba trabajando con el mismo contexto que yo. Podía decir \"refactoriza esta función para que coincida con el patrón en <code>@file:utils/helpers.ts</code>\" y realmente lo entendía.</p>\n<p><img src=\"/assets/images/cursor-at-mentions.png\" alt=\"Contexto de @ mention en Cursor\" class=\"post-img\" width=\"1639\" height=\"935\" /><br />\n<span class=\"post-img-caption\">El menú desplegable de @ mention en Cursor, mostrando opciones de contexto como @file, @folder, @codebase, @web y @docs que permiten un control de contexto explícito</span></p>\n<p>Pero incluso con mejor contexto, a menudo me encontraba en un bucle de generar, depurar y regenerar. Al agente le faltaba la visión arquitectónica para tareas más grandes.</p>\n<h2>Fase 2: MCP lo Cambia Todo</h2>\n<p>La introducción del <strong>Model Context Protocol (MCP)</strong> fue cuando las cosas se pusieron serias. MCP me permitió conectar Cursor a herramientas y fuentes de datos externas, convirtiendo al agente de un generador de código a un verdadero asistente con acceso a todo mi flujo de trabajo.</p>\n<p>Comencé a integrar MCPs para:</p>\n<ul>\n<li><strong>GitHub</strong> para extraer issues y PRs directamente al contexto</li>\n<li><strong>Linear</strong> para la integración de gestión de tareas</li>\n<li><strong>Slack</strong> para el contexto de comunicación del equipo</li>\n<li><strong>MCPs personalizados</strong> para APIs y bases de datos internas</li>\n</ul>\n<p>Con MCP, podía decir \"implementa la función descrita en Linear issue #234\" y el agente obtenía el issue, entendía los requisitos y comenzaba a construir. Ya no se trataba solo de código; se trataba de conectar los puntos en todo mi ecosistema de desarrollo.</p>\n<p><img src=\"/assets/images/cursor-mcp-integrations.png\" alt=\"Integraciones MCP en Cursor\" class=\"post-img\" width=\"1639\" height=\"935\" /><br />\n<span class=\"post-img-caption\">Panel de configuración de MCP que muestra integraciones conectadas como GitHub, Linear, Slack y servidores personalizados que extienden las capacidades de Cursor en todo el ecosistema de desarrollo</span></p>\n<h2>Fase 3: El Auge del Planificador</h2>\n<p>La introducción de <strong>Plan Mode</strong> fue el siguiente cambio de juego. Fue la primera vez que sentí que estaba colaborando con la IA, no solo delegándole. Inspirado por flujos de trabajo de desarrolladores como Ray Fernando, comencé a usar un proceso de dos pasos:</p>\n<ol>\n<li><strong>Planificar con Opus:</strong> Usaba un modelo potente como Claude Opus para generar un plan de implementación detallado, paso a paso. Le daba el objetivo de alto nivel y él lo desglosaba en una serie de tareas concretas, con nombres de archivo, firmas de funciones y lógica.</li>\n<li><strong>Ejecutar con Sonnet/GPT:</strong> Luego le pasaba ese plan a un modelo más rápido y barato como Sonnet o GPT-5.2 para ejecutar cada paso. El modelo más barato no necesitaba ser un arquitecto brillante; solo necesitaba ser un constructor diligente.</li>\n</ol>\n<p>Este flujo de trabajo fue una mejora masiva. Separaba el \"qué\" del \"cómo\", y me daba un artefacto revisable —el plan— que podía editar y aprobar antes de escribir cualquier código. También ahorraba una tonelada de dinero en tokens.</p>\n<p><img src=\"/assets/images/cursor-plan-mode.png\" alt=\"Flujo de trabajo de Plan Mode en Cursor\" class=\"post-img\" width=\"1639\" height=\"935\" /><br />\n<span class=\"post-img-caption\">Una vista dividida que muestra un plan de implementación detallado en un archivo <code>.cursor/plans/</code> a la izquierda, y el código generado correspondiente a la derecha, demostrando la separación de la arquitectura de la ejecución</span></p>\n<h2>Fase 4: El Arquitecto Emerge (Comandos + Planificación)</h2>\n<p>Aquí es donde vivo hoy. Aunque Plan Mode sigue siendo central en mi flujo de trabajo, he añadido un conjunto de <strong>comandos personalizados</strong> y <strong>reglas</strong> para ajustar el proceso e integrar mis principios arquitectónicos directamente en el IDE.</p>\n<h3>Mi Configuración Actual</h3>\n<p><strong>Reglas (<code>.cursorrules</code>):</strong> Tengo un conjunto de reglas que definen mis estándares de codificación, patrones preferidos y restricciones arquitectónicas. El agente las lee antes de cada tarea, asegurando consistencia en todo el código.</p>\n<p><strong>Comandos Personalizados:</strong> He creado comandos que envuelven mis flujos de trabajo más comunes:</p>\n<ul>\n<li><code>/plan</code> - Genera un plan de implementación detallado usando Opus</li>\n<li><code>/refactor</code> - Toma un archivo y lo refactoriza según las instrucciones</li>\n<li><code>/test</code> - Genera un conjunto de pruebas para una función dada</li>\n<li><code>/review</code> - Revisa el código contra mis reglas y sugiere mejoras</li>\n</ul>\n<p><strong>Mensajes en Cola:</strong> Uso <code>Ctrl+Enter</code> para poner en cola instrucciones de seguimiento mientras el agente está trabajando. Esto me permite pensar adelantado y mantener el impulso sin interrumpir la tarea actual.</p>\n<p><img src=\"/assets/images/cursor-custom-commands.png\" alt=\"Comandos personalizados y reglas en Cursor\" class=\"post-img\" width=\"1639\" height=\"935\" /><br />\n<span class=\"post-img-caption\">La paleta de comandos de Cursor mostrando comandos personalizados como /plan, /refactor, /test y /review, junto con un archivo <code>.cursorrules</code> que define estándares de codificación y restricciones arquitectónicas</span></p>\n<h2>La Evolución de un Vistazo</h2>\n<table>\n<thead>\n<tr>\n<th>Fase</th>\n<th>Característica Clave</th>\n<th>Qué Cambió</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>1</td>\n<td>Modo Agente + @ Mentions</td>\n<td>El contexto se volvió explícito, no adivinado</td>\n</tr>\n<tr>\n<td>2</td>\n<td>Integración MCP</td>\n<td>Herramientas y datos externos se volvieron accesibles</td>\n</tr>\n<tr>\n<td>3</td>\n<td>Plan Mode</td>\n<td>La arquitectura se separó de la ejecución</td>\n</tr>\n<tr>\n<td>4</td>\n<td>Comandos + Reglas</td>\n<td>Los flujos de trabajo se volvieron repetibles y personalizados</td>\n</tr>\n</tbody>\n</table>\n<h2>Por Qué Esto Importa</h2>\n<p>Esta evolución de agente a arquitecto es más que un truco de productividad personal. Es un vistazo al futuro del desarrollo de software. Estamos pasando de un mundo donde escribimos código a un mundo donde <strong>describimos sistemas</strong>. Nuestro trabajo es ser el arquitecto, definir el plano y dejar que los agentes hagan la construcción.</p>\n<p>Cursor, más que cualquier otra herramienta que haya usado, entiende este cambio. No se trata solo de generar código; se trata de gestionar la complejidad, mantener el contexto y dar a los desarrolladores la capacidad de construir a una escala que antes era inimaginable.</p>\n<p>Si todavía usas la IA como un simple generador de código, te animo a explorar @ mentions, MCP, Plan Mode y comandos personalizados. Es un viaje que te transformará de un desarrollador que usa IA a un arquitecto que la dirige.</p>",
  "source_hash": "sha256:88320b9a62c7c3531ce3e1d3c838c4ff391eba9503c622827333c5c8d87cf3f6",
  "model": "deepseek/deepseek-v4-flash",
  "generated_at": "2026-08-07T08:08:26.725848+00:00"
}