Cómo uso Claude Code, Cursor y Antigravity para programar más rápido sin perder criterio

El cuello de botella ya no es escribir código. Es saber qué pedir, cómo validarlo y dónde no delegar. Esto cambia el oficio más de lo que mucha gente quiere admitir, y al mismo tiempo no cambia nada del fondo: si no entiendes lo que estás construyendo, la herramienta solo acelera tus errores.

Llevo meses iterando un flujo real con tres herramientas que se solapan poco y se complementan mucho. Esto es lo que hago, no lo que vende un curso de YouTube.

Las tres herramientas, en una frase

Claude Code. Compañero técnico para tareas complejas: leer un repo desconocido, generar arquitectura base, debugging acompañado, revisión antes de commit.

Cursor. Editor con contexto profundo del proyecto. Bueno para iteraciones quirúrgicas y refactors guiados.

Antigravity. IDE de Google con foco en flujos agenticos. Útil cuando quiero un agente que haga un cambio multi-archivo coordinado.

Las tres son IA-asistido, pero el rol de cada una es distinto. Tratarlas como sustitutos te hace perder el partido.

Para qué uso Claude Code

Investigación dirigida. Llego a un repo nuevo, le pido que me explique la arquitectura, los puntos de entrada y los riesgos. En 10 minutos tengo el mapa que antes me costaba un día de leer commits.

Andamiaje. Quiero un componente nuevo con convenciones del proyecto. Le paso ejemplos similares, le digo el objetivo, recibo una primera versión que ya respeta el estilo de la base. Después la edito.

Debugging acompañado. Reproduzco el bug, formulo la hipótesis, valido con código. La IA cuestiona la hipótesis, propone alternativas, sugiere logs. Es como tener un compañero senior siempre disponible y nunca cansado.

Revisión. Antes de hacer commit, le pido crítica. Que cuestione decisiones que ya doy por buenas. A veces no tiene razón. Pero el ejercicio de defender mi decisión me hace verla mejor.

Para qué uso Cursor

Iteración quirúrgica. Edits localizados con buen autocompletado contextual. Cuando ya sé qué quiero y solo necesito velocidad de tecla.

Refactors guiados con el cursor agent. Útil para renombrados grandes, extracciones que tocan varios archivos y aplicar un patrón consistente.

Lo que no le pido a Cursor: arquitectura. Es brillante en el detalle, pero si no sabes hacia dónde vas, no te lo va a decir.

Para qué uso Antigravity

Cambios multi-archivo coordinados con un agente que mantiene contexto del repo. Por ejemplo: renombrar un dominio del modelo de datos cambiando schema, tipos, llamadas y UI. Hacerlo a mano es tedioso. Hacerlo con un grep+replace es peligroso. Con un agente que entiende relaciones, sale limpio.

Es la herramienta más nueva de las tres en mi flujo y la que estoy explorando con más cuidado. La promesa de los IDE agenticos es real, pero también lo es el riesgo de aceptar cambios masivos sin entenderlos.

Para qué NO uso ninguna

Decidir la arquitectura sin contexto del negocio. Eso lo hago yo, en un documento o en una conversación con el cliente.

Validar requisitos. Eso es conversación humana, no se delega.

Aceptar código que no entiendo. Si tengo que parar 10 minutos a leerlo, los paro. Si después de leerlo sigo sin entenderlo, lo borro.

Aprender un concepto nuevo en profundidad. Para eso, documentación oficial y un proyecto pequeño donde me equivoque. La IA me da resúmenes correctos pero superficiales — la profundidad la construyes tú.

El patrón de prompt que repito

Más que un prompt mágico, una estructura: objetivo + contexto + restricción + formato esperado.

• Objetivo: qué quiero que pase al final.
• Contexto: qué hay alrededor (archivos relevantes, convenciones, decisiones previas).
• Restricción: qué no quiero (no añadir dependencias, no romper API pública, no comentarios obvios).
• Formato: cómo quiero la respuesta (parche, archivo completo, lista de pasos).

Si me salto el contexto, gano genéricos. Si me salto la restricción, gano scope creep. Si me salto el formato, gano texto que no puedo aplicar.

La métrica honesta

No mido líneas generadas por la IA. Mido tareas terminadas con criterio: ¿el código está en producción? ¿lo entiendo? ¿sé cómo se rompería?

La trampa de la velocidad sin criterio es que produce deuda técnica disfrazada de productividad. Vas el doble de rápido durante un mes y luego pasas tres reparando lo que no entendiste cuando lo aceptaste.

Conclusión

Las herramientas IA bien usadas son un multiplicador real. No te convierten en otro desarrollador, te convierten en una versión con más alcance del que ya eras. Si eras junior con buen criterio, te vuelven un junior peligroso (en el buen sentido). Si eras junior sin criterio, te vuelven un junior peligroso en el malo.

El criterio se construye igual que siempre: leyendo código de otros, equivocándose en proyectos reales y discutiendo decisiones con gente más experimentada. La IA no acelera eso. Lo acompaña.

Si quieres ver cómo aplico esto a un proyecto real, mira el caso de Perdicestavi o el portfolio que estás leyendo ahora mismo.