How Shopify Wired Claude Code: Orchestrator + 4 Gates

Shopify rebuilt its Shop app from React Native to native Swift and Kotlin in 12 weeks with six engineers. The secret was not a better model — it was a better harness. The company’s internal tool, Helix, wraps AI coding agents in an orchestrator that breaks every migration task into small checkpoints and forces each one through four sequential quality gates before a single line ships. The result: Android startup time cut in half, app size down 109 MB, and session crashes reduced 10x.

This is not a story about prompting tricks or model selection. It is a story about engineering discipline applied to agent output — the same discipline that separates production-grade agent deployments from demo-day demos.

View original post on X →

Talha Naqvi, a Shopify engineer who helped build Helix, called it “one of the coolest things I’ve worked on” and noted it “skyrocketed the speed of migration to native for the Shopify app.” That speed came not from removing quality checks but from making them fast enough to run on every checkpoint.

Why Shopify Needed Helix

In September 2026, Shopify published three engineering blog posts that, read together, tell the full story of why they abandoned React Native and how they pulled it off:

1. “Native is now the future of mobile at Shopify” — the strategic rationale
2. “Migrating Shop app from React Native to native” — the execution playbook
3. “Helix: The internal tool powering our Shopify app’s native migration” — the agent harness

The core insight is economic, not technical. Shopify explained that 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.” The cost of maintaining two native codebases dropped below the cost of maintaining one cross-platform layer — but only if you have a harness that prevents agents from shipping slop.

View original post on X →

The Shopify App has more than 300 screens, an Apple Watch app, home and lock-screen widgets, Siri Shortcuts, and complications. Rebuilding it is not a weekend project. It is the kind of migration that would take years with traditional methods. Helix is how Shopify plans to do it in months.

View the full Shopify Engineering post →

The Orchestrator Pattern

Most AI coding workflows follow a simple loop: prompt the model, get code, review it, fix what is wrong, repeat. Helix inverts this. The orchestrator does not wait for a developer to find problems — it runs four automated quality gates before a human ever sees the output.

Here is the flow:

1. An engineer selects a screen to migrate from React Native to native.
2. Helix reads the React Native source and proposes a sequence of checkpoints — small, ordered slices of work. A checkpoint might be “create the header component,” followed by “implement the product list view,” followed by “add the search bar.”
3. The engineer reviews and approves the checkpoint plan in minutes.
4. Helix builds one checkpoint at a time, and each must pass all four gates before the next one begins.
5. Feedback from every review is recorded in a persistent memory, so the system gets more autonomous over time.

The key architectural decision is decoupling business logic from UI. Shopify built a Redux-like pattern where state is immutable and the UI is a pure function of that state. This lets agents test business logic headlessly — running reducers in milliseconds on a desktop CLI instead of waiting minutes for a simulator to boot. As one Dev.to analysis put it: “It doesn’t matter how good the model is if it can’t test its work quickly.”

The 4 Quality Gates

This is the core of the Helix system. Every checkpoint — no matter how small — must pass four sequential gates before it is committed. Failed gates block progression. Agents cannot override the checks, but they can retry indefinitely until they pass.

The guiding principle, straight from Shopify’s engineering blog: “An attempt is allowed to be wrong. It is not allowed to ship until it isn’t.”

Gate 1: Behavior Gate (Automated Tests)

The behavior gate runs CLI-based integration tests that verify the checkpoint’s functionality without requiring a simulator. Tests replicate how the reference React Native app operates — if the original app shows a product list sorted by price, the test verifies the native implementation does the same.

This is not unit testing for the sake of coverage. It is behavioral verification against a known-good reference. The tests are generated alongside the checkpoint and are specific to what that checkpoint claims to implement.

Gate 2: UI Gate (Visual Diff via Gemini)

The UI gate uses Gemini models for spatial reasoning. The orchestrator captures screenshots of both the reference app (React Native) and the new native implementation in matching states, then asks Gemini to act as a “perfectionist design reviewer.”

The system captures every difference it finds, each with a severity and an on-screen location. Visual issues fixable in code are treated as blockers by default. The orchestrator limits each comparison to what the checkpoint has actually built — a skeleton checkpoint is only compared on the navigation bar and title, not the full screen.

Gate 3: Adversarial Code Review

Two independent, context-isolated reviewer agents examine the code against Shopify’s documented architecture guidelines. The reviewers are adversarial by design — they argue over code quality, maintainability, and adherence to patterns. Both must approve before the checkpoint proceeds.

This is not a rubber-stamp LLM review. The reviewers are given the architecture docs, the existing codebase context, and the UI guidelines. Every finding must be resolved, tests re-run, and both reviewers must approve before the checkpoint can advance.

Gate 4: Human Review

The final gate is a human engineer validating the result against their expectations. This is not a line-by-line code review — the previous three gates have already verified behavior, visual fidelity, and code quality. The human review is about intent: does this checkpoint do what we actually wanted it to do?

Critically, human feedback is not discarded after use. It is recorded in a persistent memory that Helix reads on every subsequent checkpoint. This creates a feedback flywheel: early checkpoints get more human attention because uncertainty is high, but later checkpoints can run with less oversight as the system learns the engineer’s preferences and the project’s patterns.

The Feedback Flywheel

The learning loop is what separates Helix from a simple CI pipeline with extra steps. Every piece of feedback — from human reviewers, from failed gates, from adversarial review findings — is recorded in a persistent file that all agents read.

This means:

• Patterns that fail Gate 3 (adversarial review) once are avoided in future checkpoints automatically.
• Visual preferences surfaced in Gate 2 are applied proactively.
• Human corrections from Gate 4 compound across the entire migration.

The result is increasing autonomy. Shopify reports that in autonomous mode, an engineer can tell the orchestrator to “approve the next 3 checkpoints” or “run to completion, I’ll review at the end” — but the gates never get lax. Every checkpoint still proves behavior, passes visual review, and satisfies both adversarial reviewers.

The Results

The Shop app migration — the proof of concept for Helix — delivered hard numbers:

Six engineers. Twelve weeks. Feature-for-feature parity. These are not demo metrics — the native Shop app is live in the App Store and Google Play.

What the Community Is Saying

The announcement hit Hacker News with 751 points and 507 comments, making it one of the most-discussed developer stories of September 2026.

View discussion on Hacker News →

The discussion split along predictable lines. One camp endorsed the move as validation that native was always technically superior — “the benefits of staying close to platform APIs and first-party tooling win out.” The counter-camp argued that the economics only work for Shopify’s scale: most teams cannot afford to build a custom orchestrator with four quality gates.

The most insightful comments focused on the Helix architecture itself. Several commenters noted that the real innovation is not the migration but the harness — a point that Better Stack’s deep-dive reinforced by calling out the five-gate quality process.

View full analysis on Better Stack →

The Dev.to community breakdown reinforced the thesis that the architecture matters more than the model: “It doesn’t matter how good the model is if it can’t test its work quickly.”

View full Dev.to analysis →

An open-source reconstruction of the Helix workflow, helix-loop, has already appeared on GitHub as a Claude Code skill pack. It implements the same checkpoint-and-gate loop with a stop hook that prevents the agent from terminating until all gates pass — a direct application of Claude Code’s hook system.

How to Apply This Pattern Without Building Helix

You do not need 300 screens and a six-person team to use Shopify’s pattern. The architecture is portable. Here is how to implement a minimal version today:

1. Break Work into Checkpoints

Stop giving your agent entire features. Instead, decompose work into small, sequential units. Each checkpoint should be completable in under 30 minutes and reviewable in under 5.

2. Gate Each Checkpoint with Automated Tests

Write tests before or alongside each checkpoint — not after the feature is “done.” The tests are the specification. If the checkpoint claims to implement a product list, the test verifies the list renders with the correct data.

3. Add Visual Diff (Optional but Powerful)

If you have a reference implementation (existing app, Figma designs, screenshots), use a vision model to compare outputs. This catches layout regressions that tests miss.

4. Wire Up Adversarial Review

Run two independent LLM review passes on each checkpoint. Give each reviewer your architecture docs and coding guidelines. Require both to approve before proceeding.

5. Record Feedback Persistently

Create a learnings.md file (or equivalent) that your agent reads on every run. Every failed gate, every human correction, every pattern preference goes in this file. This is how the loop gets tighter over time — and it is the piece most teams skip.

The Bigger Picture: Harness Over Model

Shopify’s Helix system is the strongest evidence yet for a thesis we have been tracking on AgentConn: the value is in the harness, not the model. Helix uses multiple models — GPT for orchestration, Gemini for visual review — but the quality comes from the loop structure, not from any single model’s capabilities.

This has direct implications for how teams should allocate their agent orchestration budget:

1. Stop optimizing prompts. Start building gates. A mediocre prompt with four quality gates will outperform a perfect prompt with no verification.
2. Invest in fast feedback loops. Shopify’s architectural decision to decouple business logic from UI — making it testable in milliseconds — is arguably more important than the gate system itself.
3. Treat agent output as untrusted by default. Shopify’s principle that “an attempt is allowed to be wrong” is a mindset shift. If you expect the first output to be correct, you will not build the infrastructure to catch when it is not.

The agent fleet orchestration landscape is maturing rapidly. Shopify built Helix internally, but the pattern is already being extracted into open-source tools. The question is not whether your team will adopt gated agent workflows — it is whether you will build the gates before or after your first production incident.

What to Watch Next

• Shopify App migration progress: The 300+ screen migration is underway and expected to ship later in 2026. If the results match the Shop app numbers, it will be the largest AI-assisted codebase migration ever completed.
• helix-loop adoption: The open-source reconstruction is early (MIT license) but the architecture is sound. Watch for community contributions and real-world usage reports.
• Claude Code hooks ecosystem: The stop hook that prevents premature agent termination is a Claude Code primitive. As more teams build gate systems, expect the hooks API to become a key differentiator in the agent tooling war.

The lesson from Shopify is clear: if you want agents to ship production code, you need to build the infrastructure that makes wrong outputs cheap and correct outputs inevitable. The model is the easy part. The harness is the work.