Skills
skills/vasilyu1983/ai-agents-public/software-mobile

software-mobile

SKILL.md

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)

Android (Core)

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.

Common Patterns

App Startup Checklist

  1. Initialize dependencies

    • Configure DI container (Hilt/Koin/Swinject)
    • Set up logging and crash reporting
    • Initialize analytics

  2. Check authentication state

    • Validate stored tokens
    • Refresh if needed
    • Route to login or main screen

  3. 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

Shared Checklists

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

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

  1. Search: "mobile development best practices 2026"
  2. Search: "[iOS/Android/React Native/Flutter] updates 2026"
  3. Search: "mobile framework comparison 2026"
  4. 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

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.
Weekly Installs
63
Repository
vasilyu1983/ai-…s-public
GitHub Stars
42
First Seen
Jan 23, 2026
Security Audits
Gen Agent Trust HubPass
SocketPass
SnykWarn
Installed on
codex48
gemini-cli47
cursor46
opencode46
github-copilot43
claude-code38