Swift and Kotlin AI Assistants

TL;DR

• AI knows Swift and Kotlin, but training data skews toward web and cross-platform. Native nuances need you.
• SwiftUI and Jetpack Compose are relatively well-represented. UIKit and legacy patterns less so.
• Use AI for structure and boilerplate. You own: lifecycle, platform APIs, and "does this work on device?"

If you're building native iOS (Swift/SwiftUI) or Android (Kotlin/Jetpack Compose), AI can help. But the training corpus for mobile native code is smaller than for JavaScript and Python. Expect more corrections—and more value from your platform expertise.

Swift / SwiftUI

What AI does well:

• Basic SwiftUI views. VStack, HStack, List, Form.
• ViewModels, @State, @Binding.
• Common modifiers and layout.
• Swift syntax and conventions.

What AI gets wrong:

• SwiftUI lifecycle nuances. onAppear vs. task. When views rebuild.
• UIKit interop. Wrapping UIView, UIViewController.
• Combine vs. async/await. Mixing paradigms.
• Platform-specific APIs. HealthKit, Core Location, etc. Less training data.
• Xcode project structure. AI doesn't edit .pbxproj well.

Kotlin / Jetpack Compose

What AI does well:

• Compose UI. Column, Row, LazyColumn, Modifier.
• State hoisting, remember, LaunchedEffect.
• Basic Android patterns. Activity, Fragment.
• Kotlin syntax, coroutines basics.

What AI gets wrong:

• Compose recomposition. Key(), derivedStateOf, when to avoid recomposition.
• Android lifecycle. Configuration changes, process death.
• Platform APIs. Camera, sensors, WorkManager. Niche, less data.
• Gradle and build config. AI can suggest; often wrong for your setup.
• Material 3 vs. Material 2. AI may mix them.

The Native Developer's Edge

Your value: you know the platform. Lifecycle, memory, threading, store requirements. AI generates code; you know whether it will work when the app goes background, the user rotates the device, or the OS kills your process. That knowledge is scarce in training data.

Workflow for Native + AI

1. Prompt with platform context. "SwiftUI, iOS 17+, use async/await. Handle loading and error."
2. Review lifecycle and state. Does this survive backgrounding? Configuration change? AI often misses these.
3. Test on device. Simulator isn't enough. Real device, different OS versions.
4. Own the build. Xcode schemes, Gradle config. AI suggests; you fix.

// AI might generate: simple onAppear
.onAppear { fetchData() }

// You add: task cancellation, avoids duplicate fetches
.task {
await fetchData()
}
// .task cancels when view disappears; onAppear doesn't

Do This Next

1. Generate one SwiftUI or Compose screen with AI. Run it. Note every platform-specific fix (lifecycle, state, recomposition). That's your "AI native review" list.
2. Build a context snippet for your stack: "We use SwiftUI, iOS 17+, async/await, no UIKit. Prefer Combine for simple flows." Use it in every native prompt.