skydoves/compose-performance-skills

Auditing Compose Performance runs a Measure → Diagnose → Fix → Verify workflow for broad Jetpack Compose slowdowns. Use it for perf audits, sprint kickoffs, and written reports when you need baseline metrics, causes, fixes, and verification.

Avoiding Subcomposition Pitfalls explains when SubcomposeLayout, BoxWithConstraints, or Scaffold cause repeated measure-phase composition in Jetpack Compose. Use it to replace unnecessary subcomposition with cheaper layout primitives or tune it when subcomposition is required.

Choosing DerivedStateOf helps decide when Jetpack Compose derivedStateOf reduces recompositions and when it is just overhead. It covers input-vs-output frequency, required remember wrapping, stale captures, and snapshotFlow for one-shot side effects.

Collecting Flows Safely helps migrate Compose screens from collectAsState() to collectAsStateWithLifecycle() and tame high-frequency flows with conflate(), distinctUntilChanged(), and snapshotFlow. Use it when background collection, unstable Flow parameters, or chatty streams are causing wasted work or extra recompositions.

Configuring Lazy Prefetch tunes Jetpack Compose lazy-layout cache windows and nested prefetch for heavy scrolling. Use it when dropped frames come from composition work, especially with LazyLayoutCacheWindow or inner lazy layouts.

Configuring R8 For Compose explains how to set up minification for a Jetpack Compose app with R8 full mode, resource shrinking, and minimal keep rules. Use it when enabling release shrinking, fixing missing keeps, or checking why Compose does not need blanket keep rules.

Debugging Recompositions finds which Jetpack Compose composables are recomposing and why using Layout Inspector counts, skip counts, and argument change reasons. It also covers runtime @TraceRecomposition checks to confirm fixes in release-like builds.

Deferring State Reads moves frequently changing Jetpack Compose state reads out of Composition and into Layout or Draw with lambda-based modifiers. Use it when scroll, animation, or drag state is causing recomposition and frame drops.

Diagnosing Compose Stability helps you identify unstable parameters and non-skippable composables from Compose Compiler Reports. Use it when investigating recomposition, jank, or whether a composable can be skipped; it diagnoses only and hands off fixes to a sibling skill.

Enforcing Stability In CI sets up a CI gate for Jetpack Compose stability using the compose-stability-analyzer plugin or ComposeGuard. It generates a committed .stability baseline and runs stabilityCheck to fail builds when stability regresses.

Generating Baseline Profiles creates and measures Jetpack Compose baseline profiles with Macrobenchmark and BaselineProfileRule. Use it to improve cold startup, first-scroll jank, and time-to-fully-drawn in release builds.

Iterating With AI And MCP lets an AI agent edit a Kotlin file, hot reload the app, take screenshots, and compare results to a design intent. Use it for autonomous Compose UI iteration, snapshot rollback, and full-install fallback when schema changes break reloads.

Migrating To Modifier Node helps you author custom Jetpack Compose modifiers and migrate legacy `Modifier.composed { }` factories to `Modifier.Node` and `ModifierNodeElement<T>`. Use it for node lifecycle, specialized node interfaces, and manual invalidation in custom modifier code.

Optimizing Lazy Layouts fixes scroll jank, lost item state, and broken animateItem() behavior in Compose lazy lists and grids. Use it to add stable keys, contentType, and hoist per-item allocations in mixed feeds.

Ordering Modifier Chains helps diagnose Jetpack Compose bugs caused by modifier order, such as wrong background paint, hit areas, clipping, or measurement. It also explains when not to hoist a Modifier chain with remember for performance.

Preserving State Across Reloads explains how Compose HotSwan’s three reload tiers affect scroll, dialogs, lazy items, remember values, ViewModel state, and SavedInstanceState. Use it to keep edits in tier 1 or hoist UI state when a reload escalates.

Setting Up Compose HotSwan installs the IDE plugin and Gradle compiler plugin, then verifies sub-second hot reload in a Compose app. Use it when you need live edits on a real device or emulator and want the canonical wiring.

Stability Analyzer IDE Plugin shows Compose stability feedback live in IntelliJ and Android Studio while you edit. It installs from disk, adds gutter colors, inline hints, and an UnstableComposable inspection with quick fixes.

Stabilizing Compose Types helps fix unstable Jetpack Compose parameters after a stability diagnosis identifies them. It covers structural rewrites, @Immutable/@Stable, immutable collections, and stability configuration files for third-party or Java types.

Testing Compose In Release Mode helps measure Jetpack Compose performance against a release build with R8 enabled and Live Literals off. Use it when startup, jank, recomposition, or compiler reports need production-like numbers.

Tracing Recompositions At Runtime instruments Jetpack Compose composables with @TraceRecomposition to print per-recomposition diffs to logcat and feed the live heatmap. Use it to confirm stability fixes or diagnose recomposition issues in release-like builds.

Understanding Hot Reload Limits explains which Kotlin and Compose edits HotSwan can hot-reload and which changes force a rebuild under ART schema rules. Use it when a change did not reload, before a refactor, or when planning edits to stay on the fast path.

Understanding Stability Inference explains why the Compose compiler classifies a class or composable parameter as stable, runtime, unknown, or unstable. Use it to trace the 12-phase inference algorithm, including generics, inheritance, cross-module $stable values, and stability annotations.

Using Efficient Effects helps choose the cheapest correct Jetpack Compose effect API for a given job. It covers LaunchedEffect, DisposableEffect, SideEffect, rememberUpdatedState, RememberedEffect, and ViewModelStoreScope when effects restart, leak, or capture stale callbacks.

Using Strong Skipping Correctly explains Compose Strong Skipping Mode, including how skippability changes, when lambdas are auto-remembered, and when to use escape hatches like @DontMemoize or @NonSkippableComposable. It helps verify the mode is active and audit recomposition behavior during migration or debugging.