android-development
/android-development
Create production-quality Android applications following Google's official architecture guidance and NowInAndroid best practices. Use when building Android apps with Kotlin, Jetpack Compose, MVVM architecture, Hilt dependency injection, Room database, or multi-module projects. Triggers on requests to create Android projects, screens, ViewModels, repositories, feature modules, or when asked about Android architecture patterns.
- Author
- Albaylar ↗
- Repository
- Mobile-Development-Kit ↗
- Licence
- MIT
- Last repository change
- 05.11.2026
Assessment and security
- Files in this package
- 10
- Scripts
- 1
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 05.11.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
- 1 scripts in this package. Review them before installing, as Claude may execute them.
Scripts: scripts/generate_feature.py
What it does and when to use it
Create production-quality Android applications following Google's official architecture guidance and NowInAndroid best practices. Use when building Android apps with Kotlin, Jetpack Compose, MVVM architecture, Hilt dependency injection, Room database, or multi-module projects. Triggers on requests to create Android projects, screens, ViewModels, repositories, feature modules, or when asked about Android architecture patterns.
Original author description
Create production-quality Android applications following Google's official architecture guidance and NowInAndroid best practices. Use when building Android apps with Kotlin, Jetpack Compose, MVVM architecture, Hilt dependency injection, Room database, or multi-module projects. Triggers on requests to create Android projects, screens, ViewModels, repositories, feature modules, or when asked about Android architecture patterns.
How it works
- Quick Reference
- Workflow Decision Tree
- Core Principles
- Architecture Layers
- Module Types
- Creating a New Feature
- Standard File Patterns
- Key Dependencies
- Build Configuration
SKILL.md preview
---
name: android-development
description: Create production-quality Android applications following Google's official architecture guidance and NowInAndroid best practices. Use when building Android apps with Kotlin, Jetpack Compose, MVVM architecture, Hilt dependency injection, Room database, or multi-module projects. Triggers on requests to create Android projects, screens, ViewModels, repositories, feature modules, or when asked about Android architecture patterns.
---
# Android Development
Build Android applications following Google's official architecture guidance, as demonstrated in the NowInAndroid reference app.
## Quick Reference
| Task | Reference File |
|------|----------------|
| Project structure & modules | [modularization.md](references/modularization.md) |
| Architecture layers (UI, Domain, Data) | [architecture.md](references/architecture.md) |
| Jetpack Compose patterns | [compose-patterns.md](references/compose-patterns.md) |
| Gradle & build configuration | [gradle-setup.md](references/gradle-setup.md) |
| Testing approach | [testing.md](references/testing.md) |
## Workflow Decision Tree
**Creating a new project?**
→ Read [modularization.md](references/modularization.md) for project structure
→ Use templates in `assets/templates/`
**Adding a new feature?**
→ Create feature module with `api` and `impl` submodules
→ Follow patterns in [architecture.md](references/architecture.md)
**Building UI screens?**
→ Read [compose-patterns.md](references/compose-patterns.md)
→ Create Screen + ViewModel + UiState
**Setting up data layer?**
→ Read data layer section in [architecture.md](references/architecture.md)
→ Create Repository + DataSource + DAO
## Core Principles
1. **Offline-first**: Local database is source of truth, sync with remote
2. **Unidirectional data flow**: Events flow down, data flows up
3. **Reactive streams**: Use Kotlin Flow for all data exposure
4. **Modular by feature**: Each feature is self-contained with clear boundaries
5. **Testable by design**: Use interfaces and test doubles, no mocking libraries
## Architecture Layers
```
┌─────────────────────────────────────────┐
│ UI Layer │
│ (Compose Screens + ViewModels) │
├─────────────────────────────────────────┤
│ Domain Layer │
│ (Use Cases - optional, for reuse) │
├─────────────────────────────────────────┤
│ Data Layer │
│ (Repositories + DataSources) │
└─────────────────────────────────────────┘
```
## Module Types
```
app/ # App module - navigation, scaffolding
feature/
├── featurename/
│ ├── api/ # Navigation keys (public)
│ └── impl/ # Screen, ViewModel, DI (internal)
core/
├── data/ # Repositories
├── database/ # Room DAOs, entities
├── network/ # Retrofit, API models
├── model/ # Domain models (pure Kotlin)
├── common/ # Shared utilities
├── ui/ # Reusable Compose components
├── designsystem/ # Theme, icons, base components
├── datastore/ # Preferences storage
└── testing/ # Test utilities
```
## Creating a New Feature
1. Create `feature:myfeature:api` module with navigation key
2. Create `feature:myfeature:impl` module with:
- `MyFeatureScreen.kt` - Composable UI
- `MyFeatureViewModel.kt` - State holder
- `MyFeatureUiState.kt` - Sealed interface for states
- `MyFeatureNavigation.kt` - Navigation setup
- `MyFeatureModule.kt` - Hilt DI module
## Standard File Patterns
### ViewModel Pattern
```kotlin
@HiltViewModel
class MyFeatureViewModel @Inject constructor(
private val myRepository: MyRepository,
) : ViewModel() {
val uiState: StateFlow<MyFeatureUiState> = myRepository
.getData()
.map { data -> MyFeatureUiState.Success(data) }
.stateIn(
scope = viewModelScope,
started = SharingStarted.WhileSubscribed(5_000),
initialValue = MyFeatureUiState.Loading,
)
fun onAction(action: MyFeatureAction) {
when (action) {
is MyFeatureAction.ItemClicked -> handleItemClick(action.id)
}
}
}
```
### UiState Pattern
```kotlin
sealed interface MyFeatureUiState {
data object Loading : MyFeatureUiState
data class Success(val items: List<Item>) : MyFeatureUiState
data class Error(val message: String) : MyFeatureUiState
}
```
### Screen Pattern
```kotlin
@Composable
internal fun MyFeatureRoute(
onNavigateToDetail: (String) -> Unit,
viewModel: MyFeatureViewModel = hiltViewModel(),
) {
val uiState by viewModel.uiState.collectAsStateWithLifecycle()
MyFeatureScreen(
uiState = uiState,
onAction = viewModel::onAction,
onNavigateToDetail = onNavigateToDetail,
)
}
@Composable
internal fun MyFeatureScreen(
uiState: MyFeatureUiState,
onAction: (MyFeatureAction) -> Unit,
onNavigateToDetail: (String) -> Unit,
) {
when (uiState) {
is MyFeatureUiState.Loading -> LoadingIndicator()
is MyFeatureUiState.Success -> ContentList(uiState.items, onAction)
is MyFeatureUiState.Error -> ErrorMessage(uiState.message)
}
}
```
### Repository Pattern
```kotlin
interface MyRepository {
fun getData(): Flow<List<MyModel>>
suspend fun updateItem(id: String, data: MyModel)
}
internal class OfflineFirstMyRepository @Inject constructor(
private val localDataSource: MyDao,
private val networkDataSource: MyNetworkApi,
) : MyRepository {
override fun getData(): Flow<List<MyModel>> =
localDataSource.getAll().map { entities ->
entities.map { it.toModel() }
}
override suspend fun updateItem(id: String, data: MyModel) {
localDataSource.upsert(data.toEntity())
}
}
```
## Key Dependencies
```kotlin
// Gradle version catalog (libs.versions.toml)
[versions]
kotlin = "1.9.x"
compose-bom = "2024.x.x"
hilt = "2.48"
room = "2.6.x"
coroutines = "1.7.x"
[libraries]
androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "compose-bom" }
hilt-android = { group = "com.google.dagger", name = "hilt-android", version.ref = "hilt" }
room-runtime = { group = "androidx.room", name = "room-runtime", version.ref = "room" }
```
## Build Configuration
Use convention plugins in `build-logic/` for consistent configuration:
- `AndroidApplicationConventionPlugin` - App modules
- `AndroidLibraryConventionPlugin` - Library modules
- `AndroidFeatureConventionPlugin` - Feature modules
- `AndroidComposeConventionPlugin` - Compose setup
- `AndroidHiltConventionPlugin` - Hilt setup
See [gradle-setup.md](references/gradle-setup.md) for complete build configuration.
Files in this package (10)
- LICENSE 1 KB
- SKILL.md 7 KB
- assets/templates/libs.versions.toml.template 7 KB
- assets/templates/settings.gradle.kts.template 1 KB
- references/architecture.md 10 KB
- references/compose-patterns.md 11 KB
- references/gradle-setup.md 16 KB
- references/modularization.md 8 KB
- references/testing.md 13 KB
- scripts/generate_feature.py 11 KB
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · Albaylar/Mobile-Development-Kit | 100 | MIT |
| peterbamuhigire/chwezi-dev-engine | 100 | MIT |
| travisjneuman/.claude | 95 | MIT |
Database snapshot: 13.11.2026 · package version b9a515c08095 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100android
Use this skill when the user asks about Android development, Kotlin, Jetpack Compose, Android architecture, MVVM, Clean Architecture, Room, Hilt, Retrofit, or Android testing. - 100claude-android-ninja
Build and migrate Android apps with Kotlin, Jetpack Compose, MVVM, Hilt, Room 3 (KSP, SQLiteDriver, Flow/suspend DAOs), Navigation3, and multi-module Gradle. Use for new projects or modules, Compose screens and ViewModels, Room 3 and RemoteMediator, API 37 / targetSdk migration,… - 95android-architecture
Use when implementing MVVM, clean architecture, dependency injection with Hilt, or structuring Android app layers. - 80role-mobile:android-native
Expert guidance on Android native development — Kotlin idioms, Jetpack Compose UI, Room database, Hilt dependency injection, Coroutines and Flow for async work, WorkManager for background tasks, Gradle build configuration (KTS), Material Design 3 theming, and Navigation Compose.… - 100kotlin-android
Use when building or fixing a native Android app in Kotlin and Jetpack Compose on the UDF layered architecture — ViewModel/StateFlow, Hilt, Room, Retrofit, coroutines, type-safe Navigation, and the Gradle/AGP surface. NOT shared Android and iOS UI from one Kotlin codebase (that… - 90android-architecture
Expert guidance on setting up and maintaining a modern Android application architecture using Clean Architecture and Hilt. Use this when asked about project structure, module setup, or dependency injection.