Curso completo de Google Antigravity: Multi-Agentes, Debugging y Contexto Avanzado.

Google Antigravity es un entorno diseñado para trabajar con agentes de IA. Es un fork de Visual Studio Code y

IA. Es un fork de Visual Studio Code y tiene un funcionamiento similar a Cursor. Para instalarlo debes ir a

Cursor. Para instalarlo debes ir a antigravity.google.

antigravity.google.

En su pantalla principal simplemente elige la descarga correspondiente. Es

multiplataforma y cuenta con versiones para Mac, Windows y Linux. La

instalación es estándar, pero ten en cuenta que debes vincularlo a una cuenta de Google para su funcionamiento. Una

vez instalado, al abrirlo por primera vez, te pedirá ese enlace a la cuenta.

Aquí en la barra superior puedes verlo conectado a mi perfil, que usa como sistema de autenticación, además de mostrar una serie de ajustes rápidos quick settings que veremos enseguida.

Antigravity se presenta como una IA con agentes y es totalmente cierto, pero también es muy flexible. Puedes decidir

usarlo como un simple asistente, como un agente rápido o como un agente planificador, como veremos más adelante.

De momento, este es el panel predeterminado que se abre al entrar. Es

muy similar a Visual Studio Code, casi idéntico a sus últimas versiones. A la

izquierda, el panel para archivos y extensiones. En el centro el editor

extensiones. En el centro el editor donde se abren los archivos del proyecto y a la derecha el agente antigravity.

Desde el panel central puedes abrir un directorio concreto, clonar cualquier repositorio desde GitHub o abrir el Open Agent Manager, que si te fijas no es más que una versión ampliada del panel de la

derecha. En el panel de la derecha, el

derecha. En el panel de la derecha, el de la gente, observa que aparece un signo más que permite añadir imágenes, menciones o flujos de trabajo. Al lado

hay dos menús desplegables clave. El

primero permite elegir entre el modo fast o planning, según lo estemos usando para tareas simples o complejas. El otro

menú permite elegir el modelo o motor de razonamiento. Cuenta con modelos

razonamiento. Cuenta con modelos potentes de Gemini Cloud y opciones abiertas como GPT OSS. Respecto a la suscripción y el uso, hay algo muy

importante. De momento, Google

importante. De momento, Google Antigravity no puede usarse a través de una API Key externa. solo funciona

vinculándolo a una cuenta de Google con un nivel de uso que varía según tu cuenta sea free, pro o ultra. Los

niveles son muy generosos y esto es clave. Google te permite usar con tu

clave. Google te permite usar con tu cuenta los otros modelos avanzados que aparecen como los de Cloud, sin configuración adicional, sin coste extra y sin necesitar siquiera tener una

cuenta en esos servicios. Para los que siguen esto de cerca, saben que estamos hablando de una preview que probablemente cambiará pronto. Es una

prueba más de lo importante que es mantenerse bien informados, algo que nunca antes había sido tan crucial con IA o sin ella. Tras el primer contacto

con la interfaz, el siguiente paso es la configuración rápida, Quick Settings Panel, que puede variar según cada proyecto. Pulsando en settings, puedes

proyecto. Pulsando en settings, puedes ver qué hace cada opción gracias a los tips. Por ejemplo, para el agente puedes

tips. Por ejemplo, para el agente puedes determinar si debe estar pendiente de lo que escribimos para corregirlo. Hay

gente a la que no le gusta y además aumenta el consumo de recursos al estar comprobando constantemente nuestro trabajo. El desarrollador decide. Lo

trabajo. El desarrollador decide. Lo

mismo ocurre con el nivel de autonomía.

Podemos elegir entre que solicite confirmación o que proceda siempre.

Observa que incluso cuenta con la opción de permitir o bloquear acciones específicas mediante una allow list y una deny list. Y es que en contra de lo

que se dice esto de la IA y los agentes no es pulsar un botón y ya. La

configuración de una app compleja como Antigravity requiere conocimientos. No

hay otra forma. Además de la configuración rápida, desde aquí podemos acceder a la configuración avanzada. En

el apartado Agent tenemos la opción de añadir comandos a esas listas de permitidos o denegados para afinar el comportamiento. Son herramientas muy

comportamiento. Son herramientas muy poderosas y mal configuradas pueden ser peligrosas. Ya se empieza a leer gente

peligrosas. Ya se empieza a leer gente quejándose de que la herramienta le estropeó esto o lo otro, como si la culpa fuera del software y no del que la usa sin saber. Es como si yo me pusiera

a pilotar un Fórmula 1 y cuando me estrelle le echara la culpa al coche.

Fíjate en estas dos opciones del Quick Settings, Auto Execution y Review Policy. Observa el nivel de detalle de

Policy. Observa el nivel de detalle de los permisos de modo rápido. Autoe

Execution hace referencia a los comandos de terminal, cuáles puede y no puede autoejecutar sus manos.

Mientras que en Review Policy definimos si el agente tiene permiso para alterar tus archivos o definir la estrategia del proyecto, su cerebro. Son matices clave

que demuestran una vez más que para usar estas herramientas hay que saber lo que estamos haciendo. Y lo digo porque si no

estamos haciendo. Y lo digo porque si no iría en contra de lo que siempre he defendido, el acceso al conocimiento.

Hoy ese acceso pasa por el uso de estas IAS. Antes, para aprender a usar

IAS. Antes, para aprender a usar antigravity tendría que usar solo la documentación. Ahora, usando la

documentación. Ahora, usando la documentación con el apoyo de la IA, el aprendizaje es mucho más rápido y a meno. Por ejemplo, ante esta duda sobre

meno. Por ejemplo, ante esta duda sobre las diferencias entre esos dos apartados, aquí puedes ver la respuesta excelente de la IA. Puede que algo así convierta en obsoleto lo que he hecho

durante décadas. No lo creo y el hecho

durante décadas. No lo creo y el hecho de que esté haciendo este vídeo demuestra que no lo creo. Pero aunque

así fuera, no reconocer la tremenda ayuda que suponen estas herramientas para el conocimiento es simplemente mezquino. Son una maravilla para

mezquino. Son una maravilla para aprender, no solo para que nos hagan el trabajo. Y si además nos hacen las

trabajo. Y si además nos hacen las tareas más monótonas y aburridas, mejor.

En resumen, primero, Google Antigravity es poderoso y complejo. Segundo, los

quick settings son clave, aunque puede que el mejor modo de conocerlos sea practicando con proyectos donde no importe equivocarse. No vamos a ver todo

importe equivocarse. No vamos a ver todo en este vídeo, aunque con las prácticas veremos muchas opciones. Y no dudes en preguntarle a tu asistente de IA

favorito en cuanto tengas dudas. Vamos

con una primera práctica similar a un holaundo agéntico donde le pedimos a la gente un resultado y no escribimos el código nosotros. Pero antes destaco un

código nosotros. Pero antes destaco un principio de seguridad fundamental, el sandbox o jaula lógica. Cuando inicias

un proyecto, el agente solo puede acceder a la carpeta en la que te encuentras. Si abrimos C Proyectos Mi

encuentras. Si abrimos C Proyectos Mi App para el agente, el universo empieza y acaba en esa carpeta. No puede subir niveles y borrar archivos de otro

proyecto. Eso sí puede acceder a

proyecto. Eso sí puede acceder a herramientas globales como node.js, Python o Git. Incluso puedes afinar los permisos para que use tu punto git

config y haga commits automáticos, pero nunca modificará nada fuera de la carpeta de trabajo. Esto es muy importante. Así que dentro de una

importante. Así que dentro de una carpeta vacía y con el ID en su estado predeterminado, escribimos en el panel de chat de la gente lo siguiente:

crea una aplicación web sencilla en Python usando Flask. La página debe mostrar un título grande que diga hola antigravity y un botón. Al hacer clic en

el botón debe mostrar la fecha y hora actual dinámicamente en la pantalla. Por

favor, crea el archivo, instala las dependencias necesarias, arranca el servidor y abre automáticamente el navegador para que pueda verla funcionando.

Observa que le pido el proceso completo.

Al haber indicado antes el modo planning en lugar de fast. nos mostrará los artefactos de planificación antes de llevar a cabo las tareas, pero a partir de ahí inicia el proceso

independientemente. De nuevo, nos pedirá

independientemente. De nuevo, nos pedirá permisos según la configuración que le estemos aplicando y vemos cómo crea esta app web sencilla en unos minutos.

Pero recuerda que antigravity puede usarse para muchas tareas diferentes, ya sean simples o complejas. En muchas

ocasiones puede que queramos que la gente corrija trozos de código, no que planifique un proyecto entero. Podemos

usarlo con un flujo de trabajo síncrono que nos ayuda al tiempo que vamos escribiendo o modificando código. Aquí

no actúa como un agente en el que delegamos todo el trabajo, sino como un asistente que colabora en la edición.

Ahora bien, no sería correcto decir que es un asistente tradicional como lo era Copilot hace uno o 2 años. La diferencia

fundamental es que ahora, aunque lo usemos para autocompletado, Gemini no solo accede al contenido del archivo actual, sino que tiene contexto de todo el proyecto. Y esto lo haremos con los

el proyecto. Y esto lo haremos con los comandos inline, desde dentro de partes concretas del código y no desde el panel de agentes lateral. Partimos de un archivo que contiene una función de

JavaScript mal escrita y sin tipos. He

creado para el ejemplo este archivo calculadora.js JS. Para usar antigravity

calculadora.js JS. Para usar antigravity en el denominado comando inline debemos pulsar las teclas control + I, mientras que para abrir el panel de agente

usaríamos control + L. Al pulsar control + I vemos que aparece el editor flotante. Vamos a escribir. Refactoriza

flotante. Vamos a escribir. Refactoriza

esto para que sea más legible. usa

nombres de variables descriptivos y switch case. Observa como antigravity en

switch case. Observa como antigravity en modo inline lleva a cabo los cambios que le indicamos directamente sobre este código, pero también podemos llevar a

cabo refactorizaciones sobre trozos de código concretos. De nuevo, podemos

código concretos. De nuevo, podemos evolucionar este código a type script con el modo inline. Pulsamos otra vez control + I y escribimos en el prompt.

Convierte esto a type script. define una

interfaz para los argumentos y maneja errores si el tipo de operación no es válido. Vemos como resultado que añade

válido. Vemos como resultado que añade automáticamente las interfaces, los tipos number y las validaciones necesarias.

Hay otra posibilidad que para los que llevamos escribiendo código muchos años nos parece una maravilla. Eliminar el

tedio terrible de tener que documentar el código, algo que es aburrido pero vital. Pues bien, colocamos el cursor

vital. Pues bien, colocamos el cursor sobre la nueva función, volvemos a pulsar control + i y escribimos genera documentación JS doc explicativa. El

resultado es que en un momento tenemos un bloque de comentarios perfecto explicando parámetros y retornos.

Existe una versión intermedia entre el inline y el planning. Es el modo fast.

Si por ejemplo queremos cambios para un archivo concreto o hacer preguntas rápidas sobre el código, no necesitamos el modo planning, que es más lento y reflexivo. Así que podemos cambiar en el

reflexivo. Así que podemos cambiar en el panel de agente al modo fast, que es algo similar al chat estándar de los llms. Le podemos hacer una pregunta

como, ¿cómo funciona el método reduce en JS? Tendremos una respuesta rápida y muy

JS? Tendremos una respuesta rápida y muy completa, sin necesidad de generar artefactos ni planes complejos. En

resumen, con Antigravity podemos editar código a gran velocidad sin salir del editor. Un tema muy diferente es si lo

editor. Un tema muy diferente es si lo que queremos es crear todo el backend de una aplicación desde cero. Ahí no

podemos ir función por función, eso es cosa del pasado. Ahora lo que hacemos es utilizar el modo planning y dejar que Antigravity se ponga a trabajar mientras

nosotros nos vamos a tomar un café.

Vamos a profundizar ahora en el modo planning de antigravity. Aquí el modelo deja de responder al instante y se detiene a pensar. Es el gran cambio para

los desarrolladores. Pasamos de ser

los desarrolladores. Pasamos de ser escritores de código a arquitectos de software que supervisan el trabajo de los agentes de IA. Es además un ejemplo claro de la diferencia entre una

inferencia rápida dialogando con un chat y un razonamiento estructurado mediante el uso de una planificación muy pensada.

Ya sabemos cómo cambiar de modo fast a planning. Pasamos de priorizar la

planning. Pasamos de priorizar la velocidad a priorizar la estructura y la seguridad. Como norma general, para

seguridad. Como norma general, para cualquier tarea que implique crear más de un archivo, deberíamos usar siempre planning. Comprobamos también que tanto

planning. Comprobamos también que tanto en Auto Execution como en Review Policy tenemos seleccionado request review. Así

nos aseguramos de poder ver el plan antes de que empiece a ejecutarlo. Si en

Review Policy eligiéramos Always Proceed, el agente llevaría a cabo igualmente la planificación al estar en modo planning, pero empezaría a trabajar inmediatamente sin pedir permiso. Y para

aprender queremos tener control total sobre lo que va haciendo. La clave en el modo planning de antigravity son los denominados artefactos.

Cuando el agente planifica un proyecto a partir de nuestras indicaciones iniciales, no nos responde con código, lo hace con un artefacto. Podemos

considerarlo como un contrato o un plano de la obra que se dispone a emprender.

Antes de poner un solo ladrillo, el agente te dice, "Esto es lo que voy a hacer." Y hasta que no le demos la

hacer." Y hasta que no le demos la aprobación, hasta que no firmemos el contrato, no empieza. Estos son los elementos a destacar de un artefacto.

Primero, el propose plan. Plan

propuesto. Son pasos lógicos en lenguaje natural. Por ejemplo, uno, configurar

natural. Por ejemplo, uno, configurar entorno, dos, crear base de datos, tres, definir rutas. Segundo, file structure,

definir rutas. Segundo, file structure, estructura de archivos, un árbol visual de las carpetas y ficheros que va a crear. Esto es vital para ver si la

crear. Esto es vital para ver si la arquitectura es correcta. Tercero, shell

commands, los comandos de terminal que quiere ejecutar, npm, install, MK ir, etcétera. Vamos con una nueva demo

etcétera. Vamos con una nueva demo práctica. Crearemos un backend desde

práctica. Crearemos un backend desde cero y modificaremos el plan sobre la marcha. Para ello, usaremos una API Rest

marcha. Para ello, usaremos una API Rest con Express. El primer paso es el

con Express. El primer paso es el prompt, el encargo. En el panel de agente y con el modo planning activado escribimos, quiero crear una API Rest

básica usando node.js y express. Para

gestionar una lista de tareas to do list. Necesito endpints para crear,

list. Necesito endpints para crear, listar y borrar tareas. Usa un archivo JSON local db.jonjon

como base de datos por ahora. Configura

el servidor en el puerto 3000. El

segundo paso es el thinking process.

Observad el proceso de pensamiento. Es

más lento que en el modo fast, ya que está analizando en profundidad el contexto y elaborando todo el diseño.

Ah.

El tercer paso es el momento clave para el desarrollador, revisar en detalle el artefacto. En el análisis vemos que

artefacto. En el análisis vemos que propone crear un archivo server.jsgigante

server.jsgigante con todo el código dentro. Vamos a

aprovechar esto para ver en acción el bucle de feedback. Escribimos en el chat, "El plan está bien, pero prefiero una arquitectura más limpia. Separa las

rutas, los controladores y el modelo en carpetas distintas. MVC. Paso cuatro, el

carpetas distintas. MVC. Paso cuatro, el refinamiento. El agente genera un nuevo

refinamiento. El agente genera un nuevo artefacto.

Podemos ver como ahora la sección file structure ha cambiado. Ahora sí vemos carpetas roots controllers etcétera.

Ahora sí pulsamos el botón appr plan.

Aprobar plan. Una vez aprobado, Antigravity toma el control. Dejamos en

pantalla a la gente realizando el trabajo de modo autónomo. La terminal se abre sola, se ejecuta npm init y npm install express. En el explorador de

install express. En el explorador de archivos de la izquierda empiezan a aparecer las carpetas y archivos uno a uno en tiempo real. El agente va marcando los pasos del plan como

completados con un check verde. Observa

también como esta tarea es asíncrona.

Mientras este agente trabaja instalando dependencias, podríamos estar editando otros archivos, leyendo documentación, instruyendo a otro agente o jugando al

Fallout. Su trabajo no bloquea el tuyo.

Fallout. Su trabajo no bloquea el tuyo.

Cuando el agente diga tarea completada, abre la terminal o deja que el agente lo haga si le diste permiso y ejecuta nodeserver.jcs

nodeserver.jcs o npm Start. Muestra el mensaje en consola. Server running on port 3000.

consola. Server running on port 3000.

Esto es delegar en agentes, pasar de pedir líneas de código a pedir proyectos enteros. Debe quedar clara la

enteros. Debe quedar clara la importancia de los artefactos en antigravity, ya que son lo que el desarrollador debe revisar en profundidad antes de empezar a construir

la app. Para cerrar, tenemos el servidor

la app. Para cerrar, tenemos el servidor corriendo. La consola dice que va bien,

corriendo. La consola dice que va bien, pero funciona de verdad. Los endpints

responden. Podría abrir Postman y probarlo a mano, pero ¿y si le pido a la gente que lo compruebe él mismo?

Antigravity añade otra característica impresionante que es la verificación visual autónoma. Aunque ya hemos visto

visual autónoma. Aunque ya hemos visto un anticipo, vamos a profundizar ahora en ella. Veremos cómo el agente puede

en ella. Veremos cómo el agente puede abrir de modo autónomo el navegador, usar la app que acaba de crear, comprobar que funciona y mostránoslo

todo sin tocar nosotros el teclado.

Acabamos de ver cómo crear una API completa y cómo el propio agente se encargó de comprobar que no hubiera errores. Sin embargo, de ahí a estar

errores. Sin embargo, de ahí a estar seguros de que todo funciona correctamente, hay un gran paso. En el

desarrollo clásico de una app web tendríamos que lanzar los servidores, abrir el navegador y realizar manualmente las actividades esperadas.

Tener que hacer esto decenas o cientos de veces durante el desarrollo es el ejemplo perfecto de un trabajo tan necesario como repetitivo y aburrido.

Por eso resulta tan interesante una de las características más futuristas de Antigravity, la browser Surface o superficie del navegador. Aquí el agente

cuenta con sus propias manos y ojos para usar la aplicación como si fuera un usuario real. Esa es la idea detrás del

usuario real. Esa es la idea detrás del término browser surface. Un concepto muy ligado a los agentes autónomos.

Antigravity ya no solo crea código complejo. Además, gracias a su

complejo. Además, gracias a su integración profunda con Chrome, puede lanzar una instancia real del navegador, pero atención, no lo abre para que nosotros lo usemos. El agente puede ver

la pantalla usando la visión computacional de Gemini 3 e interactuar con todos sus componentes. Puede hacer

clic en botones, escribir en campos de texto y hacer scroll. es la denominada verificación autónoma. Aplicamos el

verificación autónoma. Aplicamos el principio de confiar, pero verificar, dejando que la parte tediosa la haga la máquina y no nosotros. Para probar esto,

necesitamos algo visual. Vamos a crear rápidamente una lista de tareas. To do

list.

Nos vamos al panel de la gente. Nos

aseguramos de estar en modo planning. y

lanzamos un prompt sencillo. Crea una

aplicación web simple en un solo archivo index.html.

index.html.

Quiero una lista de tareas que permita añadir items escribiendo en un input y pulsando enter. Dale un estilo moderno.

pulsando enter. Dale un estilo moderno.

Vemos cómo genera el archivo.

Y ahora atención. Pulsamos el botón de preview o le pedimos que abra el navegador. Ahí la tenemos, una lista de

navegador. Ahí la tenemos, una lista de tareas básicas, funcional y con diseño.

Ahora viene la magia. Vamos a pedirle una nueva función, pero le exigiremos que nos demuestre con pruebas que funciona. Fijaos bien en el prompt

funciona. Fijaos bien en el prompt porque es prácticamente un guion de pruebas en lenguaje natural. Añade un

botón rojo que diga borrar todo al final de la lista. Importante, una vez implementado, quiero que verifiques autónomamente qué funciona. Para ello,

uno. Abre la app dos. Añade tres tareas de prueba, tres. Pulsa el botón de borrar y cuatro. confirma que la lista queda vacía. Observad que no le estoy

queda vacía. Observad que no le estoy diciendo cómo programar el test unitario, le estoy diciendo qué debe probar, como si le hablara a un tester humano. Este es el momento clave.

humano. Este es el momento clave.

Soltamos el ratón y observamos el navegador controlado por el agente. En

el ID ya ha modificado el código y aparece el botón rojo. Pero lo

impresionante es que tal como lo haría una persona en el navegador, se empieza a escribir texto, tarea uno, enter.

Tarea dos, enter. El agente está interactuando en tiempo real. Ahora

mueve el foco al botón rojo de borrar todo. Click y las tareas desaparecen.

todo. Click y las tareas desaparecen.

Acabamos de presenciar un test end to end completo, verificando que el código hace exactamente lo que se supone que debe hacer. ¿Y qué nos devuelve el

debe hacer. ¿Y qué nos devuelve el agente? Volvamos al chat. No se limita a

agente? Volvamos al chat. No se limita a decir hecho. Fijaos en el informe.

decir hecho. Fijaos en el informe.

Normalmente nos adjunta evidencias.

Capturas de pantalla del antes con la lista llena y del después con la lista vacía. También revisa loss de la consola

vacía. También revisa loss de la consola para asegurarse de que no hubo errores ocultos de JavaScript. Su conclusión es clara. He verificado la funcionalidad.

clara. He verificado la funcionalidad.

El botón elimina los elementos del DOM correctamente. Esto cambia las reglas

correctamente. Esto cambia las reglas del juego una vez más. Ya son muchos cambios que han redefinido totalmente el trabajo del desarrollador. Ya no tenemos que testear cada pequeño cambio. Podemos

delegar la comprobación visual y centrarnos en la arquitectura. Hemos

visto cómo crear, cómo planificar y ahora cómo verificar. Pero incluso con IA las cosas no siempre funcionan a la primera. La pantalla de pronto se pone

primera. La pantalla de pronto se pone roja, surgen errores y todo falla. Por

suerte, Antigravity cuenta también con capacidades para autodiagnosticar y arreglar box complejos, leyendo y aprendiendo de sus propios errores. Eso

es justo lo que vamos a ver ahora.

Uno de los usos más potentes de Antigravity ataca directamente el gran problema de todo desarrollo, los errores. Antigravity no solo escribe

errores. Antigravity no solo escribe bien, también arregla bien. Se comporta

como un compañero que nos ayuda a investigar el delito, un auténtico Sherlock Holmes digital capaz de llevar a cabo un debugging en profundidad de modo totalmente autónomo. La realidad

del desarrollador está plagada de constantes errores en rojo, pantallas en blanco y las famosas excepciones de undefined is not a function. Cuando el

código falla, empieza la parte más dolorosa de este trabajo, la depuración.

Leer locks, rastrear variables y buscar una aguja en un pájar. Pero antigravity

cambia esto con el debuging autónomo.

Veremos como el agente no solo sabe escribir código, sino que sabe leer sus propios errores, formular hipótesis, investigar y solucionar el problema por

sí mismo. Para ver esto en acción,

sí mismo. Para ver esto en acción, necesitamos romper algo. No vamos a usar un error de sintaxis porque eso ya nos lo marca el editor con una línea roja

antes de ejecutar. Queremos un error de lógica, uno que explote justo cuando el programa está corriendo. He preparado

este script sencillo en Python calculadora.pi.

calculadora.pi.

Fijaos en la lista llamada carrito.

Tenemos un número 100, luego un 20, pero como texto un string y luego un 50. Y en

la función de suma no estamos validando los tipos de datos. Abrimos la terminal integrada y ejecutamos Pythoncalculadora.pi.

Pythoncalculadora.pi.

Ahí está. Type error. Python no puede sumar un entero con un texto. En el

mundo clásico pre tocaría leer la línea del error, ir al código, buscar la definición de la lista y entender qué ha pasado, muchas veces lidiando con

mensajes nada claros. Pero esto ya es cosa del pasado. Hoy no vas a hacer nada de eso. Ya ni siquiera se trata de

de eso. Ya ni siquiera se trata de copiar el error, pegarlo en un chat y pedir ayuda, como hacíamos en los inicios de la IA. Ahora, el agente Antigravity cuenta con una integración

contextual completa. Podríamos hacerlo

contextual completa. Podríamos hacerlo inline, pero vamos a usar la interfaz de la gente para ver su potencia.

Recordemos que esto es muy diferente a un chat normal, ya que tiene una perspectiva total del proyecto.

Escribimos @terminal. El último comando ha fallado. Investiga por qué y arréglo.

ha fallado. Investiga por qué y arréglo.

Fijaos en el uso de @terminal. Con esto

le estoy diciendo, no solo leas mi código, lee también la salida de la consola, el estado de la memoria y el error exacto que acaba de ocurrir.

Observa el símbolo de la a enigravity, que activa lo que llamamos menciones de contexto. Es algo similar a etiquetar a

contexto. Es algo similar a etiquetar a una persona en apps de redes sociales para fijar el foco. Aquí no etiquetamos personas, sino partes vivas del entorno de desarrollo con el que estamos

trabajando.

Al usar la desplegamos un menú donde podemos elegir @file para centrarnos en un archivo concreto, un git para revisar los últimos cambios pendientes o docs

para que la gente consulte documentación oficial externa. Es la forma más precisa

oficial externa. Es la forma más precisa de decirle a la IA. Ignora el ruido del resto del proyecto y centra toda tu potencia de razonamiento exclusivamente

en esto que te señalo, que en este caso concreto es la salida que muestra la terminal. Ahora viene lo interesante.

terminal. Ahora viene lo interesante.

Observad el panel de pensamiento de la gente. No se limita a adivinar y decir,

gente. No se limita a adivinar y decir, "Creo que es un string." No, está investigando. Mirad lo que acaba de

investigando. Mirad lo que acaba de hacer en el código. Ha inyectado un print, un log dentro del bucle para ver qué tipo de dato tiene cada variable. Y

ahora él mismo vuelve a ejecutar el script. Para alguien que haya dedicado

script. Para alguien que haya dedicado tiempo a la depuración, esto es simplemente impresionante. Aunque este

simplemente impresionante. Aunque este ejemplo es sencillo, demuestra que la gente no se limita a apretar tornillos al azar. Sabe exactamente qué tornillo

al azar. Sabe exactamente qué tornillo de los miles que puede haber en un proyecto es el que debe ajustar. El

agente ha formulado una hipótesis, quizás hay un string colado. Ha

modificado el código para depurar, ha ejecutado el programa para confirmar su teoría y ha leído el resultado. Ha

actuado exactamente igual que lo haría un desarrollador senior. Una vez

confirmado el problema, el agente propone la solución. Nos dice, "El error se debe a que el segundo elemento es un string. Voy a convertir todos los inputs

string. Voy a convertir todos los inputs a números flotantes antes de sumar para evitar fallos. Le damos permiso y ahí

evitar fallos. Le damos permiso y ahí está. Aplica el float. Pero fijaos

está. Aplica el float. Pero fijaos

además en un detalle. Ha borrado los print de depuración que puso antes.

Limpia su propio rastro. Para terminar,

ejecuta el script final por tercera vez.

Resultado, el total es 170.0.

Sin errores. El agente marca la tarea como resuelta. Esto ha salido a la

como resuelta. Esto ha salido a la primera, pero imaginad que al arreglar lo del string salta otro error diferente y entra en un bucle de fallos. Aquí es

donde entra la seguridad interna del sistema. Antigravity tiene configurados

sistema. Antigravity tiene configurados unos límites internos para no gastar recursos infinitamente. Si tras varios

recursos infinitamente. Si tras varios intentos, normalmente tres o cinco no lo consigue, se detendrá y nos pedirá ayuda. Y aquí viene un matiz importante.

ayuda. Y aquí viene un matiz importante.

No busquéis un botón de número de reintentos en los ajustes porque no existe. Como el propio agente nos

existe. Como el propio agente nos explica, la configuración es el chat. Si

estamos ante un bug muy rebelde, somos nosotros los que tenemos que darle la orden explícita. Sigue intentando

orden explícita. Sigue intentando arreglar esto hasta que funcione. O por

el contrario, si fallas a la primera, detente y avísame. Nosotros marcamos el ritmo con nuestras palabras, no con interruptores. Sirve también de ejemplo

interruptores. Sirve también de ejemplo práctico de cómo ha cambiado nuestro trabajo. Desde luego, para crear este

trabajo. Desde luego, para crear este vídeo he usado distintas herramientas de IA. Para mí tener que decir esto es como

IA. Para mí tener que decir esto es como si hace años cuando trabajabas con imágenes tuvieras que estar diciendo que habías usado Photoshop o GIMP. Pues

claro, pero estamos ante un terreno cambiante que evoluciona constantemente.

En una primera versión de este apartado, Gemini me había dicho que en la configuración existía la opción de autofix, que permite determinar el número de intentos en los bucles de

interacción que si existen otras herramientas. Por ejemplo, lo he usado

herramientas. Por ejemplo, lo he usado en Visual Studio Code, pero no lo encontraba por ningún lado. Solución:

Preguntarle al propio Antigravity en lenguaje natural. Oye, ¿dónde puedo

lenguaje natural. Oye, ¿dónde puedo fijar el número de intentos si inicias un bucle de interacción? Y ahí tienes la respuesta muy clara. Al menos de momento es una configuración interna no

accesible, pero si queremos determinarlo, que se lo digamos en lenguaje natural, sin cambiar ninguna configuración. Lo que acabamos de ver es

configuración. Lo que acabamos de ver es el fin del debogging desesperante. Tener

a una IA que puede reproducir, investigar y arreglar books leyendo las trazas de error es un acelerador de productividad masivo. Quizás la

productividad masivo. Quizás la característica más destacada por los desarrolladores que han dado el salto a estos agentes. Hasta ahora hemos

estos agentes. Hasta ahora hemos trabajado con un solo agente, un compañero fiel. Pero en el mundo real,

compañero fiel. Pero en el mundo real, los proyectos grandes no los hace una sola persona. Hay un equipo, uno hace el

sola persona. Hay un equipo, uno hace el frontend, otro los tests, otro la documentación. Vamos ahora a subir de

documentación. Vamos ahora a subir de nivel. Vamos a entrar en la Manager View

nivel. Vamos a entrar en la Manager View y aprenderemos a orquestar un equipo completo de agentes trabajando en paralelo. El desarrollador convertido en

paralelo. El desarrollador convertido en director de una orquesta de agentes.

El gran salto de antigravity en este terreno que cambia día a día es la redefinición de la relación humano y a esto es lo que permite un aumento real

de la productividad. Hasta ahora la relación humano agente era lineal. Ya no

se limitaba solo a responder, sino a realizar tareas, pero seguían siendo una a una. Le pedíamos una cosa, esperábamos

a una. Le pedíamos una cosa, esperábamos a que terminara, revisábamos y le pedíamos la siguiente. Fue un gran avance respecto a la IA, puramente conversacional, pero seguía siendo un

cuello de botella al limitarnos a una única tarea a la vez. Pero ahora el trabajo del desarrollador se plantea como el de un auténtico director de proyectos, alguien que tiene a un grupo

de expertos trabajando en un sistema complejo y supervisa sus avances.

Imaginad la escena. El director le pide al encargado del frontend que compile para ver la salida. Mientras tanto,

revisa en su pantalla el trabajo del back end y al mismo tiempo llama al encargado de los tests para que se coordine con quien está documentando la

API. Este es el trabajo real de gestión

API. Este es el trabajo real de gestión de equipos complejos y eso es exactamente lo que la Manager View nos permite hacer con agentes de IA. La

Manager View permite al desarrollador humano coordinar a múltiples agentes trabajando simultáneamente.

Pero empecemos diciendo la verdad, este trabajo de sencillo no tiene nada, es tremendamente complejo. El humano debe

tremendamente complejo. El humano debe saber qué tiene que hacer cada agente, mantener una visión panorámica del conjunto y ser capaz de supervisarlos a todos. Para acceder a esta vista,

todos. Para acceder a esta vista, pulsamos en el icono de Agent Manager.

Entramos en la sala de control de nuestros proyectos que Antigravity denomina Workspaces. De entrada, en el

denomina Workspaces. De entrada, en el panel central aparece una vista de chat.

Esto mantiene una idea exitosa, que las interfaces deben ser lo más sencillas posible, pero también puede llevar a confusión. Alguien podría pensar, "Vaya,

confusión. Alguien podría pensar, "Vaya, otra ventana de chat más como chat GPT."

Se parece, sí, pero la gran diferencia está en el motor de razonamiento. Nos

estamos comunicando con algo muy distinto a los charts conversacionales clásicos, aunque estos apenas acaben de cumplir 3 años. Así que aunque lo parezca, olvídate de la vista de chat

tradicional y fíjate en la columna de la izquierda. Aquí no vemos una lista plana

izquierda. Aquí no vemos una lista plana de chats, vemos nuestros workspaces o proyectos independientes como data commons, 2 o weather mood. Quiero

señalar algo muy importante aquí, siempre con los pies en la tierra. A

medida que aumentamos el número de agentes, la capacidad de control se hace más compleja. Sin embargo, nada impide

más compleja. Sin embargo, nada impide tener agentes trabajando no solo en un proyecto, sino en proyectos distintos a la vez. Ya sabemos que cada agente está

la vez. Ya sabemos que cada agente está confinado a su carpeta por seguridad. Un

agente de data commons no puede tocar archivos de weather mood, eso debe quedar claro. Pero el Agent Manager nos

quedar claro. Pero el Agent Manager nos permite supervisar a distintos agentes de distintos proyectos trabajando al mismo tiempo. Todo desde esta única

mismo tiempo. Todo desde esta única interfaz. Es una idea muy poderosa,

interfaz. Es una idea muy poderosa, aunque incipiente, y un síntoma claro de hacia dónde se dirige el futuro. El

desarrollador tiene la visión global, las llaves de todos los despachos y, por supuesto, la responsabilidad última. Y

permitidme un inciso sobre esto. A veces

es frustrante ver a la víctima de turno quejándose de que la IA le ha borrado una base de datos o le ha destrozado el trabajo. Realmente no entienden que

trabajo. Realmente no entienden que están manejando herramientas potentes sin la debida supervisión.

Con esto no digo que mañana no pueda pasarme a mí. Todos cometemos errores.

Lo que digo es que nunca se me ocurriría echarle la culpa a la herramienta. Lo

que me preguntaría es, ¿en qué me he equivocado yo y qué debo hacer para que no vuelva a ocurrir. Si queremos ser directores, debemos asumir la responsabilidad del cargo. Volvamos a la

interfaz. Si desplegamos uno de estos

interfaz. Si desplegamos uno de estos proyectos, vemos varias entradas debajo, aunque se llamen conversaciones, en la práctica, cada una es un agente independiente o un hilo de trabajo

distinto. Antigravity no nos muestra

distinto. Antigravity no nos muestra agente uno o agente dos, sino que los organiza por la tarea específica que realizan. Vamos a ver cómo trabajar en

realizan. Vamos a ver cómo trabajar en paralelo dentro de un mismo proyecto. En

el panel central, en el lanzador Start New Conversation In, nos aseguramos de estar en el proyecto correcto y escribimos el prompt para la primera

tarea, el frontend. Crea la estructura HTML básica para el dashboard de usuario. Al lanzarlo, veremos una nueva

usuario. Al lanzarlo, veremos una nueva entrada en la lista de la izquierda. Ese

es nuestro agente de frontend trabajando. Antes de lanzar al segundo

trabajando. Antes de lanzar al segundo debemos entender algo fundamental.

¿Saben estos agentes lo que hacen sus compañeros? La respuesta corta es,

compañeros? La respuesta corta es, comparten el escenario, pero no se leen la mente. Imaginad dos desarrolladores

la mente. Imaginad dos desarrolladores en la misma oficina. Ambos ven la misma pizarra y pueden editar los mismos archivos. Si el agente uno crea un

archivos. Si el agente uno crea un archivo, el agente 2 lo ve, pero llevan auriculares con cancelación de ruido. El

agente 2 no tiene acceso al chat ni a los pensamientos del agente uno. No sabe

por qué ha tomado esas decisiones. Solo

ve el resultado en el disco. Por eso, tú eres el director de orquesta. Tu trabajo

es hacer de puente. No basta con decirle al segundo agente, "Haz tests, tienes que darle el contexto tú mismo. Queda

claro que el trabajo del desarrollador no desaparece, sino que cambia y se potencia enormemente. Sabiendo esto,

potencia enormemente. Sabiendo esto, lanzamos al segundo agente mientras el primero sigue escribiendo. Vamos a la columna izquierda, pulsamos el botón más y abrimos un lienzo limpio. En el prompt

le decimos, tu compañero está creando el archivo index.htm html.

archivo index.htm html.

Quiero que tú revises ese archivo y configures los tests unitarios conest para asegurar que se carga correctamente.

Al darle esa instrucción explícita, forzamos al agente dos a mirar el trabajo del agente uno. Así creamos la coordinación. Ahora, si miramos la

coordinación. Ahora, si miramos la columna izquierda, tenemos dos conversaciones activas simultáneamente.

Podemos saltar de una a otra para ver el diseño y la instalación de tests en tiempo real.

El Agent Manager deja de ser un historial de chats para convertirse en un tablero de control de productividad.

Resumiendo el ciclo técnico que hemos visto, la instalación, los modos, la planificación, la navegación, la depuración y ahora la orquestación

multiagente. La herramienta es poderosa,

multiagente. La herramienta es poderosa, pero como siempre e incluso más que antes, la calidad de la sinfonía depende de la calidad de las instrucciones que

este nuevo tipo de desarrolladores sepa darle a su orquesta de IAS.

Llegamos a la última pieza del puzzle y quizás la más importante para el mundo empresarial, el contexto avanzado. Los

modelos de IA actuales son genios generalistas, saben muchísimo sobre programación estándar, pero no saben absolutamente nada de tu empresa. No

saben cuál es vuestro color corporativo ni la nomenclatura de vuestras bases de datos. De entrada para Antigravity sois

datos. De entrada para Antigravity sois unos desconocidos. El objetivo es

unos desconocidos. El objetivo es inyectar ese conocimiento específico en el cerebro de la gente. Queremos que

deje de ser una IA genérica y empiece a programar siguiendo estrictamente vuestras reglas. En las empresas estas

vuestras reglas. En las empresas estas reglas suelen estar en PDFs visuales, pero intentar que una IA lea un PDF complejo a veces da problemas técnicos o

de conversión. Así que una buena

de conversión. Así que una buena alternativa es convertir antes el PDF al formato nativo de la documentación, el markdown.md

markdown.md es el mismo formato que usamos para los archivos lemreadme.

En Githope y que han estandarizado todos los botones de razonamiento para indicarle las reglas que deben seguir.

Es texto plano ligero y la IA lo entiende a la perfección. Vamos a verlo en la práctica. Imaginad que entra un diseñador nuevo, le daríamos el manual

de identidad. Para nuestro agente hemos

de identidad. Para nuestro agente hemos resumido esas reglas, colores, fuentes y tamaños en un archivo llamado guíaestilo. Mmd. Lo subimos a la raíz de

guíaestilo. Mmd. Lo subimos a la raíz de nuestro proyecto junto al código. Fijaos

en el contenido. Define claramente que nuestro color primario es el naranja número FF5733 y que los bordes deben ser de 12 píxeles. Al estar en Mark Down, la

píxeles. Al estar en Mark Down, la estructura de títulos y negritas ayuda a Antigravity a entender que es importante sin margen de error. Ahora vamos a

pedirle que trabaje. El truco de productividad definitivo aquí es el uso de la araba para invocar este conocimiento. Abrimos el chat y le

conocimiento. Abrimos el chat y le decimos, crea el código CSS para un botón de llamada a la acción.

Importante, basa tu diseño estrictamente en las reglas definidas en el archivo guía estilo. Fijaos que al escribirla @

guía estilo. Fijaos que al escribirla @ y seleccionar el archivo le estamos diciendo al cerebro de la IA, ignora tu entrenamiento generalista y céntrate

exclusivamente en este documento. Le

damos a enviar. Ahí está. Mirad, el

código generado. Ha aplicado el background color, número FF5733 y el border radius. 12 píxeles exactos.

El agente ha actuado como un empleado diligente que consulta la documentación interna antes de ejecutar la tarea. Esto

tiene una ventaja enorme, el control. Si

mañana la empresa decide cambiar el color naranja por verde, solo tenéis que editar el archivo Mark Down. Al instante

todos los agentes del proyecto empezarán a usar el nuevo color sin reconfigurar nada. Es una constitución viva para

nada. Es una constitución viva para vuestro código y con esto cerramos el círculo. Ha sido un viaje intenso.

círculo. Ha sido un viaje intenso.

Empezamos instalando una extensión desconocida. Aprendimos a diferenciar

desconocida. Aprendimos a diferenciar entre el modo rápido y el modo planificación. Le dimos ojos a la gente

planificación. Le dimos ojos a la gente para usar el navegador, le enseñamos a depurar sus propios errores. Aprendimos

a orquestar múltiples agentes y finalmente le hemos enseñado nuestra cultura de empresa. La conclusión es clara, antigravity no viene a quitarte el trabajo, viene a quitarte la parte

aburrida. Estamos ante el nacimiento del

aburrida. Estamos ante el nacimiento del desarrollador híbrido, donde vuestra dirección estratégica se ve potenciada por la ejecución incansable de la máquina. Espero que este curso os haya

máquina. Espero que este curso os haya dado las herramientas para liderar este cambio. Gracias por acompañarme y ahora

cambio. Gracias por acompañarme y ahora a construir el futuro. Hasta la próxima.

he