Android Skills

Android & KMP development skills for Claude Code, Codex, and Copilot CLI — architecture, Compose, coroutines, flows, networking, persistence, dependency injection, testing, debugging, and Gradle.

Skills are invoked automatically based on context — working on Compose code activates the compose skill, a coroutine bug pulls in kotlin-coroutines, and so on. Each SKILL.md is plain, self-contained markdown, so the collection also works outside the plugin format.

Contents

• Installation
• Skills
• Companion tools
• Related projects
• Attribution
• License

Installation

Claude Code (plugin)

/plugin marketplace add rcosteira79/android-skills
/plugin install android-skills@android-skills

Updates are picked up automatically when the plugin version is bumped.

Codex (plugin)

Use a current Codex CLI with codex plugin support. Register this repository as a marketplace, then install the plugin:

codex plugin marketplace add rcosteira79/android-skills
codex plugin add android-skills@android-skills

Start a new Codex session after installation. Run /skills to check that the bundled skills are available, or explicitly request one in your prompt:

Use $android-skills:android-dev and $android-skills:compose to implement this screen.

The plugin installs all 21 skills and their references together, preserving the android-skills: namespace used by cross-skill instructions. Companion tools are optional and installed separately; this package does not configure MCP servers or require service credentials.

The GitHub commands require a published revision containing the Codex packaging. To test an unpublished branch or use an existing local checkout, run these commands from the repository root instead:

codex plugin marketplace add .
codex plugin add android-skills@android-skills

Use one marketplace source at a time for the android-skills name. codex plugin marketplace list shows configured sources; remove the existing source with codex plugin marketplace remove android-skills before switching between GitHub and a local checkout.

You can also browse configured marketplaces with /plugins in Codex CLI. Plugin support is available in Codex CLI and the desktop app; the IDE extension uses standalone skills instead. See the official Codex plugin guide and local skill installation guidance.

Codex packaging

Both hosts share the same skill sources:

.claude-plugin/marketplace.json                 # Claude Code marketplace
.agents/plugins/marketplace.json                # Codex marketplace
plugins/android-skills/
  .claude-plugin/plugin.json                    # Claude Code manifest
  .codex-plugin/plugin.json                     # Codex manifest
  skills/                                      # Shared skills and references

The Codex marketplace resolves ./plugins/android-skills relative to the repository root. Its manifest declares ./skills/ relative to the plugin root. No generated copies of skills are needed.

When releasing, keep the version in both plugin manifests and the Claude marketplace's metadata.version and plugin entry in sync. The Codex marketplace uses the plugin manifest's version. See OpenAI's packaging documentation for marketplace and manifest details.

Copilot CLI (plugin)

Copilot CLI detects the same plugin format automatically:

copilot plugin install rcosteira79/android-skills

Manual / other agents

Copy the skill directories into your agent's skills folder:

git clone https://github.com/rcosteira79/android-skills.git
cp -r android-skills/plugins/android-skills/skills/* ~/.claude/skills/

The SKILL.md files are plain markdown, so they can be adapted to any editor that supports custom instructions.

Skills

Foundation & architecture

• android-dev — the baseline for Android and KMP work: house defaults (DI, async, JSON, images, networking, module boundaries), routing to the specialised skills, the greenfield MVVM state/effect UI convention, four-bucket UiState modeling, and Channel(BUFFERED) over SharedFlow(replay = 0) for one-shot effects.
• modularization — visibility discipline for multi-module projects: declare everything at the lowest visibility that still compiles (private → internal → public), keep DI-bound implementation classes internal behind public interfaces, and treat widening to public as a decision that requires a real cross-module consumer.
• android-data-layer — data-layer implementation: the layered error-propagation model (repository as the error boundary, sealed DataError, Result placement with and without a domain layer) and KMP Room setup (@ConstructedBy, BundledSQLiteDriver, per-target KSP).

UI — Compose & design

• compose — Jetpack Compose expert guidance: state management (remember, derivedStateOf, hoisting, the unified keying rule, cross-phase back-writing), Modifier chains, lazy lists (LazyLayoutCacheWindow prefetch tuning), navigation (Nav 2 + Nav 3 guardrails), animation, side effects (LifecycleStartEffect/LifecycleResumeEffect), theming, accessibility, performance (Argument Change Reasons, the five compiler stability types, escape-hatch annotations, baseline profiles), focus/key-event navigation (D-pad/TV/ChromeOS, focus restoration, dialog focus traps, predictive-back), and a production-crash playbook with CMP equivalents.
• android-ux — Material Design 3 UX principles: foldable postures (tabletop, book mode), M3 contrast levels (Hct/SchemeContent), motion duration tokens and reduced motion, and an M3 compliance audit scoring screens across 10 categories with grep-based quick checks.
• coil-compose — image loading in Compose and CMP with Coil 3: the KMP specifics (LocalPlatformContext, SingletonImageLoader.setSafe, coil-compose vs coil-compose-core) and two lazy-list performance guardrails (never SubcomposeAsyncImage in lists; rememberAsyncImagePainter needs an explicit size).

Async — Kotlin

• kotlin-coroutines — scope management, structured concurrency, cancellation, and exception handling, centered on scope ownership (prefer suspend fun, let the caller own the scope) and exception discipline that doesn't break cancellation.
• kotlin-flows — Flow traps and semantic edge cases: Channel vs SharedFlow one-shot event semantics, callback bridging (callbackFlow + awaitClose), retry attempt guards, .catch scope and the CancellationException trap, side effects outside transforms, and explicit backing fields (Kotlin 2.4+).

Networking

• android-retrofit — Retrofit setup: suspend service functions returning the body directly (Response<T> only when you need status/headers/error body), the auth-interceptor throw-vs-proceed decision, loose-JSON kotlinx.serialization config, and error mapping at the repository boundary.
• kmp-ktor — Ktor client configuration traps for KMP and Android: plugin install order (HttpRequestRetry before HttpTimeout), encodeDefaults = true and the vanishing-constant-field trap, expectSuccess consistency, bearer refresh with markAsRefreshTokenRequest(), WebSocket/SSE via the serialization converter, MockEngine testing, and error mapping at the repository boundary.

Persistence & lists

• datastore — Jetpack DataStore for Android and KMP: Preferences vs Typed vs Room selection, the two error traps (IOException-specific .catch; CorruptionException + ReplaceFileCorruptionHandler for typed stores), and the KMP factory with per-platform file paths.
• paging — Paging 3 for Android and Compose: PagingSource, Pager/PagingConfig, the critical "PagingData must be a separate Flow, never inside UiState" rule, dynamic filters via flatMapLatest + debounce, cachedIn placement, LazyColumn integration (itemKey/itemContentType/load-state handling), RemoteMediator for offline-first lists with Room, and unit tests with TestPager + asSnapshot.

Dependency injection

• koin — Koin for Android and KMP: Classic DSL vs KSP annotations, expect val platformModule: Module for per-target wiring, koinViewModel in Compose, scopes, Nav 3 entry providers via koinEntryProvider(), compile-time verification with verify(), and a clear Koin-vs-Hilt positioning.

Multiplatform

• kmp-boundaries — designing Kotlin Multiplatform boundaries: choosing between expect/actual, common interfaces with platform bindings, or separate platform screens; capability granularity, the thin-actuals rule, source-set hierarchies (skikoMain, appleMain), Compose Multiplatform leaf positioning, AGP 9 KMP library plugin constraints, and a dedicated iOS Swift interop reference.

Build & Gradle

• android-gradle-logic — scalable Gradle build logic: Convention Plugins, composite builds, shared compileSdk/minSdk/Compose configuration across modules, and clean per-module build.gradle.kts files.
• gradle-build-performance — Gradle build optimisation: Build Scans, configuration cache, build cache, kapt→KSP migration, parallel execution, lazy task configuration, and a recommended gradle.properties baseline.

Testing & debugging

• android-testing — test-first discipline plus the Android/KMP test traps: Compose-test dispatching (StandardTestDispatcher default, the two-schedulers trap), semantics-first selectors, choosing the smallest test shape, test-clock vs wall-clock, animation/screenshot determinism, and commonTest names that compile on the JVM but fail Kotlin/Native.
• android-debugging — debugging Android and KMP issues: Logcat, ADB, ANR traces, R8 stack trace decoding (forward and inverse-mapping), Perfetto trace investigation escalation, memory leaks, Gradle build failures, and Compose recomposition bugs.

Platform APIs

• pdf-annotations — editing PDF annotations (highlight, free-text, stamp) and page objects with Android's platform PDF APIs: the API 36.1 / SDK-extension-18 editing surface (android.graphics.pdf.component), the version gate between PdfRenderer.Page and PdfRendererPreV.Page, the open→edit→write workflow, and the id/render-flag/save contracts.

Source access & migration

• android-source-search — fetch and verify Android source: AOSP platform internals (@hide APIs, framework classes, system services via Gitiles) and AndroidX/Jetpack library source and samples (via GitHub). A zero-setup fallback; upgrade with android-source-explorer-mcp.
• rxjava-migration — triggered only when you explicitly ask to migrate: assesses complexity, maps RxJava types and operators to coroutines equivalents, and provides interop patterns for incremental migration.

Removed

• xml-to-compose-migration — dropped in favour of Google's actively-maintained migrate-xml-views-to-jetpack-compose.

Companion tools

The skills work standalone, but several integrate with external tools for enhanced capabilities. These are independent of the plugin install — use them alongside whichever agent you choose.

• android-source-explorer-mcp — local source sync, Tree-sitter parsing, class hierarchy, and LSP for Android source navigation. The android-source-search and compose skills use it automatically when present, and fall back to Gitiles/GitHub otherwise.

  uv tool install git+https://github.com/mrmike/android-source-explorer-mcp

• jetbrains-index-mcp-plugin — semantic navigation via the IDE's symbol index (implementations, overrides, callers, references through typealiases) with much higher recall than text search. Particularly valuable for compose, android-debugging, android-testing, and rxjava-migration. Requires Android Studio / IntelliJ running with the project indexed.

• Google's android CLI — CLI-native shortcuts for compose and android-debugging: Android Knowledge Base search (android docs), runtime UI layout inspection (android layout), device/emulator orchestration, and SDK management. Skills work without it, but it's recommended for the best experience. Install instructions.

Related projects

• android/skills — Google's official Android agent skills: AGP 9 migration (pure-Android), XML-to-Compose migration, Navigation 3, R8 analysis, Play Billing upgrades, and edge-to-edge support.
• Kotlin/kotlin-agent-skills — JetBrains' official Kotlin skills: AGP 9 migration for KMP, CocoaPods → SwiftPM migration, framework-aware Java-to-Kotlin conversion, and Kotlin backend/JPA entity mapping.
• awesome-android-agent-skills — curated list of Android agent skills.
• chrisbanes/skills — narrow, opinionated Compose and Kotlin skills covering state authoring, side effects, recomposition performance, stability diagnostics, focus navigation, UI testing, structured concurrency, and KMP expect/actual boundaries.
• compose-skill (Meet-Miyani) — broad Compose + KMP skill covering MVI/MVVM, Navigation 2 & 3, Ktor, Koin/Hilt, Room, DataStore, Paging, and iOS interop.
• compose-skill (aldefy) — alternative Compose skill that bundles a static AndroidX snapshot.
• compose_skill (hamen) — ships jetpack-compose-audit (evidence-based repo scoring via Compose Compiler reports) and compose-agent (a teaching/authoring skill with 13 reference files). Install directly for the full audit+score workflow.
• material-3-skill — comprehensive Material Design 3 reference: 30+ components, design tokens, theming, responsive layout, and dynamic color.
• skydoves/android-testing-skills — 54 source-grounded testing skills as a 7-set catalog to cherry-pick from. The jvm-tests, instrumentation, and kotlin sets fit cleanly alongside android-testing without overlap. Apache-2.0.
• skydoves/compose-performance-skills — the performance side of Compose (stability, recomposition, lazy layouts, baseline profiles, R8, hot reload).
• android-reverse-engineering-skill — decompiling APKs, extracting API endpoints, and tracing call flows.

Attribution

These skills are my own work — most written from scratch, then sharpened over many audit passes. Where one drew inspiration, adapted a specific section, or (only in compose's case) started from an existing skill, the credit is below. Anything not listed is fully original.

Skill(s)	Inspiration / adapted material
android-dev, kmp-ktor, datastore, paging, koin	compose-skill (Meet-Miyani)
android-retrofit, coil-compose, rxjava-migration, android-gradle-logic, gradle-build-performance	awesome-android-agent-skills
android-data-layer	awesome-android-agent-skills; Room KMP section from compose-skill (Meet-Miyani)
kotlin-coroutines	awesome-android-agent-skills + chrisbanes/skills
android-testing, kotlin-flows	chrisbanes/skills
kmp-boundaries	chrisbanes/skills; iOS Swift interop from compose-skill (Meet-Miyani)
android-ux	material-3-skill
compose	forked from aldefy/compose-skill, then rebased on live source verification, with patterns from chrisbanes/skills, skydoves/compose-performance-skills, and compose_skill (hamen)

License

MIT