compose_skillis an expert-level AI auditing tool for Jetpack Compose. It uses compiler reports and static analysis to generate quantifiable scores and actionable fixes for a project.Android Skillsprovides official upgrade and migration workflows. Together, they address the lack of visibility in Compose performance, state management, and upgrade paths. Keywords: Jetpack Compose, AI auditing, Android Skills.
These two projects cover two core scenarios: audit optimization and upgrade migration
| Parameter | compose_skill | Android Skills |
|---|---|---|
| Primary language | Markdown, Gradle scripts, rule configuration | Markdown, structured reference documentation |
| Core license | Refer to the GitHub repository license | Refer to the GitHub repository license |
| GitHub stars | Not provided in the source | Not provided in the source |
| Core dependencies | Gradle init script, Compose Compiler Reports, Ripgrep | Reference docs, official migration steps, constraint rules |
The source material makes it clear that the value of compose_skill is not in generic commentary. Its value comes from combining Compose compile-time metrics, source rule scanning, and AI-based judgment into a traceable, reproducible technical report.
By contrast, android/skills is closer to a collection of officially maintained operating manuals. It focuses on Android upgrade, migration, and adaptation workflows, with an emphasis on prerequisites, procedural constraints, and validation methods.
The core capability of compose_skill is turning Compose audit results into structured scores
compose_skill generates a COMPOSE-AUDIT-REPORT.md file. This report does more than provide a total score. It also lists the code location for each issue, the associated risk, the recommended remediation direction, and links to official references. That makes it well suited for ongoing team reviews.
./gradlew assembleDebug \
--init-script scripts/compose-reports.init.gradle
# Inject Compose compiler report configuration through an init script
# Collect metrics and reports while minimizing changes to business codeThis command dynamically injects Compose compiler reporting into the build so the later AI audit can rely on objective input data.
Based on the examples in the article, the score covers four dimensions: performance, state management, side effects, and Composable API quality. Performance carries the highest weight, and its score is constrained by metrics such as skippable%, stability, and how Lazy lists are implemented.
Its credibility comes from compiler metrics, not just prompt-based rules
Unlike a generic AI review, compose_skill includes a Gradle init script that captures reports and metrics from the Compose Compiler during the build. This means it can inspect real stability information instead of inferring issues only from surface-level code patterns.
@Composable
fun SearchScreen(viewModel: SearchViewModel) {
// Incorrect example: state collection may continue after the UI stops
val state = viewModel.uiState.collectAsState()
// Recommended direction: after adding lifecycle-runtime-compose,
// use a lifecycle-aware collection method
// val state = viewModel.uiState.collectAsStateWithLifecycle()
}This example demonstrates a common class of issue highlighted in the report: if an Android UI does not use lifecycle-aware state collection, it may introduce unnecessary overhead and overheated state updates.
The article specifically notes that the report includes the file and line number where each issue occurs, and directly references official Android documentation. This evidence chain makes the remediation advice easier for teams to trust and easier to apply during code review.
AI Visual Insight: This image shows a quantified scoring dashboard for a Compose project, with core dimensions including performance, state management, side effects, and API quality. The key message is not isolated warnings, but systematic evaluation: multiple dimensions are mapped to unified scores so teams can compare module health horizontally and use the results as quality thresholds in continuous integration.
Static source analysis fills in engineering details that compiler reports cannot see
In addition to compiler metrics, compose_skill defines detailed Ripgrep search strategies to detect issues such as derivedStateOf misuse, missing keys in remember, and ignored Scaffold inner padding. This helps cover scenarios that are difficult for the compiler to express directly but frequently fail in real codebases.
rg "collectAsState\(" app/ feature/
# Search for state collection that does not use lifecycle awareness
rg "remember \{" app/ feature/
# Search for remember call sites that may be missing keysThese rule-based searches quickly amplify high-frequency issues, allowing the AI to identify where risk is concentrated before combining that information with compiler reports to prioritize fixes.
More importantly, the article points out that the tool identifies the highest-impact fixes and predicts how much skippable% can improve after remediation. That makes it more than a diagnostic tool. It becomes an executable optimization roadmap.
AI Visual Insight: This image shows the issue aggregation and optimization benefit view in the audit results. The main idea is to connect “what should be fixed” with “how much improvement the fix can deliver.” Technically, this means the tool has evolved from static warning output into a decision support system with impact estimation, which is especially useful for performance governance and legacy project handoff scenarios.
Android Skills provides officially defined upgrade and migration workflows
The difference between android/skills and compose_skill is that android/skills does not emphasize scoring. It emphasizes standardized execution instead. Typical tasks include AGP 9 upgrades, migration from legacy XML to Jetpack Compose, Navigation 3 adoption, R8 analysis, and Edge-to-Edge adaptation.
These skills are built as structured documents that usually include prerequisites, execution steps, operating guidelines, and validation methods. They do not just tell AI what to do. They also specify what must not be done. For example, in upgrade scenarios they may restrict the use of certain additional scripts.
Skill document structure
1. Prerequisites # Prerequisites
2. Steps # Execution steps
3. Constraints # Prohibited actions
4. Validation # Validation methodsThis structure reduces randomness in upgrade-related tasks and ensures that both AI systems and engineers follow the same controlled path.
AI Visual Insight: This image shows the Android official Skills task list or capability catalog, covering typical engineering tasks such as AGP upgrades, Compose migration, navigation, and full-screen adaptation. It reflects how official best practices are being documented and modularized so AI can execute complex refactoring work through rules rather than relying on ad hoc generation.
Using both together is a better fit for real Android teams
If your goal is to discover what is wrong in a Compose project, start with compose_skill. If your goal is to migrate a project safely from a legacy stack to a modern one, start with android/skills.
In practice, the better approach is to chain them together: first use the official Skills to complete upgrades for AGP, XML, navigation, and related areas, then run compose_skill as a quantitative audit to verify whether the migration introduced new issues in state management, performance, or API design.
FAQ: The 3 questions developers care about most
1. How is compose_skill different from a typical linter?
A typical linter is better at rule-based warnings. compose_skill, however, combines Compose Compiler reports, source scanning, and AI-based explanation. It can identify issue locations, explain why they matter, recommend remediation paths, and attach official references.
2. Is it suitable for CI integration?
Yes. Because it outputs structured reports and scores, teams can define quality thresholds per module and automatically generate audit results after each submission for regression checks and technical debt management.
3. Can Android Skills replace manual upgrade planning?
Not completely, but it can significantly reduce trial and error. It makes official migration paths, constraints, and validation steps explicit, which makes it a strong baseline for AI and engineers collaborating on upgrade tasks.
Links
- compose_skill: https://github.com/hamen/compose_skill
- Android Skills: https://github.com/android/skills
Core summary: This article reconstructs and analyzes the capability boundary between compose_skill and Android Skills. The former combines Gradle compiler reports, static source analysis, and rule-based scoring to perform quantitative audits of Jetpack Compose projects. The latter provides official structured workflows for AGP upgrades, XML-to-Compose migration, Navigation 3 adoption, and Edge-to-Edge support.