# android-native-dev

> A Claude Code skill from MiniMax-AI's skills repo for Android native development with Kotlin and Jetpack Compose — Material Design 3, Gradle wrapper config, AndroidX setup, accessibility (WCAG), and the build-fail rules that catch a broken project before any business logic gets written.

**Use case**: Bring a Kotlin/Compose Android app from empty directory to a passing assembleDebug, with Material 3 patterns and accessibility baked in

**Canonical URL**: https://agentcookbooks.com/skills/android-native-dev/

**Topics**: claude-code, skills, mobile

**Trigger phrases**: "scaffold an Android app", "fix my Gradle build", "Material 3 in Compose"

**Source**: [MiniMax-AI](https://github.com/MiniMax-AI/skills/tree/main/skills/android-native-dev)

**License**: MIT

---

## What it does

`android-native-dev` is the Android skill in [MiniMax-AI's skills repo](https://github.com/MiniMax-AI/skills) — a Kotlin / Jetpack Compose / Material Design 3 development guide that opens with project scenario assessment, not with code. The first move is to figure out what state the project is in: empty directory, Gradle wrapper present, full Android Studio project, or partial scaffolding — each branch has its own approach, and the skill refuses to start writing business logic until `./gradlew assembleDebug` succeeds.

The configuration spine: `gradle.properties` with `android.useAndroidX=true` + `android.enableJetifier=true`, build optimization flags (`org.gradle.parallel=true`), and JVM memory sizing rules tied to project size (2 GB small, 4 GB medium, 8 GB+ large). Dependencies are declared through the Compose BOM (`androidx.compose:compose-bom`) so versions stay consistent. Product flavors cover the dev / staging / prod split with environment-specific `applicationIdSuffix`, `buildConfigField` URLs, and per-flavor resources.

After scaffolding, the skill pivots to Material Design 3 — token usage, dynamic color, typography scale, motion system (`MotionTokens`), state layers, and Material's 8 dp grid. Accessibility lives alongside: touch targets ≥ 48 dp, content descriptions on icons, color contrast ≥ 4.5:1, TalkBack support, and explicit Compose semantics for custom controls. Build troubleshooting is a separate section — `OutOfMemoryError` → bump `-Xmx`, missing wrapper → `gradle wrapper`, version conflicts → BOM enforcement.

## When to use it

- Starting a new Kotlin / Jetpack Compose Android app — the scenario-assessment table picks the right scaffold path
- Configuring an existing Android Studio project that's missing files (no Gradle wrapper, no `gradle.properties`, AndroidX not enabled)
- Implementing Material 3 design tokens in Compose — color, typography, motion, state layers
- Accessibility audit on a Compose UI before Play Store submission
- Build troubleshooting — `assembleDebug` failing, OOM during compile, dependency version conflicts

When *not* to reach for it:

- Cross-platform work — `react-native-dev` or `flutter-dev` are the right skills, not this one
- Pure Java legacy codebases — the skill is Kotlin-first
- Backend Android (Gradle plugins, Android Test Orchestrator infra) — the skill is application-layer
- Compose Multiplatform / KMP — the skill stays inside Android-platform Compose, not the multiplatform variant

## Install

From [MiniMax-AI/skills](https://github.com/MiniMax-AI/skills) at `skills/android-native-dev/`. Drop into `~/.claude/skills/android-native-dev/`. Plugin marketplace install: `claude plugin marketplace add https://github.com/MiniMax-AI/skills` then `claude plugin install minimax-skills` — pulls the entire MiniMax bundle, of which `android-native-dev` is one skill.

The skill itself doesn't shell out to anything — it's pattern + checklist text. The toolchain it expects (Android Studio Hedgehog or later, Android SDK, JDK 17+, Gradle 8.x) needs to be installed locally outside the skill.

## What a session looks like

1. **Scenario assessment.** Skill checks the working directory: empty / has wrapper / full project / incomplete. Each branch has a different starting move.
2. **Required-files check.** `gradle.properties`, `settings.gradle.kts`, root + module `build.gradle.kts`, `gradle/wrapper/gradle-wrapper.properties`, `app/src/main/AndroidManifest.xml`, `MainActivity.kt`, `res/values/{strings,colors,themes}.xml`, `mipmap-*/`. Skill creates the missing pieces in that order.
3. **AndroidX + memory config.** Writes `gradle.properties` with the AndroidX flags and a JVM memory line sized to the project.
4. **Compose BOM dependencies.** Declares `implementation(platform("androidx.compose:compose-bom:..."))` and the leaf artifacts (`ui`, `material3`, `activity-compose`, `lifecycle-viewmodel-compose`).
5. **Build verification.** Runs `./gradlew assembleDebug` and treats failure as a hard stop. No business logic until the build passes — that rule is explicit in the skill.
6. **Material 3 + a11y pass.** Sets up `MaterialTheme` with the project's color tokens, ensures touch targets ≥ 48 dp, adds content descriptions, runs through the WCAG checklist for semantic structure and contrast.
7. **Product flavors (if needed).** Adds dev / staging / prod variants with environment-specific config and resource overrides.

The discipline that makes it work: refusing to skip step 5. The "ensure `assembleDebug` succeeds before writing business logic" rule heads off the most common failure mode — sinking time into a feature on top of a build that's been broken since project init.

## Receipts

_TODO — to be filled in from a real session. Once the skill has been pointed at a real Kotlin/Compose project (new or existing), this section will capture: which scenario branch the skill picked, whether the required-files checklist caught a missing piece (most likely the Gradle wrapper or `gradle.properties` AndroidX flags), and whether the Material 3 token + accessibility pass produced a TalkBack-clean UI on first run._

## Source and attribution

From [MiniMax-AI's skills repository](https://github.com/MiniMax-AI/skills/tree/main/skills/android-native-dev), an MIT-licensed skill collection. The skill cites Material Design 3 Guidelines (material.io), Android Developer Documentation, Google Play Quality Guidelines, and WCAG as its sources.

License: MIT.

The wedge over a generic "Android dev" agent: scenario assessment first, build verification before business logic, and Compose BOM as the version-management primitive. Those three rules together prevent the most common Android-scaffolding failure modes — missing wrapper, AndroidX not enabled, and Compose dependency version drift.