android-modularization

Design and enforce a four-layer multi-module Android architecture with strict dependency rules.

7|2|Updated Feb 23, 2026
One-click install
npx skills add https://github.com/javiercamarenatriguero/android-skills --skill android-modularization
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: android-modularization
Source: https://github.com/javiercamarenatriguero/android-skills/tree/main/android-modularization
Command: npx skills add https://github.com/javiercamarenatriguero/android-skills --skill android-modularization

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill addresses the complexity of managing large Android projects by providing a clear, scalable, and maintainable multi-module architecture that enforces strict layer isolation and prevents circular dependencies.

Core Features & Use Cases

  • Four-Layer Architecture: Defines app, feature, component, and common layers with clear responsibilities.
  • Dependency Rules: Enforces strict "depends on" rules between layers to maintain code health.
  • Module Structure Guidance: Provides templates for feature, component, and common modules.
  • DI and Navigation Centralization: Mandates that DI and navigation setup reside solely within the app module.
  • Integration Modules: Guides the creation of integration modules for cross-component orchestration.
  • Use Case: When starting a new Android project or refactoring an existing one, use this Skill to establish a robust modular architecture from the outset, ensuring long-term maintainability and team scalability.

Quick Start

Apply the android-modularization skill to structure a new Android project with a four-layer architecture.

Frequently Asked Questions about android-modularization

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

FAQPage Schema
How do I structure a scalable Android multi-module architecture?

Structure a scalable Android architecture by dividing your project into four layers: app, feature, component, and common. This enforces strict layer isolation, separates responsibilities, and prevents circular dependencies across modules.

What is the best way to prevent circular dependencies in large Android projects?

Prevent circular dependencies in large Android projects by enforcing strict dependency rules across a four-layer architecture. Layer isolation ensures features and components depend only on permitted modules, maintaining code health and scalability.

How do you manage inter-module dependencies in Android Gradle projects?

Manage inter-module dependencies in Android Gradle projects by applying a defined dependency graph. This graph restricts modules to depend only on specific lower layers, such as features depending on components and common modules.

Where should dependency injection and navigation setup reside in a modular Android app?

Dependency injection and navigation setup must reside solely within the app module in a modular Android app. Centralizing these configurations prevents feature modules from knowing about each other, ensuring strict layer isolation.

When do I need an integration module for cross-component orchestration?

Create an integration module for cross-component orchestration when multiple feature modules need to interact without violating layer isolation. This handles complex workflows across components while maintaining a clean dependency graph.

Can I use this four-layer modularization approach for refactoring an existing Android app?

You can use this four-layer modularization approach to refactor an existing Android app. It provides templates for feature, component, and common modules to gradually migrate code into a maintainable and scalable structure.