SkillFoxx

Compose Skill Suite

Two Jetpack Compose skills: a repository audit scored 0–100 from compiler data and a coding helper that warns as you write.

  • 379 ★ on the repository
  • Last commit
  • MIT
Skill

Extended access

Why this level

  • Runs a Gradle build in the project and writes a report file to the repository root.
  • The skill's allowed tools include read, write, search and the command line.
All reasons and checks

hamen/compose_skillAuthor:Ivan Morgillo

Install

In your terminal, with SkillFoxx CLI

npx skillfoxx add skills/compose-skill-suite

Detects the agents on your machine, shows the access level and pins the version.

Other ways to install

Access and checks

How we review

Extended accessThe tool runs code or makes network calls and only reads external data.

  • Runs a Gradle build in the project and writes a report file to the repository root.
  • The skill's allowed tools include read, write, search and the command line.

This is third-party code. Review the repository files before installing.

What it does

A pair of skills for Android projects on Jetpack Compose. `jetpack-compose-audit` scans a repository, runs the build once and reads the Compose compiler reports. The result is a score from 0 to 100, ten points per four categories (performance, state, side effects, composable API quality), the three most important fixes and a full `COMPOSE-AUDIT-REPORT.md` at the project root. Every deduction cites an official developer.android.com page. `compose-agent` works while code is being written: the agent watches state phases, parameter stability, list keys, animations, navigation and tests using the references in the `references` folder.

Who it is for. Android developers and team leads who want a measurable quality score for Compose code and agent hints while editing.

Good fit when

  • Before a release you need to find places where a screen recomposes too often.
  • A repository has accumulated Compose code and a lead needs a score with file and line citations.
  • An agent writes a new screen and you want to avoid an animation that resets on every recomposition.
  • You are debugging a blurry launch icon on Android 12 and newer.

Not a fit when

  • A design or Material 3 compliance review: the score does not cover it.
  • A repository without Compose: the audit targets Android and Compose.
  • The project cannot be built and you need a score from compiler reports.
  • You need tests, focus or Compose Multiplatform scored separately: they appear as coverage notes only.

Example request

Score the :app module for Compose quality, run the audit and show the three most important fixes with files and lines.

Limitations

The audit runs a Gradle build, injecting `compose-reports.init.gradle` with `--init-script` and leaving your `build.gradle` files untouched. The build takes time and needs a working Android environment. The analysis targets Kotlin 2.0.20 or newer with Compose Compiler 1.5.4 or newer. Design and Material 3 stay outside the score. Tests, focus, keyboard and KMP appear only as coverage notes. The skill reads project files and writes the report to the project root.

How to disable. Uninstall the skills with `claude plugin uninstall` or delete the `jetpack-compose-audit` and `compose-agent` folders from the agent's skills directory. Delete the `COMPOSE-AUDIT-REPORT.md` file manually.

FAQ

How do I install Compose Skill Suite in Claude Code?

Through the marketplace: `/plugin marketplace add hamen/compose_skill`, then `/plugin install compose-agent@compose_skill` and `/plugin install jetpack-compose-audit@compose_skill`. `npx --yes skills add hamen/compose_skill --skill '*' -y` also works.

What goes into the audit score?

Four weighted categories: performance 35%, state 25%, side effects 20% and composable API quality 20%. Each gets 0 to 10 points and the total runs on a scale up to 100.

How do I run the audit?

With `/jetpack-compose-audit` and a repository or module path, or a request like "Audit this Compose repo". The build with compiler reports starts automatically.

How does compose-agent differ from the audit?

The audit checks finished code after edits, while `compose-agent` warns during writing, for example about state writes across phase boundaries.

Do I need to edit build.gradle?

No. The `compose-reports.init.gradle` script is attached with `--init-script` and your build files stay as they were.

Discussion

No questions or reviews yet.

Skills

A set of 26 skills on Jetpack Compose performance, from a measured audit to Baseline Profiles and R8

SkillMinimal access530

A skill for Jetpack Compose and Compose Multiplatform: the agent writes UI from references and checks it against androidx source

SkillMinimal access602

Skills for Kotlin, Jetpack Compose and Android: state and effects, performance, Flow, testing, benchmarks, Gradle and PR workflows

SkillExtended access1.2K
Official

Official set of 30 skills from the Android team: Jetpack Compose, AGP 9 upgrade, R8, Perfetto profiling, Navigation 3, CameraX, Google Play policies

SkillExtended access10.5K

21 skills for Android and KMP in Claude Code, Codex and Copilot CLI: Compose, coroutines, Flow, networking, storage, Gradle

PluginMinimal access173

Lets an agent render Jetpack Compose previews to PNG and see its UI edits: plugin, CLI, VS Code extension and MCP.

PluginExtended access127

Comparison with similar tools

Cards that share the main search query, and how they differ.

ToolOfficialRepository starsMain difference
Compose Skill Suite (this card)no379
Compose Performance Skillsno530a set of 26 Compose performance skills; here two skills with one score across four categories
Compose Agent Skillno602a reference skill for writing Compose code from androidx sources; here an audit scored from compiler data is added

README in short

The README lists versions and changes for both skills, a table of scoring categories with weights and typical Compose problems with the expected gain from fixing them. Three installation paths and migration from older layouts are described separately.

README badge

Original SKILL.md

---
name: jetpack-compose-audit
description: Audit Android Jetpack Compose repositories for performance, animation phase correctness, state management, side effects, composable API quality, and adjacent Android launch UX resource risks such as blurry Android 12+ splash icons. Scans source code, scores each category from 0-10, writes a strict markdown report, and summarizes the most important fixes. Use when reviewing a Compose codebase, rating repository quality, inspecting recomposition/state issues, animation issues, or running a Compose audit.
allowed-tools: Read, Glob, Grep, Write, Bash, Agent
argument-hint: "[repo path or module path]"
---

# Jetpack Compose Audit

This skill audits Android Jetpack Compose repositories with a strict, evidence-based report.

**Skill version:** 4.3.2 — released 2026-07-07. **Compose track:** Kotlin 2.0.20+ / Compose Compiler 1.5.4+ (Strong Skipping Mode default). See the README changelog for what changed.

It is intentionally focused on four categories:

- Performance
- State management
- Side effects
- Composable API quality

This skill does **not** score design or Material 3 compliance in v1. If the audit surfaces likely design-system problems, recommend a follow-up audit with the `material-3` skill (reference implementation: <https://github.com/hamen/material-3-skill>).

Testing, focus/keyboard navigation, and Compose Multiplatform are **coverage notes**, not score categories. Map those surfaces when present, flag obvious risk, and recommend the focused `compose-agent` references (`testing`, `focus`, `kmp`) as follow-up work. Do not fold them into the 0-100 score unless the same root cause clearly affects one of the four scored categories.

Android launch UX resources are also adjacent coverage, not a score category. Always scan splash-screen theme resources; if Android 12+ could render a static splash icon blurry, include it as an `Android Launch UX` finding and allow it into `Critical Findings` / `Prioritized Fixes` when the evidence is concrete.

## Out Of Scope In v1

Owned and deliberate scope choices — call out the limitation in the report rather than silently producing thin coverage:

- Material 3 compliance, theming, color/typography tokens — defer to the `material-3` skill.
- Accessibility scoring (`semantics`, content descriptions, touch-target sizing) — flag obvious gaps as a note, do not score.
- UI test coverage and Compose test rule patterns — note presence/absence, do not score; recommend `compose-agent focus on testing` for deeper review.
- Compose Multiplatform-specific rules (`expect`/`actual`, target-specific code paths) — note surface area and obvious platform-boundary risk; recommend `compose-agent focus on kmp` for deeper review.
- Wear OS / TV / Auto / Glance surfaces — note obvious focus / keyboard / D-pad risk; recommend `compose-agent focus on focus` for deeper review.
- Build performance (incremental compilation, KSP/KAPT choice).

If the user explicitly asks for any of these, narrow the scope and state it in the report.

## When To Use

Use this skill when the user asks to:

- audit a Jetpack Compose repository
- review Compose architecture or quality

Report a problem