Have you ever used flutter? If so, what's the relative pain level like?

Alright, let's see:

> KMP stability

Regarding moving parts in KMP, I have the impression that it is quite stable now, and has been for some time. I feel it is less maintenance work than having an Android project that uses the Android UI framework and system APIs. Google loves to deprecate and invent new APIs every few years. I feel there is very little in the way of breaking changes that need changes in the code in KMP. Most of that comes from some third party libraries on major new versions. The biggest change recently was a change in the Android Gradle plugin that required to change the project structure. Arguably, that again was more of an Android than a KMP thing.

> iOS developers

Well, the app is Kotlin Multiplatform + Compose Multiplatform as UI framework. So, while it runs on iOS, the parts that would feel native to an iOS dev are near zero: There are about 50 lines of code in Swift in the project and about 1000 dealing with iOS APIs, but written in Kotlin.

As Kotlin and Compose is used in Android development, the project will always feel more accessible to Android developers. That said, Kotlin is somewhat similar to Swift and Compose is also a declarative reactive user interface framework, i.e. similar to SwiftUI. As for the setup, they need at least IntelliJ/Android Studio to compile all that Kotlin to native code before launching the app from XCode in a simulator. That's my setup at least. Certainly one could also just use gradle (the build system) from the commandline.

> KMP bugs

KMP bugs, none that I remember. About platform-specific issues we will see what will surface during the beta test. So far, one thing surfaced, but it was found easily and necessitated changing 4 lines of code.

Compose (the UI framework) is a different matter. At times, I feel it is quite unwieldy when not solving standard problems. Being designed primarily by Google, I also find that best practices change and deprecations happen fairly frequently. Certain features lacking in Compose Multiplatform I need to implement myself. For example, there are still no scroll bars.

> Coding Agents

I have little experience with that, but what I have seen, the agents have no problem generating working code for the platform-specific parts of the implementation. Some un-slopping is necessary as always.

And, as I wrote, the platform specific code takes up a tiny part of the whole code base. Of the 80k lines of source code in the production code, 2k lines of source code are platform specific.

(for context, I helped with the streetcomplete port, and have build and maintained a KMP / CMP maplibre sdk for the past two years, but otherwise consider myself a polyglot proficient in most common tech stacks at least to a moderate degree)

> Maintaining a significant new moving part in the dev process. KMP updates, management, integration, futures awareness, this all takes non-zero time.

If you're already doing that for Android, any additional tooling/infra churn for KMP is pretty negligible, except for a one-time cost of separating common kotlin code from android-specific code. KMP updates are just Kotlin updates.

> If an iOS dev wants to work on a KMP project what's the ramp up time? How much less efficiently can they contribute compared to a pure native app?

Two answers here: 1. Kotlin, the language, is quite similar to Swift, and can call ObjC APIs (or Swift annotated with @ObjC) directly via cinterop, so you're calling the same iOS SDKs. Compose is a declarative UI framework in the same vein as SwiftUI and React (and IMO with fewer footguns and quirks than SwiftUI, though there are some). It renders more like Flutter (via Skia) but it's not hard to embed as a component of a SwiftUI app. 2. KMP libraries can also export ObjC or Swift APIs, called in Swift. It's fairly common for there to be a shared business logic / service layer within an app, perhaps even shared view models, and leave the UI layer itself to SwiftUI and Compose for each platform.

Compared to something like React Native, I find that KMP is much friendlier and less opinionated about how you use it and how much you integrate it. You can use it to share a small module, or the whole app, or anywhere in between, and the seams at the boundary are not nearly as painful as you'd expect crossing languages.

> How much time is spent on problems, bugs, issues, related to KMP. This is guaranteed non-zero for any tool.

Hard to quantify, but in my time working on MapLibre Compose for the last two years, I've run into a handful of Androidx bugs, and much fewer KMP / CMP bugs. Even the same APIs, on the Compose Multiplatform side tend to have fewer pitfalls and bugs in my experience than on the Android side.

That said, the time I've spent dealing with _IDE_ bugs in JB IDEs has been far too much. These days, I spend much less time in an IDE, so it hasn't mattered as much, but I'd _like_ to spend more time there as ideally, even if agents are generating code, I want to read and navigate it in a nice environment.

> Is there less benefit to KMP with coding agents? ... just that some things are not as bad now.

Probably depends where you are on the vibe coding vs ai-assisted engineering spectrum. I'm a heavy AI user these days, close to 100% since Fable/Sol/Astra, but on code I care about, I don't vibe code, I still spend time to understand and refine at least the architecture, if not the line-by-line code. So still I prefer the single codebase because that's one fewer set of abstractions, of failure modes, of guardrails, of test harnesses, etc to worry about.

But if you care deeply about the native UI, using Compose on Android, SwiftUI on iOS, and then KMP for a shared core is an excellent architecture. The opposite, a shared Swift core, I think is also becoming more possible as Swift targets Android, though I'm unsure what the kotlin-on-android -> swift integration experience is like.