Running Swift edits on a Linux-based agent is one thing; building and testing the resulting iOS app is another. Android is harder still, because its emulator depends on hardware virtualization and macOS does not support nested virtualization out of the box.

Remote Dev sidesteps this by pairing a fleet of remote Macs, preloaded with the development environment and iOS simulators, with a separate Linux VM that has nested virtualization enabled and hosts the Android emulator. Agents reach the Mac over SSH; the Android VM is attached to that session. The result is that one agent can compile for both iOS and Android on the Mac and exercise either platform without leaving the same SSH session.

One session. Both platforms.

Each agent claims a ready Mac with an attached Android emulator. We replace Macs after use and periodically refresh idle ones.

From thirty minutes to a few minutes

Cold setup was the first problem to solve: an initial app compilation and main checkout took over 30 minutes. Rather than provisioning a Mac after a request arrives, the team maintains a pool of warm machines with main already checked out — a non-trivial operation given the size of the monorepo — plus installed tools, built apps and warm caches.

When an agent claims a Mac, it synchronizes its branch and spins up a prebuilt Android VM instance to attach. The agent keeps working in its own checkout, locally or in the cloud, and syncs changes over to the Mac, where the scripts and builds execute. End to end, the wait from requesting a Mac to inspecting code changes on a running device dropped to a few minutes.

Keeping the pool healthy needs its own background machinery. Macs are destroyed when a session ends and replacements are prepared; idle machines are periodically rotated to pull fresh main and rebuild apps and caches. That rotation is staggered so the pool stays available and active sessions are never interrupted.

Teaching River to see the Mac

The infrastructure alone wasn't enough. River was effectively blind to it and kept asserting that an iOS build can't run on Linux — able to write code, unable to verify it. The fix was a skill that teaches agents how to test their changes and prove the work, and it took several iterations before the two-machine relationship ran smoothly.

Early behavior was rough: River would forget the remote Mac existed, go silent while communicating with it, or take a long time to return to the user. Improvements came with better tooling — a CLI that encapsulates the complexity of the SSH flags — and by replacing sleeps and timeouts for long-running Mac tasks with tmux panes that River can watch in real time.

Adoption is a habit, not a rollout

Teams were accustomed to local mobile work: a real simulator, their own build, their own test run. Beyond being inefficient on constrained laptops, that model didn't scale to the large migration task at hand. Moving people onto River was as much psychological as technical — a habit had to change.

Early versions had burned some goodwill, with builds that didn't work, ran too slowly, or weren't useful day to day, prompting the reaction "This is not for me, I'll go back to coding locally." Making the tool genuinely good had to come first.

Then came the evangelism: storytelling and internal ads to spread the word that River was now great on mobile. The team personified River as someone frustrated with mobile work who gets a real Mac at home and finds every problem solved. The character hid the complexity described in this post and made later campaigns easier, including an AI-generated parody of the Mac vs PC ad. The push moved the numbers: River went from creating 6% of merged mobile pull requests to 61%.

River's share of PRs

Multiplayer threads as a feedback loop

River is multiplayer by default, a property Tobi has described as shifting Shopify's culture and letting people learn from each other's agent usage. On the mobile side, the team uses that visibility both to learn how colleagues work and to improve the experience for future threads — seeing where people get stuck, where guidance goes wrong, and where tool access gets rejected.

The analysis runs on Jev, described as a fast, cheap classifier model. It observes all mobile River conversations, tags them with multiple questions, and answers each message. Conversations are categorized by outcome quality, and the failures feed an LLM tasked with finding improvements. The loop itself runs with River, so the agent helps improve itself for later use.

River iterating

Remote Dev is the mobile environment Shopify built for AI agents — the second half of its engineering story concerns what the team learned once agents were actually working inside it, and where the work goes from here.

What agents changed about the workflow

Giving an agent a mobile dev environment is not the same as giving a human one. Builds, simulators or emulators, and device toolchains are heavyweight and stateful, so the environment has to be provisioned, kept alive, and shared in ways that tolerate a client that never gets tired and never quite fits the assumptions of existing tooling. The payoff the team points to is a development loop where agents can iterate on mobile code without a person babysitting each build.

A production-shaped playground

A sandbox that resembles production is only useful if the agent's output remains reviewable by the people who own the code. Remote Dev is designed so the environment an agent works in reflects real constraints rather than an idealized one that later falls apart on a device.

Where to go next

The team frames the work as ongoing: the environment exists to extend how far agents can go on mobile development, and the next steps are about pushing those boundaries further rather than declaring the problem solved.

Contributing to the effort

Shopify says it is hiring mobile engineers to continue this line of work, for people interested in expanding what agents can do for mobile development.

The original article was published on October 22, 2026 by Michael Garfinkle, Mauricio de Meirelles, and David Cortes.