According to a recent report, Shopify is returning to native programming for the development of its mobile applications. React Native – a framework that can be used to build iOS and Android apps from a shared codebase – has had its day there. The reason given is progress in AI-assisted programming: the extra effort of maintaining two separate codebases apparently no longer weighs as heavily as before.
The news is noteworthy for two reasons. First, Shopify had publicly championed cross-platform development for years. Second, the reversal touches on a trade-off that comes up in almost every mobile project sooner or later.
What the trade-off is really about
Cross-platform frameworks solve an economic problem, not a technical one. Natively developed apps – that is, applications built with the tools and languages of the respective platform – have always been considered closer to the system: better integration of new operating system features, finer control over performance and user behaviour. The price for this is that every feature has to be built twice, tested twice and maintained twice.
That price was precisely the main argument for shared codebases. One team instead of two, one business logic instead of two variants, one release process instead of parallel workflows. Those with scarce development capacity generally chose the path that tied up fewer people.
If AI assistants now take over part of the routine work – porting between languages, boilerplate, test scaffolding, propagating a change into the second codebase – this calculation shifts. Not because native has suddenly become better, but because the disadvantage of dual maintenance carries less weight. The arguments for platform proximity remain, while the counterarguments shrink.
Why this does not automatically apply to every project
No general rule can be derived from a single decision by one large provider. Shopify has its own mobile teams, established toolchains and enough volume to build and roll out tools internally. A mid-sized company with an app maintained by an external agency faces different conditions.
What matters, therefore, is less what Shopify does than which variable in the equation has changed. And that is the effort per line of code in recurring, well-structured work. Anyone who has not measured this variable in their own organisation cannot recalculate the equation either.
In addition: dual codebases mean not only double the development work. They also mean double the dependency maintenance, double the security updates, double the coordination with design, double the onboarding of new employees. AI assistance applies to these points to varying degrees. Code generation is something different from the responsibility for ensuring that both apps still behave the same way in three years.
What this means for ongoing technology decisions
Many architecture decisions in companies date from a time when certain assumptions held: a second frontend is expensive. A dedicated interface only pays off beyond a certain size. A migration is too costly, so the legacy system stays. These assumptions are rarely documented; they usually sit as silent premises in minutes and proposals.
It therefore makes sense to take a sober look at your own open items:
- Which decision was justified primarily by effort? That is where a reassessment is most worthwhile. Decisions made for business or regulatory reasons remain unaffected.
- How much of the work involved is actually repetitive? Translation work, data model mapping and test coverage benefit differently from conception, interface design or troubleshooting in distributed systems.
- Who bears the maintenance? An approach that becomes cheaper to create but ties up more people in maintenance is not necessarily the cheaper one.
- Is there reliable first-hand experience? Without measured turnaround times from your own team, any effort estimate involving AI remains speculation.
Beware of the counter-movement
It would be a misunderstanding to conclude from this report that shared codebases are obsolete. For many use cases – applications with a manageable interface, a strong focus on content, clear standard interactions – the old arguments remain valid. Nor does the web version of an application disappear just because native development is becoming more attractive again.
It is more realistic that the range of defensible decisions will grow. Where one option was previously effectively ruled out on cost grounds, several paths will be open in future. This raises the bar for justification: a technology choice can no longer be justified solely on the grounds that it is the cheapest.
For web and software projects, this means above all one thing: architecture decisions should come with an expiry date. Anyone who records the assumptions under which a decision was made can review it as soon as those assumptions change – and that is currently happening noticeably. The real competitive advantage lies less in the tool than in the ability to reopen old commitments without loss of face.