OpenClaw Skills for Kotlin and Android Development

Building Android apps with Kotlin involves juggling a lot of moving pieces. Jetpack Compose layouts, coroutine-based async logic, Room database schemas, Hilt dependency injection graphs, and Gradle build scripts that somehow keep getting longer. Your AI agent can help with all of it — if it knows what it is doing.

Out of the box, most AI agents have decent Kotlin knowledge. But Android development has its own idioms, and the ecosystem moves fast. Jetpack Compose has gone through several API changes since its stable release. Coroutine best practices have shifted. Hilt annotations are easy to get wrong if your agent is working from outdated training data.

OpenClaw skills solve this by giving your agent focused, up-to-date instructions for specific parts of the Android stack. This guide covers the best skills available in the OpenClaw Bazaar skills directory for Kotlin and Android developers.

Jetpack Compose Skills

Jetpack Compose is the modern toolkit for building native Android UI, and it has its own mental model. Composable functions, state hoisting, recomposition — these concepts trip up agents that default to the old View-based system.

compose-ui-patterns (14,200 installs)

This skill teaches your agent to generate idiomatic Jetpack Compose code. It covers the full range of Compose patterns: stateless composables, state hoisting with remember and mutableStateOf, lazy lists with LazyColumn and LazyRow, and Material 3 component usage. The skill also includes guidance on Compose navigation using the NavHost API, which is one of the areas where agents most frequently produce outdated code.

What makes this skill stand out is its handling of recomposition. It teaches your agent to avoid common pitfalls like performing side effects inside composable functions without LaunchedEffect, or creating new lambda instances on every recomposition. If you have ever had your agent generate a Button with an inline lambda that causes unnecessary recompositions, this skill fixes that.

compose-previews-and-testing (6,800 installs)

Writing @Preview functions and Compose UI tests requires specific patterns that general Kotlin skills do not cover. This skill handles both. It teaches your agent to create parameterized previews with @PreviewParameter, set up ComposeTestRule for UI testing, and use semantic matchers like onNodeWithText and onNodeWithContentDescription.

The testing guidance is particularly useful. Compose testing has a different API than traditional Android instrumentation tests, and agents frequently mix up the two approaches. This skill keeps your agent on the right track.

Coroutines and Async Patterns

Kotlin coroutines are powerful but easy to misuse. Structured concurrency, dispatcher selection, and cancellation handling all require careful attention.

kotlin-coroutines-expert (11,500 installs)

This is the most popular coroutine skill on the Bazaar, and for good reason. It covers structured concurrency patterns with coroutineScope and supervisorScope, proper dispatcher usage (Dispatchers.IO for disk and network, Dispatchers.Default for CPU-intensive work), and Flow collection with stateIn and shareIn operators.

The skill also addresses Android-specific coroutine concerns. It teaches your agent to use viewModelScope in ViewModels, lifecycleScope in Activities and Fragments, and repeatOnLifecycle for lifecycle-aware Flow collection. Without this skill, agents tend to collect Flows in ways that leak or miss lifecycle events.

flow-state-management (5,300 installs)

If your app uses Kotlin Flow for state management — and most modern Android apps do — this skill fills in the details that the coroutines skill does not cover in depth. It teaches your agent to build unidirectional data flow architectures using StateFlow and SharedFlow, implement MVI patterns, and handle complex state transformations with operators like combine, flatMapLatest, and distinctUntilChanged.

Room Database Skills

Room is the standard persistence library for Android, and it has a lot of annotation-driven boilerplate that agents can either handle perfectly or get completely wrong.

room-db-patterns (8,900 installs)

This skill covers the full Room workflow: defining @Entity classes with proper column annotations, writing @Dao interfaces with suspend functions for coroutine integration, creating type converters for complex data types, and setting up database migrations. It also teaches your agent to write Room queries that return Flow<List<T>> for reactive UI updates.

Migration handling is where this skill really pays off. Room database migrations are notoriously error-prone, and agents without specific guidance tend to generate auto-migrations that silently drop data. This skill teaches your agent to write manual migrations with proper SQL ALTER TABLE statements and to include migration tests.

room-testing-helpers (3,200 installs)

Testing Room databases requires an in-memory database setup and specific assertion patterns. This skill teaches your agent to create test databases with Room.inMemoryDatabaseBuilder, write migration tests using MigrationTestHelper, and verify query results in coroutine test contexts. It pairs well with room-db-patterns for full coverage.

Hilt Dependency Injection

Hilt simplifies Dagger for Android, but it still has a learning curve. Modules, components, scopes, and entry points all need to be wired correctly.

hilt-di-android (9,600 installs)

This skill teaches your agent to set up Hilt from scratch: the @HiltAndroidApp application class, @AndroidEntryPoint annotations on Activities and Fragments, @HiltViewModel for ViewModels, and @Module classes with @Provides and @Binds functions. It covers scoping with @Singleton, @ViewModelScoped, and @ActivityScoped, and it includes guidance on providing dependencies for different build flavors.

The skill also handles the Hilt testing setup, which involves @HiltAndroidTest, HiltAndroidRule, and @UninstallModules for replacing production dependencies with test doubles. This is one of the most common areas where agents stumble without specific instructions.

hilt-multimodule (4,100 installs)

For apps with multiple Gradle modules — which is the recommended architecture for large Android projects — this skill extends hilt-di-android with multi-module patterns. It teaches your agent to define Hilt modules in feature modules, use @EntryPoint interfaces for cross-module access, and structure the dependency graph so that feature modules remain independent while sharing core dependencies.

Gradle Build Optimization

Android Gradle builds are complex. Build scripts involve plugins, dependency management, product flavors, build types, signing configs, and more.

android-gradle-expert (7,400 installs)

This skill covers the Android Gradle Plugin configuration in depth. It teaches your agent to configure build.gradle.kts files with proper Kotlin DSL syntax, set up product flavors and build types, manage dependency versions with a version catalog (libs.versions.toml), and optimize build performance with configuration caching and parallel execution.

The version catalog support is particularly valuable. Many agents still generate dependency declarations with hardcoded version strings scattered across multiple build.gradle.kts files. This skill ensures your agent uses the centralized libs.versions.toml approach that Google now recommends.

gradle-convention-plugins (3,800 installs)

For multi-module projects, convention plugins eliminate duplicated build logic across modules. This skill teaches your agent to create convention plugins in a build-logic module, define reusable configurations for Android library modules and feature modules, and apply them consistently across the project. It is an advanced skill that pairs well with android-gradle-expert and hilt-multimodule for large-scale Android projects.

Combining Skills for a Complete Android Stack

These skills work well together. A typical Android project might use compose-ui-patterns, kotlin-coroutines-expert, room-db-patterns, hilt-di-android, and android-gradle-expert as a baseline. That combination gives your agent solid coverage across UI, async logic, persistence, dependency injection, and build configuration.

For larger projects with multiple modules, add hilt-multimodule and gradle-convention-plugins. For projects with heavy testing requirements, add compose-previews-and-testing and room-testing-helpers.

You can browse all Android and Kotlin skills in the OpenClaw Bazaar skills directory and filter by install count to see what the community uses most.

Browse the Skills Directory

Find the right skill for your workflow. The OpenClaw Bazaar skills directory has over 2,300 community-rated skills — searchable, sortable, and free to install.

Browse Skills →

Built a Skill? List It on the Bazaar

If you have built a skill that others would find useful, publish it on the Bazaar. Reach thousands of developers and get feedback from the community.

Learn how to publish →