claude-android-skill

🥈Silver

Claude Code skill for building Android apps with Google's architecture guidance. Enables operations teams to automate app development, following best practices from the NowInAndroid reference app.

17660Updated 2mo ago

Intermediate30min to implementautomation

Saves ~60 min per use

Quick InstallView Source

git clone https://github.com/dpconde/claude-android-skill.git

Works with:

Claude

Overview

About This Skill

This skill equips Claude with comprehensive knowledge of modern Android development patterns, including Clean Architecture with UI, Domain, and Data layers, Jetpack Compose best practices, multi-module project structure, offline-first architecture with Room, dependency injection with Hilt, and comprehensive testing strategies. It automatically activates when you request Android-related tasks, enabling Claude to generate feature modules, build Compose screens with MVVM pattern, set up repositories with offline-first architecture, configure navigation, and establish multi-module Gradle setups. The skill includes a Python script to automatically generate complete feature modules with API and implementation layers, proper Gradle build files, and Hilt dependency injection setup. Developers and operations teams benefit from faster Android app development while maintaining consistency with Google's official architecture guidelines and industry best practices.

How to Use

1. **Prepare Your Environment**: Ensure you have Android Studio with Kotlin plugin installed. Open your existing Android project or create a new one. 2. **Run the Skill**: Paste the prompt template into your AI assistant (Claude/ChatGPT) with your specific details filled in. Replace [FEATURE_NAME] with your desired feature (e.g., 'UserProfileFeature'), [PROJECT_PATH] with your project's root path. 3. **Review Generated Code**: The AI will generate all necessary files in the correct directory structure. Check the files in Android Studio to ensure they match your project's existing patterns. 4. **Add Dependencies**: The skill includes dependency suggestions in the output. Add these to your `build.gradle` files if not already present. 5. **Test the Implementation**: Run the generated unit tests to verify the feature works as expected. Use the preview composable to visually inspect the UI. 6. **Integrate with App**: Connect the new feature to your app's navigation graph or existing screens. Test the complete flow. Tip: For complex features, break them into smaller prompts (e.g., first generate the UI, then the ViewModel, then the data layer). Use the `--keep` flag in Claude Code if you want to review changes before applying them.

Use Cases

Create new Android feature modules with API and implementation layers

Build Compose screens following MVVM pattern with state hoisting

Set up repositories with offline-first architecture and Room

Configure multi-module Gradle projects with convention plugins

Setup & Installation

Quick Install

No install command available. Check the GitHub repository for manual installation instructions.

Alternative Install (Git Clone)

git clone https://github.com/dpconde/claude-android-skill

Requirements

Claude Code or compatible AI agent
Works with: Claude

Quick Start Guide

Install the Skill

Copy the install command above and run it in your terminal.

Open Your AI Agent

Launch Claude Code, Cursor, or your preferred AI coding agent.

Try It Out

Use the prompt template or examples below to test the skill.

Customize

Adapt the skill to your specific use case and workflow.

Usage Examples

Prompt Template

Build a new feature for my Android app following Google's recommended architecture (NowInAndroid reference). The feature is [FEATURE_NAME] and should include: 1) A UI layer with Jetpack Compose, 2) A domain layer with use cases, 3) A data layer with repository pattern, and 4) Proper dependency injection setup. Use Kotlin coroutines for async operations. Generate all necessary files in the correct directory structure under [PROJECT_PATH]. Include unit tests for the use cases and repository. Generate a sample screen preview for the UI component. Document any new dependencies in the build.gradle files.

Example Output

I've built the `TrendingNewsFeature` following Google's architecture guidelines. Here's what was generated in your project at `/android/app/src/main/java/com/example/myapp/trendingnews`:

**Directory Structure:**
- `TrendingNewsScreen.kt` (UI layer with Jetpack Compose)
- `TrendingNewsViewModel.kt` (ViewModel with state management)
- `TrendingNewsRepository.kt` (Data layer interface)
- `OfflineFirstTrendingNewsRepository.kt` (Concrete implementation)
- `GetTrendingNewsUseCase.kt` (Domain layer)
- `TrendingNewsModule.kt` (Dependency injection)

**Key Components:**
The `TrendingNewsScreen` displays a lazy column of news articles with pull-to-refresh functionality. The ViewModel maintains a `TrendingNewsUiState` with loading, success, and error states. The repository implements caching with Room database and network calls using Retrofit.

**Dependencies Added:**
```gradle
// build.gradle (Module)
implementation "androidx.compose.material3:material3:1.2.0"
implementation "androidx.lifecycle:lifecycle-viewmodel-compose:2.6.2"
implementation "androidx.room:room-runtime:2.6.0"
kapt "androidx.room:room-compiler:2.6.0"
implementation "com.squareup.retrofit2:retrofit:2.9.0"
implementation "com.squareup.okhttp3:logging-interceptor:4.12.0"
```

**Preview:**
```kotlin
@Preview(showBackground = true)
@Composable
fun TrendingNewsScreenPreview() {
    MyAppTheme {
        TrendingNewsScreen(
            uiState = TrendingNewsUiState.Success(
                articles = listOf(
                    NewsArticle("1", "Breaking News", "Headline", "Summary", "https://example.com/image.jpg"),
                    NewsArticle("2", "Tech Update", "Headline 2", "Summary 2", "https://example.com/image2.jpg")
                )
            ),
            onRefresh = {},
            onArticleClick = {}
        )
    }
}
```

**Tests Generated:**
- `GetTrendingNewsUseCaseTest.kt` (verifies business logic)
- `OfflineFirstTrendingNewsRepositoryTest.kt` (verifies data layer)

The feature follows NowInAndroid patterns with proper separation of concerns and uses Hilt for dependency injection. Would you like me to explain any part in more detail or make adjustments to the implementation?