Forem: Google AI

Agent Factory Recap: Supercharging Agents on GKE with Agent Sandbox and Pod Snapshots

Shir Meir Lador — Tue, 07 Apr 2026 13:04:00 +0000

In the latest episode of the Agent Factory, Mofi Rahman and I had the pleasure of hosting, Brandon Royal, the PM working on agentic workloads on GKE. We dove deep into the critical questions around the nuances of choosing the right agent runtime, the power of GKE for agents, and the essential security measures needed for intelligent agents to run code.

This post guides you through the key ideas from our conversation. Use it to quickly recap topics or dive deeper into specific segments with links and timestamps.

Why GKE for Agents?

Timestamp: 01:49

We kicked off our discussion by tackling a fundamental question: why choose GKE as your agent runtime when serverless options like Cloud Run or fully managed solutions like Agent Engine exist?

Brandon explained that the decision often boils down to control versus convenience. While serverless options are perfectly adequate for basic agents, the flexibility and governance capabilities of Kubernetes and GKE become indispensable in high-scale scenarios involving hundreds or thousands of agents. GKE truly shines when you need granular control over your agent deployments.

ADK on GKE

Timestamp: 06:58

We've discussed the Agent Development Kit (ADK) in previous episodes, and Mofi highlighted to us how seamlessly it integrates with GKE and even showed a demo with the agent he built. ADK provides the framework for building the agent's logic, traces, and tools, while GKE provides the robust hosting environment. You can containerize your ADK agent, push it to Google Artifact Registry, and deploy it to GKE in minutes, transforming a local prototype into a globally accessible service.

The Sandbox problem

Timestamp: 15:20

As agents become more sophisticated and capable of writing and executing code, a critical security concern emerges: the risk of untrusted, LLM-generated code. Brandon emphasized that while code execution is vital for high-performance agents and deterministic behavior, it also introduces significant risks in multi-tenant systems. This led us to the concept of a "sandbox."

What is a Sandbox?

Timestamp: 19:18

For those less familiar with security engineering, Brandon clarified that a sandbox provides kernel and network isolation. Mofi further elaborated, explaining that agents often need to execute scripts (e.g., Python for data analysis). Without a sandbox, a hallucinating or prompt-injected model could potentially delete databases or steal secrets if allowed to run code directly on the main server. A sandbox creates a safe, isolated environment where such code can run without harming other systems.

Agent Sandbox on GKE Demo

Timestamp: 20:25

So, how do we build this "high fence" on Kubernetes? Brandon introduced the Agent Sandbox on Kubernetes, which leverages technologies like gVisor, an application kernel sandbox. When an agent needs to execute code, GKE dynamically provisions a completely isolated pod. This pod operates with its own kernel, network, and file system, effectively trapping any malicious code within the gVisor bubble.

Mofi walked us through a compelling demo of the Agent Sandbox in action.We observed an ADK agent being given a task requiring code execution. As the agent initiated code execution, GKE dynamically provisioned a new pod, visibly labeled as "sandbox-executor," demonstrating the real-time isolation. Brandon highlighted that this pod is configured with strict network policies, further enhancing security.

The Future: Pod Snapshots

Timestamp: 29:39

While the Agent Sandbox offers incredible security, the latency of spinning up a new pod for every task is a concern. Mofi demoed the game-changing solution: Pod Snapshots. This technology allows us to save their state of running sandboxes and then near-instantly restore them when an agent needs them. Brandon noted that this reduces startup times from minutes to seconds, revolutionizing real-time agentic workflows on GKE.

Conclusion

It's incredible to see how GKE isn't just hosting agents; it's actively protecting them and making them faster.

Your turn to build

Ready to put these concepts into practice? Dive into the full episode to see the demos in action and explore how GKE can supercharge your agentic workloads.

Learn how to deploy an ADK agent to Google Kubernetes Engine and how to get your run agent to run code safely using the GKE agent Sandbox.

Connect with us

Shir Meir Lador → LinkedIn, X
Mofi Rahman → LinkedIn
Brandon Royal → LinkedIn

Hacking with multimodal Gemma 4 in AI Studio

Paige Bailey — Sat, 04 Apr 2026 03:30:29 +0000

We’re in an incredibly fun era for building. The friction between "I have a weird idea" and "I have a working prototype" is basically zero, especially with the release of Gemma 4, which is now available via the Gemini API and Google AI Studio.

Whether you want to deeply inspect model reasoning or you're just trying to build a pipeline to auto-caption an archive of historical web comics and obscure wiki trivia, you can now hit open-weights models directly from your code without needing to provision a massive GPU rig first.

Here’s a look at the architecture, how to use it, and how to go from the UI to production code in one click.

The Models: Apache 2.0, MoE, and 256k Context

Before we look at the API, the biggest detail about Gemma 4 is the license: it's released under Apache 2.0. This means total developer flexibility and commercial permissiveness. You can prototype with the Gemini API, and eventually run it anywhere from a local rig to your own cloud infrastructure.

The benchmarks are also genuinely impressive. The 31B model is currently sitting at #3 on the Arena AI text leaderboard, out-competing models massively larger than it.

When you drop into Google AI Studio, you'll see two primary models in the picker:

Gemma 4 31B IT: The flagship dense model. It has a massive 256K context window — perfect for dumping in entire codebases, massive log files, or huge JSON datasets.
Gemma 4 26B A4B IT: A Mixture-of-Experts (MoE) architecture. It's highly efficient, only activating roughly 4 billion parameters per inference. High throughput, lower cost.

(Note: There are also E2B and E4B "Edge" models meant for local on-device deployment that feature native audio input, but we're focusing on the AI Studio API today. I recommend that you go download and test the smaller models locally, though!)

Multimodal Inputs + Chain of Thought

Text is great, but Gemma 4 is natively multimodal. Let's say you want to build a pipeline to reverse-engineer prompts from a folder of distinct images.

In AI Studio, you can drop images directly into the playground alongside your prompt.

The Prompt:

"Generate descriptions of each of these images, and a prompt that I could give to an image generation model to replicate each one."

Because the Gemma models support advanced reasoning, after you click Run, you can click the Thoughts toggle to literally step through the model's chain-of-thought process before it generates its final output.

If you love understanding the "why" behind model logic, or you're trying to debug why an agent went off the rails, this level of transparency is incredibly useful.

Shipping the code

The bridge between "playing around in a UI" and "writing a script" should be exactly one click. Once you have your prompt, your images, and your reasoning configuration dialed in perfectly, click the Get Code button in the top right corner.

You can grab the exact payload required for TypeScript, Python, Go, or standard cURL. Best of all, if you toggle "Include prompt/history", it automatically handles the base64 encoding of your images and explicitly sets the thinkingConfig parameters in the code for you.

Here's what the TypeScript output looks like when you want to use Gemma 4's reasoning capabilities via the SDK:

import { GoogleGenAI } from '@google/genai';

// Initialize the client
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });

// Configure Gemma 4 reasoning logic
const config = {
  thinkingConfig: {
    thinkingLevel: 'HIGH',
  }
};

const response = await ai.models.generateContent({
  model: 'gemma-4-31b-it',
  contents: 'Tell me a fascinating, obscure story from internet history.',
  config: config
});

console.log(response.text);

Go build open-source things!

Having Apache 2.0 open-weights models accessible via a fast API completely changes the calculus for weekend projects. Whether you're building a script to summarize deeply technical whitepapers, analyze visual data natively, or wire up autonomous multi-step code generation agents—the friction is basically gone.

I can't wait to see what you build! Let me know in the comments what rabbit hole you're pointing Gemma at first. Happy hacking this weekend. :)

Agent Factory Recap: Reinforcement Learning and Fine-Tuning on TPUs

Shir Meir Lador — Tue, 31 Mar 2026 18:56:42 +0000

In our agent factory holiday special, Don McCasland and I were joined by Kyle Meggs, Senior Product Manager on the TPU Training Team at Google, to dive deep into the world of model fine tuning. We focused specifically on reinforcement learning (RL), and how Google's own infrastructure of TPUs are designed to power these massive workloads at scale.

This post guides you through the key ideas from our conversation. Use it to quickly recap topics or dive deeper into specific segments with links and timestamps.

When to Consider Fine-Tuning

Timestamp: 3:13

We started with a fundamental question: with foundational models like Gemini becoming so powerful out of the box, and customization through the prompt can often be good enough, when should you consider fine-tuning?

Fine tuning your own model is relevant when you need high specialization for unique datasets where a generalist model might not excel (such as in the medical domain), or when you have strict privacy restrictions that require hosting your own models trained on your data.

The Model Lifecycle: Pre-training and Post-training (SFT and RL)

Timestamp: 3:52

Kyle used a great analogy inspired by Andrej Karpathy to break down the stages of training. He described pre-training as "knowledge acquisition," similar to reading a chemistry textbook to learn how things work. Post-training is further split into Supervised Fine-Tuning (SFT), which is analogous to reading already-solved practice problems within the textbook chapter, and Reinforcement Learning (RL), which is like solving new practice problems without help and then checking your answers in the back of the book to measure yourself against an optimal approach and correct answers.

Why Reinforcement Learning (RL) is Essential

Timestamp: 5:50

We explored why RL is currently so important for building modern LLMs. Kyle explained that unlike SFT, which is about imitation, RL is about grading actions to drive "alignment." It’s crucial for teaching a model safety (penalizing what not to do), enabling the model to use tools like search and interact with the physical world through trial and error, and for performing verifiable tasks like math or coding by rewarding the entire chain of thought that leads to a correct answer.

The Agent Industry Pulse: Why 2025 is the year of RL

Timestamp: 8:33

In this segment, we looked at the rapidly evolving landscape of RL. Kyle noted that it is fair to call 2025 the "year of RL," highlighting the massive increase in investment and launches across the industry:

January: DeepSeek-R1 launched, making a huge splash with open-source GRPO.
Summer: xAI launched Grok 4, reportedly running a 200k GPU cluster for RL at "pre-training scale."
October: A slew of new tooling launches across Google, Meta, and TML.
November: Gemini 3 launched as a premier thinking model.
Recent: Google launched MaxText 2.0 for fine-tuning on TPUs.

The Hurdles of Implementing RL

Timestamp: 10:46

Following the industry trends, we discussed why RL is so difficult to implement. Kyle explained that RL combines the complexities of both training and inference into a single process. He outlined three primary challenges: managing infrastructure at the right balance and scale to avoid bottlenecks; choosing the right code, models, algorithms (like GRPO vs. DPO), and data; and finally, the difficulty of integrating disparate components for training, inference, orchestration, and weight synchronization.

To provide a solution across these dimensions of complexity, Google offers MaxText, a vertically integrated solution to help you perform RL in a highly scalable and performant fashion. MaxText provides highly optimized models, the latest post-training algorithms, high performance inference via LLM, and powerful scalability/flexibility via Pathways.

In contrast to DIY approaches where users assemble their own stack of disparate components from many different providers, Google’s approach offers a single integrated stack of co-designed components, from silicon to software to solutions.

The Factory Floor

The Factory Floor is our segment for getting hands-on. Here, we moved from high-level concepts to practical code with a live demo.

Why TPUs Shine for RL

Timestamp: 12:52

Before diving into the demo, Kyle explained why TPUs are uniquely suited for complex AI workloads like RL. Unlike other hardware, TPUs were designed system-first. A TPU Pod can connect up to 9,216 chips over low-latency interconnects, allowing for massive scale without relying on standard data center networks. This is a huge advantage for overcoming RL bottlenecks like weight synchronization. Furthermore, because they are purpose-built for AI, they offer superior price-performance and thermal efficiency.

Demo: Reinforcement Learning (GRPO) with TPU

Timestamp: 15:53

Don led a hands-on demonstration showing what RL looks like in action using Google's infrastructure. The demo showcased:

Using MaxText 2.0 as an integrated solution for the workload.
Leveraging models from MaxText and algorithms from Tunix.
Handling inference using vLLM.
Utilizing Pathways for orchestration and scaling to run GRPO (Group Relative Policy Optimization).

Conclusion

This holiday special was a great deep dive into the cutting edge of model fine tuning. While foundational models are getting better every day, the future of highly specialized, capable agents relies on mastering post-training techniques like RL, and having the right vertically integrated infrastructure, like TPUs, to run them efficiently.

Your turn to build

We hope this episode gave you valuable tools and perspectives to think about fine-tuning your own specialized agents. Be sure to check out the resources below to explore MaxText 2.0 and start experimenting with TPUs for your workloads. We'll see you next year for a revamped season of The Agent Factory!

Resources

Post-Training Docs https://maxtext.readthedocs.io/en/latest/tutorials/post_training_index.html

Google Cloud TPU (Ironwood) Documentation: https://docs.cloud.google.com/tpu/docs/tpu7x
Google Cloud open source code:
- MaxText - https://github.com/AI-Hypercomputer/maxtext
- GPU recipes - https://github.com/AI-Hypercomputer/gpu-recipes
- TPU recipes - https://github.com/AI-Hypercomputer/tpu-recipes
Andrej Karpathy - Chemistry Analogy: Deep Dive into LLMs like ChatGPT
Paper: "Small Language Models are the Future of Agentic AI" (Nvidia): https://arxiv.org/abs/2506.02153
Fine tuning blog: https://cloud.google.com/blog/topics/developers-practitioners/a-step-by-step-guide-to-fine-tuning-medgemma-for-breast-tumor-classification?e=48754805

Connect with us

Shir Meir Lador → https://www.linkedin.com/in/shirmeirlador/, X
Don McCasland → https://www.linkedin.com/in/donald-mccasland/
Kyle Meggs → https://www.linkedin.com/in/kyle-meggs/

Cloud Run Jobs vs. Cloud Batch: Choosing Your Engine for Run-to-Completion Workloads

Maciej Strzelczyk — Tue, 31 Mar 2026 12:19:29 +0000

Google Cloud offers plenty of different products and services, some of which seem to be covering overlapping needs. There are multiple storage solutions (Cloud Storage, Filestore), database products (Cloud SQL, Spanner, BigQuery) or ways to run containerized applications (Cloud Run and GKE). The breadth of options to choose from can be overwhelming and lead to situations where it’s not obvious which way to go to achieve your goal.

Similar situation applies to offline processing (aka batch processing). This is a situation where you have some data and want to run the same operation on each piece of this data. For example: transcoding a big video collection, resizing an image gallery or running inference against a prepared set of prompts. The recommended way to handle such situations is to use proper tools that will automatically scale, handle errors and guarantee that all data has been processed.

Cloud Batch and Cloud Run Jobs are two of the options to consider when you want to handle an offline processing task. In this article, I’ll explain what those two products have in common and what are their main differences. We will finish with a couple of examples showing when to best use each of these products.

The Similarities

Cloud Batch and Cloud Run Jobs are fundamentally aligned in their purpose and share many core features, making them both excellent choices for asynchronous, run-to-completion tasks like data conversion, media processing, and offline processing.

Both services allow you to run your code in standard Open Container Initiative (OCI) images, completely abstracting away the operational headache of managing permanent clusters. They share critical ecosystem features: both can be triggered for periodic execution using Cloud Scheduler and orchestrated into complex, multi-step data pipelines via Cloud Workflows.

Security is standardized, with both offering native integration with Secret Manager to keep credentials safe, and both fully supporting VPC Service Controls (VPC-SC) to define security perimeters.

Furthermore, the services are designed for workload portability through a compatible task indexing system; both inject environment variables like CLOUD_RUN_TASK_INDEX and BATCH_TASK_INDEX to partition data across parallel tasks. This engineering choice allows container images optimized for Cloud Run to be seamlessly migrated and executed on Cloud Batch.

Finally, both offer native support for mounting Google Cloud Storage buckets (using Cloud Storage FUSE) and NFS network shares to efficiently handle large-scale data ingestion and output.

The Differences

Core Architectural Paradigms

The fundamental choice between Cloud Run Jobs and Google Cloud Batch often comes down to the desired level of abstraction versus the required level of infrastructure control. Cloud Run Jobs represents the serverless ideal, prioritizing developer velocity and rapid scaling by entirely abstracting the underlying hardware platform. In contrast, Google Cloud Batch operates as a highly configurable orchestration layer sitting directly atop Compute Engine, granting granular control over virtual machine (VM) shapes and deep hardware integrations.

GPU Ecosystem and Support

Cloud Run Jobs supports a curated, fully managed GPU experience optimized for inference and video transcoding, though it strictly enforces a limit of one GPU per instance and a 1-hour maximum timeout for GPU-based tasks. Google Cloud Batch unlocks the entire Compute Engine accelerator portfolio, allowing users to attach multiple GPUs (up to 8 per VM) and supporting multi-day training runs with advanced interconnects like NVLink.

Task Communication

The architectural divergence between the two services is further highlighted by their approach to inter-task communication. Cloud Run Jobs operates on a "shared nothing" architecture, where parallel tasks are entirely isolated and possess no native mechanism to communicate with one another directly. This is in stark contrast to Google Cloud Batch, which is specifically engineered to support "tightly coupled" workloads, such as multi-physics simulations or complex weather forecasting. Batch facilitates high-performance communication by supporting Message Passing Interface (MPI) libraries and provisioning compute clusters with Cloud RDMA (Remote Direct Memory Access) technology. This allows nodes to exchange state data with ultra-low latency and high bandwidth, making Batch the requisite choice for sophisticated high-performance computing (HPC) scenarios.

Financial Models and Billing

Cloud Run Jobs utilizes instance-based billing, measured in 100-millisecond increments with a generous recurring free tier for vCPU and memory. Google Cloud Batch has no base service fee; users are billed strictly for the underlying Compute Engine infrastructure consumed. Batch offers significant financial leverage through Spot VMs, providing big discounts for fault-tolerant workloads.

Constraints, Limits, and Maximum Scalability

The fundamental difference in architecture directly impacts the scale, concurrency, and duration of workloads each service can handle. Cloud Run Jobs is optimized for relatively bounded workloads, while Google Cloud Batch is engineered for massive, unbounded computational scale.

Execution and Task Limits

A single Cloud Run job is limited to a maximum of 10,000 independent tasks per execution. The maximum execution length for a standard CPU-based task is 168 hours (7 days), but any task utilizing a GPU is severely restricted to a 1-hour maximum timeout. Fault tolerance allows up to 10 retries per failed task.

Google Cloud Batch is built for a significantly larger scale. A single job definition can encompass up to 100,000 tasks within a task group and supports executing up to 5,000 of these tasks in parallel. Execution duration is highly permissive; a Batch task can remain in the RUNNING state for up to 14 days by default. This extended timeout applies even to GPU-based tasks, making Batch mandatory for multi-day distributed training runs.

Specification	Cloud Run Jobs	Google Cloud Batch
Max Tasks Per Job	10,000	100,000
Max Parallel Tasks	Regional Quota Dependent	5,000
Max CPU Task Timeout	168 Hours (7 Days)	14 Days (Default limit)
Max GPU Task Timeout	1 Hour	14 Days (Default limit)
Max Retries Per Task	10	Configurable
Max Concurrent VMs	N/A (Serverless)	2,000 (single-zone) or 4,000 (multi-zone)

Use Case Examples

Example 1: Administrative Automation and Nightly ETL

Recommended Service: Cloud Run Jobs

Scenario: A SaaS platform must execute a nightly script to migrate localized data into a central BigQuery warehouse, generate daily PDF invoices for thousands of clients, and perform routine database schema migrations.

Justification: These tasks are typically I/O bound, complete within a few minutes or hours (well under the 168-hour limit), and do not require specialized CPU instruction sets. Cloud Run Jobs excels here because it requires zero infrastructure scaffolding; the team simply containerised scripts and schedules them via Cloud Scheduler.

Example 2: Massively Parallel Document and Media Processing

Recommended Service: Cloud Run Jobs (with GPU if visual processing is required)

Scenario: A media or e-commerce company must process thousands of user-uploaded videos or images daily, requiring video transcoding via FFmpeg or lightweight AI inference (e.g., YOLO object detection).

Justification: This represents an extremely parallel problem where each file can be processed independently using the task index to assign files. Cloud Run can spin up hundreds of L4-backed containers in seconds and scale to zero immediately upon completion.

Example 3: High-Performance Computing (HPC) and Multi-Physics Simulation

Recommended Service: Google Cloud Batch

Scenario: A climate research institute runs physics-based simulations for weather forecasting, or a pharmaceutical company performs massive simulations for drug discovery.

Justification: These are "tightly coupled" workloads where parallel processes must exchange state data. Batch is mandatory as it supports MPI configurations and Cloud RDMA for ultra-low latency inter-node communication.

Example 4: Distributed Machine Learning Training

Recommended Service: Google Cloud Batch

Scenario: An AI laboratory pre-training a 70-billion parameter model or performing extensive fine-tuning across terabytes of data over several days.

Justification: Cloud Run Jobs is disqualified due to the 1-hour GPU timeout and 1-GPU-per-instance limit. Batch allows provisioning A3 or A4 machine series with up to 8 GPUs per VM interconnected via NVLink for multi-day training runs.

Happy Processing!

I hope this article has helped you better understand the difference between Cloud Batch and Cloud Run Jobs - the two products designed for processing tasks to completion. Lightweight Cloud Run containers and heavy-duty Cloud Batch machines will definitely help you with all the computations tasks you may have. Try them out by creating a Cloud Run Job (code lab) or by scheduling a Cloud Batch job!

To stay up to date with all that's happening in the Google Cloud world keep an eye on Google Cloud blog and Google Cloud YouTube channel to not miss any updates!

Take your vibe coding to the next level

Martin Omander — Thu, 26 Mar 2026 16:11:25 +0000

If you’ve been following this series, you know that Cloud Run makes deployment easy and AI tools make development fast. But there is a new frontier in software engineering that combines both into a single, fluid experience: Vibe coding.

Vibe coding isn’t about being "lazy"; it’s about operating at a higher level of abstraction. It’s the ability to stay in a "flow state" where you describe your vision, and the AI handles the syntax, the boilerplate, and the deployment architecture on Cloud Run. In this final part, we look at how to master this high-velocity workflow without losing the "pro" edge.

Turn your ideas into a PRD

This video demonstrates generating user personas, core features, and success metrics, and then scaffolding an app structure to deploy on Cloud Run.

Architect your startup strategy

Learn how to generate a "best practices.md" file that covers stateful containers, structured logging, and CI/CD rules for your Cloud Run deployments.

Build and deploy production-ready features

Watch a production-ready API feature be built and deployed in under a minute using the Gemini CLI.

Vibe debugging

See how the AI can read production logs, identify a null pointer exception, and write a fix so you can get your app back online quickly.

Get started today!

The cloud is no longer a place you "send" your code; it’s an extension of your development environment. By mastering these workflows, you aren't just a developer—you're an architect of the future.

Build real-time conversational agents with Gemini 3.1 Flash Live

Thor 雷神 Schaeff — Thu, 26 Mar 2026 15:25:51 +0000

Today, we’re launching Gemini 3.1 Flash Live via the Gemini Live API in Google AI Studio. Gemini 3.1 Flash Live helps enable developers to build real-time voice and vision agents that can not only process the world around them, but also respond at the speed of conversation.

This is a step change in latency, reliability and more natural-sounding dialogue, delivering the quality needed for the next generation of voice-first AI.

Experience enhanced latency, reliability and quality

For real-time interactions, every millisecond of latency strips away the natural flow of the conversation that users expect. The new model better understands tone, emphasis and intent, enabling agents with key improvements:

Higher task completion rates in noisy, real-world environments: We’ve significantly improved the model’s ability to trigger external tools and deliver information during live conversations. By better discerning relevant speech from environmental sounds like traffic or television, the model more effectively filters out background noise to remain reliable and responsive to instructions.
Better instruction-following: Adherence to complex system instructions has been boosted significantly. Your agent will stay within its operational guardrails, even when conversations take unexpected turns.
More natural and low-latency dialogue: The latest model improves on latency and is even more effective at recognizing acoustic nuances like pitch and pace compared to 2.5 Flash Native Audio, making real-time conversations feel a lot more fluid and natural.
Multi-lingual capabilities: The model supports more than 90 languages for real-time multi-modal conversations.

Build with an expanding ecosystem of integrations

The Live API is built for production environments, but real-world systems require handling of diverse inputs, from live video streams to on-demand phone calls.

For systems that require WebRTC scaling or global edge routing, we recommend exploring our partner integrations to streamline the development of real-time voice and video agents.

LiveKit — Use the Gemini Live API with LiveKit Agents.
Pipecat by Daily — Create a real-time AI chatbot using Gemini Live and Pipecat.
Fishjam by Software Mansion — Create live video and audio streaming applications with Fishjam.
Vision Agents by Stream — Build real-time voice and video AI applications with Vision Agents.
Voximplant — Connect inbound and outbound calls to Live API with Voximplant.
Firebase AI SDK — Get started with the Gemini Live API using Firebase AI Logic.

Get started with the Live API

Gemini 3.1 Flash Live is available starting today via the Gemini API and in Google AI Studio. Developers can use the Gemini Live API to integrate the model into their application.

Explore our developer documentation to learn how you can build real-time agents:

Gemini Live API documentation: Explore features like multilingual support, tool use and function calling, session management (for managing long running conversations) and ephemeral tokens.
Gemini Live API examples: Get inspiration for the kind of voice experiences you can build today with the model.
Gemini Live API Skill: For coding agents to learn and build with the Live API.

Get started with the Google GenAI SDK:

import asyncio
from google import genai

client = genai.Client(api_key="YOUR_API_KEY")

model = "gemini-3.1-flash-live-preview"
config = {"response_modalities": ["AUDIO"]}

async def main():
    async with client.aio.live.connect(model=model, config=config) as session:
        print("Session started")
        # Send content...

if __name__ == "__main__":
    asyncio.run(main())

Vandalizing My Own Wikipedia Experience: A 90s Cyberpunk GeoCities Makeover

Paige Bailey — Fri, 20 Mar 2026 15:44:30 +0000

Wikipedia is a marvel. It is the Library of Alexandria of our time, a meticulously curated repository of human knowledge, wrapped in a user interface so ruthlessly utilitarian it makes a hospital corridor look like a rave.

But sometimes, when I am deep in a Wikipedia rabbit hole reading about List of animals with fraudulent diplomas at 2:00 AM, the sterile white background feels... insufficient. I don't want brutalist minimalism. I want the web the way the ancients intended: dripping in neon pink, plastered in Comic Sans, and crawling with pixelated cats.

So, I decided to write a custom Wikipedia User Script to turn the site into a 1998 GeoCities cyberpunk fever dream.

Instead of writing this from scratch, I wanted to see how well modern LLMs could handle writing niche MediaWiki API scripts. Here is a field report on how I built this abomination using Gemini 3.1 Pro Preview.

Grounding Gemini with Wikipedia-specific syntax

LLMs are great at writing vanilla JavaScript, but Wikipedia user scripts rely on specific, slightly archaic MediaWiki globals (like mw.loader.using and mw.util.addCSS). If you just blindly ask an LLM to "make Wikipedia pink," it usually hallucinates browser extensions or generic Tampermonkey scripts.

To bypass this, I jumped into Google AI Studio and loaded up the Gemini 3.1 Pro Preview model.

The secret sauce here was using the URL Context feature. I toggled URL Context on and pasted in the URL for Wikipedia's custom scripting documentation:
https://en.wikipedia.org/wiki/Wikipedia:User_scripts

My prompt was simple but unhinged:

"Using the provided documentation on Wikipedia User Scripts, write a script for my Special:MyPage/common.js that makes my Wikipedia viewing experience look like a 90s cyberpunk GeoCities page. I want a pink/cyan grid background, glowing Comic Sans headers, a massive scrolling <marquee> for the article title, a giant glowing sparkle mouse trail, and a squad of animated cats walking across the top of my screen."

Because Gemini 3.1 Pro Preview had the actual documentation in its context window, it knew exactly how to inject CSS securely via MediaWiki's utility functions, and it gave me a plug-and-play script.

Breaking down the script

The resulting script is a beautiful combination of modern DOM manipulation and deeply offensive 90s aesthetics.

1. The Marquee Title

If we are going to read about the Emu War, that title needs to move. The script grabs the #firstHeading element and violently wraps its inner HTML in a <marquee> tag.

var $title = $('#firstHeading');
var titleText = $title.html();
$title.html('<marquee scrollamount="15" behavior="alternate">' + titleText + '</marquee>');

Note: The fact that modern browsers in 2026 still parse and execute the <marquee> tag is a testament to the web’s unbreakable backwards compatibility. It is the digital equivalent of a vestigial tail.

2. The Sparkle Trail (A Lesson in Throttling)

To create the mouse trail, the script listens to the mousemove event and appends absolutely-positioned <span> elements containing cyberpunk symbols (✦, ★, ✨) to the DOM.

To prevent this from immediately melting my GPU (a very real threat when generating hundreds of DOM nodes a second), the model smartly implemented a timestamp throttle:

var now = Date.now();
if (now - lastSparkleTime < 40) return; // Only spawn a sparkle every 40ms
lastSparkleTime = now;

It then applies a CSS @keyframes animation to each sparkle so they slowly drift downward, rotate 180 degrees, and fade to opacity: 0 before being garbage-collected by a setTimeout a second later.

3. The Mathematics of Walking Cats

Instead of using a clunky JS setInterval to move the cats, Gemini 3.1 leaned into pure, hardware-accelerated CSS animations.

It created a fixed header container (pointer-events: none so I can still click the search bar through the cats' ethereal bodies). Then, it applied two separate animations.

The first animation slides the whole squad from 100vw (off-screen right) to -100% (off-screen left).

The second animation creates the "walking" illusion. If you think about the geometry of a walking pixel cat, it's essentially a sine wave. To achieve this, the script applies a 10px vertical bounce to each cat (transform: translateY(-10px)).

To make it look like a chaotic squad rather than a synchronized military parade, the script uses the nth-child(even) pseudo-class to offset the animation delay of every other cat:

.walking-cat {
    animation: catBounce 0.4s alternate infinite ease-in-out;
}
.walking-cat:nth-child(even) {
    animation-delay: 0.2s; /* Phase offset for the bounce! */
}

We are essentially phase-shifting the vertical oscillation of our felines to simulate independent locomotion.

The final results

I pasted the code into my Special:MyPage/common.js, hit publish, and bypassed my cache.

The result is staggering.

I am currently reading the deeply serious, heavily cited Wikipedia article for Maximilien Robespierre. The background is a dark void overlaid with a neon pink laser grid. The header "MAXIMILIEN ROBESPIERRE" is glowing in hot pink Comic Sans, aggressively bouncing off the edges of my monitor.

// Detect dark theme var iframe = document.getElementById('tweet-2035009322531660256-82'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2035009322531660256&theme=dark" }

Every time I move my mouse to hover over a citation, a massive explosion of 45-pixel-wide cyan stars erupts across the text. And above it all, a squad of five neon cats marches endlessly toward the left side of my screen, oblivious to the Reign of Terror occurring in the text below them.

It is awful. I am never turning it off.

If you want to ruin your own Wikipedia experience, you can find the complete script in the replies below. Just remember to log in, navigate to Special:MyPage/common.js and Special:MyPage/common.css, and let the 90s flow through you.

My First Experience Creating Antigravity Skills

Shir Meir Lador — Fri, 20 Mar 2026 15:23:02 +0000

Experimenting with Agent skills for the first time, feeling empowered!

Last week, I was at an event where we taught developers how to build MCP servers, agents, and deploy open models to Google Cloud Run. After the session, one of the developers shared something that really stuck with me: he was already using our content to create specialized Skills to share with his entire team.

I got inspired and decided it was time to dive into Agent Skills. During my last project, the dev-signal agent, I had a lot of learnings about how to bring agents and AI applications to production in a robust and scalable manner. I thought, this is a great opportunity to give my favorite coding agent, Google’s Antigravity (Google’s “agent-first” IDE), those skills so that going forward, it will just do it for me!

In this post, I’ll walk through how I built the 13 production skills in this repository and the patterns behind them.

What are Agent Skills?

As Romin Irani explains in “Getting Started with Google Antigravity Skills”, skills represent a shift from monolithic context loading to Progressive Disclosure.

Agents get “overwhelmed” when providing them too many tools all at once (a phenomenon known as “Tool Bloat”), to solve for that, Skills allow the agent to “load” specialist knowledge only when needed. When you ask an agent to “evaluate a shadow revision,” it will figure out it will need to leverage the Shadow Deployer skill as context for this operation.

Workspace vs. Global Scope

In Antigravity, you can manage these skills in two distinct ways depending on how you want to use them:

Workspace Scope: Located in .agent/skills/ within your project root. These are specific to your project and can be committed to GitHub so your entire team can benefit from the same production patterns.
Global Scope: Located in ~/.gemini/antigravity/skills/. These are your personal utilities that stay with you across every project you work on.

How I built the skills

Following the principles in Daniela Petruzalek’s “Building Agent Skills with skill-creator”, I took a “methodology-first” approach. I used the existing dev-signal blog series I’ve been working on and the codebase itself as core context, asking Antigravity to identify and codify the unique skills needed to build a production agent on Google Cloud.

For some of the more specialized areas, I provided additional context with patterns I’d like to follow, such as the agent evaluation codelab and blog and the agent security codelab, both written by my awesome team.

These 13 skills provide Antigravity (or any developer using them) the crucial toolkit of a Google Cloud Production Engineer. I’m currently finalizing a detailed, step-by-step walkthrough of the dev-signal agent which will be published on the Google Cloud Blog very soon! (follow me for future updates)

In the meantime, you don’t have to wait — the full repository and the skills are available for you to explore and leverage in your own projects today.

Here is the full inventory of the skills:

🏗️ Production Agent

adk-memory-bank-initializer: Long-term state logic with Vertex AI Memory Bank.
agent-containerizer: Mixed-runtime Dockerfiles (Python + Node.js).
cloud-run-agent-architect: Least-privilege Terraform for Cloud Run.
gcp-production-secret-handler: In-memory secret fetching pattern (Secret Manager).
mcp-connector-generator: Standardized MCP connection logic.

📊 Evaluation

gcp-agent-eval-engine-runner: Parallel inference and reasoning trace capture.
gcp-agent-eval-metric-configurator: Setup for Grounding and Tool Use rubrics.
gcp-agent-golden-dataset-builder: Tools for building datasets with reference trajectories.
gcp-agent-shadow-deployer: “Dark Canary” deployment scripts with revision tagging.
gcp-agent-tool-trajectory-evaluator: Custom Python metrics for Precision and Recall.

🛡️ Security

gcp-agent-model-armor-shield: Intelligent firewall (Prompt Injection, RAI, Malicious URL filters).
gcp-agent-safety-gatekeeper: Python integration pattern (safety_util.py) for sanitizing user inputs.
gcp-agent-sdp-template-factory: Terraform for Sensitive Data Protection (PII/Secret redaction).

By codifying these patterns to production skills, Antigravity can now leverage these automatically in my day to day development. I hope you find these as helpful as I do!

Pro tip - self improving skills!

Because these skills were AI-generated, they might not work perfectly for your specific environment on the first try. But that’s actually the best part of working with an agentic IDE. If a skill doesn’t work well for you, don’t just manually fix the code, let the coding agent figure it out. Once it finds the solution, you can ask it to update the corresponding SKILL.md with the learned workflow. This will capture the corrected workflow for the future, ensuring the agent doesn’t repeat the mistake while saving you tokens and time on the next run. Think of these as living documents that actively improve as you build.

Ready to get started? Clone the repository and add these skills to your Workspace or Global Scope to start building your own production-ready agents. Learn more about Agent skills.

Follow me on LinkedIn and X for updates on my next blogs and videos.

Unlocking Gemini CLI with Skills, Hooks & Plan Mode

Greg Baugues — Fri, 20 Mar 2026 13:00:00 +0000

In Unlocking Gemini CLI with Skills, Hooks & Plan Mode, we moved past the basics and into the "power user" features of Gemini CLI.

I was joined by Jack Wotherspoon from the Gemini CLI team to show how developers can exert more control over their AI agents and handle complex, multi-step projects with confidence.
From a 20-minute app build to the introduction of a "read-only" research mode, this episode was packed with tools designed to bridge the gap between AI autonomy and developer intent.

The 20-minute build: From idea to deployment

To set the stage, Jack showcased Memory Wall, a digital bulletin board built using React, Three.js, and Firebase. The kicker? It took only 20 minutes to go from a blank slate to a live-deployed application.

This served as the playground for the day's deep dives:

1. Deterministic control with hooks

One of the biggest hurdles with AI agents is their non-deterministic nature. Hooks change that. They are scripts that run at specific lifecycle points—like at session start or before a tool call.

The "dev server" hook: Jack demonstrated a hook that checks if a local dev server is running on startup. If not, Gemini CLI alerts the user and offers to start it.
Safety first: You can use hooks to run linters or "security guards" that prevent the AI from writing messy code or deleting sensitive files.

Pro tip: Use the new Background Tasks feature (Control + B) to keep your dev servers running in the terminal without blocking your conversation with Gemini.

2. "Expert Hats": These specialized skills help to refine the behavior of these tools

If you’ve ever worried about "context bloat"—where an AI gets confused by too much information—skills are your solution. Jack described these as "library books on a shelf."

Progressive disclosure: Instead of loading every best practice into every prompt, Skills load specialized knowledge (like Three.js expertise or documentation style guides) only when they are triggered
The skill creator: Gemini CLI now has a built-in skill to help you build skills. Just ask: "Create a docs-writer skill for this project," and the CLI will walk you through a setup interview.

3. The "Ask User" tool

Gone are the days of the CLI just guessing what you want. With the new Ask User tool, Gemini CLI can pause and present interactive dialogues, multiple-choice questions, and yes/no prompts. This ensures the agent is aligned with your vision before it touches a single line of code.

4. Look before you leap with Plan Mode (preview)

Perhaps the most anticipated feature is Plan Mode, currently in preview. It transforms Gemini CLI into a read-only researcher.

Research first: In Plan Mode, the agent explores your codebase and external docs to create a structured "battle plan."
User approval: It presents this plan to you for feedback. Only once you give the "green light" does it switch to execution mode to start editing files.

Ready to dive deeper?

Watch: Missed the live demo? Catch the full replay here.

Learn: Take the free DeepLearning.ai course to get hands-on and learn more.
Contribute: Gemini CLI is open-source! Check out the "Help Wanted" labels on GitHub.

Introducing the new full-stack vibe coding experience in Google AI Studio

Kat Kampf — Thu, 19 Mar 2026 18:12:23 +0000

Start building real apps for the modern web with the Antigravity coding agent along with Firebase backend integrations, now in Google AI Studio.

Today, we are launching a completely upgraded vibe coding experience in Google AI Studio, designed to turn your prompts into production-ready applications. From multiplayer experiences and installing external libraries to ways to save your progress and log in securely, you can now build truly functional, AI-native applications without ever leaving the vibe coding experience.

We’re accelerating the path from prompt to production using the new Google Antigravity coding agent. To further support modern scalable applications, we are also enabling robust backends that bring secure storage and user authentication to your apps via a built-in Firebase integration.

Experience the difference, from prototypes to production apps

Here’s how the new updates help you build real apps:

Build multiplayer experiences: Create real-time multiplayer games, collaborative workspaces and shared tools that can connect users instantly.
Add databases and authentication: The agent now proactively detects when your app needs a database or login. After you approve a Firebase integration, it provisions Cloud Firestore for databases and Firebase Authentication for a secure sign-in with Google.
Create for the modern web: The agent now uses the vast ecosystem of modern web tools. If you want smooth animations or professional icons, the agent automatically figures out the right solution — like installing Framer Motion or Shadcn — to bring your vision to life.
Connect to real-world services: Turn prototypes into production-grade software by connecting to the services you already use. You can now bring your own API credentials to securely integrate services like databases, payment processors or Google services like Maps. The agent detects when a key is required and safely stores it in the new Secrets Manager located in the Settings tab.
Pick up where you left off: Access your data across devices and sessions. Close the browser tab and the app remembers where you left off so you can continue whenever you’re ready to come back.
Access a more powerful agent: Build complex apps using simpler prompts. The agent now maintains a deeper understanding of your entire project structure and chat history, enabling faster iteration and more precise multi-step code edits.
Build with Next.js: In addition to React and Angular, we now support Next.js apps out of the box. Select your framework in the updated “Settings” panel.

See the new agent in action with Build mode

Here are a few examples of what you can build today:

Real-time multiplayer games: You can now create a massive multiplayer first-person laser tag game in a retro style from just a prompt. Tag real life opponents or beat the AI bots to earn points on the leaderboard before time runs out and win.
Play or Remix Neon Arena in Google AI Studio. Real-time collaboration: Imagine prompting for a "multiplayer experience using 3D particles." The agent automatically sets up the real-time syncing logic, imports Three.js and creates a shared space where each person's cursor spawns 3D particles that flow with curl noise.
Play or Remix Cosmic Flow in Google AI Studio. Physics and game design: Create complex 3D interactions that adhere to real-world mechanics with ease. The new agent integrates claw machine physics, timers and a leaderboard importing Three.js for animations interactive 3D elements just by asking.
Play or Remix Neon Claw in Google AI Studio. Connect to the real world: Build apps that talk to the real world. Securely store your API credentials to fetch live data from Google Maps or send updates to a database, turning a concept into a utility.
Play or Remix GeoSeeker in Google AI Studio. Generate and Catalog Your Recipes: Organize and import recipes or generate new ones with Gemini. Collaborate with your friends and family to keep your culinary traditions alive.
Try or Remix Heirloom Recipes in Google AI Studio.

Start building today

This new experience in Google AI Studio has already been used internally to build hundreds of thousands of apps over the last few months. We’re working on more integrations, like Workspace to connect Drive and Sheets to your apps, plus the ability to take your app from Google AI Studio to Google Antigravity with a single button click.

Whether you are building your first app or have agents building while you do other things, we hope these updates help accelerate your path from idea to deployed, production-ready app. Head over to Google AI Studio to try the new experience today.

Vibe-coding in Google AI Studio: my tips to prompt better and create amazing apps

Guillaume Vernade — Thu, 19 Mar 2026 17:48:19 +0000

You might already know Google AI Studio as a sandbox to play with the Deepmind models and tinker with all their parameters. But did you know that you can also vibe-code webapps for free and publish them in a few clicks?

Its Build section is a game-changer for "vibe coding" and generating functional applications without writing a single line of code. It allows you to rapidly build and iterate on ideas using the power of Gemini models, moving from simple concepts to fully deployed prototypes in minutes.

Following my own experiments with the platform over the last year, this guide covers the core capabilities of AI Studio, how it compares to other tools, and how to prompt it effectively to build your apps.

Here's what you'll find in this article:

0. Why use AI Studio?
1. The App Gallery & Remixing
2. Get started with Vibe Coding
3. Create apps with databases
4. My tips to better Vibe Code
5. Publish your app
6. AI Studio vs. Antigravity: When to use which?
7. My favorite creations

0. Why use AI Studio? (Native Gemini and Privacy)

Before diving into the "how," let's address the most common question: Why use AI Studio over other popular AI app builders on the market?

The first reason is for AI Studio's native Gemini usage. It can create apps that are using the Gemini models, in a way that (as long as you stay in AI Studio) you don't have anything to set up so you, and the folks you're sharing your app with, can use the free tier and enjoy Gemini-powered apps for free.

Note: Some advanced models require a paid API key, but there's always an alternative with a free tier.

But the main differentiator is Privacy.

On the free tiers of many competing platforms, unless you're paying, all the applications you generate are public by default. Anyone can see what you are working on. On AI Studio, your apps remain strictly private. This is a huge advantage when you are prototyping personal ideas, working on sensitive client projects, or just want to experiment freely without worrying about public visibility.

Sharing uses the same system as any Google Drive file, which makes sharing your apps easy and lets people try them without having to create a new account.

Pro tip: As with any Drive file, you can set your apps to be accessible to whoever has the link. That's what I do when I post on LinkedIn (cf. the last section of this post for examples).

In any case, even if you don't use AI Studio, my tip should still be relevant as most vibe coding agents are working similarly.

1. The App Gallery & Remixing

If you are new to vibe coding, the best way to understand how the code is generated is to explore the App Gallery directly within AI Studio.

Best Practices:

Explore: Check out the impressive examples already built by the AI Studio team. Two of my personal favorites are the Spatial understanding and the Comic Book Creator (which need a paid API key to use Nano-banana Pro, but you can try remixing it to only use Nano-Banana's free tier).
Check the code: For each app, you can click "code" in the top left corner to access all of the app's code and check how things are done (or more likely copy-paste it to an AI coding agent).
Remix: When you like an app and just want to create your own flavor of it, click "remix" to create a copy of it that you'll own. It's an excellent way to start from an existing, working codebase and make it your own.

2. Get started with Vibe Coding

Ready to build your own? The principle is incredibly straightforward: open the build page, write what you want the app to do in a prompt, hit enter, and watch the coding agent (similar to the Antigravity one) generate the UI and logic.

Note: the generation can take quite some time (about 5 mins on average), so go get a coffee or read a blog post and come back after the coding agent has finished its job.

When you get a working app, you can start adding new features by continuing to prompt in the code assistant chatbox on the left.

New: One of the cool new additions in the past weeks is that the code assistant now works server-side, which means you can close the tab or change devices and it will continue to work for you.

Depending on the case, you can also use those two buttons to provide visual clues to the model by drawing things on it, which is very convenient to give UI feedback.

Another option is to dictate what changes you need. It's very convenient when you want to add a new feature on-the-fly while on your phone, but I would not recommend it for very precise updates.

3. Create apps with databases

Since this week, you can also ask the coding agent to create apps that can save things between sessions or users. You just need to ask it to specifically use a database:

(yes, I've been wanting to create my own grocery list app for a very long time)

Just click "Enable" when asked and the magic will happen.

What it will do behind the scenes is setting up the Firebase integration and a Firestore to store your data. It will also add authentication using a Google account to your app so it knows who's trying to access which data.

You don't need to know how your database is structured, the code agent will manage everything for you depending on what your app needs. You want each user to have their own grocery list? Boom, it's done! You now want them to be able to have shared lists, that's also done! Add labels to the items, easy peasy.

Your imagination is the limit!

4. My tips to better Vibe Code

Nowadays, "vibe coding" has become a reflex for me. It is the absolute best way to prototype a user experience before potentially moving to a complex IDE. But if you're not careful, you can easily end up losing a lot of time to make the agent work in an efficient way.

So here are my top tricks to get the most out of AI Studio (in no particular order).

Design your app before building it

If you have opinions about what your app should look like (personally I usually don't, yolo), a good idea is to iterate on designs for it using something like Stitch (that is using Nano-Banana) and give the images to the coding agent so it knows what's expected.

Save your progress so you can revert (and learn when to do it)

AI makes mistakes. It might misunderstand your prompt or write code that breaks a previously working app. When this happens, you can ask it to "fix the error" and most of the time it works, but sometimes it doesn't.

One very important skill to learn when vibe coding is when to try to fix things using AI, when to start anew, and when to go fix things yourself.

My personal advice is that if the agent can't figure out how to fix something after 2 rounds, stop insisting and go back to a previous version otherwise you might end up spending an hour arguing with the AI for nothing. And when you think you're spending as much time explaining what you want than to actually do it yourself (a good example is "change this time for another"), just do it yourself.

Thankfully AI Studio makes it easy for you to go back to a previous version:

Checkpoints

Checkpoints are the built-in version history to instantly revert to the last working state. They are the most convenient way to go back to a previous working version.

Warning: Just be careful of something: you can revert the code, but not the database changes, so don't load a checkpoint that was before a database update (what I would do is load the checkpoint, copy the code, load the more recent/broken code, ask the assistant to fix it based on how it was before).

Github

Github is what I would recommend to save milestone versions. You should use it to save the state of your app when you reach a certain milestone, like when you finish adding a new feature. You can enable it in a few clicks:

And then it will just be about describing your new feature and committing it to GitHub.

One current limitation though is that the sync is one-way, so it's a good way to save your status in a place where you can easily reuse it, but you can't update your code in GitHub and sync it to AI Studio (yet).

Use Multi-Modal Prompting

Stop relying purely on text. As I said before, AI studio gives you other options:

Voice: Incredibly practical for iterating quickly, especially if you are tweaking an app from your phone.
The "Annotate App" Tool: This is my absolute favorite feature for UI work. Take a screenshot of your app, draw directly on it ("Move this button here", "Remove this menu"), and send it.

Pro Tip: Always combine the annotated image with a clear text explanation to give the model maximum context.

Split Your Files! (Avoid the Monolith)

As your app grows, the model might start to "hallucinate", forget earlier features, or tangle the logic. This is almost always a structural issue.

By default, the AI tends to cram everything into one massive app.tsx file. Veto this immediately.

Golden Rule: Tell the model from the very beginning to separate features into distinct files and components.
Why? It drastically reduces errors and makes generation faster. It also allows you to instantly spot if the AI is messing up (e.g., If you ask for a UI color change and it starts rewriting auth-service.js, you know it lost the plot and you can stop it immediately). It will save you a lot of time when reviewing and at least gives you an at a glance confidence that the right part of the codebase was updated.

Force the AI to Write Documentation

To also help the AI remembering what the app is meant to do, have it maintain as much documentation as possible (from micro to macro):

Docstrings: Always forces the app to document all its functions, what they do, what the inputs and the outputs are.
File documentation: Since you're creating a file per feature, tell the AI to maintain some documentation at the top of them to detail what the feature is about, what use cases should be covered, etc.
Design.md: Finally, ask it to maintain a design doc of the whole app at the root of it.
Why? By having the AI repeat everything multiple times you both help it (and potentially yourself) find where everything is being done and what is the expected behavior. Kind of like how error correction codes work, having something written multiple times reduces the chances that they will be deleted by mistake.

Supercharge with System Instructions

After some time you'll realize that you're always giving the same instructions to the coding agent and will get tired of repeating yourself. That's why AI Studio allows you to customize the underlying "System Instructions." Don't leave this blank! You can define your preferred tech stack, frameworks, coding style, and of course everything I mentioned before!

Think of it as the onboarding package for your new junior developer, they need to know how you are expecting them to work, how to code, document, communicate, etc... You might not get it right the first time, but it's important to reflect on it and to keep on improving your package so that the next newcomers will be better onboarded and thus get productive faster.

Here's the ones I'm always using on top of more specialized instructions (like trusting me on model names and not changing them):

## Coding/documenting guidelines

* Create a file per feature or related features, split as much as possible in different files;
* add docstrings to all functions to explain what they do;
* start each file with a long comment explaining in detail what the feature is about and the different use cases;
* maintain a `Design.md` document at the root of the app that documents all the features of the app;
* log as info all function calls (with their parameters) and log all genai calls with all their parameters (model used, prompt, config) and their outputs, just strip inline data;
* group all configurable items (like model names) in a centralized file;
* always create a way to test the scripts without altering the data;

You'll see that I also added some instruction about logging (as it always help debugging) and dry run as these are both good practices, vibe coding or not.

Try them and tell me if that improved your vibe-coding experience!

5. Publish your app

You are now happy with your app and want to share it with the world (or maybe a subset of it), AI Studio offers you two ways of publishing your app:

Share it in AI Studio

The easiest way is to just use AI Studio sharing capability.

You can either decide to share the app with specific people or to make it available to whoever has its link (that's what I use on LinkedIn for ex.).

One of the key benefits is that they will also get access to the code and be able to Remix it if they want. But you can also send a link that opens the app full screen and hides the code agent to your less technical friends.

Another nice benefit is that if your app is using Gemini, your friends will use their free tier when using the app (or their API key if using a paid model), which means it won't cost you anything.

Publish the app on Cloud run

This is what you should do if you want to publish the app for real to actual users. In a few clicks it will create a cloud run container, publish the app online and give you a URL for anyone to access it.

You'll then be able to buy a domain and give it a proper URL, deploy in different regions, automatically scale, etc... But then you'll also be the one paying for usage as it's your own app now.

6. AI Studio vs. Antigravity: When to use which?

Since AI Studio uses a similar underlying coding agent as Google's Antigravity, you might be wondering when to use which tool. Here is my rule of thumb:

Use AI Studio when:

You are prototyping a front-end UI or a lightweight full-stack application.
You want to genuinely "vibe code" using multimodal inputs (like drawing directly on the app's UI or using your voice).
You want to instantly share a working prototype with stakeholders or friends via a simple link, without managing hosting.
You want zero-setup, native access to the Gemini models to build AI features quickly.

Use Antigravity when:

You are building a production-grade, complex application with deep backend infrastructure requirements.
You need fine-grained control over your dependencies, complex build steps, and deployment pipelines.
You are integrating the AI coding agent into an existing, large-scale codebase rather than starting a project from a blank slate.

Think of AI Studio as your creative sketchbook for rapid iteration, and Antigravity as your full-fledged developer workshop.

7. My favorite creations

Now that you have mastered the basics of vibe coding, the best way to learn is by doing. I didn't follow all these rules perfectly when I started, but making mistakes is how you refine your workflow!

To show you what's possible, here are a few applications I vibe-coded entirely from scratch using most of those methods:

[AI-powered resume]: An AI-powered resume. Don't just read it, but ask Gemini questions about me (it will know some anecdotes that are not written), tailor it according to the role you want to propose to me or even ask for an audio overview. Check it out here
[Talk coach]: A coach for your talks. Give it a recording or youtube link and it will tell you how to get even better. Check it out here
[FreshList]: A copy of the app I'm working on to simplify the groceries Check it out here

See other examples in the repo I created when I thought I will have the time to vibe code an app per week.

Now anyone can host a global AI challenge on Kaggle

Megan Risdal — Thu, 19 Mar 2026 15:21:02 +0000

Kaggle's community helps the world discover what actually works in AI, and today we're launching Community Hackathons to build on that mission. Community Hackathons is built to help communities, individuals, schools and businesses and create professional-grade AI competitions using Kaggle's infrastructure, at no cost. These are a great way for builders to solve complex problems with AI and hone their professional portfolios.

As the AI landscape evolves, so too do the ways in which builders showcase their skills — moving beyond traditional predictive models toward building full applications, generating novel data insights and creatively utilizing large language models (LLMs). The gap between builders and the frontier has never been smaller and Community Hackathons are an amazing way to bring people together to discover novel results.

Leading companies and research organizations have already been using Hackathons to tackle unique AI problems by challenging the world to solve them:

The NFL has used Kaggle hackathons to create new statistics, hire talent and even make rule changes to improve player safety.
OpenAI used hackathons to red-team their first open-access model, and to help identify possibly hidden archeological sites.
The Google AI Studio team ran two Hackathons with the release of Gemini models. One challenged users to get creative with Nano Banana, and the other testing developers' vibe coding sprint abilities with the release of Gemini 3 Pro. These hackathons shared nearly $1M in combined prizes.
The Gemma 3n release was accompanied by a challenge to use "AI for global impact" and you’ll want to have tissues on hand when you review the results.

Now, Community Hackathons allows you to tap into the AI community to solve problems you care about.

Community Hackathon Features

Community Hackathons are built to be flexible and self-service, providing a seamless experience for both hosts and participants. By making the platform available to hosts worldwide, Kaggle enables diverse, custom-built challenges that drive skill development and portfolio enhancement. Hosts gain access to all the necessary tools for running a successful event, including:

Integrated tools for data hosting, interactive notebooks and discussion forums.
Support for writeup submissions and a project gallery to showcase results.
Flexibility for multiple competition tracks and judge management. Prize pools permitted up to $10,000 USD.

How to get started today

Whether your goal is to challenge the global AI community to build a world-changing application or to host a private internal skill-building event for your organization, Community Hackathons are ready.

Want to host a Hackathon? Create your own in minutes.

Want to compete? Keep an eye on the Kaggle Competitions page for new Community Hackathons appearing soon.

Have questions? Connect with other competition hosts in the dedicated Competition Hosting forum.

We can’t wait to see what you build and what new skills you hone!