$ dos herramientas, un solo developer

Llevo meses usando Claude Code y Cursor en paralelo. No es indecisión, es que resuelven cosas distintas. Cuando alguien me pregunta "¿cuál uso?", la respuesta corta es: depende de si estoy pensando en archivos o en el repo entero.

La respuesta larga es este post.

Cursor: cuando el contexto es visual

Cursor es un editor. Eso parece obvio pero es la clave de todo lo demás. Tiene autocompletado predictivo (Tab), un modo agente que puede tocar varios archivos, y la ventaja enorme de que ves el diff, el árbol de archivos y el resultado en el mismo sitio donde vas a seguir trabajando.

Lo uso cuando:

  • Estoy iterando sobre una pantalla o componente concreto y quiero ver el cambio al instante.
  • Necesito revisar cada edición línea a línea antes de aceptarla, porque el archivo es sensible (lógica de negocio, algo con estado compartido).
  • El trabajo es más "artesanal" que "mecánico": ajustar un layout, depurar un comportamiento raro de UI, refactorizar una función concreta con mucho cuidado.

El punto fuerte de Cursor es la fricción baja entre "pensar" y "ver". Escribes, revisas, aceptas o rechazas, sigues. Es un flujo de edición, no un flujo de ejecución.

Claude Code: cuando el contexto es el repo completo

Claude Code vive en la terminal. Eso también parece un detalle menor y tampoco lo es: significa que puede encadenar comandos, correr tests, leer el resultado, corregir y volver a correrlos, sin que yo tenga que estar mirando un diff cada dos segundos.

Lo uso cuando:

  • La tarea toca muchos archivos a la vez y el criterio de "terminado" es objetivo: los tests pasan, el build compila, el linter no se queja.
  • Quiero delegar un problema completo y revisar al final, no paso a paso. Por ejemplo: "migra este módulo de una librería a otra y que todo siga pasando los tests".
  • Necesito reproducibilidad: el mismo flujo lo quiero poder lanzar otra vez, o meterlo en un script, o dejarlo corriendo en segundo plano mientras hago otra cosa.
  • Estoy trabajando fuera de un IDE concreto: en un servidor, en CI, en un contenedor donde no tiene sentido abrir un editor gráfico.

La diferencia de fondo es que Claude Code está pensado para tareas con criterio de éxito verificable —compila, pasa tests, el comando devuelve 0— más que para ediciones que dependen de gusto visual.

El criterio real que uso

Simplificando mucho, me hago dos preguntas antes de abrir uno u otro:

¿Puedo describir el "terminado" con un comando? Si la respuesta es sí (tests en verde, build sin errores, script que corre de punta a punta), tiendo a Claude Code. Si el "terminado" es "que se vea bien" o "que se sienta bien al usarlo", tiendo a Cursor.

¿Cuántos archivos tocan y cuánto necesito ver cada cambio? Un cambio quirúrgico en un archivo, con matices que solo yo puedo juzgar bien: Cursor. Un cambio mecánico repetido en veinte archivos: Claude Code, y reviso el resultado agregado, no archivo por archivo.

En la práctica, un proyecto normal usa los dos en fases distintas. Diseño y ajusto una pantalla en Cursor. Cuando ya sé exactamente qué patrón quiero replicar en el resto del código, se lo paso a Claude Code para que lo aplique de forma consistente en todo el repo.

Dónde se solapan (y no pasa nada)

Los dos tienen modo agente, los dos pueden usar herramientas externas vía MCP, los dos pueden trabajar sobre varios archivos. La superposición es real y va a crecer, no a reducirse. No hay que buscar una frontera perfecta ni pelearse por "cuál es mejor" en abstracto — es una pregunta mal planteada. La pregunta útil es cuál encaja mejor con la tarea que tienes delante ahora mismo.

Si tuviera que quedarme con una sola herramienta, perdería capacidad real en algún tipo de trabajo. Por eso no elijo una vez: elijo cada vez.

Relacionado: Cómo uso Cursor IDE sin perder el control del código