mobile-ai-agents 1.0.23

package/skills/ios/swift-review.md

@@ -0,0 +1,124 @@
+# Skill — Swift Code Review
+
+**Platform:** iOS / macOS (Swift)  
+**Category:** Code Quality  
+**Composable With:** agents/ios/swift-reviewer/agent.md
+
+---
+
+## Purpose
+
+Primes an LLM with the most common Swift safety rules for a focused code review session. Use standalone for quick reviews or compose into the full Swift Reviewer agent.
+
+## When to Use
+
+- Quick inline review of a Swift class during a pair-programming session
+- When you want only memory safety and concurrency checks, not the full structured report
+- As a pre-commit hook prompt for Swift files
+
+---
+
+## Skill Prompt
+
+```
+When reviewing Swift code, enforce these rules:
+
+MEMORY SAFETY (ARC)
+- Every escaping closure that captures self must use [weak self] unless there is an explicit
+  documented reason to use [unowned self]. Unowned is only safe when self is guaranteed to
+  outlive the closure (e.g., non-escaping closures, closures stored inside self).
+- After [weak self], always guard let self = self else { return } before accessing self.
+- Flag every delegate property that is not declared weak — strong delegates create retain cycles.
+- Flag NotificationCenter observers not removed in deinit (use addObserver with a token
+  and store it as a property for automatic cleanup).
+
+FORCE UNWRAP
+- Every ! operator is a candidate for removal.
+- Preferred alternatives:
+  guard let x = optional else { return/throw/break }
+  optional ?? defaultValue
+  if let x = optional { ... }
+- The only acceptable ! is in @IBOutlet and in unit test assertions.
+
+MAIN THREAD SAFETY
+- All UIKit/SwiftUI mutations must occur on the main thread.
+- Flag any DispatchQueue.global().async block that writes to a @Published property,
+  UILabel, UIImageView, or any UI element without DispatchQueue.main.async wrapping.
+- Prefer @MainActor annotation on ObservableObject classes over scattered DispatchQueue.main.async.
+
+CONCURRENCY (Swift 5.9+)
+- Prefer async/await over completion handlers for new code.
+- Flag Task.detached — it loses the actor context and should be used only with explicit justification.
+- Flag unstructured Task { } in view bodies — use .task { } modifier instead (auto-cancelled on disappear).
+- Sendable conformance: types shared across actors must be Sendable or @unchecked Sendable with a comment.
+
+TESTABILITY
+- No singletons accessed directly: NetworkManager.shared, DatabaseManager.shared accessed
+  from within a class under test make it untestable — inject via protocol.
+- All testable classes should accept dependencies via init parameters with protocol types.
+
+For each issue: state the line or property name, what is wrong, and the corrected Swift snippet.
+```
+
+---
+
+## Example
+
+**Input (after applying skill):**
+```
+Review this Swift class:
+
+class ImageLoader: ObservableObject {
+    @Published var image: UIImage?
+
+    func load(url: URL) {
+        URLSession.shared.dataTask(with: url) { data, _, _ in
+            if let data = data {
+                self.image = UIImage(data: data)  // Main thread violation
+            }
+        }.resume()
+    }
+}
+```
+
+**Output:**
+```
+Line 6 — Strong self capture in completion handler
+  Problem: self.image is a @Published property that drives SwiftUI/UIKit updates.
+           Assigning it from a background URLSession callback is a main thread violation.
+  Fix:
+  URLSession.shared.dataTask(with: url) { [weak self] data, _, _ in
+      guard let self, let data = data else { return }
+      DispatchQueue.main.async {
+          self.image = UIImage(data: data)
+      }
+  }.resume()
+
+Better — use async/await instead:
+  @MainActor
+  func load(url: URL) async throws {
+      let (data, _) = try await URLSession.shared.data(from: url)
+      image = UIImage(data: data)
+  }
+  // @MainActor guarantees all property mutations are on the main thread.
+```
+
+---
+
+## Composition Example
+
+```
+Prepend this skill prompt before the Swift Code Reviewer system prompt to add
+ARC, force-unwrap, and concurrency checks alongside the full structured output.
+
+Or use standalone: paste this skill, then paste your Swift class and ask
+"Review this for the issues listed above."
+```
+
+---
+
+## Notes
+
+- Swift 6 strict concurrency makes many of these runtime errors into compile-time errors.
+  Set `SWIFT_STRICT_CONCURRENCY = complete` in your Xcode build settings to catch them early.
+- Objective-C interop files may require @objc annotations — the skill does not cover ObjC patterns.

package/skills/ios/swiftui-review.md

@@ -0,0 +1,49 @@
+# Skill — /swiftui-review
+
+**Platform:** iOS (SwiftUI)
+**Slash Command:** `/swiftui-review`
+**Composable With:** agents/ios/swift/agent.md
+
+---
+
+## Purpose
+
+SwiftUI view lifecycle audit — unnecessary redraws, incorrect state ownership, @StateObject vs @ObservedObject misuse, and performance issues.
+
+---
+
+## Skill Prompt
+
+```
+Audit the provided SwiftUI code for view lifecycle and performance issues:
+
+1. STATE OWNERSHIP
+   - @StateObject: owns the object lifecycle (use in the view that CREATES the object).
+   - @ObservedObject: receives an externally owned object (use in child views).
+   - Confusing these causes: premature deallocation (@ObservedObject in root view) or
+     memory leaks (new @StateObject created on every parent redraw).
+   - @State: local, ephemeral state only. Never use for shared or persisted data.
+
+2. UNNECESSARY REDRAWS
+   - Large ObservableObject with many @Published properties: every published change
+     triggers ALL views observing it. Split into focused models.
+   - body computed from non-@State, non-@Published values that change outside SwiftUI.
+   - Expensive operations in body (sorting, filtering large arrays): move to
+     computed properties on the ViewModel or use .task { } for async work.
+
+3. LIFECYCLE HOOKS
+   - .onAppear: correct for view-visible triggers but fires again on navigation return.
+     Use .task { } for async work that should be cancellable and lifecycle-aware.
+   - .onDisappear: ensure async tasks are cancelled; use structured concurrency.
+
+4. ENVIRONMENT
+   - @EnvironmentObject without ensuring injection — causes runtime crash if missing.
+   - Overuse of @EnvironmentObject for data not needed by every child.
+
+5. ANIMATIONS
+   - Animations triggered by @Published changes: wrap in withAnimation { } at the
+     call site, not inside the view.
+   - matchedGeometryEffect: requires @Namespace in the parent view, not the child.
+
+For each issue: view name, property/modifier, what causes the redraw, and the fix.
+```

package/skills/ios/swiftui-state.md

@@ -0,0 +1,122 @@
+# Skill — SwiftUI State Management Review
+
+**Platform:** iOS / macOS (SwiftUI)  
+**Category:** Code Quality  
+**Composable With:** agents/ios/swift-reviewer/agent.md, skills/ios/swift-review.md
+
+---
+
+## Purpose
+
+Focuses review on SwiftUI-specific state management mistakes — the most common source of bugs in SwiftUI apps. Covers property wrapper selection, view re-render costs, and lifecycle pitfalls.
+
+## When to Use
+
+- Reviewing a SwiftUI View file for correctness
+- When components exhibit unexpected re-renders or stale state
+- When onboarding a developer new to SwiftUI state management
+
+---
+
+## Skill Prompt
+
+```
+When reviewing SwiftUI code, enforce these state management rules:
+
+PROPERTY WRAPPER SELECTION
+- @State: local, ephemeral, value-type UI state owned by this view. Never use for reference
+  types — use @StateObject instead.
+- @StateObject: owns a reference-type ObservableObject. Created once for the view's lifetime.
+  ONLY use in the view that creates the object. Never pass an @StateObject down as @StateObject.
+- @ObservedObject: observes an ObservableObject it does NOT own. Use when the parent creates
+  the object and passes it down. If the parent is destroyed and recreated, the @ObservedObject
+  may be reset — flag this as a bug if the state must survive parent recreation.
+- @EnvironmentObject: injection through the view hierarchy. Flag if injected but never consumed,
+  or if used in deeply nested views without a clear injection point.
+- @Binding: two-way connection to a parent's @State. Flag if used to mutate parent state in
+  a way that creates a callback loop (child mutates binding → parent re-renders → child re-renders).
+- @AppStorage / @SceneStorage: persistent storage. Flag if used for large objects (>1KB) —
+  use it only for primitives and small strings.
+
+EXPENSIVE VIEW BODY
+- body must be a pure function of state. Flag any: network calls, file I/O, heavy computation,
+  or object instantiation directly in body (not in a .task, .onAppear, or @StateObject).
+- Flag ForEach or List over large collections where items are not Identifiable with stable IDs.
+- Flag animation code that runs unconditionally in body — use withAnimation { } or .animation() modifier.
+
+LIFECYCLE PITFALLS
+- .onAppear fires every time the view appears (tab switch, modal dismiss, navigation push/pop).
+  If the intent is "run once on first appear," use a @State Bool flag or .task (which respects
+  the view's lifetime and cancels on disappear).
+- .task is preferred over .onAppear for async work — it is automatically cancelled when the
+  view disappears.
+- Do not use DispatchQueue.main.async inside .task — the task already runs on the MainActor.
+
+EQUATABLE AND RE-RENDER OPTIMIZATION
+- Views with complex, stable subviews should conform to Equatable and use .equatable()
+  modifier to prevent unnecessary re-renders when parent state changes but this view's inputs don't.
+- Flag @ObservedObject properties where only one property is actually used — consider splitting
+  the ObservableObject or using Combine to observe a single publisher.
+
+For each issue: state the property/modifier/location, what is wrong, and the corrected SwiftUI code.
+```
+
+---
+
+## Example
+
+**Input:**
+```
+struct ProfileView: View {
+    @ObservedObject var viewModel = ProfileViewModel()
+
+    var body: some View {
+        VStack {
+            Text(viewModel.name)
+        }
+        .onAppear {
+            viewModel.loadProfile()
+        }
+    }
+}
+```
+
+**Output:**
+```
+Line 2 — @ObservedObject used where @StateObject is required
+  Problem: @ObservedObject var viewModel = ProfileViewModel() creates a new ProfileViewModel
+           on every re-render of the parent that contains ProfileView. The ViewModel loses its
+           state whenever the parent re-renders, causing loadProfile() to re-fire and losing
+           any in-progress state.
+  Fix: @StateObject private var viewModel = ProfileViewModel()
+       @StateObject guarantees the ViewModel is created once for the view's lifetime.
+
+Line 7 — .onAppear fires on every appear, not just once
+  Problem: If ProfileView appears multiple times (e.g., tab switch), loadProfile() fires
+           each time, causing redundant network calls and potential state resets.
+  Fix: Replace .onAppear with .task for async work (auto-cancelled on disappear),
+       or add a guard inside loadProfile() to skip if already loaded.
+  .task {
+      await viewModel.loadProfile()
+  }
+```
+
+---
+
+## Composition Example
+
+```
+Combine with skills/ios/swift-review.md for a full Swift + SwiftUI review:
+
+[paste swift-review.md skill prompt]
+[paste swiftui-state.md skill prompt]
+
+Now review this SwiftUI file: [paste file]
+```
+
+---
+
+## Notes
+
+- @Observable (Swift 5.9 / iOS 17+) replaces ObservableObject in new code. If the project targets iOS 17+, suggest migration.
+- The Equatable conformance optimization is most impactful in complex list cell views — measure with Instruments before applying widely.

package/skills/ios/unit-testing.md

@@ -0,0 +1,144 @@
+# Skill — iOS Unit Testing
+
+**Platform:** iOS / macOS (Swift)  
+**Category:** Code Quality  
+**Composable With:** agents/ios/swift-reviewer/agent.md, skills/ios/swift-review.md
+
+---
+
+## Purpose
+
+Reviews iOS unit tests (XCTest and Swift Testing) and guides generation of new tests. Covers async test patterns, mocking, isolation, and test naming conventions.
+
+## When to Use
+
+- When reviewing or writing tests for ViewModels, services, or use cases
+- When onboarding a developer new to Swift Testing (iOS 17+)
+- As a checklist before merging code with new untested logic
+
+---
+
+## Skill Prompt
+
+```
+When reviewing or writing iOS unit tests, enforce these rules:
+
+FRAMEWORK SELECTION
+- iOS 17+ / Swift 5.9+: prefer Swift Testing (@Test, @Suite, #expect, #require).
+  It is more expressive, supports parameterized tests, and integrates with Xcode 16.
+- iOS 16 and below: use XCTest (XCTestCase, XCTAssertEqual, async throws methods).
+- Do not mix frameworks in the same test target — pick one and be consistent.
+
+SWIFT TESTING PATTERNS (@Test)
+- Use #expect() for soft assertions (test continues on failure).
+  Use #require() for hard assertions (test stops on failure, like XCTUnwrap).
+- Name tests as plain sentences: @Test("returns nil when userId is empty")
+- Parameterized tests: @Test("validates email", arguments: ["", "bad", "a@b.com"])
+  func validateEmail(_ email: String) { ... }
+- Group related tests: @Suite("ProfileViewModel") struct ProfileViewModelTests { }
+- Async tests: mark the @Test func as async — no extra setup needed.
+  @Test func fetchProfileSucceeds() async throws { ... }
+
+XCTEST PATTERNS
+- Async tests: func testFetchProfile() async throws { ... } — no XCTestExpectation needed for async throws.
+- For Combine publishers: use XCTestExpectation + sink, or use the async sequence publisher.
+- @MainActor on the test class if testing @MainActor-isolated code:
+  @MainActor final class ProfileViewModelTests: XCTestCase { }
+
+MOCKING
+- Use protocol-based dependencies for all testable classes. Never mock concrete types.
+  protocol ProfileServiceProtocol { func fetchProfile(id: String) async throws -> Profile }
+  struct MockProfileService: ProfileServiceProtocol { var result: Result<Profile, Error> }
+- Mocks should be minimal structs defined in the test file, not external libraries.
+- Avoid Sourcery, SwiftMock, or OHHTTPStubs for unit tests — they add fragility.
+  Use URLProtocol subclasses for integration tests that hit URLSession.
+
+TEST ISOLATION
+- Each test must set up its own dependencies in setUp / @Test init — never share mutable state across tests.
+- Avoid singletons in tests — inject all dependencies. If testing a singleton, reset it in tearDown.
+- Use @TestStorage (Swift Testing) or static properties reset in setUp/tearDown to isolate global state.
+
+ASSERTIONS
+- Assert behavior, not implementation. Test what the system does, not how it does it.
+  Good: #expect(viewModel.state == .loaded(user))
+  Bad: #expect(mockService.fetchWasCalled == true) — tests the mock, not the ViewModel.
+- Test the unhappy path equally: empty input, network error, decoding failure, cancellation.
+- For async state (StateFlow, @Published): collect the state sequence with a timeout,
+  don't sleep(0.1) hoping the state has settled.
+
+NAMING
+- XCTest: func testGivenEmptyId_whenFetchCalled_thenReturnsError()
+- Swift Testing: @Test("returns error when id is empty")
+- One behavior per test. If a test method has two XCTAssert calls for unrelated things, split it.
+
+For each issue found: state the test name, what is wrong, and the corrected test code.
+```
+
+---
+
+## Example
+
+**Input:**
+```swift
+class ProfileViewModelTests: XCTestCase {
+    func testLoad() async {
+        let vm = ProfileViewModel(service: ProfileService())  // real service
+        await vm.loadProfile(id: "1")
+        XCTAssertNotNil(vm.profile)
+        XCTAssertNil(vm.errorMessage)
+        XCTAssertEqual(vm.state, .loaded)  // 3 assertions for same scenario
+    }
+}
+```
+
+**Output:**
+```
+testLoad — uses real ProfileService (not a mock)
+  Problem: The test hits the real network. It will fail in CI, be slow, and be non-deterministic.
+  Fix: Inject a MockProfileService that returns a canned result.
+
+testLoad — three assertions in one test
+  Problem: If the first assert fails, the others don't run, hiding additional failures.
+  Fix: One assertion per test, or use one assertion that covers the whole expected state.
+
+Corrected:
+  struct MockProfileService: ProfileServiceProtocol {
+      var result: Result<Profile, Error> = .success(Profile(id: "1", name: "Alice"))
+      func fetchProfile(id: String) async throws -> Profile {
+          try result.get()
+      }
+  }
+
+  @MainActor
+  final class ProfileViewModelTests: XCTestCase {
+      func testLoadSucceeds() async throws {
+          let vm = ProfileViewModel(service: MockProfileService())
+          await vm.loadProfile(id: "1")
+          XCTAssertEqual(vm.profile?.name, "Alice")
+      }
+
+      func testLoadSetsErrorOnFailure() async throws {
+          let service = MockProfileService(result: .failure(URLError(.notConnectedToInternet)))
+          let vm = ProfileViewModel(service: service)
+          await vm.loadProfile(id: "1")
+          XCTAssertNotNil(vm.errorMessage)
+          XCTAssertNil(vm.profile)
+      }
+  }
+```
+
+---
+
+## Composition Example
+
+```
+Use before generating tests with prompts/ios/generate-unit-test.md:
+paste this skill → paste the class to test → "generate a unit test following these rules."
+```
+
+---
+
+## Notes
+
+- Swift Testing is available from Xcode 16 / iOS 17+ minimum deployment target. For older targets, stick with XCTest.
+- `@MainActor` on the test class is required when the ViewModel under test is `@MainActor` — otherwise actor isolation warnings become errors in Swift 6.

package/skills/ios/xcode-warnings.md

@@ -0,0 +1,37 @@
+# Skill — /xcode-warnings
+
+**Platform:** iOS (Swift / Xcode)
+**Slash Command:** `/xcode-warnings`
+
+---
+
+## Purpose
+
+Explains Xcode warnings and Swift compiler warnings in plain English, then provides the correct fix. No more Stack Overflow spelunking.
+
+---
+
+## Skill Prompt
+
+```
+Explain the provided Xcode or Swift compiler warning and give the correct fix:
+
+For each warning:
+1. State what the warning means in plain English (not compiler jargon).
+2. Explain WHY the compiler/Xcode is flagging it — the underlying problem.
+3. Provide the correct fix with a code snippet.
+4. Note if there is a Quick Fix available in Xcode (lightning bolt) or if manual change is needed.
+
+COMMON WARNINGS AND THEIR REAL MEANINGS:
+- "Initialization of variable 'x' was never used" → you created a variable you don't read.
+- "Result of call to 'async-named-function' is unused" → you're calling async without await.
+- "Expression always evaluates to true/false" → redundant condition.
+- "'weak' variable 'x' is never used" → [weak self] captured but self never called.
+- "Immutable value 'x' was never used" → let binding where a constant wasn't needed.
+- "Closure captures 'x' before it is declared" → capture list ordering issue.
+- "Publishing changes from background threads is not allowed" → @Published write off main thread.
+- "Non-sendable type 'X' in implicitly asynchronous access to..." → Swift 6 concurrency warning.
+- Deprecation warnings: what replaces the deprecated API and why it changed.
+
+If multiple warnings are provided, handle each one.
+```

package/skills/react-native/README.md

@@ -0,0 +1,42 @@
+# React Native Skills
+
+Reusable skill prompt modules for React Native (TypeScript) performance reviews and bridge audits.
+
+## Index
+
+| Skill | File | When to Use |
+|---|---|---|
+| RN Performance | [performance.md](performance.md) | Re-render prevention, `useCallback`/`useMemo`, FlatList config, animation thread |
+| Bridge Audit | [bridge-audit.md](bridge-audit.md) | Old Architecture bridge call overhead, synchronous native calls, JSI migration candidates |
+
+## Usage
+
+```
+# Quick performance triage
+[paste skill prompt from performance.md]
+
+Review this component for performance issues: [paste component]
+```
+
+## Composable Pattern
+
+```
+# Full performance + bridge audit
+[paste performance.md skill]
+[paste bridge-audit.md skill]
+
+Audit this screen: [paste code]
+```
+
+## Composable With
+
+- [`agents/react-native/performance-optimizer`](../../agents/react-native/performance-optimizer/) — full structured performance audit
+
+## Contributing
+
+Ideas for new skills:
+- `typescript-patterns.md` — TypeScript anti-patterns in RN codebases
+- `navigation-patterns.md` — React Navigation v7 type-safety and deep linking
+- `testing-patterns.md` — Jest, React Native Testing Library, Detox patterns
+
+Copy `templates/skill-template.md`.

package/skills/react-native/bridge-audit.md

@@ -0,0 +1,104 @@
+# Skill — React Native Bridge Audit
+
+**Platform:** React Native (TypeScript)  
+**Category:** Performance & Optimization  
+**Composable With:** agents/react-native/performance-optimizer/agent.md, skills/react-native/performance.md
+
+---
+
+## Purpose
+
+Audits React Native code specifically for Old Architecture bridge overhead — synchronous calls, excessive serialization, and patterns that block the JS thread. Also flags migration candidates for the New Architecture (JSI/Fabric).
+
+## When to Use
+
+- When profiling shows dropped frames but re-render analysis doesn't explain it
+- When auditing an Old Architecture app before migrating to New Architecture
+- When a native module feels slow even though JS logic is fast
+
+---
+
+## Skill Prompt
+
+```
+When auditing React Native code for bridge overhead, check for:
+
+OLD ARCHITECTURE — BRIDGE CALL PATTERNS
+- NativeModules calls in the render path or in useEffect without debouncing:
+  Each bridge call serializes arguments to JSON, crosses the bridge asynchronously,
+  deserializes on the native side, and returns the same way. In a hot path (scroll,
+  animation, frequent re-render), this compounds into dropped frames.
+  Fix: cache native module results, debounce calls, or move to useRef to avoid re-triggering.
+
+- Synchronous native calls (NativeModules.SomeModule.callSyncMethod()):
+  Synchronous bridge calls BLOCK the JS thread until the native side returns.
+  If the native operation takes >1ms, it will cause visible jank at 60 FPS.
+  Fix: replace with async calls + caching, or migrate to JSI TurboModules (async by default,
+  faster than the bridge even for async calls).
+
+- High-frequency bridge calls in event handlers:
+  onScroll, onMomentumScrollEnd, and gesture handlers that call native modules on every event
+  are problematic. Use the Animated API with useNativeDriver: true to keep animation logic
+  on the native side without any bridge crossing.
+
+- Large payload serialization:
+  Passing large objects (e.g., full image buffers, large arrays) across the bridge serializes
+  them to JSON on the JS side and deserializes on native. Use native JSI references (Blob, ArrayBuffer)
+  or keep large data on the native side and pass handles (IDs) across the bridge instead.
+
+NEW ARCHITECTURE — JSI / FABRIC MIGRATION CANDIDATES
+Flag these patterns as HIGH priority migration candidates to JSI TurboModules:
+- Any NativeModule called more than once per second
+- Any synchronous NativeModule call
+- Any module that transfers binary data (images, audio, video buffers)
+- Custom gesture handling that uses PanResponder — migrate to react-native-gesture-handler (runs on UI thread via JSI)
+
+FABRIC (New Renderer) COMPATIBILITY
+- Ensure all custom native view components use the Fabric component API if targeting New Architecture.
+- Flag any legacy requireNativeComponent() calls — they do not work with Fabric.
+
+For each issue: identify the call site, explain the bridge cost, and suggest the JSI/async alternative.
+```
+
+---
+
+## Example
+
+**Input:**
+```
+const ProfileScreen = () => {
+  const [deviceId, setDeviceId] = useState('');
+
+  useEffect(() => {
+    const id = NativeModules.DeviceInfo.getDeviceIdSync();
+    setDeviceId(id);
+  }, []);
+
+  return <Text>{deviceId}</Text>;
+};
+```
+
+**Output:**
+```
+Synchronous bridge call in useEffect — HIGH impact
+  Problem: getDeviceIdSync() blocks the JS thread until the native side returns.
+           If DeviceInfo takes >1ms (disk read, system call), JS is frozen during that time.
+           This is noticeable during screen mount, especially on low-end devices.
+  Fix:
+  useEffect(() => {
+    NativeModules.DeviceInfo.getDeviceId().then(setDeviceId);
+    // Or if using a library: DeviceInfo.getDeviceId().then(setDeviceId)
+  }, []);
+
+  Migration candidate: HIGH — device ID is fetched once; migrate to a TurboModule that
+  caches the value natively and returns via JSI without serialization cost.
+```
+
+---
+
+## Notes
+
+- This skill is most relevant for apps still on Old Architecture (RN < 0.74 or new arch not enabled).
+- New Architecture apps are largely immune to bridge-crossing overhead but still benefit from
+  avoiding large payload transfers across JSI.
+- Pair with Flipper's Bridge Spy plugin to measure actual bridge traffic before and after fixes.

package/skills/react-native/expo-optimize.md

@@ -0,0 +1,55 @@
+# Skill — /expo-optimize
+
+**Platform:** React Native (Expo)
+**Slash Command:** `/expo-optimize`
+
+---
+
+## Purpose
+
+Expo config audit, OTA update strategy, bundle size reduction, and EAS Build optimization. The complete Expo production checklist.
+
+---
+
+## Skill Prompt
+
+```
+Audit the provided Expo project configuration for production optimization:
+
+APP.JSON / APP.CONFIG.JS AUDIT:
+- Missing splash screen configuration (white flash on startup).
+- Missing android.adaptiveIcon (Android 8+ adaptive icons).
+- Missing ios.infoPlist privacy usage descriptions for permissions.
+- jsEngine not set: set to "hermes" for better startup performance.
+- Missing updates configuration for OTA updates.
+- android.versionCode and ios.buildNumber automation strategy.
+
+OTA UPDATE STRATEGY (expo-updates):
+- Set updates.fallbackToCacheTimeout appropriately (default 0 is risky).
+- Configure update channels (production, staging, preview) via eas.json.
+- Conditionally check for updates: use Updates.checkForUpdateAsync() with user notification.
+- Critical updates: force reload with Updates.reloadAsync().
+- Never OTA-update native code changes (config plugins, new native modules).
+
+BUNDLE SIZE:
+- Run: npx expo export --analyze to identify large modules.
+- Remove unused expo-* SDK packages from app.json plugins array.
+- Use Metro bundle splitting for large feature modules.
+- Replace heavy libraries with lighter alternatives:
+  moment.js → date-fns (20× smaller)
+  lodash (full) → lodash/pick (tree-shaken)
+  react-native-vector-icons → @expo/vector-icons (bundled, no native setup)
+
+EAS BUILD OPTIMIZATION:
+- eas.json build profiles: development (simulator), preview (APK for testing), production (AAB/IPA).
+- Enable build cache to avoid redundant Gradle/Xcode builds.
+- Use managed workflow unless you genuinely need custom native code.
+- Add .easignore to exclude dev files from upload.
+
+HERMES OPTIMIZATION:
+- Confirm hermes is enabled (app.json jsEngine: "hermes").
+- Hermes benefits: bytecode pre-compilation, lower memory on Android.
+- Incompatible libraries with Hermes (flag if found in package.json).
+
+Output a prioritized list of changes with the config/code snippet for each.
+```