Source: Android Developers Blog — 2026-08-06
Summary
Google Android Developer Relations engineer Jose Alcérreca lays out the philosophy behind the roughly 20 official "Android Skills" Google maintains for coding agents — narrow packages covering fast-moving surfaces like AGP 9, Navigation 3, Camera APIs, and Perfetto SQL. The core rule: only build a skill where there's a verifiable knowledge gap against state-of-the-art models, and treat every skill as deliberately disposable, re-evaluating each one against new model releases and retiring it the moment the underlying model has absorbed that knowledge on its own.
Key Takeaways
- Google explicitly builds skills only where testing shows a demonstrable gap between what SOTA models already know and what a given API surface requires — skills aren't built preemptively for every feature.
- Every installed skill costs context even when unused: 100-200 tokens injected into the baseline of every single task just from being present, ballooning to thousands of tokens once actually activated.
- Skills are re-evaluated against each new model release specifically to check whether the model has now absorbed that knowledge natively, at which point the skill is deliberately retired rather than kept "just in case."
- Target surfaces are consistently the newest, fastest-moving parts of the Android platform — AGP 9, Navigation 3, Camera APIs, Perfetto SQL — exactly where a model's training data is most likely to be stale.
- This is a rare public look at how one of the largest platform owners manages its own agent-skill library at scale, treating skill sprawl as a cost to be actively managed rather than a feature to keep accumulating.
Reel Script
Hook: Most teams building AI coding tools treat every new skill they write as a permanent addition — write it once, ship it forever. Google's Android team does the opposite on purpose: every skill they build is designed from day one to eventually get deleted.
Core Concept: A "skill" here is a small package of extra knowledge you give a coding AI agent to fill a gap — documentation, examples, or conventions for something the underlying model doesn't reliably know on its own. The obvious instinct is to build a skill for everything, but Google's philosophy pushes back hard on that instinct with a simple economic fact: every skill you install costs the agent something just by existing, even if it's never actually used for a given task. That's the hidden tax nobody accounts for when skill libraries grow without bound — you're not just adding capability, you're adding baseline overhead to every single interaction, whether or not that particular task ever needed the skill you added.
Hands-On: Here's the number worth putting on screen: each installed skill adds 100 to 200 tokens to the baseline context of every task, whether it gets used or not — and once it actually does get activated for a relevant task, that cost balloons into the thousands of tokens. Multiply that by twenty-plus skills sitting in a library and you can see how "just add another skill" quietly turns into real performance and cost drag across every single agent interaction, not just the ones that needed it. The lifecycle worth sketching is the discipline behind managing that cost: identify a real, testable knowledge gap against the current best models — not a hypothetical one — build the narrowest skill that closes exactly that gap, then re-test that same skill against every new model release, and the moment the model has absorbed the knowledge on its own, retire the skill entirely rather than leaving it installed as dead weight.
Takeaway: If you're building or maintaining a library of skills, plugins, or tools for an AI agent, audit it with this same lens — every entry has an ongoing token cost whether it's used or not, and "it doesn't hurt to keep it" is the wrong default. Go measure what your own skill library is silently costing before you add the next one.