luismori.

AI Coding Workflows

Cursor Claude Code Subagents

Subagentes de Cursor y /simplify de Claude Code: un flujo de trabajo práctico

Una mirada práctica a cómo se complementan los subagentes y Skills de Cursor con los subagentes, worktrees y el nuevo comando /simplify de Claude Code para investigar, implementar y limpiar código.

12 min de lectura

TL;DR

  • El January 22, 2026, Cursor 2.4 introdujo Subagents y Skills, lo que le dio a Cursor una forma más clara de dividir la investigación y la ejecución en líneas de trabajo especializadas y paralelas.
  • El modelo de Cursor para las instrucciones persistentes ahora es más claro: usa .cursor/rules o AGENTS.md para instrucciones siempre activas y archivos SKILL.md para flujos de trabajo dinámicos específicos de cada tarea.
  • Claude Code ahora tiene capacidades igual de sólidas en la terminal: subagentes personalizados, Plan Mode, aislamiento con git worktree y, en Claude Code v2.1.63, los comandos integrados /simplify y /batch.
  • El mejor flujo de trabajo combinado no consiste en «elegir una herramienta para siempre». Consiste en investigar y explorar en paralelo con Cursor, implementar en la herramienta que ya estés usando para la tarea y, antes de abrir el PR, hacer una pasada de limpieza y revisión con /simplify en Claude Code.
  • Una advertencia importante de mi revisión de fuentes: el registro público de cambios de Anthropic confirma claramente la existencia de /simplify, pero la documentación oficial actualmente explica con mucho más detalle los subagentes, los comandos, Plan Mode y los worktrees que /simplify en sí. Considera /simplify una buena pasada de limpieza, no un sustituto de la revisión de código ni de las pruebas.

Hay una convergencia real entre las herramientas de programación con IA. Cursor está mejorando en la delegación paralela integrada al IDE. Claude Code está mejorando en flujos de trabajo estructurados en la terminal, aislamiento con worktrees y comportamiento reutilizable de agentes. La pregunta interesante ya no es «¿qué herramienta gana?», sino «¿en qué aporta más valor cada herramienta?».

Para mí, la respuesta es sorprendentemente práctica: usar Cursor para distribuir la investigación y la exploración del código, y luego usar Claude Code para pulir la implementación y el ciclo de revisión.

Qué agregó realmente Cursor

El cambio más grande en Cursor durante los últimos meses no es solo «mejor autocompletado». Es el avance hacia la orquestación paralela de agentes.

Cursor 2.0, lanzado el October 29, 2025, introdujo una interfaz más centrada en agentes y la capacidad de ejecutar hasta ocho agentes en paralelo con un solo prompt, usando git worktrees o máquinas remotas para evitar conflictos entre archivos. Esto importa porque convirtió a Cursor de un asistente conversacional individual en una plataforma de coordinación.

Luego, el January 22, 2026, Cursor 2.4 agregó dos elementos que hacen que esa orquestación sea mucho más práctica:

1. Subagentes

El anuncio de Cursor describe los subagentes como agentes independientes que manejan partes concretas de una tarea principal en paralelo, cada uno con su propio contexto y configuración. Esa es la idea central del diseño.

Esto resuelve dos molestias que aparecen constantemente en sesiones largas con IA:

  • la conversación principal se contamina con exploraciones que no llevan a nada
  • una tarea que genera mucho ruido, como explorar el repositorio o procesar la salida de la terminal, le quita atención al hilo de planificación, que aporta más valor

Los subagentes son una solución clara para ambos problemas. Permiten que el agente principal mantenga el foco mientras las tareas secundarias se realizan por separado.

2. Skills

Las Skills de Cursor son un modelo mental más útil de lo que muchos creen. Según el anuncio de Cursor 2.4, las Skills son un estándar abierto basado en archivos SKILL.md, diseñado para conocimientos específicos de un dominio, scripts y flujos de trabajo procedimentales que se pueden descubrir y aplicar solo cuando son relevantes.

Esto hace que las Skills sean fundamentalmente distintas de las reglas:

  • Rules son instrucciones persistentes
  • Skills son capacidades dinámicas

La distinción es importante porque gran parte de la frustración con las herramientas de IA proviene de poner todo en un archivo de instrucciones enorme y luego preguntarse por qué el contexto se vuelve excesivo o contradictorio.

La estructura de configuración de Cursor ahora es mucho más clara

Según la documentación de Cursor, el modelo más útil es:

  • .cursor/rules para reglas del proyecto versionadas y con alcance definido
  • AGENTS.md para un archivo de instrucciones más simple, basado en Markdown, en la raíz del proyecto
  • archivos SKILL.md para flujos de trabajo reutilizables que solo deben cargarse cuando sean relevantes

La documentación de la CLI de Cursor también señala que lee AGENTS.md y CLAUDE.md en la raíz del proyecto, junto con .cursor/rules. Ese detalle importa si trabajas tanto con Cursor como con Claude Code, porque significa que un mismo repositorio puede admitir ambas herramientas sin duplicar todas sus instrucciones.

Por qué los subagentes importan más de lo que parece

El titular de la funcionalidad es «paralelismo», pero su valor más profundo es la higiene del contexto.

Cuando un agente puede delegar la exploración del repositorio, investigaciones que generan mucha salida en la terminal o tareas de implementación acotadas a subagentes aislados, ocurren tres cosas buenas:

  1. El hilo principal sigue siendo fácil de leer.
  2. El trabajo delegado puede realizarse en paralelo.
  3. El agente principal puede razonar a un nivel más alto en lugar de tener que cargar con cada detalle intermedio.

Por eso los subagentes son especialmente útiles para:

  • investigar el código y la historia de repositorios grandes
  • comparar varios enfoques antes de implementar uno
  • dividir una funcionalidad amplia en unas pocas líneas de trabajo con poca superposición

Son menos efectivos cuando varias tareas necesitan editar los mismos archivos. El paralelismo solo ayuda cuando se puede asignar con cierta claridad la responsabilidad de cada archivo. De lo contrario, generas trabajo de integración en lugar de ganar eficiencia.

Este último punto es en parte documentación y en parte criterio operativo. Los anuncios de Cursor destacan las líneas de trabajo paralelas y la ejecución aislada. La consecuencia práctica es evidente: cuanto más toquen tus agentes los mismos archivos de alta actividad, menos útil será el paralelismo.

Dónde encaja mejor Claude Code

Cursor destaca cuando quiero un entorno de investigación e implementación integrado al IDE y con varios hilos de trabajo.

Claude Code destaca cuando quiero un ciclo de ingeniería integrado a la terminal, explícito e inspeccionable.

La documentación de Anthropic ahora hace que varias partes de ese ciclo sean especialmente sólidas:

Plan Mode

El Plan Mode de Claude Code se basa en analizar primero en modo de solo lectura e implementar después. Anthropic lo documenta explícitamente como un flujo seguro de análisis de código, y la guía de flujos comunes lo recomienda para cambios de varios pasos, exploración de código y planificación interactiva.

Eso lo hace ideal cuando quiero hacer una pausa antes de escribir código y obligar al agente a mostrar su razonamiento de forma clara.

Subagentes personalizados

Claude Code también admite subagentes personalizados mediante .claude/agents/ a nivel de proyecto y ~/.claude/agents/ a nivel de usuario. La documentación de Anthropic es mucho más explícita aquí de lo que muchos creen: Claude puede delegar automáticamente a subagentes especializados, puedes restringir sus herramientas y puedes compartir con tu equipo los que sean específicos del proyecto.

En otras palabras, Claude Code ya no es solo «un agente en la terminal». Se ha convertido en un sistema multiagente estructurado por derecho propio.

Aislamiento con worktrees

Esta es una de las piezas más importantes del conjunto.

La documentación de Anthropic ahora cubre:

  • claude --worktree
  • el aislamiento de subagentes con worktrees
  • el comportamiento de limpieza automática
  • ramas separadas para cada worktree

Esto importa porque los agentes paralelos sin aislamiento pronto convierten las ramas y los diffs en un caos. Los worktrees hacen que el paralelismo sea real y no solo una aspiración.

Qué cambia con /simplify

La parte de tu borrador que más quería verificar era /simplify.

La fuente confirmada más clara que encontré es el registro oficial de cambios de claude-code de Anthropic en GitHub. En Claude Code v2.1.63, Anthropic agregó /simplify y /batch como comandos integrados.

Eso basta para afirmar con confianza que el comando existe y se lanzó oficialmente.

Lo que está menos documentado, al menos públicamente al March 24, 2026, son los detalles de su comportamiento. La documentación de Anthropic es extensa en cuanto a comandos, subagentes, worktrees y planificación, pero mucho más limitada específicamente sobre /simplify de lo que sugería tu nota original.

Por eso, el modelo mental responsable es:

  • /simplify es un comando oficial integrado
  • corresponde a la etapa de limpieza y revisión posterior a la implementación
  • aun así debes inspeccionar el diff y ejecutar las pruebas

Yo lo usaría de la misma manera que una buena revisión de código hecha por una persona: no para reemplazar las comprobaciones de corrección, sino para detectar código que funciona técnicamente pero que resulta torpe, repetitivo o más complejo de lo necesario.

¿Y /batch?

/batch se lanzó en la misma versión de Claude Code. Junto con el soporte de worktrees de Claude Code, es una señal de que Anthropic está apostando fuerte por los cambios paralelos a gran escala, no solo por sesiones de programación de un solo hilo.

Eso convierte a /batch en el equivalente de /simplify para «grandes migraciones»:

  • usa /batch para trabajo amplio que se pueda dividir
  • usa /simplify para pulir y limpiar después de la implementación

El flujo de trabajo combinado más útil

Si ya alternas entre Cursor y Claude Code, creo que el flujo que más valor aporta es este:

1. Explora en Cursor

Usa los subagentes de Cursor para dividir la investigación en hilos paralelos:

  • un subagente identifica las rutas de código relevantes
  • otro inspecciona las abstracciones y convenciones existentes
  • otro revisa pruebas, ejemplos o implementaciones anteriores

Aquí es donde brillan los subagentes de Cursor. Mantienen limpio el hilo principal mientras el repositorio se explora desde varios ángulos.

2. Guarda cada tipo de instrucción en el lugar adecuado

Mantén las reglas persistentes del equipo en:

  • .cursor/rules
  • AGENTS.md
  • CLAUDE.md

Luego, mantén los flujos de trabajo procedimentales en SKILL.md.

La clave es evitar mezclar estas capas. Las Rules deben ser estables. Las Skills deben depender de la situación.

3. Implementa en el entorno que mejor se adapte a la tarea

Si ya estás trabajando de lleno en el IDE, quédate en Cursor.

Si la tarea requiere mucho trabajo de shell o Git, o se beneficia de una gestión explícita de worktrees y de Plan Mode, cambia a Claude Code.

Esto tiene menos que ver con ideología que con reducir la fricción. Usa la herramienta que simplifique los próximos 30 minutos.

4. Haz una pasada de limpieza con Claude Code

Cuando la funcionalidad ya funcione, cambia a Claude Code y ejecuta:

claude
# then inside Claude Code
/simplify

Si el cambio es lo bastante grande como para que la paralelización sea el desafío principal, considera en su lugar los flujos de trabajo de Claude Code basados en worktrees o /batch.

5. Revisa el diff como lo haría una persona

Esta parte sigue siendo importante.

El mejor flujo de trabajo con IA no consiste en «confiar en el último agente». Consiste en:

  • dejar que el agente haga la limpieza
  • inspeccionar el diff
  • ejecutar las pruebas
  • abrir el PR solo cuando el código se vea diseñado con intención, no solo técnicamente completo

Cursor vs. Claude Code: la verdadera diferencia

Después de revisar la documentación, esta es la distinción más clara que puedo hacer:

HerramientaDestaca en
CursorExploración paralela integrada al IDE, investigación con ayuda de subagentes, flujos de trabajo con agentes en segundo plano, edición flexible con múltiples modelos
Claude CodePlanificación integrada a la terminal, control explícito de subagentes, aislamiento con worktrees, flujos reutilizables basados en comandos, ejecución orientada a PR

Por eso no creo que /simplify sea realmente una historia de «una alternativa a Cursor».

Es una herramienta para dar los toques finales dentro de un flujo de trabajo más amplio.

Cursor te ayuda a pensar y distribuir el trabajo. Claude Code te ayuda a pulirlo y llevarlo a término.

Lo que realmente recomendaría

Si quieres una ruta práctica de adopción, mantenla simple:

  1. Usa subagentes de Cursor para explorar el código y dividir los planes.
  2. Usa Skills para flujos de trabajo reutilizables y Rules / AGENTS.md para instrucciones persistentes del repositorio.
  3. Usa Claude Code Plan Mode cuando el cambio sea lo bastante riesgoso como para que quieras una etapa explícita de planificación en modo de solo lectura.
  4. Usa Claude Code /simplify antes del PR para mejorar la estructura del código, no para reemplazar la revisión.
  5. Usa worktrees cuando los agentes paralelos puedan entrar en conflicto.

Ese flujo te permite obtener la mayor parte de los beneficios sin obligar a todo el equipo a adoptar una postura dogmática sobre una sola herramienta.

Fuentes