compose-stability-diagnostics

Diagnose Jetpack Compose recomposition issues using compiler stability reports.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/soygabimoreno/Los-ANDROIDES --skill compose-stability-diagnostics
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: compose-stability-diagnostics
Source: https://github.com/soygabimoreno/Los-ANDROIDES/tree/main/.agents/skills/compose-stability-diagnostics
Command: npx skills add https://github.com/soygabimoreno/Los-ANDROIDES --skill compose-stability-diagnostics

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you diagnose why Jetpack Compose recomposes or fails to skip due to parameter stability, compiler reports, and instance churn, so UI performance becomes predictable.

Core Features & Use Cases

  • Understand strong skipping and comparison semantics: Learn how Kotlin 2.0.20+ strong skipping changes when unstable parameters break skippability, and how Compose compares stable vs unstable inputs.
  • Generate and interpret Compose compiler reports: Produce module/classes/composables metrics and read stability and skippability directly from the report files.
  • Apply targeted stability fixes: Convert interface collections to kotlinx.collections.immutable, use @Immutable/@Stable correctly, and stabilize lazy item inputs with hoisting and remember.

Quick Start

Run a release build with Compose compiler reports enabled for the module you suspect, then compare the reported composable and parameter stability to identify which inputs churn identity across recompositions.

Frequently Asked Questions about compose-stability-diagnostics

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

FAQPage Schema
Why does my Jetpack Compose screen recompose excessively when parameters seem unchanged?

Excessive Jetpack Compose recomposition typically happens when composable parameters lack stability, causing instance churn that breaks skippability. This Skill diagnoses parameter stability issues using compiler reports to identify unstable inputs and non-skippable restartable composables.

How do I generate and interpret Jetpack Compose compiler reports for stability diagnostics?

Generate Jetpack Compose compiler reports by running a release build with reports enabled for the suspected module. Read the generated module, class, and composable metrics files to interpret stability indicators and identify parameters churning identity across recompositions.

How does Kotlin 2.0 strong skipping change Compose parameter stability requirements?

Kotlin 2.0.20+ strong skipping changes when unstable parameters break skippability by altering how Compose compares stable versus unstable inputs. This Skill helps interpret these comparison semantics to determine why composables fail to skip.

What is the best way to fix unstable parameters in Compose lazy lists?

Fix unstable parameters in Compose lazy lists by stabilizing item inputs using hoisting and remember, converting interface collections to kotlinx.collections.immutable, and correctly applying @Immutable or @Stable annotations.

When should I use @Immutable versus @Stable annotations in Jetpack Compose?

Use @Immutable versus @Stable in Jetpack Compose based on compiler report stability indicators showing non-skippable restartable composables. This Skill guides correct annotation usage to resolve parameter instability and restore predictable skipping behavior.

Can I diagnose Compose recomposition issues without enabling compiler reports?

Diagnosing Compose recomposition without compiler reports is limited because you need generated class and composable metrics files to read stability and skippability indicators directly. This Skill workflow requires running a release build with reports enabled to identify unstable parameters.