Mobile Development Skill — Quick Reference Skill

Mobile Development Skill — Quick Reference

This skill equips mobile developers with execution-ready patterns for building native and cross-platform mobile applications. Apply these patterns when you need iOS/Android app architecture, UI components, navigation flows, API integration, offline storage, authentication, or mobile-specific features.

When to Use This Skill

Use this skill when you need:

iOS app development (Swift, SwiftUI, UIKit)
Android app development (Kotlin, Jetpack Compose)
Cross-platform development (React Native, WebView)
Mobile app architecture and patterns
Navigation and routing
State management (Redux, MobX, MVVM)
Network requests and API integration
Local data storage (Core Data, Room, SQLite)
Authentication and session management
Push notifications (APNs, FCM)
Camera and media access
Location services
App Store / Play Store deployment
Mobile performance optimization
Offline-first architecture
Deep linking and universal links

Quick Reference Table

| Task | iOS | Android | Cross-Platform | When to Use | |------|-----|---------|----------------|-------------| | Native UI | SwiftUI + UIKit | Jetpack Compose + Views | React Native | Native: Best performance; Cross-platform: Code sharing | | Navigation | NavigationStack | Navigation Component | React Navigation | Platform-specific for native feel | | State Management | @State/@Observable | ViewModel + StateFlow | Redux/MobX | iOS: @Observable; Android: ViewModel; RN: Redux | | Networking | URLSession + async/await | Retrofit + Coroutines | Axios/Fetch | Native: Type-safe; RN: JavaScript ecosystem | | Local Storage | Core Data + SwiftData | Room Database | AsyncStorage/SQLite | Native: Full control; RN: Simpler | | Push Notifications | APNs | FCM | React Native Firebase | Native: Platform-specific; RN: Unified API | | Background Tasks | BGTaskScheduler | WorkManager | Headless JS | For scheduled/background work | | Deep Linking | Universal Links | App Links | React Navigation linking | For URL-based app entry | | Authentication | AuthenticationServices | Credential Manager | Expo AuthSession | For social/biometric auth | | Analytics | Firebase/Amplitude | Firebase/Amplitude | Expo Analytics | Track user behavior |

Decision Tree: Platform Selection

Need to build mobile app for: [Target Audience]
    │
    ├─ iOS only?
    │   ├─ New app? → SwiftUI (modern, declarative)
    │   ├─ Existing UIKit codebase? → UIKit + incremental SwiftUI adoption
    │   └─ Complex animations? → UIKit for fine-grained control
    │
    ├─ Android only?
    │   ├─ New app? → Jetpack Compose (modern, declarative)
    │   ├─ Existing Views codebase? → Views + incremental Compose adoption
    │   └─ Complex custom views? → Custom View for fine-grained control
    │
    ├─ Both iOS and Android?
    │   ├─ Need maximum performance / platform fidelity?
    │   │   └─ Build separate native apps (Swift + Kotlin)
    │   │
    │   ├─ Need faster development + code sharing?
    │   │   ├─ JavaScript/TypeScript team? → React Native (Expo-managed or bare)
    │   │   ├─ Dart team? → Flutter
    │   │   └─ Kotlin team? → Kotlin Multiplatform (KMP)
    │   │
    │   ├─ Kotlin Multiplatform (KMP)?
    │   │   ├─ Share business logic only? → KMP shared module + native UI
    │   │   ├─ Share some UI? → Compose Multiplatform (validate iOS maturity for your needs)
    │   │   └─ Shared modules need platform UI? → Keep native UI, share domain/data/networking
    │   │
    │   └─ Wrapping existing web app?
    │       ├─ Simple wrapper? → WebView (iOS WKWebView / Android WebView)
    │       └─ Native features needed? → Capacitor or React Native WebView
    │
    └─ Prototype/MVP only?
        └─ React Native or Flutter for fastest iteration

Decision Tree: Architecture Pattern

Choosing architecture pattern?
    │
    ├─ iOS (Swift)?
    │   ├─ SwiftUI app? → MVVM with @Observable/ObservableObject (based on OS baseline)
    │   ├─ Complex SwiftUI? → TCA (Composable Architecture) for testability
    │   ├─ UIKit app? → MVVM-C (Coordinator pattern)
    │   ├─ Large team? → Clean Architecture + MVVM
    │   └─ Simple app? → MVC (Apple default)
    │
    ├─ Android (Kotlin)?
    │   ├─ Compose app? → MVVM with ViewModel + StateFlow
    │   ├─ Views app? → MVVM with LiveData
    │   ├─ Large team? → Clean Architecture + MVVM
    │   └─ Simple app? → Activity/Fragment-based
    │
    └─ React Native?
        ├─ Small app? → Context API + useState
        ├─ Medium app? → Redux Toolkit or Zustand
        └─ Large app? → Redux + RTK Query + feature-based structure

Decision Tree: Data Persistence

Need to store data locally?
    │
    ├─ Simple key-value pairs?
    │   ├─ iOS → UserDefaults
    │   ├─ Android → SharedPreferences / DataStore
    │   └─ RN → AsyncStorage
    │
    ├─ Structured data with relationships?
    │   ├─ iOS → Core Data or SwiftData
    │   ├─ Android → Room Database
    │   └─ RN → WatermelonDB or Realm
    │
    ├─ Secure credentials?
    │   ├─ iOS → Keychain
    │   ├─ Android → EncryptedSharedPreferences / Keystore
    │   └─ RN → react-native-keychain
    │
    └─ Large files/media?
        ├─ iOS → FileManager (Documents/Cache)
        ├─ Android → Internal/External Storage
        └─ RN → react-native-fs

Decision Tree: Networking

Need to make API calls?
    │
    ├─ iOS?
    │   ├─ Simple REST? → URLSession + async/await
    │   ├─ Complex API? → URLSession + Codable
    │   └─ GraphQL? → Apollo iOS
    │
    ├─ Android?
    │   ├─ Simple REST? → Retrofit + Coroutines
    │   ├─ Complex API? → Retrofit + OkHttp interceptors
    │   └─ GraphQL? → Apollo Android
    │
    └─ React Native?
        ├─ Simple REST? → fetch() or Axios
        ├─ Complex API? → RTK Query or React Query
        └─ GraphQL? → Apollo Client

Core Capabilities

iOS Development

UI Frameworks: SwiftUI (declarative), UIKit (imperative)
Architecture: MVVM, Clean Architecture, Coordinator, TCA (Composable Architecture)
Concurrency: Swift Concurrency (async/await, actors, TaskGroup); keep UI state on @MainActor; enable strict concurrency checks as appropriate
Storage: Core Data, SwiftData, Keychain
Networking: URLSession, async/await patterns
Platform compliance: Privacy manifests + required-reason APIs, background execution limits, and accessibility settings (Dynamic Type, VoiceOver)
Defensive Decoding: Handle missing fields, array/dict formats, snake_case/camelCase

Android Development

UI Frameworks: Jetpack Compose (declarative), Views (XML)
Architecture: MVVM, Clean Architecture, MVI
Concurrency: Coroutines, Flow, LiveData
Storage: Room, DataStore, Keystore
Networking: Retrofit, OkHttp, Ktor

Cross-Platform Development

Kotlin Multiplatform (KMP): Share domain/data/networking; keep native UI; consider Compose Multiplatform when shared UI is worth the constraints
React Native: JavaScript/TypeScript; evaluate New Architecture readiness and native-module surface area; Expo-managed path is often fastest for greenfield apps
Flutter: Dart; high code sharing; validate platform-specific gaps and plugin maturity for your requirements
WebView: WKWebView (iOS), WebView (Android), JavaScript bridge

Platform Baselines (Verify Current Requirements)

iOS/iPadOS (Core)

Privacy manifest files (app + embedded SDKs) are maintained and reviewed https://developer.apple.com/documentation/bundlereferences/privacy_manifest_files
Required-reason APIs are declared with valid reasons https://developer.apple.com/documentation/bundlereferences/privacy_manifest_files
Background work uses supported primitives (avoid fragile timers) https://developer.apple.com/documentation/backgroundtasks
App Transport Security is configured; exceptions are justified and documented https://developer.apple.com/documentation/bundlereferences/information_property_list/nsapptransportsecurity
Concurrency is implemented with Swift Concurrency (async/await, actors, TaskGroup) and checked with current Swift language mode settings https://docs.swift.org/swift-book/LanguageGuide/Concurrency.html
Swift 6 migration / strict concurrency guidance is followed when upgrading toolchains https://developer.apple.com/documentation/swift/adoptingswift6
UI/UX follows current Human Interface Guidelines (including accessibility) https://developer.apple.com/design/human-interface-guidelines/ios

Android (Core)

Background work uses WorkManager for deferrable, guaranteed work https://developer.android.com/topic/libraries/architecture/workmanager
Network calls and auth state survive process death (no hidden singleton assumptions) [Inference]
Target SDK meets current Google Play requirements (verify policy + deadlines) https://support.google.com/googleplay/android-developer/answer/11926878
Prefer Play Integrity API over deprecated SafetyNet Attestation https://developer.android.com/google/play/integrity
Prefer Credential Manager for passkeys and modern sign-in flows https://developer.android.com/identity/sign-in/credential-manager

Cross-Platform (Core)

Feature parity is explicit (document what is native-only vs shared) [Inference]
Bridges are treated as public APIs (versioned, tested, and observable) [Inference]
React Native upgrades follow the official upgrade guide; validate New Architecture readiness against your native-module surface area https://reactnative.dev/docs/upgrading
Expo SDK upgrades follow Expo release notes and upgrade guides https://expo.dev/changelog

Optional: AI/Automation Extensions

Note: Skip unless the app ships AI/automation features.

iOS: Core ML / on-device inference primitives https://developer.apple.com/documentation/coreml
Android: Google ML Kit https://developers.google.com/ml-kit
Verify: model size/battery impact, offline/online behavior, user controls (cancel/undo), and privacy boundaries [Inference]

Common Patterns

App Startup Checklist

Initialize dependencies
- Configure DI container (Hilt/Koin/Swinject)
- Set up logging and crash reporting
- Initialize analytics
Check authentication state
- Validate stored tokens
- Refresh if needed
- Route to login or main screen
Configure app state
- Load user preferences
- Set up push notification handlers
- Initialize deep link handling

Offline-First Architecture

1. Local-first data access
   - Always read from local database
   - Display cached data immediately
   - Show loading indicator for sync

2. Background sync
   - Queue write operations
   - Sync when connectivity available
   - Handle conflict resolution

3. Optimistic updates
   - Update UI immediately
   - Sync in background
   - Rollback on failure

Push Notification Setup

iOS (APNs):
1. Enable Push Notifications capability
2. Request user permission
3. Register for remote notifications
4. Handle device token
5. Implement notification delegate

Android (FCM):
1. Add Firebase to project
2. Implement FirebaseMessagingService
3. Handle notification/data messages
4. Manage notification channels (Android 8+)
5. Handle background/foreground states

Performance Optimization

| Area | iOS | Android | Metric | |------|-----|---------|--------| | Launch time | Pre-warm, lazy loading | Cold start optimization | < 2s cold start | | List scrolling | LazyVStack, prefetch | LazyColumn, paging | 60 FPS | | Image loading | AsyncImage, cache | Coil/Glide, disk cache | < 100ms visible | | Memory | Instruments profiling | LeakCanary, Profiler | No memory leaks | | Battery | Background App Refresh limits | Doze mode compliance | Minimal drain |

App Store Deployment Checklist

iOS App Store

[ ] App icons (all required sizes)
[ ] Launch screen configured
[ ] Privacy manifest per target and embedded frameworks (iOS 18+)
[ ] Required-reason APIs declared with justifications
[ ] Third-party SDK privacy manifests attached; SDK signature attestation (iOS 19+)
[ ] Info.plist permissions explanations
[ ] App Store screenshots (all device sizes)
[ ] App Store description and keywords
[ ] Privacy policy URL
[ ] TestFlight beta testing

Google Play Store

[ ] App icons and feature graphic
[ ] Store listing screenshots
[ ] Privacy policy URL
[ ] Content rating questionnaire
[ ] Target API level compliance
[ ] Data safety form
[ ] Internal/closed/open testing tracks

Navigation

Resources

references/ios-best-practices.md — iOS architecture, concurrency, testing, performance, defensive decoding, and accessibility
references/android-best-practices.md — Android/Kotlin architecture, coroutines, Compose, testing, performance
references/operational-playbook.md — Mobile architecture patterns, platform-specific guides, security notes, and decision tables
references/cross-platform-comparison.md — React Native vs Flutter vs KMP vs native: performance, ecosystem, CI/CD, migration paths
references/mobile-testing-patterns.md — Testing pyramid, XCTest, Espresso, Detox, Maestro, device farms, performance testing
references/offline-first-architecture.md — Local databases, sync strategies, conflict resolution, background sync, optimistic updates
references/push-notifications-guide.md — APNs, FCM, permission patterns, notification channels, rich notifications, analytics
references/deep-linking-guide.md — Universal Links, App Links, deferred deep links, React Native integration, routing architecture
data/sources.json — Curated external references by platform

Shared Checklists

../software-clean-code-standard/assets/checklists/mobile-release-checklist.md — Product-agnostic mobile release readiness checklist (core + optional AI)

Shared Utilities (Centralized patterns — extract, don't duplicate)

../software-clean-code-standard/utilities/auth-utilities.md — Argon2id, jose JWT, OAuth 2.1/PKCE (backend auth for mobile clients)
../software-clean-code-standard/utilities/error-handling.md — Error patterns, Result types
../software-clean-code-standard/utilities/resilience-utilities.md — Retry, circuit breaker for network calls
../software-clean-code-standard/utilities/logging-utilities.md — Structured logging patterns
../software-clean-code-standard/utilities/testing-utilities.md — Test factories, fixtures, mocks
../software-clean-code-standard/references/clean-code-standard.md — Canonical clean code rules (CC-*) for citation

Templates

Anti-Patterns to Avoid

| Anti-Pattern | Problem | Solution | |--------------|---------|----------| | Blocking main thread | UI freezes, ANRs | Use async/coroutines for all I/O | | Massive view controllers | Hard to test/maintain | Extract to MVVM/services | | Hardcoded strings | No localization | Use NSLocalizedString/strings.xml | | Ignoring lifecycle | Memory leaks, crashes | Respect activity/view lifecycle | | No offline handling | Poor UX without network | Cache data, queue operations | | Storing secrets in code | Security vulnerability | Use Keychain/Keystore | | Using decode() without fallback | Crashes on missing/malformed API data | Use decodeIfPresent() with defaults | | Missing @Bindable for @Observable | NavigationStack bindings don't work | Add @Bindable var vm = vm in body |

Trend Awareness Protocol

IMPORTANT: When users ask recommendation questions about mobile development, you MUST use a web search capability (if available) to check current trends before answering. If web search is unavailable, say so and answer using data/sources.json, clearly flagging that the recommendation may be stale.

Trigger Conditions

"What's the best mobile framework for [use case]?"
"What should I use for [cross-platform/native/hybrid]?"
"What's the latest in iOS/Android development?"
"Current best practices for [Swift/Kotlin/React Native]?"
"Is [React Native/Flutter/Expo] still relevant in 2026?"
"[React Native] vs [Flutter] vs [native]?"
"Best approach for [offline/push/deep linking]?"

Required Searches

Search: "mobile development best practices 2026"
Search: "[iOS/Android/React Native/Flutter] updates 2026"
Search: "mobile framework comparison 2026"
Search: "[Expo/Swift/Kotlin] new features 2026"

What to Report

After searching, provide:

Current landscape: What frameworks/approaches are popular NOW
Emerging trends: New patterns or tools gaining traction
Deprecated/declining: Approaches that are losing relevance
Recommendation: Based on fresh data and recent releases

Example Topics (verify with fresh search)

Current iOS + Swift Concurrency migration guidance
Current Play target SDK policy and identity/auth guidance
React Native New Architecture maturity and upgrade pain points
Expo-managed vs bare React Native tradeoffs
Flutter vs React Native vs KMP ecosystem in 2026
Compose Multiplatform readiness for iOS in 2026

Related Skills

../software-frontend/SKILL.md — Web-facing UI patterns and Next.js integration
../software-backend/SKILL.md — API design, auth, and backend contracts for mobile clients
../qa-testing-strategy/SKILL.md — Mobile CI, test strategy, and reliability gates
../qa-resilience/SKILL.md — Resilience patterns for networked mobile apps
../qa-testing-ios/SKILL.md — iOS-focused test planning, XCTest/Swift Testing patterns, device matrix, and app health checks
../software-ui-ux-design/SKILL.md — Mobile UI/UX design patterns and accessibility

Fact-Checking

Use web search/web fetch to verify current external facts, versions, pricing, deadlines, regulations, or platform behavior before final answers.
Prefer primary sources; report source links and dates for volatile information.
If web access is unavailable, state the limitation and mark guidance as unverified.

Agent Skills: Mobile Development Skill — Quick Reference

Install this agent skill to your local

Skill Files