Shopify React Native Migration: How AI Coding Agents Made Native Cheaper Than 'Write Once'

In 2020, Shopify made one of the most-watched bets in mobile development: going all-in on React Native, betting that one JavaScript codebase could serve its entire fleet of iOS and Android apps. The bet paid off — the company published “Five Years of React Native at Shopify” in January 2025, saying the framework’s future was bright and Shopify planned to keep investing in it.

Then, on September 10, 2026, the same team published “Native is now the future of mobile at Shopify,” announcing that every Shopify mobile app is moving back to fully native Swift and Kotlin.

Here’s the twist that makes the Shopify React Native migration more than a routine framework pivot: Shopify isn’t leaving React Native because React Native failed. The post is explicit about this — their React Native apps were fast, the framework was working well, and the 2020 bet “has been extremely successful.” The reason is something stranger and more interesting: coding agents changed the economics that made React Native the right call in the first place.

The HN thread — “Shopify is moving from React Native back to Swift and Kotlin” — stood at 985 points and 670 comments when captured during research for this post, and it was still climbing. But those numbers are a lagging indicator. The argument underneath them is the real signal.

The Shopify React Native Migration, Explained: From “All-In” to “Back to Native”

The six-year arc, in one paragraph

The 2020 decision rested on three goals: stop building the same features twice, let developers work across the stack, and spend less time chasing feature parity. For six years, React Native delivered on all three. Shopify wrote that the costs — performance tuning, keeping up with framework updates, maintaining foundational integrations — were acceptable tradeoffs. Then, by late 2025, the company’s own assessment changed: agents were no longer just writing code faster; they were “capable of making us question whether building software twice still meant doing twice the work.”

That’s the whole story in one sentence. Everything else — Helix, the forks, the 12-week rebuild — follows from it.

The Actual Argument: Agents Erased the Code-Sharing Discount

Cross-platform frameworks exist to solve an economics problem. Writing every feature twice costs roughly twice the engineering time, so sharing one implementation across platforms was the discount that justified React Native, Flutter, Kotlin Multiplatform, and the rest of the category. The discount also bought something softer but real: developers without mobile backgrounds could ship mobile features, and feature parity came mostly for free.

Shopify’s argument is that LLMs collapsed the discount — the economic core of the Shopify React Native migration. When Shopify prototyped rebuilding core parts of its biggest apps in Swift and Kotlin, it found that agents:

• could implement a feature on Android using the iOS version as a reference, and vice versa;
• helped developers ramp up and contribute outside their primary stack;
• dramatically reduced the cost of maintaining parity through shared specifications, tests, and review checkpoints.

Read that first bullet again, because it’s the load-bearing one. The expensive part of “building twice” was never typing the code twice. It was the translation layer: understanding what the iOS version does, reconstructing the intent, handling edge cases, keeping analytics events identical. That’s exactly the kind of bounded, well-specified task agents excel at with a reference implementation in hand — Shopify’s Shop-app migration post confirms agents “were particularly effective when they had an existing implementation to work from,” porting features, scaffolding screens, and refining layouts from visual feedback.

The company is also refreshingly honest about what didn’t change. Native still means building and maintaining two platforms — that cost “has not disappeared.” What changed is that agents now absorb enough of the implementation, translation, testing, and review work that cross-platform code-sharing is no longer the deciding factor it was in 2020.

That translation work is also where the security surface lives — hand agents a reference codebase and you should know about attack classes like the MOSAIC attack on AI coding agents. And there’s a second half to the ledger. The advantages of going native remain intact — and Shopify enumerates them: closer to platform capabilities, first-party tooling, fewer framework and dependency layers between code and platform. Once the “build twice” penalty shrinks, the balance tips. You’re no longer paying a big premium for native, so you get native’s benefits at a price you can actually afford.

Worth noting: Shopify says it has used LLMs to build software since 2021 — “one year before ChatGPT” — so this wasn’t a knee-jerk reaction to a demo, but a deliberate re-evaluation from first principles once a core assumption changed.

Inside Helix: How Shopify Migrated With Agent Loops

The obvious failure mode is the one everyone who has tried “point an agent at the old codebase and one-shot the rewrite” already knows. Shopify tried the freeze-into-specs-and-implement approach and reports it produces “a huge amount of unmaintainable code that can’t be shipped.”

Their answer is an internal system called Helix, and its design is worth studying because it’s a template for any large-scale agent-driven refactor. It’s also what made the Shopify React Native migration executable at enterprise scale in months rather than years.

Helix takes a gradual approach: “it doesn’t expect the first output to be correct, and builds a loop where an imperfect attempt simply cannot move forward until it becomes a good result.” A developer points Helix at a screen. Helix reads the React Native code and proposes a sequence of checkpoints — small, ordered slices of work that can be reviewed in minutes. Then, checkpoint by checkpoint, it builds. Paraphrasing the published pipeline as pseudocode:

1
2
3
4
5
6
7
8
9
10

for each checkpoint in Helix.plan(screen_from_react_native_source):
    implementation = agent.implement(checkpoint)
    assert tests.prove(implementation)        # must prove its behavior with tests
    assert visual.review(implementation)      # must match the running app
    assert adversarial_reviewers(2).accept()  # must survive two adversarial
                                              #   agent code reviewers
    assert human.approves()
    commit()
    memory.record(all_review_feedback)        # loop gets more autonomous
                                              #   as migration progresses

Each gate has to pass before the next checkpoint starts, and feedback from every review is remembered so the loop grows more autonomous over time.

The results, per the companion Shop-app migration post:

• Proof of concept: one engineer spent a week with coding agents migrating as much of the React Native app as possible into a SwiftUI app. Not production-ready — but convincing enough that a close, feature-for-feature migration was achievable.
• The rebuild: a core group of six engineers built the native foundations and main user journeys, with feature teams joining midway to validate their areas. From proof of concept to a fully rebuilt native app published in the app stores: 12 weeks.
• Continuity constraints: users had to stay signed in, keep receiving push notifications, and analytics events had to keep flowing to downstream systems like recommendations. The migration was also used to deliberately retire some screens.

The numbers Shopify published comparing native to the React Native predecessors are striking for a migration that was supposedly about economics, not performance:

Two more pieces of tooling round out the picture, and both generalize:

Tardis, a debugging tool giving agents structured access to live native app events, logs, and state, plus the ability to send commands to the app. For parity reviews, it captures screenshots and event windows from the React Native and native apps at named checkpoints, letting agents compare event names, counts, and payload fields while tolerating values that naturally differ between runs, like timestamps and page UUIDs.

The plan-hash trick. Shopify built the migration workflow as an extension for the Pi coding agent, with specialized subagents inspecting the React Native source, documenting behavior, preparing platform plans, implementing, and reviewing parity. Engineers reviewed plans before implementation — and plan acceptance was tied to a hash of the plan’s contents, so changing a plan invalidated its previous acceptance. Approval stayed attached to the plan actually reviewed. (We’ve covered what happens when approval mechanisms in AI coding assistants break down in our GhostApproval write-up.) That’s a small mechanism doing serious work: it closes the classic agent-workflow hole where an approved plan silently mutates.

Also worth underlining for anyone planning something similar: the migration team reported that agents needed fast feedback loops, and simulator interaction was the bottleneck. Agents changed code in seconds but took minutes to test results. Shopify’s fix was architectural — business logic decoupled from the UI, runnable headlessly on desktop, and exposed to agents via a CLI that iterates in milliseconds instead of minutes. If your app’s architecture can’t be driven headlessly by an agent, your agent-driven velocity is capped by simulator babysitting.

The Fallout: Skia, FlashList, and the React Native Ecosystem

Shopify isn’t just leaving; it’s dismantling its own React Native open-source footprint, and the post handles this with unusual specificity.

React Native Skia — Shopify will sponsor it through the end of 2026. William Candillon will keep working on it beyond that, forking the repo in the coming months and publishing the library under a new name; the original repo gets archived once the transition completes. Shopify’s message to dependent teams: consider sponsoring the fork.

FlashList — the high-performance list library Shopify describes as getting roughly 2M downloads per week and as “the default way to render high-performance lists in React Native.” Shopify will keep fixing critical compatibility issues, and is “in discussions with several companies” about long-term stewardship. At the time of writing, the GitHub repo is live and actively maintained — the stewardship question is open, and whoever answers it inherits one of the React Native ecosystem’s most load-bearing dependencies.

Restyle — Shopify has announced it is archiving the repo. It will keep Restyle working through the end of 2026 and then stop maintaining it, welcoming forks and offering help with handover. (At the time of writing, the repo itself has not yet been archived.)

Zoom out and the pattern is uncomfortable for Meta’s framework strategy. Shopify wasn’t just a React Native user; it was one of the framework’s most credible enterprise validators and biggest ecosystem contributors. When the reference “we bet big and won” case exits, the story every framework team tells its executives changes. React Native “remains an excellent framework” in Shopify’s own words — and that’s exactly what makes the exit contagious. If even the successful adopters leave when the economics shift, the question for every remaining shop is what, specifically, keeps them.

Did the Shopify React Native Migration Validate or Kill Cross-Platform?

Neither, quite. It validated something more specific — and killed a particular argument, not the whole category.

Where agents favor native. Shopify’s profile is the textbook case: large teams, long-lived apps measured in decades, hard parity requirements, deep platform integration (the main Shopify app has 300+ screens, home and lockscreen widgets, an Apple Watch app, and Siri Shortcuts), and the engineering capacity to build migration infrastructure like Helix and Tardis. When your horizon is long, the amortized maintenance savings of owning two clean native codebases — with agents doing the porting — beat the accumulated friction of a shared abstraction layer. Fewer framework layers between your code and the platform is a compounding advantage.

Where cross-platform still wins. The math doesn’t flip for everyone. Small teams shipping a web-and-mobile product, startups where iteration speed dominates platform polish, apps with modest native-API surface, anyone who can’t staff real Swift and Kotlin expertise on both platforms — for these, agents make cross-platform cheaper too. Agents help React Native shops just as they help native shops. The relative advantage Shopify describes is that agents made the native option cheap enough for a company that could already afford either. A five-person team didn’t get two platform-native expert teams out of this; it got a slightly better version of the leverage it already had.

The honest framing: agents raised the ceiling on native for big organizations more than they raised the floor for everyone. Frameworks aren’t dead; their strongest enterprise argument — “native means paying double forever” — is now materially weaker than it was when Shopify published “Five Years of React Native at Shopify” in January 2025.

The adjacent ecosystems should read this closely. Kotlin Multiplatform shares business logic rather than UI, which partially preserves the agent-era value proposition (one spec, shared tests) while accepting native UI — arguably closer to what Shopify actually rebuilt. Flutter draws UI itself, which buys pixel-identical parity but sits even further from first-party platform tooling — the exact thing Shopify cited as a benefit of leaving. Expo has made React Native viable for teams without deep mobile expertise; its value proposition was always leverage-per-engineer, which agents now amplify rather than replace.

What This Means for Your Stack in 2027

Three practical takeaways for anyone making platform decisions right now — whether or not a Shopify React Native migration is on your radar.

1. Re-run your cross-platform ROI with agent-augmented maintenance costs. Every “React Native vs. native” analysis you’ve read assumed a standing tax for building twice. That tax is now a variable, and it’s falling. If your platform decision is older than late 2025, it was made under a different price regime. Shopify’s numbers — 23–50% faster cold starts, a 10x stability improvement, a 37% smaller Android binary — are what the “expensive” option delivered for a team that rebuilt with agents. Price both branches of the decision against today’s agent capability, not 2020’s.

2. Treat “agent portability” as a first-class architectural variable. The most transferable idea in these posts isn’t about React Native at all. Shopify restructured its apps so business logic runs headlessly and agents can drive it through a CLI in milliseconds. That decision did more for agent productivity than any model upgrade — because “it doesn’t matter how good the model is if it can’t test its work quickly, which is especially difficult on mobile.” Whatever stack you’re on, ask: can an agent build, test, and verify a change here without a human in the simulator?

3. Build the guardrails before you need them. Helix’s design — small checkpoints, tests as proof, two adversarial reviewer agents, human approval, memory of past feedback — plus the plan-hash mechanism is a complete, borrowable pattern for any agent-driven migration. The counterexample is the one Shopify explicitly warns about: freeze everything into specs and task files up front, one-shot the implementation, and you get unmaintainable slop. Gradual, gated, self-correcting loops beat ambitious one-shots.

The deepest takeaway is about how decisions get made. Shopify reversed a famously successful, publicly documented, six-year-old architecture decision — not because the old choice failed, but because an assumption underneath it changed, and the team noticed. “We don’t hold on to a decision just because it was successful at the time” is the sentence that will outlast the framework debate. In 2027, the winners won’t be the ones that picked native or cross-platform. They’ll be the ones that re-picked when the math changed.

Further reading on RaryTempo:

• Cursor Composer 2.5: The Next Evolution in AI-Native Development — AI-native coding tools and what they change about everyday engineering
• Vibe Coding Security: How AI-Built Apps Are Leaking Corporate and Personal Data — the security side of agent-written code
• DeepSeek Reasonix: The Open-Source Terminal AI Coding Agent Challenging Claude Code — reasoning models in the coding-agent stack

Sources: Shopify Engineering, “Native is now the future of mobile at Shopify” and “Migrating Shop app from React Native to native” (both Sep 10, 2026); Shopify/flash-list GitHub repository; Hacker News discussion captured September 11, 2026.

References and further reading

• Shopify Engineering — “Native is now the future of mobile at Shopify” and “Migrating Shop app from React Native to native” (both Sep 10, 2026)
• Five Years of React Native at Shopify — Shopify Engineering, January 2025
• React Native — official project site
• Shopify/flash-list — GitHub repository
• Shopify/react-native-skia — GitHub repository
• Shopify/restyle — GitHub repository
• Hacker News — discussion thread captured September 11, 2026

• Next Post →