Skip to content
Back to search

android-skills

Android and KMP development skills for Claude Code

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/rcosteira79--android-skills/badge.svg)](/listings/rcosteira79--android-skills)

HTML

<a href="/listings/rcosteira79--android-skills"><img src="/api/listings/rcosteira79--android-skills/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

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](https://developers.openai.com/codex/plugins) and [local skill installation guidance](https://developers.openai.com/codex/skills).

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](https://developers.openai.com/plugins/build/plugins) 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.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 26 lines
  1. {
  2. "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
  3. "name": "android-skills",
  4. "description": "Android and KMP development skills for Claude Code",
  5. "owner": {
  6. "name": "Ricardo Costeira"
  7. },
  8. "metadata": {
  9. "description": "Android and KMP development skills for Claude Code — architecture, Compose, coroutines, flows, networking (Retrofit, Ktor), persistent storage (Room, DataStore), pagination, dependency injection (Hilt, Koin), testing, debugging, Gradle, and Material Design 3",
  10. "version": "5.9.0"
  11. },
  12. "plugins": [
  13. {
  14. "name": "android-skills",
  15. "source": "./plugins/android-skills",
  16. "description": "Android and KMP development skills for Claude Code — architecture, Compose, coroutines, flows, networking (Retrofit, Ktor), persistent storage (Room, DataStore), pagination, dependency injection (Hilt, Koin), testing, debugging, Gradle, and Material Design 3",
  17. "version": "5.9.0",
  18. "author": {
  19. "name": "Ricardo Costeira"
  20. },
  21. "repository": "https://github.com/rcosteira79/android-skills",
  22. "license": "MIT",
  23. "keywords": ["android", "kotlin", "kmp", "compose", "coroutines", "flows", "ktor", "room", "datastore", "paging", "koin", "hilt", "material3", "jetpack", "gradle"]
  24. }
  25. ]
  26. }
README.md · README · 207 lines
  1. <div align="center">
  2. # Android Skills
  3. **Android & KMP development skills for Claude Code, Codex, and Copilot CLI** — architecture, Compose, coroutines, flows, networking, persistence, dependency injection, testing, debugging, and Gradle.
  4. ![version](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fraw.githubusercontent.com%2Frcosteira79%2Fandroid-skills%2Fmain%2F.claude-plugin%2Fmarketplace.json&query=%24.metadata.version&label=version&color=3b82f6&prefix=v)
  5. ![skills](https://img.shields.io/badge/skills-21-8b5cf6)
  6. ![license](https://img.shields.io/badge/license-MIT-2f9e6f)
  7. ![Claude Code](https://img.shields.io/badge/Claude_Code-plugin-d97757)
  8. ![Codex](https://img.shields.io/badge/Codex-plugin-10a37f)
  9. ![Copilot CLI](https://img.shields.io/badge/Copilot_CLI-plugin-24292e)
  10. </div>
  11. 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.
  12. ## Contents
  13. - [Installation](#installation)
  14. - [Skills](#skills)
  15. - [Companion tools](#companion-tools)
  16. - [Related projects](#related-projects)
  17. - [Attribution](#attribution)
  18. - [License](#license)
  19. ## Installation
  20. ### Claude Code (plugin)
  21. ```
  22. /plugin marketplace add rcosteira79/android-skills
  23. /plugin install android-skills@android-skills
  24. ```
  25. Updates are picked up automatically when the plugin version is bumped.
  26. ### Codex (plugin)
  27. Use a current Codex CLI with `codex plugin` support. Register this repository as a marketplace, then install the plugin:
  28. ```bash
  29. codex plugin marketplace add rcosteira79/android-skills
  30. codex plugin add android-skills@android-skills
  31. ```
  32. Start a new Codex session after installation. Run `/skills` to check that the bundled skills are available, or explicitly request one in your prompt:
  33. ```text
  34. Use $android-skills:android-dev and $android-skills:compose to implement this screen.
  35. ```
  36. 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.
  37. 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:
  38. ```bash
  39. codex plugin marketplace add .
  40. codex plugin add android-skills@android-skills
  41. ```
  42. 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.
  43. 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](https://developers.openai.com/codex/plugins) and [local skill installation guidance](https://developers.openai.com/codex/skills).
  44. #### Codex packaging
  45. Both hosts share the same skill sources:
  46. ```text
  47. .claude-plugin/marketplace.json # Claude Code marketplace
  48. .agents/plugins/marketplace.json # Codex marketplace
  49. plugins/android-skills/
  50. .claude-plugin/plugin.json # Claude Code manifest
  51. .codex-plugin/plugin.json # Codex manifest
  52. skills/ # Shared skills and references
  53. ```
  54. 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.
  55. 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](https://developers.openai.com/plugins/build/plugins) for marketplace and manifest details.
  56. ### Copilot CLI (plugin)
  57. Copilot CLI detects the same plugin format automatically:
  58. ```bash
  59. copilot plugin install rcosteira79/android-skills
  60. ```
  61. ### Manual / other agents
  62. Copy the skill directories into your agent's skills folder:
  63. ```bash
  64. git clone https://github.com/rcosteira79/android-skills.git
  65. cp -r android-skills/plugins/android-skills/skills/* ~/.claude/skills/
  66. ```
  67. The `SKILL.md` files are plain markdown, so they can be adapted to any editor that supports custom instructions.
  68. ## Skills
  69. ### Foundation & architecture
  70. - **`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.
  71. - **`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.
  72. - **`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).
  73. ### UI — Compose & design
  74. - **`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 lazy-list crash patterns (duplicate keys, per-item `rememberSaveable`).
  75. - **`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.
  76. - **`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).
  77. ### Async — Kotlin
  78. - **`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.
  79. - **`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+).
  80. ### Networking
  81. - **`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.
  82. - **`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.
  83. ### Persistence & lists
  84. - **`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.
  85. - **`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`.
  86. ### Dependency injection
  87. - **`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.
  88. ### Multiplatform
  89. - **`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.
  90. ### Build & Gradle
  91. - **`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.
  92. - **`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.
  93. ### Testing & debugging
  94. - **`android-testing`** — test-first discipline plus the Android/KMP test traps: Compose-test dispatching (v1 vs v2 test APIs, 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.
  95. - **`android-debugging`** — debugging Android and KMP issues on a root-cause-first foundation: ANR trace retrieval, baseline-first performance investigation, R8 stack trace decoding (forward and inverse-mapping), runtime UI inspection with `android layout`, and a per-session-tag template for tracing a bad value across layers. Defers Perfetto and ANR triage to Google's `android-profiler` and `anr-audit-and-fix` skills.
  96. ### Platform APIs
  97. - **`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.
  98. ### Source access & migration
  99. - **`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](https://github.com/mrmike/android-source-explorer-mcp).
  100. - **`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.
  101. ### Removed
  102. - **`xml-to-compose-migration`** — dropped in favour of Google's actively-maintained [`migrate-xml-views-to-jetpack-compose`](https://github.com/android/skills/tree/main/jetpack-compose/migration).
  103. ## Companion tools
  104. 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.
  105. - **[android-source-explorer-mcp](https://github.com/mrmike/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.
  106. ```bash
  107. uv tool install git+https://github.com/mrmike/android-source-explorer-mcp
  108. ```
  109. - **[jetbrains-index-mcp-plugin](https://github.com/hechtcarmel/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.
  110. - **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](https://developer.android.com/tools/agents/android-cli).
  111. ## Related projects
  112. - [android/skills](https://github.com/android/skills) — Google's official Android agent skills: AGP 9 migration (pure-Android), XML-to-Compose migration, Navigation 3, Compose performance audits, profiling (Perfetto), ANR triage, R8 analysis, adaptive layouts, Play Billing upgrades, and edge-to-edge support.
  113. - [Kotlin/kotlin-agent-skills](https://github.com/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.
  114. - [awesome-android-agent-skills](https://github.com/new-silvermoon/awesome-android-agent-skills) — curated list of Android agent skills.
  115. - [chrisbanes/skills](https://github.com/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.
  116. - [compose-skill (Meet-Miyani)](https://github.com/Meet-Miyani/compose-skill) — broad Compose + KMP skill covering MVI/MVVM, Navigation 2 & 3, Ktor, Koin/Hilt, Room, DataStore, Paging, and iOS interop.
  117. - [compose-skill (aldefy)](https://github.com/aldefy/compose-skill) — alternative Compose skill that bundles a static AndroidX snapshot.
  118. - [compose_skill (hamen)](https://github.com/hamen/compose_skill) — 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.
  119. - [material-3-skill](https://github.com/hamen/material-3-skill) — comprehensive Material Design 3 reference: 30+ components, design tokens, theming, responsive layout, and dynamic color.
  120. - [skydoves/android-testing-skills](https://github.com/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.
  121. - [skydoves/compose-performance-skills](https://github.com/skydoves/compose-performance-skills) — the performance side of Compose (stability, recomposition, lazy layouts, baseline profiles, R8, hot reload).
  122. - [android-reverse-engineering-skill](https://github.com/SimoneAvogadro/android-reverse-engineering-skill) — decompiling APKs, extracting API endpoints, and tracing call flows.
  123. ## Attribution
  124. 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.
  125. | Skill(s) | Inspiration / adapted material |
  126. |---|---|
  127. | `android-dev`, `kmp-ktor`, `datastore`, `paging`, `koin` | [compose-skill (Meet-Miyani)](https://github.com/Meet-Miyani/compose-skill) |
  128. | `android-retrofit`, `coil-compose`, `rxjava-migration`, `android-gradle-logic`, `gradle-build-performance` | [awesome-android-agent-skills](https://github.com/new-silvermoon/awesome-android-agent-skills) |
  129. | `android-data-layer` | [awesome-android-agent-skills](https://github.com/new-silvermoon/awesome-android-agent-skills); Room KMP section from [compose-skill (Meet-Miyani)](https://github.com/Meet-Miyani/compose-skill) |
  130. | `kotlin-coroutines` | [awesome-android-agent-skills](https://github.com/new-silvermoon/awesome-android-agent-skills) + [chrisbanes/skills](https://github.com/chrisbanes/skills) |
  131. | `android-testing`, `kotlin-flows` | [chrisbanes/skills](https://github.com/chrisbanes/skills) |
  132. | `kmp-boundaries` | [chrisbanes/skills](https://github.com/chrisbanes/skills); iOS Swift interop from [compose-skill (Meet-Miyani)](https://github.com/Meet-Miyani/compose-skill) |
  133. | `android-ux` | [material-3-skill](https://github.com/hamen/material-3-skill) |
  134. | `compose` | forked from [aldefy/compose-skill](https://github.com/aldefy/compose-skill), then rebased on live source verification, with patterns from [chrisbanes/skills](https://github.com/chrisbanes/skills), [skydoves/compose-performance-skills](https://github.com/skydoves/compose-performance-skills), and [compose_skill (hamen)](https://github.com/hamen/compose_skill) |
  135. ## License
  136. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.