Shopify rebuilt its Shop app from React Native into fully native Swift and Kotlin codebases, going from proof of concept to an app published in the stores in 12 weeks with AI assistance. The app dates to 2020 and has been built on React Native from its inception, a choice that had served it well but became worth revisiting as coding agents matured.
Trigger for the rewrite
Shopify's stated reason for reconsidering a shared mobile codebase is that advances in coding agents changed the tradeoffs of maintaining one; building separately for iOS and Android still costs more, but agents made the split reasonable again. For Shop specifically, the change arrived alongside a planned adoption of React Native's New Architecture, which would have forced the team to revisit native module integrations, rendering and the boundary between shared and platform-specific code. Before committing to that work, they tested whether agents could build directly in SwiftUI and Jetpack Compose while keeping behavior aligned across platforms.
A one-week experiment
The test was small: one engineer, one week, with agents asked to port as much of the existing React Native app as possible to SwiftUI on iOS. Using the React Native app as a reference, the engineer recreated screens, interactions and flows quickly. The output was not production-ready, but a close, feature-for-feature migration looked achievable, which was enough to green-light the full effort.
Agents proved most effective when an existing implementation was available to work from. They ported defined features, scaffolded screens, wired data, implemented animations and refined layouts based on visual feedback.
How the migration was run
A core group of six engineers built the native foundations and the main user journeys; feature teams joined midway to validate their areas and handle edge cases. The overriding constraint was continuity: existing users had to stay signed in and keep receiving push notifications, interactions had to emit the events downstream systems expect — with the context recommendations rely on — and the update needed to feel like a normal release. The team also used the migration to simplify the app, deliberately retiring some screens and streamlining others.
Because agentic workflows differ from traditional ones, the team often ran multiple agent sessions across separate worktrees rather than having one developer change, run and iterate. Their approach centered on giving agents clear tasks, keeping build and test loops fast, and reviewing changes often. They released a reusable migration workflow as an extension for the Pi coding agent: specialized subagents inspected the React Native source, documented its behavior, prepared platform plans, implemented features and reviewed parity, with source review covering UI, state, navigation, analytics, accessibility and data behavior. Engineers approved requirements and plans before implementation, and plan acceptance was tied to a hash of the plan's contents so that editing a plan invalidated its earlier approval.
Agents also needed to observe the running app. The team built Tardis, a debugging tool that gives them structured access to live native events, logs and state and lets them send commands to the app, so they could investigate issues, check navigation and analytics, and validate fixes with less manual UI inspection. For parity reviews, a Tardis feature captured screenshots and event windows from both the React Native and native apps at named checkpoints; with raw event capture enabled, agents compared event names, counts and payload fields. Comparison instructions accounted for values that legitimately vary between runs, such as timestamps and page UUIDs, while checking the relationships between events and their page or entity context.
Native expertise remained essential. Generated code could meet feature requirements while still introducing duplication, architectural drift or performance problems, so repository guidance, linting, tests, static analysis, performance checks and code review all stayed in the loop. The learning curve was gentler than expected: declarative UI concepts carried over for React Native engineers moving to SwiftUI and Jetpack Compose, while platform knowledge guided architectural decisions and reviews.
Measured results
The team compared the native apps with their React Native predecessors on startup time, session stability, app size, build time and rendering performance. Cold-start recordings measure from tapping the app icon until the initial home feed content is visible.
| Platform | Native | React Native | Startup time reduction |
|---|---|---|---|
| iOS | 2466 ms | 3200 ms | 23% |
| Android | 2233 ms | 4433 ms | 50% |
Stability. Session stability, historically at 99.5%+, has climbed above 99.95% on the native releases — a 10x reduction in crashing sessions.
App size. The native Android release build shrank by 109 MB versus React Native. On iOS, release build size was roughly unchanged, growing by 1 MB.
| Platform | Native | React Native | Difference |
|---|---|---|---|
| iOS | 68 MB | 67 MB | +1 MB (+1.5%) |
| Android | 184 MB | 293 MB | −109 MB (−37.2%) |
Build time. Android release builds fell by roughly 75%; iOS release builds take about the same time as before. Faster builds let the team test new builds sooner and consume less compute.
Runtime performance. On a Pixel device, the native Android app reaches 120 FPS while scrolling the feed and navigating between screens, achieved with very little optimization work so far.
What carries forward
A guiding principle of the effort was that Android and iOS must remain at feature parity at all times — previously enforced by the shared codebase, now enforced through the development and release process. The team describes this first version as raising the ceiling for the app and as a baseline to improve on; further performance polish is planned, and the team intends to share more as its tooling and process evolve.



