Claude Android Ninja

Android Kotlin Compose Development

Route tasks through the Quick Reference table and Workflow Decision Tree; open linked references/ files only for the active task.

Quick Reference

Examples

Greenfield Android app with convention plugins

User goal: new repo matching the skill stack.

Actions: copy assets/settings.gradle.kts.template, assets/libs.versions.toml.template, assets/convention/ into build-logic/ per assets/convention/QUICK_REFERENCE.md; wire includeBuild("build-logic"); read modularization.md and gradle-setup.md.

Result: root + app + core modules with version catalog and convention plugins applied.

New feature screen (Compose + ViewModel)

User goal: one new flow in a feature module.

Actions: modularization.md for module naming and dependency direction; compose-patterns.md for Screen, state, effects; kotlin-patterns.md + coroutines-patterns.md for StateFlow / events; architecture.md for domain vs data boundaries.

Result: feature module with Screen composable, ViewModel, UiState, and DI aligned to existing graphs.

Offline-first list with Room 3 and remote API

User goal: cached list + network refresh.

Actions: compose-patterns.md for Paging 3 + RemoteMediator; architecture.md for repository placement; Room 3 + SQLiteDriver per Workflow Decision Tree database bullets and migration.md if upgrading.

Result: single source of truth in Room, UI driven by PagingData or equivalent pattern from the guide.

Target SDK / compile SDK bump (e.g. API 37)

User goal: migrate toolchain and platform requirements.

Actions: walk migration.md; pin AGP/Kotlin/KSP using gradle-setup.md and dependencies.md; cross-check edge-to-edge, media, security sections linked from the Workflow Decision Tree for API 37.

Result: compileSdk / targetSdk raised with manifest, Gradle, and feature code adjusted per the migration doc.

Troubleshooting

Workflow Decision Tree

Creating a new project? → Start with assets/settings.gradle.kts.template for settings and module includes → Start with assets/libs.versions.toml.template for the version catalog → Copy all files from assets/convention/ to build-logic/convention/src/main/kotlin/ → Create build-logic/settings.gradle.kts (see assets/convention/QUICK_REFERENCE.md) → Add includeBuild("build-logic") to root settings.gradle.kts → Add plugin entries to gradle/libs.versions.toml (see assets/convention/QUICK_REFERENCE.md) → Copy assets/proguard-rules.pro.template to app/proguard-rules.pro → Read modularization.md for structure and module types → Use gradle-setup.md for build files and build logic

Configuring Gradle/build files? → Use gradle-setup.md for module build.gradle.kts patterns → Use gradle-setup.md → "Build Performance" for optimization workflow, diagnostics, and bottleneck troubleshooting → Copy convention plugins from assets/convention/ to build-logic/ in your project → See assets/convention/QUICK_REFERENCE.md for setup instructions and examples → Copy assets/proguard-rules.pro.template to app/proguard-rules.pro for R8 rules

Setting up code quality / Detekt? → Use code-quality.md for Detekt convention plugin setup → Start from assets/detekt.yml.template for rules and enable Compose rules

Adding or updating dependencies? → Follow dependencies.md → Update assets/libs.versions.toml.template if the dependency is missing

Adding a new feature/module? → Follow module naming in modularization.md → Implement Presentation in the feature module → Follow dependency flow: Feature → Core/Domain → Core/Data

Building UI screens/components? → Read compose-patterns.md for screen architecture, state, components, modifiers → Use compose-patterns.md -> State Management -> "Loading and refresh UX" for stable layout during loads and refreshes (avoid full-screen spinners that wipe context) → Use android-theming.md for Material 3 colors, typography, and shapes → Always align Kotlin code with kotlin-patterns.md → Create Screen + ViewModel + UiState in the feature module → Use shared components from core/ui when possible

Handling State and Events? → Use StateFlow for state; Channel + receiveAsFlow() for strict one-shot UI commands; SharedFlow for multicast or replay-intended events (see coroutines-patterns.md) → Survive process death with SavedStateHandle (see compose-patterns.md)

Setting up app theme (colors, typography, shapes)? → Follow android-theming.md for Material 3 theming and dynamic colors → Use semantic color roles from MaterialTheme.colorScheme (never hardcoded colors); pair every fill with its on* partner - see Color Pairing Rules → Declare the full M3 color set in Color.kt (surface containers, dim/bright, *Fixed/*FixedDim) so dynamic color and contrast variants stay consistent - see Full Color Role Reference and Surface Container Hierarchy → Express depth via container tone first, shadows only for components that float over arbitrary content - see Tonal Elevation vs Shadows → Use outline for interactive borders/focus, outlineVariant for decorative dividers - see outline vs outlineVariant → Support light/dark themes with user preference toggle → Enable dynamic color (Material You) for API 31+, harmonize brand/extended colors against primary - see Brand Color Harmonization → Honor the system contrast slider on Android 14+ (API 34) by shipping Medium/High-contrast scheme variants and reading UiModeManager.getContrast() - see User Contrast Preference → For region-local palette overrides (destructive scopes, on-media toolbars), use a nested MaterialTheme with colorScheme.copy(...) - see Scoped Themes → Pick Card / OutlinedCard / ElevatedCard by surface separation, not importance, and override shapes at the token level - see Card Variants and Component Shape Defaults

Writing any Kotlin code? → Always follow kotlin-patterns.md → Ensure practices align with architecture.md, modularization.md, and compose-patterns.md

Setting up data/domain layers? → Read architecture.md → Hilt @Binds, scopes, and DI anti-patterns: architecture.md -> Domain Layer -> "Dependency Injection Setup" → Create Repository interfaces in core/domain → Create implementations in core/data using Room 3/Retrofit/DataStore → Use DataStore for simple key-value pairs, Room 3 for complex relational data (suspend / Flow DAOs, SQLiteDriver)

Implementing Lists and Scrolling? → Use LazyColumn/LazyRow with stable keys and contentType (see compose-patterns.md) → For large datasets, use Paging 3 (see compose-patterns.md -> "Paging 3") → For Room-backed grids with a remote API, use RemoteMediator (compose-patterns.md)

Handling Navigation? → Use Navigation3 for adaptive navigation (see android-navigation.md) → Avoid navigation anti-patterns (see android-navigation.md -> "Navigation Anti-Patterns")

Optimizing Performance? → Follow the Performance Checklist in android-performance.md → If the user asks for automated Play Console vitals (CI/Slack, no Play Console UI), use android-performance.md → Optional: Play Vitals observability (Play Developer Reporting API) → Use BasicTextField2 for high-frequency text input

Auditing battery drain or stuck wake locks? → Use android-performance.md → "Excessive partial wake locks (Play Vitals core metric)" for the threshold (>2 hr cumulative non-exempt per session, >5% of sessions over 28 days, enforced March 2026), the use-case-to-substitute matrix, sensor batching, and stuck-worker diagnosis → Required: UIDT API for user-initiated transfers; WorkManager + WorkInfo.stopReason for syncs; manual wake lock acquired only after packet arrival on sockets → Forbidden: a manual wake lock alongside FusedLocationProviderClient callbacks, MediaSessionService audio, or any system API that already wakes the CPU

Testing? → Read testing.md for testing philosophy and patterns → Use Turbine for testing Flow emissions (see testing.md -> "Testing Flow Emissions with Turbine") → Create Repository interfaces in core/domain → Implement Repository in core/data → Create DataSource + DAO in core/data

Implementing offline-first or data synchronization? → Follow android-data-sync.md for sync strategies, conflict resolution, and cache invalidation → Use Room 3 as single source of truth with sync metadata (syncStatus, lastModified) → Schedule background sync with WorkManager → Monitor network state before syncing

Setting up navigation? → Follow android-navigation.md for Navigation3 architecture, state management, and adaptive navigation → See modularization.md for feature module navigation components (Destination, Navigator, Graph) → Configure navigation graph in the app module → Use feature navigation destinations and navigator interfaces

Setting up deep links, App Links, Digital Asset Links, verification, Dynamic App Links, or custom schemes? → Read android-navigation.md → "Deep Links" for NavKey parsing, synthetic back stack, manifest filters, assetlinks.json, verification, DomainVerificationManager, Dynamic App Links (API 35), custom schemes, troubleshooting → Use testing.md → "Testing Deep Links" for am start, pm set-app-links / pm verify-app-links --re-verify / pm get-app-links / dumpsys package d, Digital Asset Links REST (append return_relation_extensions=true for dynamic rules), custom-scheme launch semantics, and instrumented onNewIntent tests → Required: Play Console → Release → Setup → App signing → uppercase SHA-256 in assetlinks.json; deep-link Activity android:exported="true", android:launchMode="singleTask", onNewIntent + setIntent; android:autoVerify="true" only on HTTPS intent-filters → Forbidden: security-critical flows on custom URI schemes - use HTTPS App Links

Adding tests? → Use testing.md for patterns and examples → Use testing.md for empty, loading, error, offline, permission-denied, and session-loss routing before tightening coverage → Use testing.md when choosing Compose Preview Screenshot Testing vs Roborazzi for visual regression → Use testing.md → "Screenshot Testing" for Compose Preview Screenshot Testing setup → Keep test doubles in core/testing

Handling runtime permissions? → Follow android-permissions.md for manifest declarations and Compose permission patterns → Request permissions contextually and handle "Don't ask again" flows → For Photo Picker, document contracts, FileProvider, URI grants, and sharesheet routing, use android-media.md and android-media.md → Sharing media and files

Showing notifications or foreground services? → Use android-notifications.md for notification channels, styles, actions, and foreground services → Check POST_NOTIFICATIONS permission on API 33+ before showing notifications → Create notification channels at app startup (required for API 26+)

Playing audio or video in the background (target SDK 37)? → Use android-media.md → "Background media playback hardening (API 37)" for MediaSessionService, mediaPlayback foreground service type, and MediaSession lifecycle → Required: declare FOREGROUND_SERVICE_MEDIA_PLAYBACK and android:foregroundServiceType="mediaPlayback"; build a MediaSession around a Media3 Player; release session and player in onDestroy(); stop the service on Player.STATE_ENDED → Forbidden: standalone MediaPlayer / AudioTrack / raw ExoPlayer background playback without a MediaSession; requestAudioFocus() from a service with no session; manual wake locks alongside MediaSessionService

Sharing logic across ViewModels or avoiding base classes? → Use delegation via interfaces as described in kotlin-delegation.md → Prefer small, injected delegates for validation, analytics, or feature flags

Adding crash reporting / monitoring? → Follow crashlytics.md for provider-agnostic interfaces and module placement → Use DI bindings to swap between Firebase Crashlytics or Sentry

Enabling StrictMode guardrails? → Follow android-strictmode.md for app-level setup and Compose compiler diagnostics → Use Sentry/Firebase init from crashlytics.md to ship StrictMode logs

Choosing design patterns for a new feature, business logic, or system? → Use design-patterns.md for Android-focused pattern guidance → Align with architecture.md and modularization.md

Measuring performance regressions or startup/jank? → Use android-performance.md for Macrobenchmark, Baseline Profiles, and ProfileInstaller setup → Keep benchmark module aligned with benchmark build type in gradle-setup.md → If the user explicitly requests to investigate jank or add custom trace points, use android-performance.md for System Tracing (androidx.tracing) setup → For trace-backed debugging rules (what to require from the user, what not to infer without artifacts), use android-performance.md

Setting up app initialization or splash screen? → Follow android-performance.md → "App Startup & Initialization" for App Startup library, lazy init, and splash screen → Avoid ContentProvider-based auto-initialization - use Initializer interface instead → Use installSplashScreen() with setKeepOnScreenCondition for loading state → Migrate windowBackground-only splash, dedicated SplashActivity, or Android 12+ double-splash issues via migration.md → Legacy splash to Splash Screen API

Adding icons, images, or custom graphics? → Use android-graphics.md for Material Symbols icons and custom drawing → Download icons via Iconify API or Google Fonts (avoid deprecated Icons.Default.* library) → Use Modifier.drawWithContent, drawBehind, or drawWithCache for custom graphics

Creating custom UI effects (glow, shadows, gradients)? → Check android-graphics.md for Canvas drawing, BlendMode, and Palette API patterns → Use rememberInfiniteTransition for animated effects

Ensuring accessibility compliance (TalkBack, touch targets, color contrast)? → Follow android-accessibility.md for semantic properties and WCAG guidelines → Provide contentDescription for all icons and images → Ensure 48dp × 48dp minimum touch targets → Test with TalkBack and Accessibility Scanner

Working with images and color extraction? → Use android-graphics.md → "Image Loading with Coil3" for AsyncImage, SubcomposeAsyncImage, rememberAsyncImagePainter, and Hilt ImageLoader setup → Use android-graphics.md for Palette API and color extraction

Implementing complex coroutine flows or background work? → Follow coroutines-patterns.md for structured concurrency patterns → Use appropriate dispatchers (IO, Default, Main) and proper cancellation handling → Prefer StateFlow (and SharedFlow where appropriate) over Channel for observable state; use Channel for one-shot commands as in coroutines-patterns.md → Use callbackFlow to wrap Android callback APIs (connectivity, sensors, location) into Flow → Use suspendCancellableCoroutine for one-shot callbacks (Play Services tasks, biometrics) → Use combine() to merge multiple Flows in ViewModels, shareIn to share expensive upstream → Handle backpressure with buffer, conflate, debounce, or sample

Need to share behavior across multiple classes? → Use kotlin-delegation.md for interface delegation patterns → Avoid base classes; prefer composition with delegated interfaces → Examples: Analytics, FormValidator, CrashReporter

Refactoring existing code or improving architecture? → Review architecture.md for layer responsibilities → Read architecture.md -> "Cross-cutting anti-patterns (quick reference)" for common layering mistakes → Check design-patterns.md for applicable patterns → Follow kotlin-patterns.md for Kotlin-specific improvements → Ensure compliance with modularization.md dependency rules

Debugging crashes, ANRs, or obfuscated stack traces? → Follow android-debugging.md for Logcat, ANR traces, and Compose recomposition debugging → Use android-debugging.md for R8 mapping files and manual de-obfuscation

Proposing install, cold start, or black-box smoke driven by ADB or UIAutomator? → Use testing.md for device targeting, am start, logcat smoke, and instrumented UIAutomator skeletons → Use testing.md for am start deep-link matrices and pm verify-app-links when the task is link verification, not generic launch

Auditing R8 keep rules / fixing release size or release-only crashes? → Use gradle-setup.md → "R8 Keep-Rules Audit" for the redundant-library list, impact hierarchy, subsuming-rule detection, reflection-narrowing playbook, and AGP 9 default-optimization re-audit

Going edge-to-edge / fixing IME, insets, or system-bar bugs? → Use compose-patterns.md → "Edge-to-Edge (Mandatory on API 36)" for IME insets (fitInside(WindowInsetsRulers.Ime.current) vs imePadding() ordering and double-padding pitfalls), system-bar appearance/contrast (isAppearanceLight*Bars, isNavigationBarContrastEnforced), NavigationSuiteScaffold / pane-scaffold inset handling, full-screen Dialog decorFitsSystemWindows, StatusBarProtection scrim, and the per-Activity edge-to-edge checklist → At target SDK 37, add IME visibility-after-rotation handling in the same guide's #### IME (soft keyboard) insets block → Manifest must set android:windowSoftInputMode="adjustResize" for any Activity hosting text input

Debugging performance issues or memory leaks? → Enable android-strictmode.md for development builds → Use android-performance.md for profiling and benchmarking → For ANR, jank, or main-thread claims without measurements, follow android-performance.md before concluding cause → Use android-debugging.md for LeakCanary and heap dump analysis → Check coroutines-patterns.md for coroutine cancellation patterns

Setting up CI/CD or code quality checks? → Use android-ci-cd.md for Play-bound AAB, tracks, signing boundaries, staged rollout, and upload automation routing → Use code-quality.md for Detekt baseline and CI integration → Use gradle-setup.md for build cache and convention plugins → Use testing.md for test organization and coverage

Handling sensitive data or privacy concerns? → Follow crashlytics.md for data scrubbing patterns → Use android-permissions.md for proper permission justification → Check android-strictmode.md for detecting cleartext network traffic

Migrating legacy code (LiveData, Fragments, Accompanist, RxJava, Room 2.x)? → Use migration.md for all migration paths (including Room 2.x → Room 3) → Use migration.md → Compose-XML interop (hardening) when ComposeView / AndroidView share a screen with XML or focus-sensitive Views → Follow architecture.md for MVVM patterns

Migrating to target SDK 37 (Android 17)? → Walk migration.md → Android 17 (API 37) Migration top to bottom, then open each cross-link inside that section for full rules → Ship JNI or bundled .so files: align ELF segments and Play 16 KB page-size checks per migration.md → 16 KB memory page size → Required: catalog compileSdk / targetSdk 37; pin agp, Gradle wrapper, kotlin, and ksp only after ./gradlew help succeeds per gradle-setup.md and dependencies.md; cleartext, loopback, CT, and explicit URI grants per android-security.md; adaptive large-screen layouts, adjustResize on the launcher Activity, and IME-after-rotation per compose-patterns.md; background audio/video via android-media.md; Robolectric rules per testing.md → Robolectric and SDK 37 (Android 17) only when JVM tests use RobolectricTestRunner → Forbidden: production-wide cleartext without domain-scoped Network Security Config; cross-process loopback without the API 37 permission where the platform requires it; background MediaPlayer / AudioTrack / raw ExoPlayer without Media3 MediaSessionService + mediaPlayback FGS + MediaSession; Robolectric releases older than 4.13 on current JDKs; ACTION_SEND (and similar) intents that attach content URIs without explicit FLAG_GRANT_READ_URI_PERMISSION or FLAG_GRANT_WRITE_URI_PERMISSION → `co

…(truncated)