I’m going native for my next startup. Here’s why you might want to, too.
The Revelation
I’m going to build my next app. A mobile app. And it’s an easy choice of language. Flutter? React Native? Used to be easy. Fast and loose, one codebase, deploy to iOS and Android in one shot - doesn’t matter what engines these things use, right?
Now, things have changed. Claude Code is in play. First, it was ultra-powered autocomplete. Then it was writing my features. Lately, it feels more like a coworker.
The revelation came over me recently when Apple announced Liquid Glass, its new design standard. The Flutter team said they won't support it. The gist of one article I read on the topic: if you rely on Flutter and the standard Cupertino widgets for your app, it may end up looking outdated on the latest generation of Apple devices. Your app will suck. Developers started chatting about whether to switch to React Native instead. But in the course of reading up on that, I had a revelation - they are asking the wrong question.
The question is not whether Flutter is dead, compared to React Native.
The question is whether cross-platform development frameworks are even a thing anymore if AI does native development work for you.
I think not.
The Old New Normal
Cross-platform development frameworks only came into being under certain economics. Coding for both iOS and Android is expensive. Talent is limited. Two codebases are a management headache and mistakes happen. Flutter and React Native were our friends: you know, don’t mind the performance hits, don’t mind the layer of abstraction, don’t mind the rough edges? Write once, deploy everywhere!
It was a pretty good deal, given that the alternative was to pay two teams to build your app twice over.
The productivity gains outweigh the cost of the abstraction.
But what happens when the economics shift?
The New Value Equation
Two things are true that make this change everything about mobile development.
One is that AI makes code generation cheap. The 2025 Stack Overflow Developer Survey says that 84% of developers use or intend to use AI in their development. Half (51%) use it daily. The biggest advantage of cross-platform frameworks was “write less code”. But if AI can generate native code almost as fast as you can write cross-platform code, there’s no value in "writing less." You just have to write 10,000 lines of code once instead of twice, or you can describe your requirements to AI and it will generate 20,000 lines of native, platform-specific code for you in a few minutes.
The other is that AI makes the quality of your specifications the only scarce resource. The 2025 JetBrains Developer Ecosystem Survey says that 85% of developers use AI tools in their development environments these days. Almost 90% of developers report saving at least an hour a week. The scarce skill is not "writing clever abstractions." The scarce skill is "writing clear requirements." The developer who can clearly specify what an app should do is worth a lot more than the one who can cleverly find a way to leverage cross-platform technology to overcome a limitation in the behaviour of a single-platform API.
This is a radical shift. Code is becoming cheap. Specifications are becoming valuable. Cross-platform frameworks are on the wrong side of the equation.
The Spec-First Future
Here’s what I expect mobile development to look like over the next few years.
Your app is a well-structured specification document. It might be Markdown, it might be something else, it might be a new format we create. The spec defines the behaviour of the app, the user flows, the business logic, edge cases. It’s platform agnostic not because it runs on all platforms but because it doesn’t specify implementation for any platform.
When it comes time to deploy the app, AI generates native Swift for iOS, native Kotlin for Android, and native web code. These are all platform-specific deliverables. It uses platform-native UI elements, conventions, and features. There is no layer of abstraction. There are no compromises.
If you need to change things, you change the spec and regenerate. If a new platform emerges (like AR glasses or a voice interface) you generate for that platform. You don’t have to rewrite your cross-platform app on a platform that its creators never envisioned.
The layer of abstraction is not Flutter or React Native. The layer of abstraction is the specification.
Why This Beats "Write Once, Run Anywhere"
The case against cross-platform frameworks in the age of AI is a simple one.
First, the abstraction penalty is no longer justifiable. There were always penalties associated with using a cross-platform framework: worse performance, non-platform conforming behaviour, bugs at the abstraction layer. Developers accepted those penalties because building cross-platform applications was so much more productive. But if the productivity advantage of native application development is almost as good, there’s no reason to accept penalties for the sake of productivity.
Second, specs age better than implementations. A good spec that captures the desired behaviour of your app can be retargeted to new platforms, new operating system versions and even new paradigms all with relative ease. Flutter’s widget tree encodes assumptions about apps and their behaviour. Those assumptions are not valid for apps that use spatial computing or have a conversational paradigm. A good spec that captures user intent is always more portable.
Third, the single codebase is an anti-advantage. When there’s a single codebase, a bug fix or a feature enhancement has to be made just once and be effective everywhere. You run the risk of fighting the abstraction layer for every divergence between platforms. With generated native code for the platforms, you can make platform-specific fixes and enhancements. You can even generate non-fatal platform-specific behaviour if that’s what user expectations demand.
Finally, we’ve seen this movie before. Assembly language didn’t become obsolete because programmers became better at writing in assembly language. It became obsolete when compilers got good enough that programmers didn’t need to work in assembly language any longer. jQuery didn’t become obsolete because browser developers went back to all implementing idiosyncratic and incompatible DOM interfaces. It became obsolete when browser development stabilised and developers had frameworks that addressed the same need. Cross-platform frameworks may be the next abstraction to get compiled away; a powerful approach that developers will mostly stop needing.
Where I Might Be Wrong
I could be overthinking this, and I’m upfront about things that might be counterarguments.
One version of the scenario is buggy AI-generated code will be its own consistency problem. Generating native code for every platform will create subtle inconsistencies in how the code works that would not be the case with a single codebase. Determining “why does this work on iOS, but not Android” may be harder, not easier, when there’s not just one shared codebase, but genuinely different codebases for each target of deployment. 66% of developers report spending more time on “almost-right” AI-generated code, a point which MIT Technology Review shared recently. Trust in AI coding tools has been declining over time, even as their usage has been increasing.
Another version of the scenario is that cross-platform frameworks become AI-native. Flutter could become “AI-Assisted Flutter” where the framework does the abstraction, but AI does the boilerplate. The abstraction doesn’t need to go away altogether. It could just get thinner and smarter. If Flutter becomes a thin spec layer that AI implements natively for you, I may have collapsed my own argument into theirs.
Then there’s the debugging problem, which may be more complex than I envision. If AI generates your native code, who debugs it if something goes wrong? Do developers need to know Swift and Kotlin now, or can AI debug it as well? This is an open question. A world where humans don’t understand their own codebases has its challenges.
The Timeline
I don’t know how long this will take. 2 years? 10 years? I can’t say for sure.
What I do know is that I’m watching Claude Code write better Flutter code than I am, faster than I am. And each time I do, I ask myself: if AI can write Flutter this well, why would I create an abstraction layer between AI and the native ecosystem? Why not let it write Swift? Why not let it write Kotlin?
It’s a question that’s getting harder to ignore.
Conclusion
Every generation of developers has solved the problem of the previous generation so well that it becomes impossible to have that problem ever again. Compilers solved the assembly problem. Garbage collectors solved the memory problem. Cross-platform frameworks solved the two-codebase problem. And perhaps now AI is solving the cross-platform problem — by making native development so fast, we don’t need the abstraction anymore.
The future belongs to developers who can express themselves.
Code is a commodity. Vision is not.
The best cross-platform code is no cross-platform code. 🤪