Every Google I/O follows a pattern. Half the session titles sound transformative. Half of those are vaporware that won't ship for 18 months. You learn to filter fast.
This year though, three announcements actually cut through — not because of the demo polish, but because they fix friction I deal with every single day as an Android developer. If you're building Android apps and using AI tools in your workflow, these matter now, not someday.
1. Android CLI Is Now Stable
The Android Command Line Interface (Android CLI) reaching stable status might look like a boring infrastructure milestone. It isn't. Stability here has a very specific meaning: the API surface is now locked. No more breaking changes between releases. For individual developers, that's a convenience. For AI agents building on top of it, it's a hard prerequisite.
Think about it from the AI's perspective. When you ask an AI coding assistant "what's the latest version of Jetpack Compose?" or "what Hilt annotations do I need for a Worker class?" — it's drawing on training data that could be 12 to 18 months old. The library has moved on. The answer is stale before you even read it. A stable CLI changes this entirely: agents can query authoritative sources at runtime and always return the current, correct answer.
Programmatic Version Lookup
You can now retrieve Android SDK and dependency versions programmatically through automation workflows. Small thing, massive practical impact. No more cross-referencing the Gradle catalog, Maven search, and Google's "What's New" pages to figure out whether 2.7.0 or 2.7.1-alpha02 is the right Compose version to pin.
Journey Support
This is the capability I'm most curious to dig into. "Journey" in Android CLI context means multi-step, stateful workflows — an AI agent can now run a connected sequence of operations rather than making isolated one-shot suggestions. Imagine: analyze the project → identify all deprecated API usages → propose a migration path → apply changes in the right order. That's a journey. That's useful.
Android Studio Code Intelligence for Agents
This one has the biggest day-to-day potential. AI agents can now leverage Android Studio's own code intelligence engine to explore your actual project — analyze files, find usages of classes and methods, navigate declarations, understand what's already in scope before making suggestions.
I've lost count of the times an AI tool suggested a perfectly valid function that imported the wrong package, or defined a method that already existed three files away. It wasn't being stupid — it just had no context beyond what I pasted. This directly fixes that.
The real unlock: AI agents can now interact with your Android project the same way you do in the IDE — not blindly, but with actual structural understanding of what's there. That's a meaningful step toward agents that assist rather than just autocomplete.
Additionally, Google's AI agent framework now officially supports Android development through Android-specific resource bundles and developer skills — meaning third-party agent frameworks can build on top of this infrastructure, not just Gemini.
2. Expanded Android Skills for AI Agents
Here's a frustration every Android developer has had with AI tools: they understand general programming well. They fall apart on Android-specific patterns.
Ask any major LLM to write a coroutine scope tied to a Fragment's lifecycle and there's a real chance it gives you something that either leaks memory or crashes on back navigation. Ask it about Hilt component scopes and it might confidently produce a module that won't compile because it's mixing @Singleton and @ActivityScoped in a way that violates the component hierarchy.
The problem isn't the model's intelligence — it's the knowledge surface. Android has its own mental model: lifecycles, Compose recomposition, Hilt component trees, Gradle variants, Play Store policies. None of this maps cleanly to general programming knowledge. Google's Android Skills are specialized knowledge packages that give AI agents deep, Android-specific context to reason from instead of guessing.
The new skill areas announced this year:
The Glance skill is the one I'm most personally excited about. Widget development with RemoteViews was painful — XML from 2009 wrapped in callbacks. Glance is the right solution, but the learning curve is steep enough that most tutorials still get something subtly wrong. Having a skill specifically trained on correct Glance patterns could save hours of debugging incorrect recomposition behavior.
These skills are accessible directly through the Android CLI, not just through Gemini. That means you can build them into your own tooling, your own CI pipelines, your own custom agents. It's not a locked-in feature — it's an open platform.
The broader idea is that instead of every AI tool reinventing the wheel on Android knowledge, there's now a shared, authoritative, Google-maintained source that any model or agent can tap into. Better code generation, more accurate recommendations, faster implementation of patterns that would otherwise require chasing down the right documentation page.
3. Android Bench Adds More Models
We've had generic coding benchmarks for AI models for years. HumanEval. MBPP. SWE-Bench. They all measure roughly the same thing: can the model solve Python programming puzzles?
That tells you essentially nothing about how well an AI handles Jetpack Compose, Kotlin coroutines, or Hilt dependency injection. The skills being tested in Python don't translate directly. Writing a correct collectAsState() call in Compose requires understanding the Compose lifecycle. Writing a Room migration requires knowing the schema version contract. Writing a Hilt module requires understanding component scoping. None of this shows up in generic benchmarks.
Android Bench evaluates AI models on real Android engineering tasks — things like:
- Correctly implementing a ViewModel with Compose state hoisting
- Writing a Room migration that doesn't corrupt an existing schema
- Setting up Hilt with the right component scope for each dependency
- Implementing a coroutine flow that properly cancels on lifecycle events
- Handling configuration changes without leaking state
This year, Google added support for more open-source models — particularly Gemma variants — alongside results for newer proprietary models including Gemini 3.5 Flash. The leaderboard is public, which means you can compare models on Android-relevant tasks before choosing one for your daily workflow.
I've personally tested six or seven AI tools for Android code over the past year. The quality gap between them is enormous — some are genuinely useful, some are confidently wrong in ways that take longer to debug than just writing the code yourself. Android Bench finally gives us an objective comparison. No more "I tried it and it felt okay."
Practical use: Before picking an AI assistant for your team, check Android Bench. If a model scores well on Room migrations and Compose state management, that's more meaningful than its general HumanEval score.
The Bigger Picture — Agentic Development Is Coming, But Slowly
Google's message at I/O was clear: Android development is moving toward an agentic era. Developers work alongside AI tools that can understand, navigate, and modify a codebase — not just generate single code snippets on demand.
A stable Android CLI, rich Android-specific AI skills, and honest model benchmarking are the three foundations of that vision. And for the first time, it feels like the infrastructure is being built deliberately rather than bolted together.
That said — don't confuse "AI can now write better boilerplate" with "AI can make architecture decisions." The things that separate good Android apps from bad ones aren't about syntax. They're about understanding why you should scope your ViewModel the way you do, why your coroutine is cancelling at the wrong time, why your Compose state is causing unnecessary recomposition. That requires judgment, and judgment still needs a human.
The best Android developers I know are relentlessly pragmatic about tools. They'll adopt anything that genuinely saves time and throw away anything that adds noise. The announcements from this I/O feel like they belong in the first bucket — tools that make real work faster, not demos that look impressive and disappear by next year.
Try Android CLI if you haven't. Pay attention to Android Bench when choosing your AI stack. And if you're building widgets — Glance skills might finally make that less painful than it's been for the last decade.
No comments yet. Be the first to leave one!