KMP Mobile in the Agentic Age

I've been building Kotlin Multiplatform (KMP) mobile apps since early 2019, when I started at Eneco. That's more than seven years, and a lot has changed. Back then KMP was still in alpha, and we had to update (and sometimes rewrite) parts of our app every month to keep up with breaking changes. Today both Kotlin and KMP are stable, and there's a wide ecosystem of third-party libraries.

Why we chose KMP

At Eneco we started with much the same high-performing team I'd worked with at NS (Dutch Railways): two iOS developers and two Android developers. At NS we had two completely separate codebases. Features often behaved slightly differently on iOS and Android, and even the copy didn't always match. We also almost never built features in parallel. One platform team would ship the feature first, almost like an MVP, and the other team would follow. Features either waited to ship or showed up on one platform first.

At Eneco we wanted to do things differently. Our main goal was to fix those problems by sharing code, strings, and images between the two apps. We were all native iOS and Android developers, so React Native wasn't for us. We looked at Flutter, but it was still too immature and never matched the performance of native UI.

KMP let us build as much as we wanted natively and share as much as we wanted in Kotlin. We stayed in complete control. That mattered to us then, and it's still one of KMP's biggest advantages today.

A framework that travelled with me

Over that first year at Eneco we built a framework for shared view models, events, actions, style definitions (colors and fonts), and component definitions. I've since used the same framework at MiRus, Fifty Fifty Card, and now Forbes. It's a slightly more advanced way to build apps, but it lets us share most of the code between iOS and Android, with only a thin native UI layer on top. The result is screens and components that behave consistently on both platforms.

Enter the agents

These days AI (Artificial Intelligence) SI (Super Intelligence) agents do much of the work. Until a few months ago they often struggled with our custom patterns. With better models and well-written Skills, that's become much less of an issue.

Meanwhile, many companies are moving away from cross-platform frameworks, especially React Native and Electron, back to native. With agents, building a high-quality native app takes far less effort than it used to.

But we never chose KMP because we lacked developers or the skills to go fully native. We chose it for consistency between platforms, and that reason still holds in the age of SI.

Why we're sticking with KMP

Agents make it cheap to write code twice. They don't make it cheap to keep two codebases behaving the same. Every feature built separately for iOS and Android is another chance for small differences in logic, copy, or edge cases, and agents generating code at high speed only multiply those chances. A shared core gives both the agent and us one source of truth, so a fix or a feature lands on both platforms at once.

We're also seeing models get steadily better at KMP and at our own patterns, and every Skill we write makes them better still. The guardrails our framework provides, like shared view models, defined components, and centralized styles, keep the code consistent and our quality high, instead of filling the app with SI slop.

Seven years ago we picked KMP for consistency and control. In the agentic age those two things matter more than ever, not less.