android-clean-architecture

Structure Android and Kotlin Multiplatform projects with Clean Architecture layers.

Updated May 9, 2026
One-click install
npx skills add https://github.com/kk20300113-png/my-claude-skills --skill android-clean-architecture-kk20300113-png
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: android-clean-architecture
Source: https://github.com/kk20300113-png/my-claude-skills/tree/main/android-clean-architecture
Command: npx skills add https://github.com/kk20300113-png/my-claude-skills --skill android-clean-architecture-kk20300113-png

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill solves the common pain point of disorganized, tightly coupled Android and Kotlin Multiplatform codebases that are hard to test, maintain, and scale as projects grow, by providing standardized, battle-tested Clean Architecture patterns.

Core Features & Use Cases

  • Standardized Module Structure: Pre-defined module boundaries (domain, data, presentation, core) with enforced dependency rules to keep business logic independent of frameworks.
  • Layer Pattern Templates: Ready-to-use implementations for UseCases, Repository interfaces/implementations, and data mappers compatible with Android (Room) and KMP (SQLDelight, Ktor) tech stacks.
  • Dependency Injection Setup: Pre-configured examples for Koin (KMP-friendly) and Hilt (Android-only) to eliminate boilerplate wiring between layers.
  • Real-World Use Case: When building a cross-platform fitness tracking app, use this Skill to keep your step tracking and workout logging business logic in a pure Kotlin domain layer, implement local storage with SQLDelight, and sync data via Ktor without leaking platform-specific code into shared modules.

Quick Start

Use the android-clean-architecture skill to structure your new Android or Kotlin Multiplatform project with properly separated domain, data, and presentation layers following Clean Architecture best practices.

Frequently Asked Questions about android-clean-architecture

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I structure a Kotlin Multiplatform project with clean architecture?

To structure a Kotlin Multiplatform project with clean architecture, you separate code into domain, data, and presentation layers. This keeps business logic in a pure Kotlin domain layer, ensuring it remains independent of platform-specific frameworks like Android or iOS.

How do I set up dependency injection for an Android clean architecture project?

You set up dependency injection for an Android clean architecture project by using pre-configured examples for either Koin or Hilt. Koin is suitable for Kotlin Multiplatform projects, while Hilt is tailored specifically for native Android-only development to wire layer dependencies.

Can I use SQLDelight and Ktor in the data layer of a clean architecture Android app?

Yes, you can use SQLDelight and Ktor in the data layer of a clean architecture Android app. The architecture provides ready-to-use repository implementations and data mappers compatible with SQLDelight for local storage and Ktor for network data syncing.

What is the best way to keep domain logic independent of Android frameworks?

The best way to keep domain logic independent of Android frameworks is by enforcing strict module boundaries and applying the dependency inversion principle. This ensures UseCases and Repository interfaces reside in a pure Kotlin domain layer without leaking platform-specific code.

Does clean architecture work with reactive data flows using Kotlin coroutines and Flows?

Yes, clean architecture works with reactive data flows using Kotlin coroutines and Flows. The architecture pattern supports implementing reactive data streams across the domain and data layers to handle asynchronous operations efficiently across Android and KMP projects.

Why use UseCase and Repository patterns for Android and KMP applications?

Use the UseCase and Repository patterns for Android and KMP applications to eliminate tightly coupled codebases. These patterns standardize module boundaries, making your project significantly easier to test, maintain, and scale as your cross-platform application grows.