android-clean-architecture

Overview of android-clean-architecture skill

The android-clean-architecture skill helps you shape Android and Kotlin Multiplatform apps around clean boundaries instead of ad hoc feature code. It is best for engineers who need a practical architecture starting point for modules, dependency rules, UseCases, Repositories, and data-layer design—not a generic theory lesson.

What this skill is for

Use android-clean-architecture when you need to decide where logic belongs, how modules should depend on each other, and how to keep UI, domain, and data concerns from collapsing into one layer. It is especially relevant if you are standardizing a new codebase or refactoring a growing app.

Who benefits most

This android-clean-architecture skill fits teams building Android apps, KMP shared code, or Compose-based products that already feel too tightly coupled. It is also useful when you are choosing between feature modules, layered modules, or a simpler single-module setup with clean boundaries.

Main differentiators

Unlike a vague architecture prompt, android-clean-architecture focuses on concrete structure: module layout, allowed dependencies, repository placement, and where to put Room, SQLDelight, Ktor, Koin, or Hilt integration. That makes it more decision-oriented when you are trying to avoid overengineering or accidental layer leaks.

How to Use android-clean-architecture skill

Install and activate it

Use the android-clean-architecture install flow from your skills manager, then open the skill file and keep it in scope while planning or editing architecture. If your environment supports loading by path, point it at skills/android-clean-architecture/SKILL.md so the model can follow the architecture rules during the task.

Give it a concrete architecture job

The android-clean-architecture usage works best when you ask for a specific outcome, such as module breakdown, dependency mapping, or layer placement. Strong input names the platform, current stack, and constraint set.

Example prompt shape:

• “Design an android-clean-architecture module layout for a Compose + Hilt app with offline sync.”
• “Refactor this KMP feature into android-clean-architecture layers using Room on Android and SQLDelight in shared code.”
• “Review these modules and point out dependency rule violations.”

Read the right parts first

Start with SKILL.md, then focus on the sections that define when to activate, recommended layout, and dependency rules. Those are the parts that materially affect implementation choices. If your repo has only this single file, treat those sections as the source of truth and adapt them to your own package names and build setup.

Provide inputs that improve output quality

Give the skill a short inventory of what exists already: modules, persistence tools, DI framework, network stack, and whether the app is Android-only or KMP. Also state what you want preserved, such as existing feature boundaries or public APIs. The more specific your current state, the less likely the android-clean-architecture guide will invent unnecessary layers.

android-clean-architecture skill FAQ

Is android-clean-architecture only for new projects?

No. The android-clean-architecture skill is useful for both greenfield and refactor work. It is strongest when you need to impose boundaries on an existing app that has grown messy, because it helps you decide what to move without rewriting everything at once.

How is this different from a normal prompt?

A normal prompt can ask for layered architecture, but android-clean-architecture gives you a focused structure for Android and KMP decisions. That means better guidance on dependency direction, module naming, and where to place data source and repository code.

Is it beginner-friendly?

Yes, if you are willing to work from a concrete module map. It is less suitable if you want a high-level explanation of Clean Architecture with no implementation detail. Beginners get the most value when they use it to validate a simple, explicit structure rather than a sprawling one.

When should I not use it?

Do not use android-clean-architecture if your app is tiny, your team is intentionally avoiding layered architecture, or you only need a quick feature implementation with no modular design work. In those cases, the skill can add structure you do not need.

How to Improve android-clean-architecture skill

State the architecture decision you need

The fastest way to improve android-clean-architecture output is to ask for one decision at a time: module boundaries, dependency graph, data flow, or DI wiring. If you ask for “best architecture,” the result will usually be less useful than a request like “where should caching live in this KMP repository setup?”

Give the skill your real constraints

Mention the stack and limits that matter: Android only or KMP, Compose or XML, Room or SQLDelight, Ktor or Retrofit, Hilt or Koin, and whether offline-first is required. Those details change the recommended structure and prevent a generic android-clean-architecture guide from overfitting to the wrong backend or storage model.

Watch for common failure modes

The most common mistake is letting every feature own its own mini-architecture without shared rules. Another is placing business logic in presentation code because it is faster in the moment. Use the skill to check those boundaries early, then revise the result with your actual package tree and build files.

Iterate with a repo-shaped follow-up

After the first output, ask for a dependency audit or a file-by-file placement plan against your current tree. For example: “Map these existing packages to the android-clean-architecture layout and flag anything that should move to domain or data.” That kind of follow-up turns the skill from a concept guide into a migration tool.