# Research: Annie + Pixel 9a — Mobile App Development Workflow

**Date:** 2026-03-31
**Status:** Research complete — practical workflow defined
**Context:** Pixel 9a purchased (or being purchased). Annie runs on Titan (aarch64 DGX Spark). Rajesh has a MacBook.

---

## TL;DR — What Annie Can Actually Do Today

| Capability | Verdict | Method |
|-----------|---------|--------|
| Write Android app code | YES | Claude Code CLI on Titan |
| Build Android APK on Titan (aarch64) | PARTIALLY — with workarounds | Gradle + custom Hermes binary |
| Build Android APK in cloud | YES — easiest path | EAS Build (Expo) or GitHub Actions |
| Push APK to Pixel via ADB | YES | `adb install app.apk` |
| Hot reload to Pixel during dev | YES | Metro (RN) / flutter run (Flutter) over WiFi ADB |
| Run automated UI tests on Pixel | YES | uiautomator2 Python library |
| Screenshot + visual regression | YES | ADB screencap + Pillow/OpenCV diff |
| Performance profiling via ADB | YES | `adb shell dumpsys` |
| Build iOS app | NOT ON TITAN — needs Mac | SSH to Rajesh's MacBook + xcodebuild |
| Deploy to App Store | YES (via Mac) | Fastlane + xcodebuild on MacBook |
| Deploy to Google Play | YES | Google Play Developer API + fastlane supply |
| Full end-to-end automation | YES — all steps scriptable | See Section 7 |

**Best framework for Annie:** Expo (React Native) for most apps. Flutter as second choice. Kotlin Multiplatform only if deep Android-native integration is needed.

---

## 1. Framework Selection: React Native vs Flutter vs KMP

### 1.1 The Decisive Factors for an AI Developer

An AI developer (Annie) differs from a human developer in key ways:
- No GUI IDE — everything must be CLI
- Writes code in bulk via Claude Code; needs fast feedback loop
- Prioritizes toolchain reliability over language ergonomics
- Needs the framework to work on aarch64 Linux host (Titan)

### 1.2 React Native + Expo (RECOMMENDED)

**Why it wins for Annie:**

1. **JavaScript ecosystem** — Claude Code has the deepest training data on JS/TS. React Native code generation is highest quality.
2. **Expo/EAS Build eliminates the aarch64 problem** — Annie never needs to run `gradle` locally. EAS Build compiles in the cloud (Google Cloud for Android, Apple cloud for iOS). Annie pushes code, cloud returns APK.
3. **Hot reload via Metro bundler** — Metro serves JS bundle over WebSocket. Annie runs `npx expo start` on Titan, and the Pixel connects over WiFi to pull code changes. Sub-second feedback.
4. **CLI-first by design** — `npx expo start`, `eas build`, `eas submit`. No GUI required.
5. **ADB port forwarding** — `adb reverse tcp:8081 tcp:8081` tunnels Metro from Titan to phone over USB/WiFi ADB.
6. **Agent skills available** — Callstack's `agent-skills` repo (GitHub: callstackincubator/agent-skills) provides React Native-optimized AI coding patterns.

**Limitations:**
- Hermes JS engine prebuilt binary is x86_64 only — blocks local gradle builds on Titan
- Workaround: build locally disabled (hermesEnabled=false) for dev; EAS Build for production
- Native modules requiring C++ compilation still need x86_64 host

**Cost:** Free tier on EAS Build gives ~30 free builds/month. Enough for personal use.

### 1.3 Flutter (Strong Second Choice)

**Pros:**
- Dart is simpler than TypeScript for AI to generate correctly
- `flutter run` on real device via ADB is excellent
- `flutter doctor` CLI is best-in-class setup verification
- No JavaScript runtime — pure compiled Dart

**Critical blocker on Titan (aarch64):**
- Flutter SDK does not officially support building Android apps from a Linux aarch64 HOST (GitHub issue #75864, open since 2021, still unresolved as of March 2026)
- Specifically: `gen_snapshot` (the Dart compiler for AOT) has no aarch64 Linux build
- Workarounds: use QEMU to emulate x86_64 (slow, ~3x overhead) or use a cloud CI (GitHub Actions x86_64 runner)
- Flutter hot reload on `flutter run` (JIT mode, debug only) does work on aarch64 for connecting to device — the ADB connection and hot reload path avoid `gen_snapshot`
- **Conclusion:** Flutter dev mode + hot reload works on Titan. Flutter release builds require cloud CI.

### 1.4 Kotlin Multiplatform (NOT RECOMMENDED for Annie)

**Why it's not the right fit:**
- Kotlin/Native compiler does not support building on aarch64 Linux hosts (YouTrack KT-36871, open)
- Android builds with Kotlin/JVM (not KMP) work fine, but that's standard Android, not cross-platform
- Jetpack Compose Multiplatform (the UI layer) is still maturing
- Much less AI training data than React Native or Flutter
- Best suited for sharing business logic, not UI — requires more architectural decisions
- **Verdict:** Use only if you're adding shared logic to an existing native app

### 1.5 Framework Comparison Matrix

| Criterion | Expo (React Native) | Flutter | KMP |
|-----------|:-------------------:|:-------:|:---:|
| AI code generation quality | Excellent | Good | Fair |
| CLI tooling completeness | Excellent | Excellent | Good |
| Hot reload to Pixel (WiFi ADB) | YES | YES (debug) | NO |
| Build Android on Titan (aarch64) | Via EAS cloud | Via cloud CI only | Via cloud CI |
| Build iOS on Titan | NO (needs Mac always) | NO | NO |
| Market adoption 2026 | ~45% | ~35% | ~20% |
| Community support | Largest | Large | Growing |
| Annie's verdict | **FIRST CHOICE** | **Second** | Skip |

---

## 2. Android Development Without an IDE

### 2.1 The Toolkit (all CLI)

```
Java/Kotlin compiler:   OpenJDK 21 (aarch64 — fully supported)
Build system:           Gradle (runs on JVM — aarch64 native)
Android SDK:            sdkmanager (x86_64 binary — see caveat below)
ADB:                    android-tools package (aarch64 native — fully supported)
APK signing:            apksigner (part of build-tools)
APK deployment:         adb install app.apk
```

### 2.2 aarch64 Toolchain Reality Check

**What works natively on Titan:**
- `adb` — fully supported, available in Ubuntu/Debian packages for arm64
- OpenJDK 21 — fully supported on aarch64 (OpenJDK AArch64 Port Project)
- `gradle` — runs on JVM, architecture-agnostic
- `kotlin` compiler (JVM target, not Kotlin/Native) — works fine on aarch64
- Fastlane — Ruby gem, architecture-agnostic
- Google Play API client libraries — pure Python/Ruby

**What does NOT work natively on Titan:**
- Android SDK `sdkmanager` — the official binary is x86_64 ELF only
- Android build-tools (`aapt2`, `d8`, `apksigner`) — x86_64 binaries
- Hermes compiler (`hermesc`) — x86_64 binary, no aarch64 Linux build
- `gen_snapshot` (Flutter AOT compiler) — x86_64 only on Linux

**Workarounds for the non-working parts:**
1. **EAS Build (Expo)** — cloud build service, Annie pushes code, gets APK back. Zero local SDK needed.
2. **GitHub Actions** — free x86_64 Linux runners. Annie commits code, workflow builds APK, artifact downloadable.
3. **Docker x86_64 emulation** — `docker run --platform linux/amd64` on aarch64 host (slow but works for builds)
4. **Community aarch64 SDK** — GitHub: `lzhiyong/android-sdk-tools` provides aarch64 builds of Android SDK tools. Unofficial but functional. GitHub: `chenxqiyu/android-build-tools-for-arm64-aarch64-linux-depoly` provides build-tools for aarch64.
5. **Build on Mac** — SSH to Rajesh's MacBook for one-time builds; then ADB deploy APK to Pixel

### 2.3 Recommended Local Setup for Annie (Android-only development)

```bash
# Install on Titan (all work natively on aarch64):
sudo apt install adb openjdk-21-jdk

# Install community aarch64 Android SDK tools:
# (lzhiyong/android-sdk-tools builds)
# Sets ANDROID_HOME, adds platform-tools, cmdline-tools

# For React Native / Expo:
# Skip local gradle entirely — use EAS Build
npm install -g @expo/cli eas-cli

# For Flutter (debug/dev only — release builds via CI):
# Download Flutter SDK for linux-arm64 channel (beta/master)
# flutter run --debug works on aarch64 for hot reload
```

### 2.4 Full Android CLI Build Flow (native Kotlin, no React Native)

```bash
# Initialize project
npx react-native@latest init MyApp --template @react-native-template-typescript

# Develop + hot reload (Titan → Pixel via WiFi ADB)
npx expo start &
adb connect <pixel-ip>:5555
adb reverse tcp:8081 tcp:8081  # tunnel Metro to phone

# Cloud build (production APK)
eas build --platform android --profile preview
# Returns download URL for .apk or .aab

# Install on Pixel
adb install -r MyApp.apk

# Deploy to Google Play
eas submit --platform android
# OR: fastlane supply --aab app-release.aab --track internal
```

---

## 3. iOS Development (Annie → Mac → Phone)

### 3.1 The Hard Constraint

**iOS apps REQUIRE Xcode, and Xcode ONLY runs on macOS.** No exceptions. This means Annie cannot build iOS apps directly on Titan. Period.

However, Annie can fully automate the iOS build pipeline by SSHing into Rajesh's MacBook.

### 3.2 Annie's iOS Build Architecture

```
Titan (Annie writes code)
    ↓ git push
MacBook (Rajesh's, SSH accessible)
    ↓ git pull
    ↓ fastlane match (certificates)
    ↓ xcodebuild archive
    ↓ xcodebuild -exportArchive (.ipa)
    ↓ fastlane pilot upload (TestFlight)
    ↓ fastlane deliver (App Store)
```

Annie triggers all of this via SSH:
```bash
ssh rajesh@macbook.local "cd /path/to/project && fastlane ios beta"
```

### 3.3 Setting Up the Mac as a Build Server

Requirements on MacBook:
```bash
# Install Xcode (GUI required once, then CLI-only)
xcode-select --install

# Install fastlane
gem install fastlane

# Install match for certificate management
fastlane match init  # once, stores certs in private git repo

# Create Fastfile
fastlane init
```

Annie's SSH commands for iOS:
```bash
# Build and push to TestFlight
ssh rajesh@mac "cd ~/projects/myapp && fastlane ios beta"

# Build and push to App Store
ssh rajesh@mac "cd ~/projects/myapp && fastlane ios release"

# Build specific version
ssh rajesh@mac "cd ~/projects/myapp && fastlane ios build version:1.2.3"
```

### 3.4 React Native iOS Build from Mac CLI

```bash
# On Mac (triggered by Annie via SSH)
cd ios && pod install && cd ..
npx react-native build-ios --scheme MyApp --mode Release

# OR via fastlane:
fastlane ios build  # custom lane in Fastfile
```

### 3.5 Flutter iOS Build from Mac CLI

```bash
# On Mac
flutter build ios --release --no-codesign
# Then sign and package via fastlane
fastlane ios distribute
```

### 3.6 Can the Pixel Help with iOS? No.

The Pixel 9a cannot run iOS apps. There is no iOS simulator on Android. The only iOS testing path is:
- Rajesh's iPhone (physical device, sideload via Xcode/TestFlight)
- iOS Simulator on Mac (command-line launchable: `xcrun simctl`)

Annie can trigger iOS Simulator tests via SSH:
```bash
ssh rajesh@mac "xcrun simctl boot 'iPhone 16 Pro' && xcrun simctl install booted MyApp.app && xcrun simctl launch booted com.example.myapp"
```

---

## 4. Testing on the Pixel 9a

### 4.1 Installing and Running Apps

```bash
# Install APK
adb install -r app-release.apk

# Launch app
adb shell am start -n com.example.myapp/.MainActivity

# Clear app data (reset state for testing)
adb shell pm clear com.example.myapp

# Uninstall
adb uninstall com.example.myapp
```

### 4.2 UIAutomator2 — Annie's Primary Testing Tool

`uiautomator2` (Python library by openatx) is the cleanest path for Annie. It installs an HTTP server APK on the phone, then Annie's Python code drives it over HTTP/JSON-RPC. No Java required, no Android SDK needed for test execution.

```python
import uiautomator2 as u2

# Connect to Pixel (via ADB USB or WiFi)
d = u2.connect()  # auto-detects connected device

# Basic interactions
d.app_start("com.example.myapp")
d(text="Login").click()
d(resourceId="com.example.myapp:id/email").set_text("test@example.com")
d(text="Submit").click()

# Wait for element
d(text="Dashboard").wait(timeout=5.0)

# Screenshot
d.screenshot("test_result.png")

# Assert element visible
assert d(text="Welcome, Rajesh").exists(timeout=3)

# Scroll
d.swipe_ext("up", scale=0.8)
```

Setup:
```bash
pip install uiautomator2
# On first use, installs UIAutomatorServer APK on phone automatically
python -m uiautomator2 init
```

### 4.3 Appium (Alternative — More Enterprise)

Appium is the industry standard but heavier:
- Requires Java JDK 21+, Node.js 18+, Appium server running
- More setup than uiautomator2
- Advantage: same tests run against Android AND iOS (with different drivers)
- Good for cross-platform test suites

**Annie's recommendation:** Use uiautomator2 for Android-only testing. Use Appium only if cross-platform test suites are needed.

### 4.4 Screenshot-Based Visual Testing

```python
import uiautomator2 as u2
from PIL import Image, ImageChops
import numpy as np

d = u2.connect()

# Capture current state
screenshot = d.screenshot()  # returns PIL Image

# Compare with baseline
baseline = Image.open("baseline_login.png")
diff = ImageChops.difference(screenshot, baseline)
diff_array = np.array(diff)
max_diff = diff_array.max()

if max_diff > 10:  # threshold
    screenshot.save("regression_login_actual.png")
    print(f"VISUAL REGRESSION: max pixel diff = {max_diff}")
```

For AI-powered visual comparison, Percy (percy.io) integrates with Appium and provides automated diffing with noise reduction.

### 4.5 Performance Profiling via ADB

Annie can run these directly on Titan and parse results in Python:

```bash
# CPU usage for app
adb shell dumpsys cpuinfo | grep com.example.myapp

# Memory usage
adb shell dumpsys meminfo com.example.myapp

# Battery stats (reset first, then run test, then read)
adb shell dumpsys batterystats --reset
# ... run test ...
adb shell dumpsys batterystats com.example.myapp

# Frame rate / jank detection
adb shell dumpsys gfxinfo com.example.myapp

# Network stats
adb shell dumpsys netstats detail | grep com.example.myapp

# Systrace (full profiling)
adb shell perfetto -o /data/misc/perfetto-traces/trace.pftrace -t 10s

# ANR/crash logs
adb logcat -b crash
```

### 4.6 ADB over WiFi (Pixel 9a Specific)

The Pixel 9a has native WiFi ADB auto-reconnect (Pixel-exclusive feature). Setup:

```bash
# One-time USB setup
adb tcpip 5555

# After each boot (or use Shizuku for persistence)
adb connect <pixel-ip>:5555

# Verify
adb devices  # should show <ip>:5555 device

# Pixel-specific: pairing via QR code (Android 11+)
# Settings → Developer Options → Wireless debugging → Pair with QR code
```

**Important:** Wireless ADB does NOT persist across reboots. Two options for Annie's 24/7 workflow:
1. USB cable permanently connected to Titan (simpler)
2. Shizuku app on Pixel + automation to re-enable after boot (no cable needed)

---

## 5. App Store Deployment

### 5.1 Google Play

**Account setup (one-time, Rajesh does this):**
- Google Play Developer account: $25 one-time fee
- Enable Google Play Android Developer API in Google Cloud Console
- Create service account → download JSON key
- Grant service account "Release manager" role in Play Console

**Annie's deployment commands:**

```bash
# Via fastlane supply (most flexible)
fastlane supply --aab app-release.aab \
  --track internal \
  --json_key play-store-credentials.json \
  --package_name com.example.myapp

# Via EAS Submit (easiest for Expo apps)
eas submit --platform android --track internal

# Via Google Play API directly (Python)
# Using google-api-python-client
from googleapiclient.discovery import build
# ... see GIST: forbroteam/4a7668ff7344cf67ecef3e28058acb06
```

**Testing tracks (no review process):**
- **Internal testing**: Up to 100 testers, available within seconds of upload. BEST for Annie's iteration.
- **Closed testing (alpha)**: Up to 2,000 testers, requires 12 testers for 14 days (personal accounts)
- **Open testing (beta)**: Public, anyone can join
- **Production**: Full review required

**Key 2026 change:** Personal developer accounts now require 12 testers opted in for 14 days before going to production (waived for organization accounts).

### 5.2 Apple App Store

**Account (Rajesh sets up once):**
- Apple Developer Program: $99/year
- Includes: App Store publishing, TestFlight (10,000 testers), Xcode

**Annie's iOS deployment pipeline (via SSH to Mac):**

```ruby
# Fastfile on MacBook
lane :beta do
  match(type: "appstore")       # fetch signing certs from private git repo
  increment_build_number        # auto-increment build number
  build_ios_app(scheme: "MyApp") # xcodebuild wrapper
  upload_to_testflight           # push to TestFlight
end

lane :release do
  match(type: "appstore")
  build_ios_app(scheme: "MyApp")
  deliver(submit_for_review: true) # push to App Store + submit for review
end
```

Annie triggers:
```bash
ssh rajesh@mac "cd ~/projects/myapp && fastlane ios beta"
```

**TestFlight:** Builds available within minutes. Annie can invite testers, manage groups, and read feedback — all via App Store Connect API (no GUI needed).

---

## 6. Development Environment on Titan (aarch64 Summary)

### 6.1 What's Fully Supported on aarch64 Linux

| Tool | Status | Install |
|------|--------|---------|
| OpenJDK 21 | Native aarch64 | `sudo apt install openjdk-21-jdk` |
| Gradle | Via JVM (arch-agnostic) | Bundled with project or `sdk install gradle` |
| ADB | Native aarch64 | `sudo apt install adb` |
| Node.js | Native aarch64 | `nvm install 22` (nvm supports aarch64) |
| npm / npx | Via Node.js | Bundled |
| Expo CLI | Via npm | `npm i -g @expo/cli` |
| EAS CLI | Via npm | `npm i -g eas-cli` |
| Fastlane | Via Ruby | `gem install fastlane` |
| Python (uiautomator2) | Native | `pip install uiautomator2` |
| Flutter SDK (dev/debug) | Partial — no release builds | Download linux-arm64 from master channel |
| React Native Metro | Via Node.js | Works fine |

### 6.2 What Requires Cloud or Mac

| Tool | Issue | Solution |
|------|-------|----------|
| Android SDK `sdkmanager` | x86_64 binary only | EAS Build or GitHub Actions |
| Android build-tools (aapt2, d8) | x86_64 binary only | EAS Build or GitHub Actions |
| Hermes compiler (hermesc) | x86_64 binary only (no aarch64 Linux build) | EAS Build; or compile hermesc from source |
| Flutter release builds | gen_snapshot missing for aarch64 Linux | GitHub Actions (x86_64 runner) |
| Xcode / iOS builds | macOS only | SSH to Rajesh's MacBook |

### 6.3 Hermes Workaround (if local builds needed)

If Annie wants to build APKs locally without EAS:
```bash
# Build hermesc from source (one-time, ~20 min)
git clone https://github.com/facebook/hermes.git
cd hermes
cmake -S hermes -B build_release -G Ninja -DCMAKE_BUILD_TYPE=Release
cmake --build ./build_release

# Set in gradle.properties or react-native.config.js
echo "react.hermesCommand=/home/annie/hermes/build_release/bin/hermesc" >> gradle.properties
```

---

## 7. Practical End-to-End Workflows

### 7.1 Android App: Write → Build → Test → Deploy

```
Annie writes code (Claude Code on Titan)
    ↓
git commit + push (Titan → GitHub)
    ↓
EAS Build triggered (eas build --platform android)
    [cloud: ~3-5 min for Android]
    ↓
Download APK (eas build:list → download URL)
    ↓
adb install app.apk (Pixel connected via WiFi ADB)
    ↓
uiautomator2 test suite runs from Titan
    ↓
adb shell dumpsys meminfo (performance check)
    ↓
If tests pass: eas submit --platform android --track internal
    ↓
Google Play internal testing (available in ~30 seconds)
```

### 7.2 Hot Reload Development Loop (React Native / Expo)

```
Annie edits code on Titan
    ↓
Metro bundler (npx expo start, running on Titan)
detects file change
    ↓
Pixel polls Metro over WiFi (adb reverse port forwarding)
    ↓
JS bundle updated on phone in <1 second
    ↓
App refreshes automatically (no reinstall needed)
    ↓
Annie takes screenshot via: adb exec-out screencap -p > screen.png
    ↓
Annie reads screenshot / runs uiautomator2 assertions
```

### 7.3 iOS App: Write → Build → Test → Deploy

```
Annie writes code on Titan
    ↓
git push to GitHub
    ↓
Annie SSHes to MacBook:
  ssh rajesh@mac "cd ~/projects/myapp && git pull && fastlane ios beta"
    ↓
MacBook: fastlane runs xcodebuild → .ipa → TestFlight upload
    ↓
TestFlight build available (~10-15 min for processing)
    ↓
Rajesh (or testers) get email notification
    ↓
iOS Simulator test (Annie via SSH):
  ssh rajesh@mac "xcrun simctl launch booted com.example.myapp"
```

### 7.4 Full Automation Checklist

All of these steps are automatable today (March 2026):

- [x] Code generation: Claude Code CLI
- [x] Git operations: standard git CLI
- [x] Android cloud build: `eas build` or GitHub Actions
- [x] ADB install: `adb install`
- [x] UI automation: uiautomator2 Python
- [x] Screenshot capture: `adb exec-out screencap -p`
- [x] Performance metrics: `adb shell dumpsys`
- [x] Android Play deployment: `fastlane supply` or EAS Submit
- [x] iOS build trigger: SSH + fastlane
- [x] TestFlight upload: fastlane pilot
- [x] App Store submission: fastlane deliver

---

## 8. AI-Native Mobile Development Patterns (2026)

### 8.1 Claude Code for Mobile

Claude Code already works well for React Native and Flutter. Practical patterns:

**Task: Generate a new screen**
```bash
claude -p "Create a React Native screen for expense tracking.
Use Expo Router, TypeScript.
Props: expenses: Expense[], onAdd: (e: Expense) => void.
Style: dark theme, matching existing screens in src/screens/"
```

**Task: Fix a failing test**
```bash
# Annie can run tests, read output, fix code, rerun — fully autonomous
npx jest --testPathPattern=ExpenseScreen 2>&1 | \
  claude -p "Fix the failing tests. The test file is at tests/ExpenseScreen.test.tsx"
```

**Flutter + Claude Code workflow** (confirmed working, March 2026 by community reports):
- A developer built a full task manager app in 2 days using Claude Code
- Firebase auth + Firestore backend + local notifications — all generated
- Claude Code handles pub.dev dependencies, State management, navigation

### 8.2 Expo: The Simplest End-to-End Path

Expo is the highest-leverage framework for Annie because:

1. **EAS Build eliminates the aarch64 build problem entirely** — Annie never touches `gradle` or `sdkmanager`
2. **OTA updates** — `eas update` pushes JS bundle changes directly to installed app, no APK reinstall needed (for minor updates)
3. **Managed workflow** — Expo handles native module config; Annie only writes JS/TS
4. **EAS Submit** — directly submits to Google Play or App Store from CLI

```bash
# Entire workflow from Annie's perspective:
npx create-expo-app MyApp --template blank-typescript
cd MyApp

# Develop (hot reload on Pixel)
npx expo start
# Pixel opens Expo Go app, scans QR, gets hot reload

# Build production APK
eas build --platform android --profile preview

# Deploy to Google Play internal testing
eas submit --platform android

# Push OTA update (JS changes only, no store review)
eas update --channel production --message "Bug fix"
```

### 8.3 Services That Provide AI-Driven App Development

| Service | What it does | Verdict for Annie |
|---------|-------------|-----------------|
| **EAS Build** (Expo) | Cloud build for React Native | ADOPT — core infrastructure |
| **Codemagic** | CI/CD for mobile, Mac-in-cloud for iOS | Good for iOS CI without a Mac |
| **Bitrise** | Mobile CI/CD, iOS Mac runners | Alternative to Codemagic |
| **GitHub Actions** | Free x86_64 Linux + Mac runners | ADOPT for open source projects |
| **Firebase App Distribution** | Alternative to TestFlight for Android beta | Consider for multi-tester scenarios |
| **Callstack agent-skills** | React Native optimized prompts for AI agents | Useful for Claude Code prompting |

---

## 9. Developer Accounts — What Rajesh Needs

| Account | One-Time | Annual | Required For |
|---------|----------|--------|-------------|
| Google Play Developer | $25 | $0 | Publishing to Google Play |
| Apple Developer Program | $0 | $99 | Publishing to App Store + TestFlight |
| Expo EAS Free Tier | $0 | $0 | ~30 builds/month, sufficient for personal use |
| GitHub (free) | $0 | $0 | CI/CD via Actions |

**Personal account testing caveat (Google Play 2026):** Personal accounts must have 12 testers opted-in for 14 days before a production release. Organization accounts are exempt. Rajesh could use an Organization account to avoid this (requires separate registration).

**Apple Developer note:** $99/year is mandatory even for a single personal app. No way around it for TestFlight or App Store.

---

## 10. Open Questions / Next Steps

1. **ADB persistent connection:** Will Annie use USB cable or WiFi ADB? USB is more reliable. WiFi requires boot reconnect.
2. **EAS account:** Create under Rajesh's email. Free tier sufficient for personal projects.
3. **MacBook SSH access:** Does Annie have persistent SSH key access to Rajesh's MacBook? Set up `~/.ssh/authorized_keys` on Mac.
4. **fastlane match repo:** iOS cert management needs a private git repo (can use GitHub private repo).
5. **Annie's phone tool:** Should Annie have a `develop_app` kernel tool that orchestrates the full write→build→test→deploy pipeline?
6. **Hermes on Titan:** Build hermesc from source once and cache the binary — enables fully local Android debug builds.
7. **Pixel as development proxy:** Pixel can also serve as a testing device for Annie's other tools (browser agent via Chrome for Android, etc.)

---

## Sources

### Framework Comparison
- [Kotlin Multiplatform vs Flutter vs React Native 2026 — Java Code Geeks](https://www.javacodegeeks.com/2026/02/kotlin-multiplatform-vs-flutter-vs-react-native-the-2026-cross-platform-reality.html)
- [React Native vs Flutter vs KMP — Medium/AviRoot](https://medium.com/@avirootinfosolution/react-native-vs-flutter-vs-kotlin-multiplatform-a-ctos-decision-guide-2026-21dc43277cf0)
- [Flutter vs React Native vs KMP 2026 — syedali.dev](https://syedali.dev/flutter-vs-react-native-vs-kotlin-multiplatform-2026)
- [Why Flutter Outperforms React Native 2026 — Foresight Mobile](https://foresightmobile.com/blog/why-flutter-will-outperform-the-competition-in-2026)
- [Agent Skills for React Native — callstackincubator/agent-skills (GitHub)](https://github.com/callstackincubator/agent-skills)

### aarch64 / ARM64 Toolchain Issues
- [Flutter ARM64 Linux Host Issue #75864 — flutter/flutter (GitHub)](https://github.com/flutter/flutter/issues/75864)
- [Flutter build fails on linux-arm64, gen_snapshot issue #177936 — flutter/flutter (GitHub)](https://github.com/flutter/flutter/issues/177936)
- [React Native No Prebuilt ARM64 Binary issue #39814 — facebook/react-native (GitHub)](https://github.com/facebook/react-native/issues/39814)
- [hermesc not built for Linux ARM64 issue #46504 — facebook/react-native (GitHub)](https://github.com/facebook/react-native/issues/46504)
- [Android SDK ARM64 host support — Google Issue Tracker #227219818](https://issuetracker.google.com/issues/227219818)
- [Android SDK tools for aarch64 — lzhiyong/android-sdk-tools (GitHub)](https://github.com/lzhiyong/android-sdk-tools)
- [Android development on debian/arm64 — Andreas Shimokawa](https://ashimokawa.codeberg.page/posts/android_development_on_arm64_linux/)

### Expo / EAS Build
- [EAS Build Introduction — Expo Docs](https://docs.expo.dev/build/introduction/)
- [EAS Build Setup — Expo Docs](https://docs.expo.dev/build/setup/)
- [Expo 2026 — MetaDesign Solutions](https://metadesignsolutions.com/expo-2026-the-best-way-to-build-cross-platform-apps/)
- [EAS Pricing — expo.dev](https://expo.dev/pricing)

### Hot Reload
- [Metro Bundler Overview — Gabriel Barth Medium](https://gabriel-barth.medium.com/metro-bundler-a-javascript-bundler-for-react-native-e5bf96315570)
- [Flutter Hot Reload Docs — flutter.dev](https://docs.flutter.dev/tools/hot-reload)
- [Flutter Wireless Debugging — Yazeed Al-Khalaf Medium](https://yazeedalkhalaf.medium.com/debug-your-flutter-app-on-a-real-android-device-over-wifi-bd70a7c25abe)

### Testing
- [uiautomator2 Python Wrapper — openatx/uiautomator2 (GitHub)](https://github.com/openatx/uiautomator2)
- [Appium with Python 2026 — BrowserStack](https://www.browserstack.com/guide/appium-with-python-for-app-testing)
- [Visual Testing with Appium 2026 — percy.io](https://percy.io/blog/visual-testing-appium)
- [ADB Android Performance Profiling — dumpsys guide](https://www.oreateai.com/blog/android-memory-analysis-a-detailed-explanation-of-the-adb-shell-dumpsys-meminfo-command/95239040fff8a47e05e9e6e9bb76295c)
- [ADB CLI testing guide — Test Automation University](https://medium.com/test-automation-university/using-adb-and-cmdline-to-ease-android-app-testing-19f64340dae7)

### Deployment
- [Google Play Developer API upload APK — fastlane supply docs](https://docs.fastlane.tools/actions/supply/)
- [Google Play CLI upload script — Paweł Szymański Medium](https://stasheq.medium.com/upload-apk-to-google-play-via-command-line-script-d93b0d6a28c5)
- [Google Play internal testing requirements 2026](https://support.google.com/googleplay/android-developer/answer/14151465?hl=en)
- [Google Play Developer Account Fees](https://www.devstree.com.au/google-play-developer-account-fees-what-you-need-to-know/)
- [iOS App Distribution Guide 2026 — Foresight Mobile](https://foresightmobile.com/blog/ios-app-distribution-guide-2026)
- [Apple Developer Program — developer.apple.com](https://developer.apple.com/programs/)
- [Fastlane for iOS CI/CD — runway.team](https://www.runway.team/blog/how-to-build-the-perfect-fastlane-pipeline-for-ios)
- [GitHub Actions + Fastlane iOS — byteable.medium.com](https://byteable.medium.com/build-and-deploy-your-ios-app-with-github-actions-and-fastlane-48c328cc5541)

### AI Tools for Mobile
- [Claude Code vs Cursor 2026 — UI Bakery](https://uibakery.io/blog/claude-code-vs-cursor)
- [Build Flutter App with Claude Code — Easy Flutter Medium](https://medium.com/easy-flutter/how-i-built-a-flutter-app-using-claude-code-in-2-days-full-workflow-3c27ed6319dc)
- [Claude Code vs GitHub Copilot vs Cursor 2026 — Cosmic](https://www.cosmicjs.com/blog/claude-code-vs-github-copilot-vs-cursor-which-ai-coding-agent-should-you-use-2026)
- [Build React Native app with Claude AI — Design+Code](https://designcode.io/react-native-ai/)