Android Studio Quail 4 (2026.1.4) is the final stable release in the Quail line and was presented by Google on September 1, 2026 as ready for production use. The most important change for developers using AI in the IDE is not simply the arrival of a new model: Studio can now combine an agent with specialized Android Skills and, optionally, with Gemma 4 running locally. In practice, this separates two things that are often confused: skills tell the agent how to carry out specific Android workflows; the language model is the engine that interprets the request and generates or modifies code.
What changes in Quail 4 for AI-assisted development
According to the official Android Developers announcement, Quail 4 ships with 23 Android Skills curated by the Android team and preloaded in the IDE. They cover tasks where a generic LLM answer can become outdated quickly or require a large amount of context, such as upgrading the Android Gradle Plugin, analyzing performance, migrating to Navigation 3, and adapting interfaces to different screen sizes.
The release also expands AI inside the normal Studio workflow. In addition to skills, the Quail 4 release page lists local Gemma 4 integration and features where AI can help explain app behavior, such as analyzing recompositions observed in Layout Inspector. The right interpretation, therefore, is that Quail 4 makes AI more deeply integrated into the IDE and more aware of Android-specific procedures — not that every task becomes automatic or no longer requires review.
Android Skills: what they are and why they matter
Android Skills follow the open Agent Skills standard. Google describes them as packages of specialized knowledge and on-demand workflows. Instead of keeping every possible instruction in the model context at all times, the agent identifies the task, checks metadata for installed skills, and loads the full instructions for the relevant skill when needed.
This is especially useful for multi-step tasks, version-specific migrations, or configuration decisions. The official catalog includes, for example, Upgrade to AGP 9, Migrate to Compose, Set up Navigation 3, Make app adaptive, Analyze Perfetto traces, and Audit R8 configuration. The benefit is not a guarantee of correct code; it is giving the agent a specialized playbook that is closer to current Android tools and practices.
Skills can be invoked automatically when the request matches a skill description, or explicitly: the documentation says developers can type @ in the input box to select a specific skill. Teams can also create custom skills for internal rules, architecture, or repeatable workflows.
Where Gemma 4 fits — and where it does not
Gemma 4 is a local model that can be selected as an AI provider in Android Studio. It does not replace Android Skills. A skill can guide the agent through a migration or audit; the model processes those instructions together with project context. That distinction matters because a team can use the same skills with different models or, in compatible environments, reuse the skills outside Studio.
In Quail 4, Studio includes an inference engine that runs Gemma 4 directly on the computer. The local model guide lists two options: Gemma E4B, requiring 12 GB of total RAM and about 4 GB of storage, and Gemma 26B MoE, requiring 24 GB of RAM and about 17 GB of storage. The Quail 4 announcement adds that machines with 32 GB or more tend to provide the best experience.
The main reason to choose Gemma 4 is operational: offline work, policies that require local AI processing, or a preference to keep code on the machine while the model runs. Google also cautions that local models can typically provide lower quality, higher latency, and more limited feature support than cloud Gemini models. “Local” therefore does not automatically mean “better”; it represents a different set of tradeoffs.
When to use Quail 4 in production
| Scenario | Practical choice | Why |
|---|---|---|
| Team IDE on the stable channel | Quail 4 can be adopted | Google classifies it as stable and ready for production. |
| Android migration with known steps, such as AGP 9 or Navigation 3 | Use Agent Mode with the matching skill | The skill adds task-specific instructions and reduces the need for a long setup prompt. |
| Project that must work offline or under restrictive AI policy | Evaluate local Gemma 4 | The model runs on-device and can avoid dependence on a remote provider during the session. |
| Resource-constrained machine or work that requires higher quality and broader feature coverage | Prefer cloud Gemini when policy allows | The documentation warns that local models can be slower and less accurate. |
| Critical build, security, billing, or production behavior changes | Use AI as assistance, not final approval | Code diffs, tests, and official documentation remain part of validation. |
Migration and configuration examples
1. Upgrade a project to AGP 9
Instead of asking only “update my project,” a developer can request the migration and let the agent identify the AGP 9 skill or invoke it explicitly. The skill acts as a migration playbook, while the proposed changes still need to be checked against the real project, the Upgrade Assistant, the compatibility matrix, and tests. The AGP 9 documentation cites the skill as one option for assisting the upgrade.
2. Move custom skills when upgrading from older versions
Teams already using custom skills should note a directory change. The Agent Mode skills documentation says skills should be stored in .agents/skills or .android-studio/skills, at the project root or home directory. Pre-Quail Android Studio versions also loaded skills from .skills and agent/skills; when moving to Quail 1 or later, those files should be moved to the newer directories.
3. Configure Gemma 4
Quail 4 lets you choose Gemma in the agent model selector or open Settings > Tools > AI > Model Providers > Gemma. Studio handles downloading, verifying, and updating the model weights. Before standardizing this for a team, compare workstation capacity with RAM and storage requirements and test a representative repository task.
How to review generated code before accepting it
Quail 4 reduces context setup work, but it does not remove the need for review. The Gemini in Studio documentation itself warns that AI responses can be inaccurate. In the code transformation flow, the IDE shows a diff so the developer can review, refine, and accept only the desired changes. In Agent Mode, changes can also be tracked by file, kept, or reverted.
- Read the diff before accepting: look for API changes, dependencies, permissions, error behavior, and silent configuration changes.
- Run build, tests, and lint: a skill can guide the process, but it does not replace validation against your combination of Gradle, SDK, libraries, and devices.
- Review security and data handling: do not automatically approve changes involving authentication, Intents, WebView, storage, networking, billing, or credentials.
- Control agent permissions: Android Studio lets you define whether the agent can write files, run commands, access the network, or interact with other services. The permissions documentation recommends granting access according to the workflow that actually needs it.
- Set a context-sharing policy: for cloud Gemini, code context sharing is controllable and can be restricted with .aiexclude. The data and privacy page explains these controls and differences between usage modes.
An adoption flow that reduces risk
- First update a non-critical project or branch to Quail 4 and validate plugins, AGP, emulators, and team tooling.
- Pick a repeatable task — for example a Navigation 3 migration, Perfetto analysis, or R8 audit — and compare the result with the current manual process.
- Choose a model by workload: Gemma 4 when local and offline execution is required; cloud Gemini when quality, speed, or broader feature coverage is the priority and policy allows it.
- Keep human confirmation for diffs and commands that affect the project. Broader permissions should be reserved for known, reversible workflows.
- Turn internal routines into custom skills only after the procedure has been documented and tested by the team.
In short
The key advance in Android Studio Quail 4 is less about “adding another chatbot” and more about structuring AI around Android development work. Android Skills add reusable specialized instructions; Gemma 4 provides a local model option; and Agent Mode connects those pieces to actions inside the IDE. Quail 4 is already a stable release for production use, but generated code still requires diff review, builds, tests, and human judgment. The right model and permission choices depend on the balance each team accepts between quality, hardware, privacy, and autonomy.
