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.
Safety scan
A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.
Badge for your README
Markdown
[](/listings/dpconde-claude-android-skill)HTML
<a href="/listings/dpconde-claude-android-skill"><img src="/api/listings/dpconde-claude-android-skill/badge.svg" alt="findsafeskills safety rating" /></a>Install
Install instructions from the README
As written by the repo's author. findsafeskills has not verified these steps.
1. Clone this repository into your Claude Code skills directory:
git clone https://github.com/dpconde/claude-android-skill.git
2. Claude Code will automatically detect and load the skill when you work on Android projects.
What was scanned
The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.
SKILL.md · Manifest · 204 lines
View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)
- ---
- 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.
README.md · README · 210 lines
View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)
- # [WIP] Android Development Skill for Claude Code
- A production-ready skill that enables Claude Code to build Android applications following Google's official architecture guidance and best practices from the [NowInAndroid](https://github.com/android/nowinandroid) reference app.
- ## Overview
- This skill provides Claude with comprehensive knowledge of modern Android development patterns, including:
- - **Clean Architecture** with UI, Domain, and Data layers
- - **Jetpack Compose** patterns and best practices
- - **Multi-module project structure** with convention plugins
- - **Offline-first architecture** with Room and reactive streams
- - **Dependency injection** with Hilt
- - **Comprehensive testing** strategies
- ## Installation
- 1. Clone this repository into your Claude Code skills directory:
- ```bash
- git clone https://github.com/dpconde/claude-android-skill.git
- ```
- 2. Claude Code will automatically detect and load the skill when you work on Android projects.
- ## Usage
- The skill automatically activates when you request Android-related tasks. Simply ask Claude to:
- - "Create a new Android feature module for user settings"
- - "Build a Compose screen with MVVM pattern"
- - "Set up a Repository with offline-first architecture"
- - "Add navigation to my Android app"
- - "Configure multi-module Gradle setup"
- Claude will follow the patterns and best practices defined in this skill.
- ## Project Structure
- ```
- claude-android-skill/
- ├── SKILL.md # Main skill definition and quick reference
- ├── references/ # Detailed documentation
- │ ├── architecture.md # UI, Domain, Data layers patterns
- │ ├── compose-patterns.md # Jetpack Compose best practices
- │ ├── gradle-setup.md # Build configuration & convention plugins
- │ ├── modularization.md # Multi-module project structure
- │ └── testing.md # Testing strategies and patterns
- ├── assets/
- │ └── templates/ # Project templates
- │ ├── libs.versions.toml.template
- │ └── settings.gradle.kts.template
- └── scripts/
- └── generate_feature.py # Feature module generator script
- ```
- ## Core Principles
- This skill teaches Claude to follow these key Android development principles:
- 1. **Offline-first**: Local database as source of truth, synchronized with remote data
- 2. **Unidirectional data flow**: Events flow down, data flows up (UDF pattern)
- 3. **Reactive streams**: Use Kotlin Flow for all data exposure
- 4. **Modular by feature**: Each feature is self-contained with clear API boundaries
- 5. **Testable by design**: Use interfaces and test doubles, avoid mocking frameworks
- ## Reference Documentation
- ### Quick Navigation
- | Topic | File | Description |
- |-------|------|-------------|
- | Architecture | [architecture.md](references/architecture.md) | MVVM pattern, layers, repositories, use cases |
- | Compose UI | [compose-patterns.md](references/compose-patterns.md) | Screens, state hoisting, side effects, theming |
- | Build Setup | [gradle-setup.md](references/gradle-setup.md) | Convention plugins, version catalogs, configuration |
- | Modularization | [modularization.md](references/modularization.md) | Module types, dependencies, feature structure |
- | Testing | [testing.md](references/testing.md) | Unit tests, UI tests, test doubles, strategies |
- ## Architecture Overview
- ```
- ┌─────────────────────────────────────────┐
- │ UI Layer │
- │ (Compose Screens + ViewModels) │
- ├─────────────────────────────────────────┤
- │ Domain Layer │
- │ (Use Cases - optional, for reuse) │
- ├─────────────────────────────────────────┤
- │ Data Layer │
- │ (Repositories + DataSources) │
- └─────────────────────────────────────────┘
- ```
- ### Module Types
- ```
- app/ # Application module
- feature/
- ├── featurename/
- │ ├── api/ # Public navigation contracts
- │ └── impl/ # Internal implementation
- core/
- ├── data/ # Repositories
- ├── database/ # Room DAOs & entities
- ├── network/ # Retrofit & API models
- ├── model/ # Domain models
- ├── ui/ # Reusable components
- ├── designsystem/ # Theme & design tokens
- └── testing/ # Test utilities
- ```
- ## Features
- ### Code Generation
- The skill includes a Python script to generate feature modules:
- ```bash
- python scripts/generate_feature.py settings \
- --package com.example.app \
- --path /path/to/project
- ```
- This creates a complete feature module with:
- - API module with navigation definitions
- - Implementation module with Screen, ViewModel, UiState
- - Gradle build files with proper dependencies
- - Hilt dependency injection setup
- ### Templates
- Pre-configured templates for common Android project files:
- - `libs.versions.toml.template` - Gradle version catalog
- - `settings.gradle.kts.template` - Project settings
- ## Standard Patterns
- ### ViewModel Pattern
- ```kotlin
- @HiltViewModel
- class MyFeatureViewModel @Inject constructor(
- private val repository: MyRepository,
- ) : ViewModel() {
- val uiState: StateFlow<MyFeatureUiState> = repository
- .getData()
- .map { MyFeatureUiState.Success(it) }
- .stateIn(
- scope = viewModelScope,
- started = SharingStarted.WhileSubscribed(5_000),
- initialValue = MyFeatureUiState.Loading,
- )
- }
- ```
- ### Screen Pattern
- ```kotlin
- @Composable
- internal fun MyFeatureRoute(
- viewModel: MyFeatureViewModel = hiltViewModel(),
- ) {
- val uiState by viewModel.uiState.collectAsStateWithLifecycle()
- MyFeatureScreen(uiState = uiState)
- }
- ```
- ### Repository Pattern
- ```kotlin
- interface MyRepository {
- fun getData(): Flow<List<MyModel>>
- }
- internal class OfflineFirstMyRepository @Inject constructor(
- private val dao: MyDao,
- private val api: MyNetworkApi,
- ) : MyRepository {
- override fun getData(): Flow<List<MyModel>> =
- dao.getAll().map { it.toModel() }
- }
- ```
- ## Technology Stack
- This skill configures projects with:
- - **Language**: Kotlin
- - **UI**: Jetpack Compose
- - **Architecture**: MVVM with UDF
- - **DI**: Hilt
- - **Database**: Room
- - **Network**: Retrofit + Kotlinx Serialization
- - **Async**: Kotlin Coroutines + Flow
- - **Testing**: JUnit, Turbine, Compose Testing
- - **Build**: Gradle with Convention Plugins
- ## License
- This project is licensed under the MIT License - see the LICENSE file for details.
- ## Acknowledgments
- Based on patterns and practices from:
- - [NowInAndroid](https://github.com/android/nowinandroid) by Google
- - [Android Architecture Guidelines](https://developer.android.com/topic/architecture)
- - [Jetpack Compose Best Practices](https://developer.android.com/jetpack/compose)
- ## Resources
- - [Android Developer Documentation](https://developer.android.com)
- - [NowInAndroid Repository](https://github.com/android/nowinandroid)
- - [Kotlin Documentation](https://kotlinlang.org/docs/home.html)
- - [Jetpack Compose Pathway](https://developer.android.com/courses/pathways/compose)
Ratings and comments
Sign in to rate this skill.
Sign inFree to use. If it’s helped, pass it on.