almasumdev

Android adaptive icons and iOS app icon light/dark/tinted modes. Use this when creating or revising app launcher icons.

Cross-platform icon pipeline — SVG source, Android VectorDrawable, SF Symbols, Flutter/RN delivery, sizing, and parity. Use this when adding or refactoring the icon set.

Scalable, theme-aware illustrations for mobile — pipeline, tokenization, and platform delivery. Use this when authoring or shipping illustrations.

Structuring a cross-platform component library into primitives, patterns, and compositions with predictable folder layout and public API. Use this when starting or reorganizing a component library.

Slots, compound components, and headless primitives for flexible mobile component APIs. Use this when a component needs to serve many callers without becoming a grab-bag of props.

Modeling component variants as a closed matrix of size × intent × state, with explicit enums and slot APIs. Use this when designing or refactoring a component's public API.

Docs-as-code for design systems — Zeroheight, Storybook, DocC/DokkaHtml/dartdoc, and API reference. Use this when establishing or revising the documentation site.

Building a Style Dictionary v4+ pipeline with platform transforms and CI publishing. Use this when setting up or evolving the token build.

When and how to use a Backend-for-Frontend (BFF) for mobile -- scoping, ownership, and anti-patterns. Use when deciding whether a BFF is justified or designing one.

GraphQL server design tuned for mobile -- persisted queries, batching, N+1 mitigation, and Apollo client integration. Use when building or reviewing a GraphQL API for mobile apps.

Design mobile-friendly HTTP APIs with predictable pagination, filtering, sorting, sparse/partial responses, and a consistent error envelope. Use when specifying new endpoints or reviewing existing ones for mobile use.

REST conventions tuned for mobile clients -- resources, HTTP caching, idempotency, and versioning. Use when designing or reviewing RESTful endpoints.

Server-side OAuth 2.1 + PKCE for native mobile apps -- authorization endpoint, token endpoint, refresh rotation, and device binding. Use when implementing or reviewing the auth server for mobile clients.

Model multi-device sessions on the backend with sliding vs absolute expiry, device listing, and remote logout. Use when building the session model or a "Your devices" screen.

Choose between access+refresh tokens and opaque server sessions for mobile; design revocation and device binding. Use when deciding the token model for a new mobile backend or hardening an existing one.

Baseline infrastructure for a mobile backend -- edge caching, feature flags, and multi-region strategy. Use when planning or auditing the deployment shape of a mobile backend.

Schedule, batch, and constrain background work with WorkManager, BGTaskScheduler, and push-over-poll patterns to minimize battery and data cost.

Attribute battery drain to CPU, radio, GPS, display, and background work using Android Battery Historian and Xcode Energy Log / Instruments Energy gauge.

Shrink APK/AAB and IPA size with R8/ProGuard, dead-code elimination, asset hygiene, and Android App Bundle / App Thinning best practices.

Cut local and CI build times on Android (Gradle config cache, build cache, KSP over KAPT) and iOS (Xcode build cache, ccache, modules). Use when clean builds exceed ten minutes.

Downsample, cache, and choose the right image format (AVIF, HEIC, WebP) to cut memory, network, and decode time on iOS and Android.

Find and fix common memory leaks caused by listeners, closures, singletons, and lifecycle mismatches on iOS, Android, Flutter, and React Native.

Capture and analyze heap dumps on Android (Android Studio Profiler, LeakCanary) and iOS (Instruments Allocations/Leaks). Use when memory-related crashes or growth are suspected.

Deliver responsive images via CDN with AVIF/WebP, placeholders, and progressive loading on iOS, Android, Flutter, and React Native.

Idiomatic use of `expect`/`actual` declarations in Kotlin Multiplatform, when to prefer interfaces + DI instead, and how to design platform abstractions that age well. Use when you need platform-specific behavior in `commonMain`.

Canonical Kotlin Multiplatform project layout — source set hierarchy (commonMain, androidMain, iosMain, jvmMain, jsMain, wasmJsMain), module graph, and Gradle composite build patterns. Use this when bootstrapping a new KMP repo or restructuring an existing one.

How to split a Kotlin Multiplatform codebase into shared modules (domain, data, ui-shared, feature-*), keep DI boundaries clean across targets, and avoid "one giant shared module" pitfalls. Use when the `shared/` module starts ballooning.

GitHub Actions CI/CD for Kotlin Multiplatform — matrix builds (ubuntu for JVM/Android/JS, macOS for iOS), caching, Maven Central / SPM / CocoaPods publishing. Use when wiring CI or a release pipeline.

Gradle Kotlin DSL patterns for KMP — version catalogs, hierarchical source sets, convention plugins, assembling XCFrameworks and fat frameworks. Use when wiring or refactoring a KMP build.

Building an offline-first repository in KMP with Ktor + SQLDelight, including conflict resolution, background sync, and NetworkBoundResource-style flow. Use when designing features that must work without a connection.

Using `kotlinx.serialization` in a KMP codebase — JSON config, polymorphism, sealed hierarchies, custom serializers, and CBOR/ProtoBuf. Use when defining DTOs or wire formats.

Setting up the Ktor HTTP client in `commonMain` with per-platform engines, auth, interceptors, retries, and logging. Use when implementing networking for a KMP app.

Expert guidance on structuring a Java-based Android application using Clean Architecture, feature modularization, and dependency injection with Hilt. Use this when asked about project structure, module layout, or DI in a Java codebase.

Expert guidance on building an offline-first data layer in Java using Room, Retrofit, and the Repository pattern. Use this when designing repositories, DAOs, DTO-to-entity mapping, or cache strategies.

Expert guidance on implementing MVVM in Java using Jetpack ViewModel and LiveData with unidirectional data flow. Use this when building screens, wiring Fragments/Activities to state holders, or reviewing MVVM code in Java.

Expert guidance on writing and maintaining Android Gradle build files in Groovy DSL for a Java project — product flavors, signing configs, build types, and dependency management. Use this when configuring build.gradle for new modules or flavors.

Expert guidance on setting up GitHub Actions CI for a Java Android project — JDK 17, Gradle caching, lint, unit + instrumented tests, signing, and Play Publisher. Use this when creating or tuning CI pipelines for a Java-based Android app.

Expert guidance on using java.util.concurrent (ExecutorService, ThreadPoolExecutor, Futures, ListenableFuture) on Android from Java. Use this when designing background work, custom thread pools, or cancellation-aware pipelines.

Expert guidance on Retrofit 2 + OkHttp 4 from Java — services, converters, interceptors, call adapters, timeouts, and error body parsing. Use this when building or reviewing the networking layer in a Java Android app.

Expert guidance on RxJava 3 for Android — Observable, Single, Flowable, schedulers, disposables, and error handling. Use this when building reactive pipelines or maintaining existing RxJava code in Java.

Biometric authentication on mobile using BiometricPrompt and LAContext, with keys cryptographically gated by user biometry. Use when adding unlock, re-auth, or step-up auth flows.

Multi-factor authentication on mobile — TOTP, push-based MFA, and recovery UX. Use when adding or reviewing a second factor.

OAuth 2.1 + PKCE for native mobile apps. Covers redirect URIs, AppAuth libraries, and the flows that are safe vs deprecated. Use when implementing or reviewing user login.

Handling access and refresh tokens on mobile — storage, rotation, revocation, and expiration. Use when wiring up the authenticated HTTP layer.

Anti-tampering on mobile — signature checks, runtime application self-protection (RASP), and realistic return on investment. Use to decide which integrity controls are worth shipping.

Code obfuscation on mobile — R8 / ProGuard on Android, SwiftShield and its limitations on iOS, and realistic expectations. Use when hardening release builds.

Detecting rooted Android and jailbroken iOS devices as a risk signal — not a silver bullet. Use when deciding which operations to allow on a compromised device.

GDPR on mobile — lawful basis per processing purpose, Data Subject Access Requests (DSAR), and deletion workflows. Use when shipping in the EEA / UK or any GDPR-aligned jurisdiction.

Emit JSON-structured logs on mobile with correlation ids, consistent field names, and redaction. Use when setting up logging in Kotlin, Swift, Dart, or TypeScript mobile code.

Emit counters, gauges, and histograms from mobile apps using OpenTelemetry metrics, with patterns for batching, labels, and avoiding cardinality explosions. Use when adding product or engineering metrics beyond the core RUM set.

Design actionable metric alerts for mobile telemetry that deep-link to traces and sessions, avoid paging noise, and page only for symptoms users feel. Use when creating or cleaning up Datadog / Grafana / Sentry alerts.

Define and capture the core mobile RUM SLIs (startup time, jank, ANR, crash, network error rate, battery) with Firebase, Sentry, Datadog, or OTel. Use when setting up client-side performance metrics.

Compare and configure mobile APM vendors (Firebase Performance, Sentry Performance, Datadog RUM Mobile, Embrace, New Relic Mobile) and pick the right one for the app. Use when selecting or migrating a performance-monitoring stack.

Measure mobile UX quality with frozen frames, slow frames, ANRs, app hangs, and interaction-to-next-paint style metrics. Use when diagnosing jank, adopting JankStats / MetricKit, or reporting UX health.

How mobile session replay works (view-hierarchy reconstruction, not screen recording), how to configure privacy masking, and the cost / privacy tradeoffs. Use when evaluating or enabling Sentry, Datadog, or LogRocket session replay on mobile.

Build funnel analytics and user-journey graphs on top of the mobile event taxonomy. Use when analyzing conversion, drop-off, or retention in Amplitude, Mixpanel, PostHog, or GA4.

Labels, errors, grouping, and autofill for mobile forms. Use this when building any screen that collects user input — login, signup, checkout, profile editing.

Announcing validation results, shaping error messages, and recovering focus. Use this when implementing client-side validation or async server-side errors in forms.

POUR (Perceivable, Operable, Understandable, Robust) principles translated to mobile contexts. Use this when kicking off a new feature or doing an accessibility triage of an existing screen.

WCAG 2.2 success criteria translated to mobile platforms — gestures, inputs, orientation, focus, and target size. Use this when scoping accessibility acceptance criteria for a mobile feature.

Keyboard, D-pad, and hardware-switch support on iOS (Full Keyboard Access), Android, Flutter, and React Native. Use this when building screens that must be usable without touch.

Supporting iOS Switch Control + Voice Control, Android Switch Access + Voice Access, and AssistiveTouch. Use this when building any interactive UI, especially custom gestures, drag-and-drop, or non-standard controls.

Minimum touch-target sizes, hit-slop, and spacing on iOS, Android, Flutter, and React Native. Use this when designing icon buttons, toolbars, list actions, or anything smaller than a full-width row.

Right-to-left (RTL) layout mirroring, bidirectional text, numerals, and accessibility implications on iOS, Android, Flutter, and React Native. Use this when supporting Arabic, Hebrew, Urdu, or Farsi locales.

Use Apple's phased release for automatic updates on iOS — behavior, pausing, resuming, and interaction with manual updates. Use this when shipping production iOS builds.

Use Play percentage rollouts and iOS phased release to limit blast radius. Use this when planning or operating a production release.

Generate keystores, enrol in Play App Signing, and understand v1/v2/v3/v4 APK signature schemes. Use this when setting up Android release signing.

Diagnose and fix common Apple and Google code-signing errors. Use this when a release build fails to sign, upload, or install.

Manage Apple certificates, provisioning profiles, automatic vs manual signing, and fastlane match. Use this when setting up iOS release signing.

Publish Android apps to Amazon Appstore, Huawei AppGallery, Samsung Galaxy Store, and deal with HMS vs GMS. Use this when targeting non-Google Android markets.

Release to the App Store using App Store Connect, TestFlight, metadata, and screenshots. Use this when shipping an iOS build to Apple.

Release to Google Play using internal/closed/open tracks, AAB uploads, and the Data Safety form. Use this when shipping an Android build to the Play Console.

Expert guidance on detecting mobile performance regressions — startup time, frame jank, scroll performance, binary size — with baselines and noise-aware thresholds. Use when setting up perf gates in CI or when a release is suspected of regressing.

Measure code coverage honestly across mobile stacks — JaCoCo (JVM), llvm-cov (iOS), lcov (Flutter), Jest (RN) — and report it to Codecov / Coveralls without chasing meaningless numbers. Use when setting up coverage or when asked to raise a coverage gate.

Expert guidance on running mobile test suites in CI — matrix design, caching, sharding, artifacts, required checks — without paying for slow, flaky runs. Use when configuring GitHub Actions, GitLab CI, Bitrise, or Codemagic for mobile testing.

Expert guidance on automated and manual accessibility testing for mobile apps — Espresso AccessibilityChecks, XCTest accessibility audits, Flutter a11y guidelines, RN a11y assertions. Use when adding a11y coverage or when asked how to catch accessibility regressions in CI.

Expert guidance on snapshot / golden image testing across mobile stacks — Paparazzi (Android), swift-snapshot-testing (iOS), golden_toolkit (Flutter), and RN snapshot tests. Use when asked to lock down UI visuals or catch unintended rendering regressions.

Compare and apply UI test tooling across mobile — Espresso, XCUITest, flutter_test / integration_test, Detox, and Maestro. Use when deciding which UI test layer fits a feature and how to structure selectors, waits, and page objects.

Expert guidance on writing fast, deterministic unit tests for mobile codebases across Kotlin, Swift, Dart, and TypeScript. Use when asked to structure unit tests, pick a runner, or apply the AAA pattern.

Guidance on choosing between fakes, stubs, and mocking libraries (MockK, Mockito, mocktail, ts-jest, Swift test doubles) for mobile unit tests. Use when asked to mock a collaborator or to decide which double to use.

Navigation patterns for mobile apps (stack, tab, modal, drawer, nested flows) with platform conventions across SwiftUI, Compose, Flutter, and React Native. Use when structuring navigation or handling deep links.

Comparison of mobile state management patterns (MVVM, MVI, TEA, Redux, BLoC, Observable, Compose state, SwiftUI state) and how to choose. Use when designing state flow or evaluating a state library.

Canonical mobile UI patterns (list, detail, tab, sheet, master-detail, search, form) with platform-aware guidance across SwiftUI, Compose, Flutter, and React Native. Use when designing or reviewing screens.

Mobile app lifecycle across iOS and Android (foreground, background, suspended, killed), state restoration, process death, and cross-platform parallels in Flutter and React Native. Use when handling background work, persistence of in-flight state, or resume flows.

Implementing and testing deep links on mobile - Android App Links, iOS Universal Links, custom URL schemes, attribution providers, and sunset guidance for Firebase Dynamic Links. Use when adding, debugging, or migrating deep link behavior.

End-to-end push notifications on mobile - FCM and APNs architecture, payload shapes, notification vs data messages, permissions, and cross-platform handling in Flutter and React Native. Use when adding, debugging, or rearchitecting push.

Pragmatic conflict resolution for mobile sync - last-write-wins, field-level merge, three-way merge, vector clocks, and CRDT basics. Use when two clients can modify the same record offline.

Designing a mobile app as offline-first - caching tiers, authoritative sources, read and write paths, and the boundaries between device and server. Use when a feature needs to work without connectivity or when diagnosing stale/inconsistent data.

Expert guidance on managing state in Jetpack Compose using ViewModel, StateFlow, remember/rememberSaveable, state hoisting, and unidirectional data flow. Use this when implementing screens or refactoring stateful composables.

Expert guidance on a modern Kotlin-first Android application architecture using Clean Architecture, Gradle module separation, version catalogs, and Hilt DI. Use this when asked about project structure, module layout, or dependency injection.

Expert guidance on building a Kotlin offline-first data layer with Room, Retrofit, Flow-based observables, and the repository pattern. Use this for repositories, caching, and synchronization.

Expert guidance on Gradle Kotlin DSL for Android — build.gradle.kts patterns, convention plugins in build-logic, version catalogs, and settings configuration. Use this when touching any build file.

Expert guidance on CI/CD for Kotlin Android projects — GitHub Actions, Gradle remote cache, signing, Play Publisher, and Firebase App Distribution. Use this when setting up or debugging CI pipelines.

Expert guidance on writing correct Kotlin coroutines — structured concurrency, scopes, dispatchers, cancellation, supervisorScope, and exception handling. Use this whenever you add suspending code.

Expert guidance on Kotlin Flow — cold vs hot flows, StateFlow / SharedFlow, common operators, combining, back-pressure, and testing with Turbine. Use this for any reactive data stream work.

Expert guidance on configuring Retrofit + OkHttp + kotlinx.serialization for Kotlin Android — interceptors, auth refresh, retries, error mapping, and test doubles. Use this for any networking setup.