--- title: "The Compose Recomposition Mistakes I Keep Seeing in Production" url: https://daily.dev/posts/the-compose-recomposition-mistakes-i-keep-seeing-in-production-qbkrh7nka source_url: https://proandroiddev.com/the-compose-recomposition-mistakes-i-keep-seeing-in-production-214ecdb365cb type: article source: "ProAndroidDev" published: 2026-08-10T15:43:56.065Z updated: 2026-08-10T15:44:34.770Z tags: ["performance", "android", "kotlin", "jetpack-compose"] reading_time: 14 upvotes: 0 comments: 0 language: en --- > ## Documentation Index > Fetch the complete documentation index at: https://daily.dev/llms.txt > Use this file to discover all available pages before exploring further. # The Compose Recomposition Mistakes I Keep Seeing in Production **[ProAndroidDev](https://daily.dev/sources/pand)** · 14 min read · 0 upvotes · 0 comments ## Summary A deep dive into five common Jetpack Compose recomposition mistakes found in production codebases: creating objects (formatters, brushes, regexes) during composition, passing unstable domain models across module boundaries, misusing `remember` with wrong or missing keys, prop-drilling high-frequency values through multiple composable layers, and passing entire UiState objects where only a few fields are needed. Each mistake is shown with a before/after code example, an explanation of why it survives code review, and practical fixes. The post also covers four diagnostic tools — Layout Inspector recomposition counts, Compose compiler reports, composition tracing, and a debug recomposition highlighter — along with a six-point PR review checklist. ## Full article daily.dev links to this article rather than hosting it. Read it at the original source: ## Questions this post answers ### How do I stop unnecessary recompositions when passing a domain model to a Compose list item? Domain classes compiled outside the Compose compiler module are treated as unstable, forcing instance-equality checks instead of value equality. Mapping to an immutable UI model (all `val` fields, `ImmutableList` for collections) in the ViewModel before passing to the composable lets the compiler infer stability and skip unchanged items. For third-party or legacy classes you can't modify, declare them stable via the `stabilityConfigurationFile` compiler option. _Android teams navigating this boundary trade-off track Compose stability patterns on daily.dev._ ### What happens if I use remember without keys in Jetpack Compose? `remember` without keys caches the result of the lambda on the first composition and never recomputes it, even when the values the lambda closes over change. This silently ships stale data — the filtered list, formatted string, or computed value stays frozen at its initial state. Every variable the lambda reads must be listed as a key; an unstable key (e.g., a freshly constructed object) causes a cache miss on every recomposition, adding overhead with no benefit. _Developers catching `remember` bugs before they reach users share findings like this on daily.dev._ ### How can I stop a high-frequency value like a playback progress float from recomposing every composable layer it passes through in Jetpack Compose? Pass the value as a lambda `() -> Float` instead of a plain `Float` parameter. Intermediate composables hold a stable lambda reference and are skipped entirely. The leaf composable reads the lambda inside a `drawBehind` or `layout` block, so the change is replayed at the draw phase without triggering composition at all — achieving zero recompositions for a value updating ten times per second. _Developers optimizing Compose rendering pipelines find performance deep-dives like this on daily.dev._ ## Similar posts on daily.dev - [The Hidden Dangers of Jetpack Compose State \(And How to Fix Them With Real Examples\)](https://daily.dev/posts/the-hidden-dangers-of-jetpack-compose-state-and-how-to-fix-them-with-real-examples--gzvp0k5zv) · ProAndroidDev · 0 upvotes · 0 comments - [Jetpack Compose Performance Optimization](https://daily.dev/posts/jetpack-compose-performance-optimization-qw7nfjbya) · Towards Dev · 7 upvotes · 0 comments - [Leverage the essentials: Jetpack Compose best practices](https://daily.dev/posts/leverage-the-essentials-jetpack-compose-best-practices-xxhv9qgoo) · Medium · 0 upvotes · 0 comments --- Tags: [#performance](https://daily.dev/tags/performance), [#android](https://daily.dev/tags/android), [#kotlin](https://daily.dev/tags/kotlin), [#jetpack-compose](https://daily.dev/tags/jetpack-compose) [View this post on daily.dev](https://daily.dev/posts/the-compose-recomposition-mistakes-i-keep-seeing-in-production-qbkrh7nka)