android-native-dev

Trigger phrases

Phrases that activate this skill when typed to Claude Code:

• scaffold an Android app
• fix my Gradle build
• Material 3 in Compose

What it does

android-native-dev is the Android skill in MiniMax-AI’s skills repo — 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 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, 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.