Android Kotlin Pack

Why Your Compose State Machine is Leaking Memory

You know the feeling. You write a Composable function, it looks good in the preview, and then you drop it into the app. The first scroll janks. You add remember, but now the input field resets on every keystroke. You hoist the state to the ViewModel, and suddenly your UI is just a dumb view with a callback hell that's impossible to test. You try to optimize with derivedStateOf, but you miss a dependency, and now your LazyColumn items re-inflate unnecessarily, burning CPU cycles and battery.

This isn't a Compose problem; it's an architecture problem. We've seen teams spend weeks debugging recomposition loops that are actually caused by leaking contexts in ViewModels, or Retrofit calls that block the main thread because the data layer wasn't built with Flow in mind. The Android ecosystem moves fast. Jetpack Compose provides robust APIs for building adaptive user interfaces, but without a strict pattern, those APIs become a trap ^[1]. You end up with a monolithic ViewModel that holds everything, a Room DAO that returns raw List objects, and a dependency injection graph that's a spiderweb of @Singleton annotations that shouldn't be there.

We built the Android Kotlin Pack so you don't have to debug state hoisting by trial and error. This pack gives you production-grade templates for Compose screens, Retrofit interfaces, Room DAOs, and Hilt modules. It enforces the patterns that actually work: state hoisting, derived state, reactive data streams, and scoped dependency injection. You get the structure out of the box, so you can focus on shipping features instead of reinventing the wheel.

The Cost of "Works on My Machine" Architecture

Every hour you spend fixing a UI glitch is an hour you're not shipping. When your architecture is loose, those glitches compound. You ship a feature, and Crashlytics fills with OutOfMemoryError because your ViewModel retained a Context that outlived the screen. Your P99 latency spikes because a Room query isn't Flow-backed, forcing you to wrap it in runBlocking or risk a main thread violation. You spend three days refactoring the data layer because you didn't decouple the repository from the DAO, and now every new feature requires touching five files.

The cost isn't just time; it's technical debt that kills velocity. A 2024 study on mobile development cycles showed that teams with modular, type-safe data layers ship features 40% faster than those with monolithic architectures ^[7]. When your data layer is mixed with UI state, you can't test it in isolation. You have to spin up a real server, mock the network, and pray the Room database is in a clean state. Onboarding new developers takes weeks because they have to untangle your dependency graph and learn your undocumented patterns.

If you're using Flutter Starter Pack for cross-platform state management, you know how critical consistent patterns are. The same applies here. Without strict architecture, your Android codebase becomes a legacy project from day one. You're not building an app; you're maintaining a Frankenstein of patterns. The Android Kotlin Pack eliminates this by providing a canonical structure that scales. You get validation scripts that catch missing dependencies before they hit CI, templates that enforce type safety, and references that align with official Android developer guides. Stop paying the debt. Install the pack and ship with confidence.

How a Fintech Team Eliminated Room Deadlocks

Imagine a fintech team building a trading app with 200 endpoints. They started with a monolithic ViewModel. Network calls were mixed with UI state. Room DAOs returned List, causing main thread crashes when queries took too long. They adopted Clean Architecture ^[1], but their implementation was inconsistent. Some screens used MVI, others used MVVM, and the data layer was a mess of suspend functions and Flow emissions mixed together. They implemented Hilt, but misused @Singleton on a request-scoped Retrofit client, causing stale data and memory leaks.

The breaking point came when they added a new feature: real-time price updates. The existing architecture couldn't handle the concurrency. Room deadlocks appeared because multiple DAOs were writing simultaneously without proper transaction handling. Retrofit calls were duplicated because the repository didn't cache responses correctly. The team realized the issue wasn't code; it was missing patterns.

They audited their codebase and standardized on the Android Kotlin Pack. They replaced raw List returns with Flow emissions, ensuring reactive updates without boilerplate. They used derivedStateOf for scroll optimization, eliminating jank in their price lists. They implemented Response wrappers for Retrofit calls, so they could properly check HTTP status codes and handle errors without crashing. They validated their libs.versions.toml with a JSON schema, ensuring all dependencies were defined correctly. The result? Zero main thread crashes, 40% faster UI, and a codebase where new screens take hours, not days, to add. This is what happens when you stop guessing and start following proven patterns.

If you're comparing architectures, check how iOS Swift Development Pack handles SwiftUI state to see parallel approaches to reactive programming. For React Native teams, the React Native Mobile Pack offers insights into bridge optimization that complement Android's coroutine model.

What Changes When Your Data Layer is Type-Safe

With the Android Kotlin Pack installed, your team ships with type-safe data layers out of the box. Your Compose screens use derivedStateOf automatically, eliminating jank and unnecessary recompositions. Your Room DAOs emit Flow, ensuring reactive updates without boilerplate and leveraging the full power of SQLite ^[2]. Your Retrofit calls are wrapped in Flow with proper error handling, so you never miss a network failure. Hilt modules are pre-configured for scoping, so you don't leak memory or create duplicate instances.

The pack enforces Clean Architecture principles, separating concerns between UI, domain, and data layers ^[3]. Your repositories use suspend functions and Flow to abstract data sources, making testing trivial. You can mock the repository without touching the network or database. The validation script checks your project structure for required dependencies, Hilt usage, and state management patterns, exiting non-zero on failure. This means you catch architecture violations in CI, not in production.

You get a consistent architecture across all modules, making onboarding trivial and refactoring safe. You focus on features, not framework plumbing. The pack includes worked examples like a Movie Detail screen demonstrating adaptive layouts and error state handling, and a Repository implementing Clean Architecture with Room and Retrofit sources. These examples show you exactly how to structure your code, so you don't have to guess. If you need to test your UI, the Mobile Testing Pack provides end-to-end testing workflows that integrate seamlessly with this architecture.

What's in the Android Kotlin Pack

• skill.md — Orchestrator skill file defining the Android Kotlin Pack scope, referencing all templates, references, scripts, and examples. Provides high-level architecture guidance and workflow instructions.
• templates/compose-screen.kt — Production-grade Compose screen template demonstrating state hoisting, derivedStateOf for scroll optimization, adaptive layouts via mediaQuery, and ViewModel integration with stateIn.
• templates/retrofit-api.kt — Production-grade Retrofit API interface template using Kotlin Coroutines, Flow, Response wrappers, and proper error handling annotations for network calls.
• templates/room-dao.kt — Production-grade Room DAO template featuring Flow emissions, suspend functions, complex queries, and entity relationships for local data persistence.
• templates/di-module.kt — Hilt dependency injection module template for providing Retrofit, Room, and Repository instances with proper scoping and singleton patterns.
• references/compose-patterns.md — Canonical knowledge on Jetpack Compose patterns including state hoisting, derivedStateOf usage, LazyColumn optimization, adaptive layouts, and Glance widgets based on official docs.
• references/architecture-guide.md — Canonical knowledge on Android architecture including Clean Architecture principles, MVI/MVVM patterns, data layer responsibilities, and best practices from Android developer guides.
• scripts/validate-project.sh — Executable validation script that checks project structure for required dependencies, Hilt usage, and state management patterns. Exits non-zero on failure.
• validators/compose-deps-schema.json — JSON Schema validator for libs.versions.toml to ensure required Compose dependencies are defined with correct version references.
• examples/MovieDetailScreen.kt — Worked example of a Movie Detail screen using Compose, demonstrating adaptive layout, image loading placeholder, and error state handling.
• examples/MovieRepository.kt — Worked example of a Repository implementing Clean Architecture with Room and Retrofit sources, using Flow and suspend functions.

Ship Production-Grade Android Apps Today

Stop debugging state hoisting. Start shipping. The Android Kotlin Pack gives you the structure, templates, and validation tools to build scalable, type-safe Android apps. Upgrade to Pro to install.