Android Diary / 8 min read

Android Studio Quail 4 Goes Stable

Android Studio Quail 4 Goes Stable: Why "Android Skills" and Local Gemma 4 Matter More Than They Look

Google just shipped Android Studio Quail 4 to the stable channel - the closing release of a Quail cycle that's spent the last few months focused on speeding up development workflows with AI agents built directly into the IDE. Skim the headline and it's easy to file this under "another AI update, nothing new." But two changes in this release are worth digging into more carefully, because they address real, everyday pain points for Android developers - including those of us working on enterprise apps and Android TV/STB devices.

The Actual Problem Being Solved

Before getting into features, it's worth naming the underlying problem. LLMs are generally quite capable at coding, but the moment they hit platform-specific territory - fast-moving Android APIs, Gradle Plugin version migrations, or complex build configuration structures - the output is frequently wrong or outdated. Anyone who's asked an AI assistant to help upgrade AGP and gotten back APIs that were deprecated two years ago knows this pain well.

This isn't really a "the model isn't smart enough" problem - it's a missing context problem. General-purpose models are trained on broad web data, and platform-specific details - especially anything that changed recently - often aren't well documented publicly yet at the time the model was trained.

📺 The official recap video covering the highlights from the last four Quail releases: youtube.com/watch?v=lKqh34XT7Q8

Android Skills: Injecting Domain Expertise Into the Agent

Quail 4's answer to this is Android skills - modular instruction sets curated directly by the team that builds Android, following the open agent skills specification. Unlike the "write a long manual prompt yourself" approach most of us default to, these skills now ship bundled directly with the IDE - no manual downloads required.

The mechanism itself is fairly elegant: when you write a prompt to the agent, Android Studio analyzes it and matches it against the metadata of installed skills, automatically invoking whichever is most relevant. The practical effect is that the agent gets instant domain expertise without you having to re-write best practices every time you open a new chat.

23 curated skills ship out of the box, including a few examples:

[Your prompt]                      [Skill auto-invoked]
──────────────────────             ───────────────────
"upgrade AGP to version 9"    ──▶   AGP 9 Upgrade
"why is my app lagging?"      ──▶   Android Profiler
"migrate to Navigation3"      ──▶   Navigation3
"build an adaptive tablet UI" ──▶   Adaptive

What's interesting is that the mechanism is also open for customization - teams can build their own skills for specific internal workflows, and even use them outside Android Studio via the Android CLI (android skills add --all). For enterprise teams with their own migration SOPs or architecture standards, this means "team best practices" can become a reusable artifact an AI agent can act on, rather than something documented once in a wiki nobody reads.

🖼️ Illustration of the 23 bundled curated skills: view image on Android Developers Blog

Coming from a background of maintaining codebases with a wide API target range (API 25 up to the latest, since STB/Android Box devices rarely get OS updates), what stands out to me is the opposite side of this coin: skills like these are typically curated against an "ideal," up-to-date Android environment. If you're building for devices with legacy API-level constraints or custom firmware, generic best practices still need to be re-validated against your own reality. The skill accelerates the starting point - it doesn't replace understanding the constraints of the platform you're actually shipping to.

Local Gemma 4: AI Coding Without Sending Code to a Server

The second change I'd argue matters more in the long run is the native integration of Gemma 4 - Google's most capable open model to date - as a local model directly inside Android Studio, with no manual third-party setup required.

A few relevant technical details:

• The smallest models can run with 12GB of RAM, though machines with 32GB+ perform best.
• Management is one click: pick Gemma in the model selector, or go through Settings > Tools > AI > Model Providers > Gemma - Android Studio handles downloading, verifying, and updating the model weights automatically.
• A lightweight inference engine ships bundled with the IDE to run Gemma 4 locally.
• Because Gemma 4 has native agentic tool-calling capabilities, you can run complex, multi-file refactoring plans with the agent entirely offline.

🖼️ Gemma model selection screen: view image on Android Developers Blog

That last point is the one I find most relevant to a specific kind of work environment. If you're operating under strict enterprise security policy - source code isn't allowed to leave the internal network, let alone get sent to a third-party API - a native local model option changes the risk calculation entirely. Historically the choice has usually been binary: "use an AI assistant and accept code leaving the network" or "skip AI assistants entirely for compliance reasons." A natively integrated local model like Gemma 4 offers a genuine third option: get the benefit of an AI agent without code ever leaving the developer's machine.

The trade-off is worth stating plainly too: however good Gemma 4 is, local model performance generally won't match large cloud models on tasks that require complex reasoning across huge codebases. It's a balance between privacy/control and raw capability - not a wholesale replacement, but a genuinely useful additional option in the toolbox.

UX Improvements for Multitasking Agents

Since Quail 2 introduced parallel chats - running multiple agent conversations side by side in separate editor tabs - Quail 4 adds a handful of UX refinements that sound minor on paper but add up in day-to-day use:

• Code symbols (class names, functions, file paths) mentioned in agent responses are now automatically detected and rendered as clickable hyperlinks.
• The Recent Chats panel now shows real-time status indicators: a loading spinner when an agent is actively running tools, a red indicator when it's waiting on your input, and a blue badge when a background task has finished and is ready for review.
• The previously separate Task and Walkthrough artifacts are now consolidated into a single Summary of Changes tab, giving a cleaner diff-review experience before changes are applied.
• For reasoning models, the agent's step-by-step thinking is now organized into collapsible blocks, keeping the chat scannable while still letting you inspect the underlying logic on demand.

🖼️ Recent Chats panel with real-time status notifications: view image on Android Developers Blog

For anyone already used to running several parallel agent tasks - say, one tab doing a Compose refactor on a cloud model while another handles documentation with local Gemma 4 - real-time status notifications sound like a small thing, but they cut down on the constant tab-switching that fragments focus.

Three Paths to Premium AI Capability

Android Studio still ships with a default Gemini model out of the box, with capability dynamically adjusted to keep the free experience solid. For more granular access to the most powerful models, or additional quota for long coding sessions, there are three upgrade paths: bring your own API key (including keys from other providers like Anthropic or OpenAI), subscribe to Google AI Pro/Ultra for automatically unlocked premium capacity, or use Gemini Enterprise for organizations that need Google Cloud-level privacy and security guarantees (currently rolling out to select organizations on the Canary channel).

Why This Matters Beyond the "Ideal" Use Case

If there's one thread running through the entire Quail 4 release, it's this: Google is starting to seriously decouple two things that used to be treated as one package - "using an AI coding assistant" and "sending your code to the cloud." With customizable Android skills and a natively integrated local model, developers get real control over the privacy, cost, and capability trade-off, instead of being forced into one generic approach.

For developers working under specific constraints - data security requirements, legacy target devices, or internal policy around AI tooling - changes like this are worth paying attention to far more than surface-level "shiny new feature" announcements. The local Gemma 4 integration in particular is worth trying if you're curious how far an AI agent can go without relying on a network connection at all.

Reference: Leverage Android skills and Gemma 4 in Android Studio Quail 4 - Android Developers Blog