Cross-Platform Was a Labor-Saving Device. Shopify Just Stopped Needing One.

In 2020, Shopify bet its mobile future on React Native and said so loudly. It became the framework's most-cited enterprise adopter, shipped libraries half the ecosystem depends on, and in January 2026 published a post whose argument was that the future of React Native was bright.

On 10 September 2026, the same team published a post titled Back to Native. Every Shopify mobile app is being rewritten in Swift and Kotlin.

Here is the sentence that matters, because it is not the one you would expect:

Agents can now do enough of the implementation, translation, testing, and review work that it's no longer the deciding factor it was in 2020.

They are not leaving because it was slow. They went out of their way to say their React Native apps are fast. They are leaving because the thing the framework was for stopped being expensive.

What a cross-platform framework is actually for

Strip the engineering language off and every cross-platform framework makes the same offer: do not pay for the second implementation.

That is the whole pitch. It has always been a labor argument wearing an engineering costume. You accept a dependency layer, an upgrade treadmill, a permanent arms-length distance from first-party platform APIs, and a class of bug that exists only at the bridge. In exchange, you write the feature once instead of twice.

It was a good trade for fifteen years because the second implementation was genuinely expensive. Two teams, two languages, two review cycles, two sets of platform trivia to keep in someone's head.

Shopify's claim is that the price of the second implementation collapsed, and the costs of the framework did not. When the thing you were buying gets cheap and the thing you were paying stays the same, you stop buying.

Whatever you think of the conclusion, the reasoning is clean, and it is the first time a company of that size has published it.

The receipts

This is not a memo about a plan. Parts of it already shipped.

The Shop app is already rebuilt and in the app stores. Proof of concept to published native app in 12 weeks. That number is the entire argument in one data point, and it is why the post is worth reading rather than dismissing.

The Shopify app is the hard one and is still in flight. Their description: over 300 screens, home and lockscreen widgets, an Apple Watch app, complications, Siri Shortcuts. It ships later this year.

They also chose a greenfield rewrite over an incremental migration, which reverses their own 2020 decision to go the other way. Rewrites are the thing everyone tells you never to do. The cost curve that made that advice correct is the exact curve they are claiming changed.

The part almost everyone will skip

The headline is the framework reversal. The useful half is a paragraph about latency that has nothing to do with mobile.

They found the bottleneck was not writing code. Agents write code in seconds. The bottleneck was waiting to find out whether the code worked, which took minutes, because checking meant booting a simulator.

Their fix is architectural:

Business logic should be completely decoupled from the UI and be able to run headlessly on desktop. We then make it available to agents via a CLI that allows them to iterate on it in milliseconds instead of minutes without involving simulators.

That is a design rule you can lift wholesale, and it generalises well past mobile:

Architect for the agent's iteration latency, not the human's.

A human developer waiting ninety seconds for a build reads something, thinks, context-switches. The wait is annoying but it is amortised across a thoughtful edit. An agent doing the same loop is idle, and it wants to run that loop hundreds of times. A feedback loop a human tolerates is a feedback loop an agent drowns in.

If you are wondering why your coding agent stalls out on your codebase and flies on a toy one, measure the time from edit to signal. That number is the ceiling on everything else.

The internal system driving the migration is called Helix. It reads the React Native code and proposes ordered checkpoints, and each one has to clear four gates: prove its behaviour with tests, match the running app in a visual review, survive two adversarial code reviewers, and get a human's approval before commit. Worth noting that a company confident enough to rewrite everything still put four gates and a person in front of each commit.

Who this does not apply to

The honest counterweight, because "Shopify left React Native" will get flattened into "React Native is over" by Thursday.

The argument scales with your headcount, not with your framework. Shopify can staff two platform teams. If you cannot, the second implementation still costs you the thing you do not have, and no agent fixes that, because the expensive part of a small team is not typing.

Their 12 weeks is not your 12 weeks. It is 12 weeks with a purpose-built migration system, a mature design system, and engineers who already know both native platforms well. The number is real and it is not portable.

And their own post cuts against a clean story. The bet was right in 2020 on the same facts, and they say so. This is a repricing, not a repudiation.

The ecosystem gets the bill

One consequence lands on people who made no such decision. Shopify maintained a chunk of the React Native commons, and that is now being unwound.

FlashList, at roughly 2 million downloads a week, is getting critical fixes while Shopify looks for someone else to take long-term stewardship. React Native Skia is sponsored through the end of 2026, after which its creator forks and republishes it under a new name. Restyle is being archived, maintained to the end of 2026, then stopped.

None of that is bad faith; the wind-down is unusually well telegraphed. But it is the reminder that a library maintained by a company is maintained for as long as that company's strategy needs it. If you depend on those three, your next twelve months just acquired a task.

The uncomfortable question for everything else

Once you accept the reasoning, it does not stay in mobile. Every abstraction whose central justification is "so you do not have to write it twice" is now up for repricing.

The ORM that exists so you do not write SQL per database. The backend-for-frontend so you do not write the endpoint per client. The shared schema DSL that generates types for four languages. The monorepo codegen layer. Each of those has real benefits beyond deduplication, and each of those benefits should now be stated out loud rather than assumed, because the deduplication was carrying more of the argument than anyone admitted.

The test is simple and slightly uncomfortable: if writing it twice were free, would you still want this layer?

For a good abstraction the answer is yes, and the reasons are about consistency, correctness or a single place to fix a bug. For a lot of layers the honest answer is no. Those are the ones to look at.

What is worth taking

Shopify may be wrong. Rewrites have a famous failure mode and the Shopify app has not landed yet; the 300-screen one is where this gets tested, not the one that already shipped.

But the framing survives either way. Labor arbitrage was doing more work in our architecture diagrams than we ever wrote down, and it is now worth asking which of our layers were load-bearing and which were just cheaper than hiring.

Sources. Back to Native, Mustafa Ali, Shopify Engineering, 10 September 2026, which is the source of every quote and figure above, and the same team's January 2026 post on the New Architecture for the position being reversed. Related here: what one finished task actually costs, the best agent scores 25.6 percent, and what the same company did to Tailwind in the same week, in 110 million installs a week.