android

muzhicaomingwang's avatarfrom muzhicaomingwang

Build, review, and refactor Android mobile apps (Kotlin) using modern Android patterns. Use for tasks like setting up Gradle modules, Jetpack Compose UI, navigation, ViewModel/state management, networking (Retrofit/OkHttp), persistence (Room/DataStore), DI (Hilt/Koin), testing, performance, release builds, and Play Store readiness.

⭐1stars🔀0forks📁View on GitHub🕐Updated Jan 10, 2026
[Code Generation]

When & Why to Use This Skill

This Claude skill is a comprehensive Android development assistant designed to build, review, and refactor mobile applications using Kotlin and modern architectural patterns. It streamlines the entire development lifecycle—from initial project scaffolding with Jetpack Compose and Gradle to implementing robust data layers with Room and Retrofit—ensuring high-quality, maintainable code that adheres to MVVM and Unidirectional Data Flow (UDF) principles.

Use Cases

  • Architecting new applications: Generate a complete multi-module project structure following Clean Architecture principles, including Hilt dependency injection and navigation graphs.
  • UI Development with Jetpack Compose: Create declarative, stateless UI components and manage screen states using ViewModel and StateFlow for reactive, modern user interfaces.
  • Data Persistence and Networking: Implement reliable remote data fetching with Retrofit and local caching strategies using Room database or DataStore.
  • Refactoring and Modernization: Convert legacy Java or XML-based codebases to modern Kotlin and Compose-based architectures while improving code modularity and testability.
  • Testing and Quality Assurance: Generate comprehensive unit tests for domain logic and ViewModels, and set up UI tests to ensure application stability and Play Store readiness.
nameandroid
descriptionBuild, review, and refactor Android mobile apps (Kotlin) using modern Android patterns. Use for tasks like setting up Gradle modules, Jetpack Compose UI, navigation, ViewModel/state management, networking (Retrofit/OkHttp), persistence (Room/DataStore), DI (Hilt/Koin), testing, performance, release builds, and Play Store readiness.

android

Use this skill when working on Android client (大前端 / 移动端) codebases.

Defaults (unless repo dictates otherwise)

  • Language: Kotlin
  • UI: Jetpack Compose (if legacy XML exists, follow existing structure)
  • Architecture: MVVM + unidirectional data flow (UDF)
  • Async: Kotlin Coroutines + Flow
  • DI: Hilt if present; otherwise keep consistent with current
  • app/: application module (entry, navigation, composition root)
  • core/: shared utilities and platform abstractions (optional)
  • data/: API + persistence implementations
  • domain/: use-cases, business models (pure Kotlin)
  • feature/<name>/: feature modules or packages (UI + presentation)

Workflow

  1. Establish constraints
  • Min/target SDK, build system, existing modules.
  • Compose vs XML, single-module vs multi-module.
  1. Define app flows
  • Identify screens and navigation graph.
  • Define state models per screen and their events/actions.
  1. Data layer design
  • API models vs domain models (mapping boundaries).
  • Retrofit service interfaces + OkHttp interceptors (auth, logging).
  • Caching strategy: memory vs disk (Room/DataStore).
  1. UI & state
  • Compose: keep Composables stateless where possible; state hoisted to ViewModel.
  • ViewModel exposes StateFlow<UiState> and accepts events/intents.
  • Handle loading/error/empty states explicitly.
  1. Error handling
  • Normalize errors (network, auth, validation) to domain-friendly types.
  • Avoid leaking Retrofit/Room types into UI.
  1. Performance & UX
  • Avoid recomposition traps; use stable models and remember.
  • Images: Coil; pagination for long lists; debounce inputs.
  • Accessibility basics: content descriptions, large text support.
  1. Quality gates
  • Unit tests for domain and ViewModels.
  • UI tests where meaningful (Compose testing).
  • Lint/detekt/ktfmt if configured; keep build green.

Output expectations when making changes

  • Keep diffs localized; avoid broad refactors unless requested.
  • Add/adjust tests when changing behavior.
  • For new features: include navigation entry, UI state contract, and data wiring.