If you hang out on LinkedIn, you've seen the take: cross-platform is dead. Kotlin Multiplatform, Flutter, React Native: nice ideas from the recent past that already feel like ancient history in the AI era.
Yes, the title is a joke. But the argument behind it is a good one, and it deserves a proper answer.
The logic goes like this: cross-platform exists because writing every feature twice is expensive. Agents make it cheap. So why keep a shared layer? Write the spec once, let agents and skills spit out a Swift app and a Kotlin app, and maintain both. Two native products, one developer product builder, one pace.
On paper, it's hard to resist. And since we make a living around Kotlin Multiplatform, take what follows with a grain of salt. I will defend one idea: sharing the part of your app that must be identical. But first, let's be fair to agentic coding.

What the argument gets right
A fully native app feels the way users expect it to. One developer can ship a feature on both platforms, so velocity goes up. Both products can move at the same pace, so feature parity stops being a project of its own.
Shopify's engineers made this case publicly in September 2026, when they announced they are moving their mobile apps from React Native back to Swift and Kotlin. Their reasoning: coding agents changed what it costs to build the same feature twice. And to their credit, they're upfront about it: native still means maintaining two platforms, and that cost hasn't gone away. It just stopped being the deciding factor.
I think they're right about that part. Agents are good at translating a feature from one language to another. I've done it myself.
But there's a premise hiding in that argument, and that's the one I disagree with.
I've never sold Kotlin Multiplatform as a productivity gain.
I sold it as a guarantee: the same rules, the same behavior, on every platform, checked once. It's value you add to a product, not time you save on a project. So if agents make writing code cheaper, fine: they're knocking down an argument I never made.
Then reality shows up
I love a challenge and I'm curious about what AI can do, so when a client wanted to try, I said yes. We built exactly this workflow. Agents write more or less the same code in Swift and in Kotlin, and at first glance the two codebases look alike.
But the two platforms never start from the same place. The Android app was written from scratch, AndroidX first. The iOS app grew out of the codebase of an older app. And agents pick up whatever habits they find: existing code is part of the prompt. Android then had to catch up to reach feature parity.
Long after the code was written, I spotted something by pure chance. Some of our building blocks were meant to be disposable: small and mostly stateless. On iOS, with no dependency injection (DI) framework, the agents built them with factories, every time. On Android, the DI framework turned them into singletons.
That sounds like a detail. It isn't. A disposable object that lives forever can carry state into the next call, and it sits in memory when nothing needs it.
No user ever noticed. No bug report, no incident. Just debt.
Ironically, the healthier side was the one with the legacy code and no DI framework, a pure accident of history. But that's the point: real projects are never symmetrical. A specification can be written once. The starting point can't.
We went back through the codebase, fixed it, and added new rules for the agents. But nobody can write every rule in advance: each drift you discover is a rule you didn't have yet. And I keep asking myself an uncomfortable question: if I found this one by chance, how many others are still hiding in there?
What nobody counts
When people say agents made native “free”, they're counting one thing: the time it takes to write the code. They're not counting what comes after.
Writing twice means reviewing twice. And when the two reviews disagree, who decides? The iOS reviewer says the factory is right. The Android reviewer says the singleton is right. Neither codebase is the reference, as we found out. Someone has to be, and that someone is a human with a limited attention span.
Then there's the fatigue. The second pass is where you skim, and skimming is exactly how our drift survived for so long.
Finally, the cost isn't only technical. Babbel's engineers ran into this from the product side. Their two implementations kept drifting apart on analytics events and A/B tests: a property named slightly differently, an experiment that triggered from a different place on each platform. The fixes were cheap. The class of bug wasn't. Product decisions were being made from dashboards that told two slightly different stories. A drift nobody sees isn't harmless. It's just quiet.
What a shared layer changes
Kotlin Multiplatform doesn't force you to share your screens. It invites you to share your behavior and business rules, and leaves the UI up to you: native, or Compose Multiplatform. What matters is sharing the parts where having two versions was never a feature: the rules, the data, the flows.
Think of it as a cursor. You decide where to put it, depending on your product and your team. Babbel put it at the view model, kept every screen native, and says the divergences disappeared. Other teams push it all the way up and share the UI too. Both are valid answers to the same question: what's worth having only once?
It doesn't solve everything. Depending on where your cursor is, you may still have two UIs to review. But you've shrunk the surface that needs checking, and in a world where code is cheap and attention isn't, that's the surface that matters.
Where agents actually help me
Agents help me produce more of what I already build: KMP and Compose Multiplatform apps, and open source libraries I never had time to create or maintain. They didn't change what I believe. They just made it cheaper to act on it.
I also think agents lower the barrier to entry. For years, the idea was never the obstacle: getting started was. Project setup, platform-specific behavior, Kotlin/Native in an existing iOS app… that's where an agent can keep you company.
Trivago is a good example. In a LinkedIn post, one of their engineering leads described moving their mobile apps to Kotlin Multiplatform in about ten weeks, with roughly 95% of the code written by AI. These are their own numbers, but look at the direction: agents didn't send them back to native, they helped them move to shared code.
So what is dead?
Not cross-platform. What changed is the question.
For years, we asked who would write the code. Now that code is cheap, the question is what you can afford to verify. Two codebases mean two sets of lines to trust, and a growing pile of rules to keep them honest.
So no, agentic coding didn't kill cross-platform. It made one idea of it more valuable: share what must be identical, and check it once. Kotlin Multiplatform promises the same behavior everywhere, and that promise is worth more when code is cheap and trust isn't.
These articles might interest you
Tutorials, lessons learned and best practices around KOSI and the Kotlin ecosystem, from the people who maintain the libraries.
17/11/2026
Inara has no magic: read the code it writes
In most DI frameworks, a module is an anonymous bag of bindings, and dependencies are looked up by type. Inara gives modules an identity. Let's open the hood and read the code it generates: there is no trick, only plain Kotlin you can Cmd+click through.
Read more
09/11/2026
LARPing enthusiasm: the ghost of disengagement
I can hand the work to AI, but not my judgment or my product sense. A story of sliding into disengagement, and of a comeback still in progress.
Read more
02/11/2026
Inara: Inject your dependencies at compile time
I created Kodein, yet I now believe it is detrimental to the Kotlin Multiplatform ecosystem. Meet Inara, a Kotlin Symbol Processor that resolves your dependencies at compile time, and learn why we are sunsetting Kodein.
Read more
19/10/2026
LARPing enthusiasm: the AI creativity frenzy
AI lets me build in weeks what once took years, and it feels like a drug. Am I really creating, or just LARPing enthusiasm? A personal reflection on agency, will and shared code.
Read more
17/10/2026
MocKMP: a mocking processor for Kotlin/Multiplatform
Want to run your unit tests on every Kotlin/Multiplatform target? MocKMP generates mocks and fakes at compile time with a Kotlin Symbol Processor, no reflection needed, and keeps a familiar mocking API.
Read more
04/09/2025
Use Swift in a Kotlin/Multiplatform library
Need to use a Swift-only iOS API such as CryptoKit in your Kotlin/Multiplatform library? Salomon shows how to bridge it through Objective-C and Kotlin/Native cinterop, with tested code.
Read more