android-module-structure
Module layout, dependency rules, and Gradle convention plugins for Android and Kotlin Multiplatform (KMP) projects. Use this skill whenever setting up a new Android/KMP project, deciding where a new module should live, asking "how should I structure this", creating a new feature module, adding a core submodule, configuring Gradle convention plugins, working with version catalogs, or making any decision about project-level architecture. Trigger on phrases like "set up the project", "add a module", "create a feature", "how should I structure", "project structure", "convention plugin", "build-logic", or "where does X live".
- License 许可
- GPL-3.0
- 最近更新
- 2026-11-14
- Stars
- ★ 1.4k
- Forks
- 82
01 前言 Front Matter
- name
- android-module-structure
- description
- Module layout, dependency rules, and Gradle convention plugins for Android and Kotlin Multiplatform (KMP) projects. Use this skill whenever setting up a new Android/KMP project, deciding where a new module should live, asking "how should I structure this", creating a new feature module, adding a core submodule, configuring Gradle convention plugins, working with version catalogs, or making any decision about project-level architecture. Trigger on phrases like "set up the project", "add a module", "create a feature", "how should I structure", "project structure", "convention plugin", "build-logic", or "where does X live".
03 SKILL.md 正文
Android / KMP Module Structure
Core Philosophy
- Feature-layered modularization: split by feature first, then by layer within each feature.
- Clean Architecture layers:
presentation→domain←data. Domain is innermost and depends on nothing. - Code lives in a feature module unless it is needed by more than one feature — then it moves to the appropriate
coresubmodule. - Features never depend on each other. Cross-feature shared data belongs in
core:domain(domain models) orcore:presentation(shared composables/UI logic), not in the owning feature.
Module Layout
:app
:build-logic ← Gradle convention plugins
:core:domain ← Shared domain models, repository interfaces, error types, Result
:core:data ← Shared data logic, Ktor HttpClient factory, shared DB schemas/DAOs
:core:presentation ← Shared UI utilities (ObserveAsEvents, UiText, etc.)
:core:design-system ← Reusable Compose components, colors, theme, typography
:feature:<name>:domain ← Feature-specific domain models, repo interfaces, error types
:feature:<name>:data ← Repo implementations, DTOs, mappers, Room DAOs
:feature:<name>:presentation ← ViewModel, screen composables, state, actions, events
For standalone, self-contained concerns that involve meaningful complexity (multiple classes, configuration, or a non-trivial API surface), create a dedicated module under :core (e.g., :core:location, :core:analytics). Do not create a separate module for a single class or a trivial utility — that belongs in an existing core module instead.
A shared Room database is a good candidate for a dedicated :core:database module. It contains the @Database class, all entity definitions, all DAOs, and migrations. Feature modules that need DB access depend on :core:database directly, while features that don't need it remain decoupled.
Dependency Rules
| Layer | May depend on |
|---|---|
presentation |
domain (own feature), core:domain, core:presentation, core:design-system |
data |
domain (own feature), core:domain, core:data |
domain |
core:domain only — never data or presentation |
:app |
everything (wires all modules) |
Every layer and module may access core:domain.
Convention Plugins (:build-logic)
Define a convention plugin for every non-trivial Gradle config:
| Plugin | Purpose |
|---|---|
android-application |
App module config (applicationId, versionCode, etc.) |
android-library |
Base Android library config |
android-feature |
Android library + Compose + Koin + shared feature deps bundled |
domain-module |
Pure Kotlin/KMP module, no Android deps |
compose |
Compose compiler + BOM |
koin |
Koin dependency block |
ktor |
Ktor client + serialization |
room |
Room + KSP config |
kotlinx-serialization |
KotlinX Serialization plugin + dep |
Use version catalogs (libs.versions.toml) for all dependency and version management. No hardcoded versions in build files.
Key Libraries
| Concern | Library |
|---|---|
| DI | Koin |
| Networking | Ktor Client |
| Local DB | Room |
| Preferences | DataStore |
| Navigation | Compose Navigation (type-safe) |
| Serialization | KotlinX Serialization (Ktor + Nav routes) |
| Image loading | Coil |
| Logging | Kermit |
| Async | Coroutines + Flow |
| Background tasks | WorkManager |
| Secrets | local.properties + BuildConfig (Android); BuildKonfig (KMP) |
| Testing | JUnit5, Turbine, AssertK, kotlinx-coroutines-test |
| UI testing | ComposeTestRule |
Checklist: Adding a New Feature Module
- [ ] Create
:feature:<name>:domain,:feature:<name>:data,:feature:<name>:presentationmodules - [ ] Apply appropriate convention plugins to each module (
domain-module,android-library/android-feature) - [ ] Verify no cross-feature dependencies are introduced
- [ ] If logic is shared across 2+ features, extract to the appropriate
coresubmodule
04 同仓库更多 Skills
review-animations
Reviews animation and motion code against a high craft bar derived from Emil Kowalski's design engineering philosophy. Default to flagging; approval is earned.
prototype
Build multiple genuinely different versions of a UI piece you describe, rendered behind a visual picker so you can flip through them live and promote the one that feels right. Only runs when explicitly invoked; it does not trigger on its own.
pick-ui-library
Pick the right library for a given frontend task from a curated, opinionated list — numbers, OTP inputs, charts, command menus, virtualization, drag and drop, toasts, state, styling, and more. Only runs when explicitly invoked; it does not trigger on its own.
improve-animations
Survey a codebase's animation and motion code as a senior motion advisor, then produce a prioritized audit and self-contained implementation plans for other agents (or cheaper models) to execute. Read-only on source code — it plans improvements, it does not apply them. Use when the user asks to "improve the animations", "audit the motion", "make this app feel better", or wants a roadmap of animation fixes rather than a review of a single diff.
grilling
Interview the user relentlessly about a plan or design. Use when the user wants to stress-test a plan before building, or uses any 'grill' trigger phrases.
grill-with-docs
A relentless interview to sharpen a plan or design, which also creates docs (ADR's and glossary) as we go.