Por qué abandoné Antigravity y Google AI Pro por Claude Code + Copilot (y no me arrepiento)

La promesa de Antigravity: el IDE que iba a cambiar todo

Noviembre de 2025. Google presenta Antigravity junto al lanzamiento de Gemini 3, con Sergey Brin en modo fundador, trabajando noches enteras con el equipo de ingeniería, y la promesa de que los agentes de IA por fin iban a tener "su propio espacio de trabajo". El pitch era brutalmente bueno: un fork de VS Code reconstruido desde cero con filosofía agent-first, herencia directa de Windsurf (esa adquisición de 2.400 millones que Google no se pudo resistir), navegador integrado, ejecución paralela de hasta cinco agentes simultáneos, artefactos verificables... y, lo más llamativo de todo, gratis.

Sí. Gratis. Con Gemini 3 Pro incluido y límites de velocidad que Google describió como "generosos". Para alguien que trabaja a diario con Python, JavaScript, PHP y Swift, y que ya estaba pagando un plan de Google AI Pro (el de 20€ al mes, con Gemini Advanced), aquello sonaba como la convergencia perfecta: el IDE agentic más potente del mercado, sin coste adicional, integrado en el ecosistema que ya usaba.

Así que lo instalamos. Lo probamos. Y en cuestión de días, algo salió terriblemente mal.

El momento en que todo se torció: cómo 5 peticiones me vaciaron un mes de cuota

Aquí está el problema con las promesas de "generoso" cuando no te especifican exactamente qué significa eso: que cada desarrollador tiene una definición distinta de la palabra. La nuestra, al parecer, no coincidía con la de Google.

Antigravity gestiona sus límites de uso por ventanas de tiempo que se renuevan cada cinco horas. Suena razonable en papel. Pero hay un detalle que cambia todo: los agentes agentic no hacen una petición, hacen decenas. Cuando le pides a un agente de Antigravity que construya una feature o refactorice un módulo complejo, por debajo se está lanzando una cascada de llamadas al modelo: planificación, ejecución de comandos en terminal, verificación, iteraciones, acceso al navegador integrado... Cada paso cuenta. Y cuenta rápido.

El resultado fue esto: en cinco peticiones de trabajo real, con tareas de complejidad media-alta en proyectos reales, habíamos consumido lo que equivalía a un mes de cuota de uso. No era un error. No era un bug. Era simplemente la naturaleza del modelo agentic multiplicada por una arquitectura de límites que no estaba diseñada para el tipo de trabajo que hacemos.

Y eso nos molestó muchísimo.

No por el hecho de que hubiera límites, eso es completamente comprensible. Sino por la total imprevisibilidad del consumo. No podías planificar tu semana de trabajo. No sabías si la tarea que ibas a lanzar te dejaba sin cuota para el resto del día. Era como intentar llenar el depósito de un coche sin saber cuántos litros caben ni cuánto consumen los últimos kilómetros. La sensación de trabajar mirando constantemente el medidor de cuota, esperando que no se agotara antes de que el agente terminara de ejecutar... eso no es productividad, eso es ansiedad digital.

Y encima, teníamos activo el plan de Google AI Pro, el de 20€ al mes, que supuestamente nos daba acceso premium a Gemini Advanced. Pagando, y con la sensación constante de que el recurso se escapaba entre los dedos como arena.

La investigación: buscando el stack que de verdad funcione

Después de ese momento de frustración, hicimos lo que hacemos siempre: investigar. Sin prisa, sin dejarnos llevar por el hype de turno y con una pregunta muy concreta encima de la mesa: ¿qué herramientas de IA para desarrollo ofrecen un modelo de uso predecible, potencia real y no te dejan tirado en mitad de una sesión de trabajo?

Evaluamos varias opciones. Cursor, con su modelo de suscripción mensual y su madurez en el ecosistema VS Code, estaba en la lista. También exploramos configuraciones con API directa a distintos modelos. Pero lo que terminó de encajar, y lo que hoy es nuestro stack de trabajo, fue una combinación que quizás no es la más obvia a primera vista: Claude Code + Cowork + GitHub Copilot.

Te explicamos por qué cada pieza.

El nuevo stack: Claude Code + Cowork + Copilot

Claude Code: el agente que trabaja desde la terminal

Claude Code es la herramienta de codificación agentic de Anthropic, y funciona desde la línea de comandos. Para quien lleve tiempo en Linux o en cualquier entorno Unix, esto es casi un abrazo familiar: tu terminal, tus proyectos, tu contexto, sin una capa de interfaz gráfica interponiéndose entre tú y lo que quieres hacer.

Pero la potencia real de Claude Code no está en que sea una herramienta de terminal. Está en cómo entiende el contexto de un proyecto. Puedes lanzarlo en el directorio raíz de tu aplicación y, sin necesidad de explicarle la estructura desde cero, es capaz de navegar por los archivos, entender las dependencias, leer la lógica existente y ejecutar tareas complejas de refactorización, debugging o implementación de nuevas features con una coherencia que, honestamente, nos sorprendió la primera vez que lo vimos trabajar.

La diferencia respecto al modelo de Antigravity es fundamental en términos de previsibilidad del gasto. Con Claude Code, el modelo de uso es claro y controlable. Sabes lo que estás consumiendo, puedes ajustar la profundidad de las tareas que delegas, y no te encuentras con sorpresas al final del día. Es un esquema de trabajo que respeta tu planificación.

Además, la calidad del razonamiento técnico de Claude en tareas de código es consistentemente alta. No perfecta, ningún modelo lo es, pero sí consistente. Y en desarrollo, la consistencia vale más que el pico ocasional de genialidad seguido de tres alucinaciones consecutivas.

Cowork: automatización para los que no quieren perder el tiempo

Cowork es la propuesta de Anthropic para quienes necesitan automatizar tareas de gestión de archivos y workflows sin necesidad de meterse en código de bajo nivel. Es una herramienta de escritorio que actúa como capa de orquestación: puedes definir flujos de automatización, trabajar con archivos, gestionar tareas recurrentes y conectar distintos procesos de tu entorno de trabajo.

Para nosotros, Cowork ha entrado de forma natural en la gestión de tareas auxiliares al desarrollo: preparación de entornos, organización de outputs, gestión de flujos de revisión... Ese tipo de trabajo que técnicamente podrías hacer tú mismo, pero que a las 11 de la noche, después de cuatro horas de debug, agradeces enormemente delegar.

La integración con el resto del stack de Anthropic hace que la experiencia sea fluida. No estás pegando piezas de distinta naturaleza con cinta de carrocero, sino trabajando con herramientas que comparten una filosofía de diseño común.

GitHub Copilot: el copiloto que siempre ha estado ahí

GitHub Copilot no necesita demasiada presentación a estas alturas. Lleva años siendo la capa de asistencia de código más adoptada del sector, y hay una razón para eso: funciona bien en el flujo de trabajo cotidiano. No como agente autónomo que lanza tareas complejas, sino como ese compañero que completa el código mientras escribes, sugiere la firma del siguiente método, te recuerda que ya existe una función con esa lógica en otro módulo y te ahorra el 40% de las pulsaciones de teclado en una sesión normal.

En combinación con Claude Code, los roles están muy bien definidos. Copilot es la asistencia en tiempo real, inline, mientras escribes. Claude Code es el agente al que delegas las tareas de mayor profundidad y autonomía. Son capas complementarias, no redundantes.

¡Dale caña al mono! Porque cuando tienes estas tres piezas trabajando en paralelo, la sensación de productividad cambia de forma cualitativa. Ya no estás interrumpiendo tu flujo mental para formular la prompt perfecta ni mirando ansioso el contador de tokens. Estás desarrollando.

Comparativa real: Antigravity vs nuestro stack actual

Límites de uso y previsibilidad del gasto

Este es el punto más crítico y el que detonó el cambio. Antigravity, en su modelo de preview pública, tiene límites de velocidad por ventana de cinco horas. En teoría, esos límites se renuevan y el acceso es continuo. En la práctica, cuando trabajas con tareas agentic reales, con proyectos de complejidad media o alta, esos límites se agotan mucho antes de lo esperado. El sistema de agentes que ejecuta múltiples herramientas (terminal, editor, navegador) consume quota de forma exponencial, no lineal. No puedes planificarte.

Con nuestro stack actual, el modelo de uso es transparente y controlable. Sabes qué estás consumiendo, cuándo y para qué. Puedes calibrar la agresividad con la que delega tareas al agente según el momento del mes o la importancia de la tarea. Esa capacidad de control vale más de lo que parece cuando tu tiempo de desarrollo tiene deadlines reales.

Control y transparencia

Uno de los puntos que más nos llamó la atención al pasar a Claude Code es el nivel de visibilidad sobre lo que el agente está haciendo. En la terminal, los pasos son explícitos. Ves qué archivos toca, qué comandos ejecuta, en qué orden razona. No hay una capa de abstracción que te oculte el proceso bajo una interfaz bonita.

Esto puede sonar como una desventaja para quien prefiera interfaces gráficas más amigables. Pero para perfiles técnicos que quieren mantener el control de su base de código, es exactamente lo contrario: es confianza. Sabes qué está pasando. Puedes intervenir. Puedes revertir. No dependes de que el sistema de artifacts del IDE interprete bien tu feedback.

Antigravity tiene un sistema de artifacts muy interesante en papel, con comentarios estilo Google Docs sobre los planes de implementación, feedback asíncrono al agente... Pero cuando el agente ya ha consumido la mitad de tu cuota antes de que puedas revisar nada, esa elegancia de diseño pierde bastante brillo.

Integración con el flujo de trabajo real

Otro punto a favor de nuestro stack: trabajamos donde siempre hemos trabajado. Claude Code vive en la terminal. Copilot vive en el editor. No hemos tenido que migrar a una nueva interfaz, aprender un nuevo paradigma de organización de proyectos ni ajustar nuestros flujos de trabajo a lo que el IDE espera de nosotros. Son herramientas que se adaptan a cómo trabajamos nosotros, no al revés.

Antigravity propone una filosofía de trabajo nueva, y eso tiene su valor. Para equipos que empiezan de cero o quieren adoptar una metodología agent-first de forma integral, puede ser una opción a considerar en el futuro, cuando los límites de uso sean más predecibles y el modelo de pricing esté más maduro. Pero para quien ya tiene flujos establecidos y proyectos en marcha, la fricción de adopción no se justifica con las ventajas actuales.

Lo que hemos aprendido de este cambio

Más allá de la comparativa técnica, este proceso nos ha enseñado algo que aplicamos ahora a cualquier evaluación de herramienta: desconfía de los límites que no están claramente especificados. "Generoso" no es un número. "Rate limits razonables" no es una SLA. Antes de integrar una herramienta en tu flujo productivo real, necesitas entender exactamente qué obtienes, cuánto puedes consumir y qué pasa cuando superas ese umbral.

También hemos aprendido que la potencia técnica bruta de un modelo o plataforma importa menos de lo que parece. Antigravity tiene un benchmark en SWE-bench impresionante: 76,2% en SWE-bench Verified, una barbaridad si lo comparas con donde estábamos hace dos años. Pero un benchmark alto no te ayuda si te quedas sin cuota antes de terminar la tarea.

La productividad real no se mide solo en capacidades, se mide también en fiabilidad, en previsibilidad y en adecuación al flujo de trabajo de cada equipo. Y en esos tres parámetros, nuestro stack actual, Claude Code + Cowork + Copilot, gana sin demasiada discusión.

¿Significa esto que Antigravity es mala herramienta? No, en absoluto. Es un proyecto ambicioso con ideas genuinamente interesantes, especialmente la ejecución paralela de agentes y el sistema de artifacts con feedback asíncrono. Pero en su estado actual, con un modelo de uso que no está diseñado para trabajo agentic intensivo y continuado, no era lo que necesitábamos.

Puede que en seis meses, con un modelo de pricing claro y límites más generosos de verdad, la conversación cambie. Estaremos atentos. Mientras tanto, seguimos con lo que funciona.

Reflexión final

Cambiar de stack no es una decisión fácil. Hay inercia, hay curva de aprendizaje, hay el síndrome del "a lo mejor con un poco más de paciencia se arregla". Pero hay un momento en que la frustración acumulada supera claramente a la esperanza de que las cosas mejoren solas. Para nosotros, ese momento llegó después de la quinta petición.

Lo bueno de vivir en este sector es que las opciones son reales, el ecosistema de herramientas de IA para desarrollo está madurando a una velocidad brutal, y siempre hay una combinación que se adapta mejor a tu forma de trabajar. La nuestra, hoy, es Claude Code + Cowork + Copilot. Predecible, potente, integrado en el flujo que ya conocíamos. Eso vale más que cualquier benchmark.

Si estás evaluando un cambio similar o tienes curiosidad por alguno de los componentes de este stack, cuéntanos en comentarios. Nos encanta comparar notas con otros desarrolladores que están navegando el mismo caos tecnológico que nosotros.

Síguenos en Instagram en @the.vikingmonkey y en LinkedIn en linkedin.com/company/thevikingmonkey para no perderte el próximo análisis. Publicamos regularmente sobre herramientas, stacks, automatizaciones y todo lo que nos da por experimentar en el laboratorio del mono.