He pasado la última tarde probando el nuevo Build Mode de Google AI Studio. La promesa de construir una aplicación móvil nativa sin configurar un solo archivo Gradle o abrir Android Studio suena a típica campaña de marketing corporativo. Sin embargo, al ver cómo una caja de arena remota escribe Kotlin, diseña interfaces con Jetpack Compose y las renderiza en un emulador web funcional a partir de un párrafo en lenguaje natural, te das cuenta de que el suelo técnico se está moviendo bajo nuestros pies.

Este movimiento no es un hecho aislado. Forma parte de un giro de timón que la comunidad técnica ha bautizado como "Gemini Goes Agentic". Los LLM están dejando atrás el rol pasivo del chatbot de preguntas y respuestas para asumir tareas que requieren planificar, corregir errores en tiempo real y ejecutar código en entornos de desarrollo controlados.

La anatomía del Build Mode en AI Studio

Para quienes han lidiado con el ecosistema de Android, la barrera de entrada nunca ha sido únicamente escribir la lógica. Configurar el SDK, pelearse con las versiones del JDK, sincronizar dependencias de Gradle y soportar emuladores locales que consumen gigabytes de memoria RAM suele agotar la paciencia de cualquiera. Google AI Studio ataca precisamente esa fricción.

El flujo es directo. Le describes la aplicación al agente de desarrollo en la interfaz web. El modelo genera un árbol completo de directorios nativos con su configuración Gradle y archivos de código Kotlin estructurados en componentes de Jetpack Compose. El entorno virtual compila el código y levanta un emulador basado en web. Si hay errores de compilación, el propio agente lee la salida del compilador, reescribe el bloque problemático y vuelve a intentar el proceso de compilación.

Este sistema presenta una arquitectura interesante pero con limitaciones claras:

  • Ejecución del lado del cliente: Las aplicaciones generadas son autónomas y funcionan en el dispositivo local. Si necesitas persistencia remota, autenticación compleja o gestión de bases de datos compartidas, el agente te proporcionará el esqueleto de la llamada API, pero el backend sigue requiriendo desarrollo tradicional o integración manual.
  • Gradle gestionado: Aunque no lo veas, el compilador Gradle funciona por debajo en servidores aislados de Google. Puedes descargar el proyecto completo en un archivo ZIP para continuar la edición en tu propio equipo, lo cual resulta útil cuando el prototipo requiere un control fino de las dependencias.
  • Acceso al hardware simulado: El emulador en el navegador simula el comportamiento de sensores, GPS y almacenamiento local, permitiendo iteraciones inmediatas sin conectar cables.

Del chat estático a la planificación activa

¿Por qué ocurre esto ahora? La respuesta corta es el cambio de enfoque en la arquitectura cognitiva de los modelos. Tradicionalmente, enviar una consulta a Gemini devolvía un bloque estático de texto. Si el código sugerido tenía un error de sintaxis, era el programador quien debía copiar el error, pegarlo en el chat y esperar una corrección.

Con "Gemini Goes Agentic" y la llegada de Gemini 3.5 Flash como motor de baja latencia, el modelo utiliza un bucle de planificación y ejecución. El agente no responde inmediatamente al usuario. Primero elabora un plan de acción:

  1. Leer el archivo de configuración.
  2. Comprobar las funciones existentes.
  3. Escribir el nuevo fragmento.
  4. Ejecutar el compilador para validar la sintaxis.
  5. Analizar el resultado y ajustar si es necesario.

Este flujo de planificación colaborativa permite que el desarrollador apruebe o modifique la estrategia del agente antes de que este gaste tokens escribiendo código inútil. Además, con la API de agentes gestionados de Google, ahora es posible delegar tareas complejas a entornos Linux efímeros que corren en la nube de Google, donde el modelo tiene acceso a bash, herramientas de análisis y compiladores reales sin comprometer la seguridad del equipo local.

Código: Creación y compilación autónoma de Kotlin

Para entender cómo funciona este bucle agéntico detrás de las cámaras, podemos estructurar un script de orquestación local en Python. En este ejemplo, el agente de Gemini utiliza una herramienta personalizada para generar un código Kotlin, compilarlo mediante el compilador de Kotlin en el sistema y ejecutarlo, analizando los errores si la compilación falla.

import google.generativeai as genai
import subprocess
import os

# Configuración inicial del motor de Gemini
genai.configure(api_key=os.environ.get("GEMINI_API_KEY", "tu-clave-aqui"))

def ejecutar_compilacion_kotlin(codigo_fuente: str, nombre_clase: str) -> str:
    """
    Herramienta que guarda, compila y ejecuta código Kotlin localmente.
    Permite al agente validar su propio trabajo de programación.
    """
    archivo_kt = f"{nombre_clase}.kt"
    archivo_jar = f"{nombre_clase}.jar"

    # Escribir el código en un archivo físico
    with open(archivo_kt, "w", encoding="utf-8") as f:
        f.write(codigo_fuente)

    try:
        # Llamar al compilador de Kotlin en el sistema
        proceso_compilar = subprocess.run(
            ["kotlinc", archivo_kt, "-include-runtime", "-d", archivo_jar],
            capture_output=True,
            text=True,
            timeout=15
        )

        if proceso_compilar.returncode != 0:
            return f"Fallo en compilación:\n{proceso_compilar.stderr}"

        # Ejecutar el binario generado
        proceso_ejecutar = subprocess.run(
            ["java", "-jar", archivo_jar],
            capture_output=True,
            text=True,
            timeout=10
        )

        return f"Ejecución exitosa. Salida:\n{proceso_ejecutar.stdout}"

    except subprocess.TimeoutExpired:
        return "Error: Tiempo de espera agotado durante la ejecución."
    except FileNotFoundError:
        return "Error: No se encontró 'kotlinc' o 'java' instalado en el sistema."
    finally:
        # Limpieza de archivos temporales
        for archivo in [archivo_kt, archivo_jar]:
            if os.path.exists(archivo):
                os.remove(archivo)

# Inicializar el modelo con capacidad de usar la herramienta
modelo = genai.GenerativeModel(
    model_name="gemini-3.5-flash",
    tools=[ejecutar_compilacion_kotlin]
)

# Iniciar un canal de chat con resolución automática de herramientas
chat = modelo.start_chat(enable_automatic_function_calling=True)

# El agente procesará la petición, decidirá llamar al compilador y mostrará el resultado final
respuesta = chat.send_message(
    "Escribe una clase Kotlin que verifique si una palabra es un palíndromo, "
    "compílala con el nombre 'Verificador' y muéstrame la salida."
)

print(respuesta.text)

Este script ejemplifica el núcleo de la filosofía de los nuevos agentes de desarrollo. El modelo ya no es solo una calculadora de texto con esteroides; es un hilo de ejecución lógico capaz de interactuar con el sistema operativo para verificar que lo que propone funciona de verdad.

El cambio de enfoque en la ingeniería de software

La posibilidad de construir prototipos móviles rápidos y delegar la compilación a agentes inteligentes reduce el coste de experimentar. Cualquiera con una buena idea de diseño o un flujo lógico definido puede plasmar una app móvil en minutos.

Pero esto no significa la desaparición del perfil técnico. Al contrario, las responsabilidades se desplazan hacia tareas de mayor abstracción: diseñar flujos de datos limpios, establecer políticas de gobierno y guardrails de seguridad, supervisar que los agentes no introduzcan dependencias obsoletas y estructurar arquitecturas generales. El código repetitivo e instrumental pasa a segundo plano; el diseño arquitectónico y el control de calidad se convierten en el verdadero cuello de botella.