Android
AuraScore 83/100

Enterprise Android Architecture Modularization Matrix

Evaluate monolithic enterprise codebases to produce a multi-module migration matrix.

Use this template when advising professional services clients on migrating legacy Android codebases into scalable dynamic feature or layer-based modules. It establishes a structured triage across dependency coupling, build performance, and team ownership.

Template

Role: Staff Android Systems Architect specializing in enterprise codebase modernizations.

Context

  • Client Application: {{client_app_name}}
  • Current Architecture: {{legacy_architecture_pattern}}
  • Target Modularization Model: {{target_modularization_approach}}
  • Build System and Tooling: {{build_system_tooling}}
  • Core Business Verticals: {{key_business_verticals}}
  • Engineering Org Structure: {{team_topologies_model}}

Task

Generate a comprehensive multi-module migration decision matrix that maps monolithic packages to isolated Gradle modules while mitigating dependency cycles and reducing build times.

Method

  1. Analyze the coupling indices between the domain layers identified in {{legacy_architecture_pattern}} and target features.
  2. Map existing sub-packages against the strategic business domains in {{key_business_verticals}}.
  3. Identify high-risk dependency cycles across shared utility layers and core data sources.
  4. Formulate module boundary definitions aligned to {{target_modularization_approach}} (e.g., core, feature, api, impl).
  5. Evaluate build impact under {{build_system_tooling}}, quantifying cacheability and configuration time trade-offs.
  6. Assign module ownership boundaries tailored to {{team_topologies_model}} to reduce pull request merge contention.
  7. Score migration complexity, technical debt severity, and test coverage requirements for each target module.
  8. Construct the prioritization matrix categorizing modules into immediate, secondary, and long-term migration phases.

Constraints

  • MUST express all module transitions in a comparative matrix format with clear grading scales.
  • MUST NOT recommend circular module dependencies or monolithic core catch-all modules.
  • Analysis MUST explicitly address interface decoupling using API/Implementation module splits.
  • Every module migration path must include a concrete fallback rollback strategy.

Output format

  • Executive Architecture Summary (150-200 words)
  • Modularization Decision Matrix: Markdown table with columns: [Current Package, Proposed Module Name, Module Type, Dependency Weight (1-5), Build Impact Score, Team Owner, Migration Phase, Risk Factor]
  • Dependency Inversion Protocol (bulleted contract rules)
  • Phased Rollout Sequence (ordered list with milestone gates)

Self-review

  • Ensure all 8 matrix columns are fully populated without generic placeholder descriptions.
  • Verify that no proposed module introduces bidirectional dependencies.
  • Check that team allocations match the topology provided in {{team_topologies_model}}.
AuraScore breakdown
83/100Provisional
Instruction clarity15/15 · Strong

Explicit role, a named task, and discrete steps the model can follow.

Context architecture12/12 · Strong

Background, inputs and variables the model needs before it starts.

Constraint engineering12/12 · Strong

Hard boundaries — what the model must and must not do.

Output specification6/14 · Thin

A named, field-level shape for the response.

Reasoning structure10/10 · Strong

Ordered work items that force analysis before an answer.

Model compatibility10/10 · Strong

Length and structure that travel across frontier models.

Token efficiency5/10 · Thin

Signal density — instruction weight without padding.

Reusability7/7 · Strong

Documented variables so the scaffold adapts to new inputs.

Robustness5/5 · Strong

Quality bar, assumptions and behaviour when inputs are thin.

Observed performance1/5 · Thin

How much real usage the template has behind it.

developers
developers-android
professional-services
android
modularization
gradle