kotlin-project-modularization

Analyze Kotlin Multiplatform and Android module boundaries for structural problems.

11|2|Updated Sep 8, 2015
One-click install
npx skills add https://github.com/jitrapon/astro-mobile --skill kotlin-project-modularization-jitrapon
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: kotlin-project-modularization
Source: https://github.com/jitrapon/astro-mobile/tree/main/.claude/skills/kotlin-project-modularization
Command: npx skills add https://github.com/jitrapon/astro-mobile --skill kotlin-project-modularization-jitrapon

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you evaluate whether a Kotlin Multiplatform or Android project is modularized in a way that improves ownership, dependency direction, build hygiene, and long-term maintainability.

Core Features & Use Cases

  • Module boundary review: Assess whether app, feature, data, and common modules have clear responsibilities.
  • Dependency analysis: Check whether dependencies flow in a clean direction and whether any module leaks internals.
  • Granularity and structure guidance: Identify when modules are too coarse, too fine, or using the wrong module type for the job.
  • Use case: Review a KMP app before a refactor and decide which modules should split, merge, or become more internal.

Quick Start

Review the repository's module graph and tell me what to split, merge, or hide to improve Kotlin Multiplatform modularization.

Frequently Asked Questions about kotlin-project-modularization

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

FAQPage Schema
How do I review Kotlin Multiplatform module boundaries for structural problems?

To review Kotlin Multiplatform module boundaries, analyze app, feature, data, and common modules to verify dependency direction, visibility control, granularity, and ownership cohesion. This structural analysis identifies leaked internals and incorrect module types during architecture audits.

What is the best way to analyze a dependency graph for Android modularization?

Analyzing an Android modularization dependency graph requires checking whether dependencies flow in a clean direction without leaking internals. This structural review assesses module granularity, ownership cohesion, and testability to determine which modules should split, merge, or become internal.

How do I know if my Kotlin modules are too coarse or too fine grained?

To determine if Kotlin modules are too coarse or too fine, assess their granularity and structure against ownership cohesion. Evaluating module type choice and responsibility boundaries reveals whether modules should split, merge, or hide internals to improve maintainability.

Can I use this modularization review for Kotlin Multiplatform and Android apps?

Yes, this modularization review applies to both Kotlin Multiplatform and Android apps. It evaluates app, feature, data, and common modules during design reviews, refactors, and architecture audits to verify dependency direction, visibility control, and testability.

When should I refactor Android modules to hide internals?

You should refactor Android modules to hide internals when dependency analysis reveals leaked module internals or incorrect dependency directions. Adjusting visibility control and module type choice during a refactor improves build hygiene and long-term maintainability.