The case for cross-platform survives, though not for all the reasons it used to. Agentic coding reshapes the decision in ways more interesting than the framework-is-dead takes suggest.
A product owner planning a mobile app in 2026 tends to arrive with a fair question. If AI agents can write most of the code, why share a codebase at all? Point a few agents at the problem, let one build the iOS app and another the Android app, and skip the compromises that Flutter and React Native ask you to make.
It is a reasonable question, and it deserves a real answer rather than a reflex. The short version:
To see why, it helps to remember what cross-platform development was solving in the first place, then look honestly at what agentic coding does and does not do to that math.
Two platforms, two native languages. Apple runs on Swift and Objective-C, Android on Kotlin and Java. Building for both used to mean two codebases, two teams (or one team switching context all day), two release trains, and the same bug fixed twice.
Two frameworks showed up to solve that, each making a different bet:
Same goal behind both: one team shipping to both platforms from a single codebase.
The payoff was mostly economic, and it still holds:
And the frameworks long ago outgrew the toy-app reputation. React Native runs major screens at Shopify, Microsoft, and Coinbase. Flutter ships in production at Netflix and Philips.
Nothing is free. Four costs came bundled with the convenience:
That last point deserves its own line, because the whole agentic argument pivots on it:
Hold that thought. (If you want the older side of this debate laid out in full, our native versus hybrid app development covers the pre-AI trade-offs in detail.)
Most of the React Native vs Flutter comparisons you will find are running on three-year-old facts, which matters because the argument here only works on current ones. Here is where the two frameworks actually sit now, plus the third option most articles skip:
A few numbers behind the table. React Native's New Architecture migrations report cold starts around 43 percent faster and memory use down about a quarter, and Expo is now the recommended way to start a project. Flutter's Impeller killed the shader-compilation stutter that dogged early versions and brought smooth 120Hz animation. Kotlin Multiplatform adoption roughly doubled in a year, from 7 to 18 percent of surveyed developers, and runs in production at Netflix, McDonald's, Cash App, and Duolingo.
For ordinary apps (lists, forms, navigation, checkout) the performance question has quietly resolved. Users cannot tell the frameworks apart. Differences remain only at the edges: heavy animation, and cold start on mid-range Android.
The Kotlin Multiplatform model is worth picturing, because it reframes the whole decision: share the engine, build each cockpit natively.
So does agentic coding blow all of this up?
The most rigorous trial we have, does not flatter the tools. In 2025, METR ran a randomized controlled trial with experienced developers working on repositories they knew intimately. When they were allowed to use AI:
The tools were current for the period (Cursor with Claude models), so this was not a straw-man setup. The result is also narrower than the headlines made it sound: it measured senior engineers on mature code they already understood, close to the worst case for AI assistance. On boilerplate, prototypes, unfamiliar codebases, and repetitive scaffolding, agents earn their keep. But the gap between how fast developers feel and how fast they are is worth sitting with.
The follow-up is where it gets interesting. By early 2026, METR's raw numbers had swung toward a speedup, but the study broke down before it could prove one. So many developers now refused to work without AI that the comparison group fell apart. METR's careful conclusion is that developers are probably faster now than they were in 2025, though it can no longer measure by how much with confidence. The 2025 slowdown was real for its moment. The honest successor to it is a moving target, not a tidy reversal.
The useful frame is the one the largest current study lands on. Google's 2025 DORA report, drawn from nearly 5,000 developers, found that around 90 percent now use AI at work, and that the tool works as an amplifier: it makes strong teams faster and makes weak teams' problems worse, lifting throughput while also raising instability. Point good practices at an agent and you get faster delivery. Point weak ones and you get faster mess.
That is where the two-native-apps idea starts to wobble. Three things get in its way.
If agents make two native codebases cheaper to write, they also make one shared codebase cheaper to maintain. Both sides of the ledger move together, so the old advantage of one over two does not disappear. Everything got faster, and doubling your surface area still doubles the surface for everything that can go wrong.
Large language models are best at what they saw most: JavaScript, TypeScript, and Python. They are measurably weaker at strict, statically typed native languages like Swift and Kotlin. Anyone who has watched an agent confidently produce not-quite-right Swift has felt it. Now recall the native surface from earlier:
Cross-platform frameworks let you spend most of your time in JavaScript or Dart, where agents are stronger, and touch native code only at the edges. Choosing two native apps points your agents at their weakest languages for the entire build.
and AI raises volume faster than quality:
Every one of those checks happens once per codebase. Two codebases means two rounds of it.
Put the pieces together:
Inside a working team, this is less dramatic and more useful than either the hype or the doom suggests. On our mobile team, agents now do a first pass on the unglamorous work: reading a large codebase, tracing how a change ripples through it, surfacing the dead dependency nobody remembered.
The limits are just as concrete, and they match the research:
None of this argues against the tools. It argues for keeping a human accountable for the output, which is the whole job now. Our cross-platform build for GfK, which paired a shared codebase with on-device OCR and AI models, is a good example of where that human judgment earns its place.
Three questions settle most of the cross-platform vs native app development decision.
Is your app mostly standard features? Think content, shopping, dashboards, social feeds, internal business tools. If yes, go cross-platform. Agentic coding speeds it up, and you have only one codebase to check its work.
Does it push the hardware hard, or plug into things like CarPlay or the Apple Watch? Then go native (iOS or Android). Agents make native work more approachable than it used to be, but this is where they slip most, so budget for more human review.
Do you need to reuse the same core logic across both apps while keeping each one looking and feeling truly native? That is where Kotlin Multiplatform fits. You share the engine and build each interface natively, which happens to be how agents work best, strong on the shared logic and out of the way on the native screens.
If cross-platform is the answer, the React Native or Flutter choice has not changed much. A JavaScript team, or a web product on the roadmap, points to React Native. A polished, animation-heavy look that stays identical on both platforms points to Flutter. Either way, the tool matters less than the habits around it. Agentic coding rewards teams that test, review, and keep their dependencies clean, and it exposes teams that do not faster than hand-written code ever did.
AI is accelerating mobile development, but faster coding does not automatically mean simpler products. Every additional codebase still adds testing, security checks, dependency management, debugging, and maintenance.
For standard apps, cross-platform development remains a strong choice because one shared codebase keeps complexity under control. Native development still leads when deep hardware or platform integration matters, while Kotlin Multiplatform offers a practical balance between shared business logic and native user experiences.
In this episode, we examine how AI changes the development equation and help businesses understand where React Native, Flutter, Kotlin Multiplatform, and native development now fit.
Agentic coding did not settle the native-versus-cross-platform question so much as raise the stakes on getting it right. The shared codebase keeps its economics because agents speed up maintenance as much as writing, and the review load they add is lightest when there is one codebase to review. Native stays the right call for hardware-heavy work, where agents help least. The rest is judgment.
At VT Netzwelt, we choose the architecture from the product in front of us, then put agentic and AI workflows on top of the testing and review that make them safe. The tools are fast. The thinking is still the job.
If you are weighing this decision for a specific product, our mobile app development services cover native, cross-platform, and shared-core builds, and the team offers a free 30-minute consultation to talk your case through.
No, agentic coding does not make cross-platform frameworks obsolete. It speeds up every approach roughly equally, which keeps the single-codebase advantage intact and adds a new one, fewer places to review AI-generated output.
React Native has a slight edge, because AI models tend to perform best in widely represented languages like JavaScript, TypeScript, and Python, and weaker in strict native languages like Swift and Kotlin. Flutter’s Dart is a smaller language in the training data, though current models still handle it well. Team skills and product needs should decide this more than model preference.
For most apps, no. Building two native apps points AI agents at Swift and Kotlin, the languages they handle worst, and doubles the code you have to review for bugs and security flaws. Native is worth it when the product needs deep hardware or platform features, not as a default.
Yes. Kotlin Multiplatform is used in production by Netflix, McDonald’s, and Cash App, with Google’s official support. Sharing business logic while keeping the UI native is the proven path. Fully shared UI through Compose Multiplatform is stable on iOS but still maturing, so adopt that part deliberately.
Often not. Veracode found that about 45 percent of AI-generated code contained a common vulnerability, and separate research shows AI tools invent package names that attackers then register. Dependency scanning and human review are necessary whenever agents write code.
Not always, and it depends on the work. AI tools help most with boilerplate, unfamiliar code, and prototyping. A METR study found experienced developers were 19 percent slower on code they knew well in 2025, then found them probably faster by 2026 but could no longer measure it cleanly. Google’s DORA research sums it up: AI amplifies a team’s existing strengths and weaknesses rather than fixing anything on its own.
Are You Prepared for Digital Transformation?
Mobile App Development
Swift vs React Native in 2026: compare performance, Apple features, security, maintenance, cost, and use cases to choose the right framework for your app.
iOS app development
Confused about iOS app pricing? See real 2026 cost ranges for MVP, mid-level, and enterprise apps, plus what drives the price up or down.
Mobile App Development
Build secure healthcare apps in 2026 with HIPAA-ready architecture, protected data workflows, and compliance-focused development best practices.