android-skills

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