From DX to AX (Agent Experience) — How an environment optimized for AI can also improve the human experience

"AI-First Development Infrastructure Architecture" Series Part 3 (of 3)

In Part 1, I wrote about how separate repositories become a "wall" when delegating code to AI. In Part 2, we explored the ideas, technologies, and infrastructure Shopify used to create a "World" that broke down that wall. The question for this final part is a simple one: how far does the effectiveness of this AI-prepared environment extend beyond AI itself?

I’ll start with the conclusion: an environment prepared for AI ultimately becomes an environment that is easier for humans to work in as well. What Shopify's engineering organization has repeatedly articulated is the discovery that "Agent-Friendly (AI-friendly) is almost the same as Human-Friendly." The goal of development teams is shifting from the long-discussed "DX (Developer Experience)" to "AX (Agent Experience)." In this article, I will organize this transition and the by-products that humans receive.

First, a clarification of terms. The "DX" here is not the digital transformation often heard in society. It stands for Developer Experience.

Shopify is a company that has distanced itself from other e-commerce platforms through its developer experience. However, whether that experience has been properly evaluated is another matter. Even if developers on the ground wanted to use Shopify, e-commerce department managers would often choose the "security of a large company" like Salesforce Commerce Cloud, considering their own careers. It was not uncommon for the usability for creators to be underestimated in decision-making.

Nevertheless, its capabilities were genuine. In the past, e-commerce modifications involved directly pasting HTML into text fields in the admin panel. Then came the ability to write code in a local editor and deploy it directly – a revolutionary concept at the time, though commonplace now. Conversely, because this commonplace ability was not available for a long time, e-commerce was not exactly a popular job among developers. Sophisticated tools like Hydrogen are an extension of this. The fact that we have been able to continue building with Shopify since 2013 was due to this foundation.

That company is now once again leading the way in "usability for AI (AX)." An organization that continually invested in DX smoothly transitions into AX. This story is not a sudden mutation, but an extension of that trajectory.

01 AI doesn't tolerate "tacit understanding"

Human teams operate largely on tacit knowledge. "This library loads in this order," "that environment variable can be found by asking a senior colleague." Even if the README is outdated, or the CI occasionally turns red for no apparent reason, experience somehow allows us to overcome it.

AI cannot overcome these things. It will act based on an old README, be confused by broken CI signals, and halt before undocumented procedures. The ambiguity that a human might simply dismiss as "oh, that's just how it is" becomes an outright obstacle for AI.

That's why Shopify had to eliminate ambiguity one by one to make AI work. The AGENTS.md file placed in each directory symbolizes this. This is not a README for humans, but a command instruction for AI. Looking at Shopify's public repositories (for example, checkout-kit's AGENTS.md), it says: development commands must always be executed within shadowenv's virtual environment. Access tokens and merchant IDs should never be logged, and synthetic placeholders should be used for validation.

Only after writing all of this can AI stop acting wildly based on speculation.

At this point, some of you might be able to relate. If you were to give the same level of detailed instructions to a human colleague, you'd sense an atmosphere of "they should just understand it." But when the recipient is AI, we surprisingly and honestly write out every single step. This is because we can cut straight to the chase and accept that "if you don't tell it, it won't know." Any excessive expectation of tacit knowledge is dismissed from the outset.

Therefore, instructions can be written more meticulously for AI than for humans, who tend to have expectations. You can freely include prerequisites, prohibitions, and procedures. And what's interesting is that these comprehensive instructions are equally useful for humans. By discarding high-context expectations and writing down everything necessary, low-context communication triumphs.

02 Accumulated wisdom prevents the same mistakes from happening twice

Shopify's system has another layer of feedback.

River misinterprets the cause of a bug or gets stuck in a build. A human engineer, seeing this in a public Slack channel, interjects with, "that library loads in this order." So far, this is a common scenario. What's different is what happens next: the feedback doesn't disappear in a chat reply, but is committed as a skill file update or an AGENTS.md diff. Shopify calls these pebbles.

The next time River approaches the same task, it first reads the updated skill file before proceeding. Thus, it doesn't repeat the same mistake. A human's single comment transforms into accumulated knowledge within the codebase.

It has been reported that this feedback loop increased River's pull request merge rate from 36% to 77% in about two months. This wasn't due to retraining the base model; it was a result of the codebase itself becoming smarter. This growth illustrates the immense leverage gained by storing expertise, which is based on their own environment, within the repository. Moreover, River only operates in public channels. This means that it's not just one person's expertise, but the collective feedback of engineers across Shopify that accumulates. The method of collecting knowledge is also very effective. The figure of "1 in 8 company-wide merged PRs" mentioned in Part 1 is also built upon this foundation.

03 "Investment for AI" becomes "investment for humans"

This is the most important point I want to convey in this series.

Deleting old documentation, making CI red signals meaningful, and clarifying person-dependent procedures. These were all tasks initiated "to prevent AI from getting lost." Yet, once completed, the ones who rejoice the most are the newly joined human engineers.

It's natural when you think about it: an AI encountering a codebase for the first time and a new hire on their first day are in very similar situations. They don't know the big picture. They don't share the tacit understanding. They rely solely on documentation and CI signals. A state where AI can operate without getting lost is almost identical to a state where new hires can get up to speed in the shortest possible time. Many of the neglected technical debts are also exposed and resolved during this tidying process.

Dana Lawson, CTO of Netlify, asserts that "writing code is no longer the central focus of engineering." The job of future tech leads will be to continuously design guardrails and context so that AI and humans can work safely in the same environment. She calls this "shepherds of the production environment." While it may sound a bit exaggerated, the direction is clear: a shift from being code-by-code artisans to designing the very place where AI and humans work.

Insights as Flagship – Even at our scale, AX has already begun

While I've been discussing Shopify's scale, the concept of AX directly applies to companies like ours.

As I wrote in Part 1, we consider source code (GitHub repositories) as one of the "three sacred treasures of the AI era," and we store not only code but also our deliberations and records there. This is a small AX investment: placing the context of decisions where AI can read them.

This same thinking is already being applied in our own products. A clear example is security audits. We audit the code of our in-house applications with the latest AI, confirm zero critical vulnerabilities, and fix even medium-level issues before release. We are adding an "AI review" step to human reviews. Ensuring code and documentation are prepared for AI to read is a direct investment in AX.

In client work, the line drawn in Part 1 still holds true. Do not cross the contractual wall. Within that boundary, document design intentions and operational habits in the project folder. For now, this is work "to make it easier to instruct AI," but the same documentation also accelerates the onboarding of new members joining the project. The Shopify discovery that investing in AX is the same as investing in DX holds true even at a smaller scale.

Limitations and Operational Considerations

While I’ve written positively so far, establishing AX won't solve everything. In fact, as AI becomes faster and capable of writing more, the bottlenecks shift elsewhere.

The shift moves to human review. An agent may build a large pull request in 30 minutes, but a human will spend an hour reading it, including any subtle logical errors embedded within. Even if AI generation speeds up, the time required for review does not decrease. Shopify's engineering lead, Farhan Thawar, and others, point to the danger of "comprehension debt" accumulating in an organization by repeatedly merging without fully understanding the generated logic.

The numbers are also in. According to a survey by CodeRabbit, which we also use for daily reviews, AI-generated PRs have approximately 1.7 times more bugs and more than 3 times more readability issues than those written by humans. This indicates that the ability to write quickly and in large quantities is a separate issue from maintaining quality.

The line we’ve maintained when entrusting our clients’ production environments comes into play here. We don’t let AI write and then merge without human review. Generated code still undergoes human review and security scrutiny. We apply the same rigor to AI output as we do to third-party penetration tests and ISMS operations. Investment in AX and this discipline are two sides of the same coin.

Summary

Over three parts, we've followed Shopify's "World" and River. The wall of separate repositories (Part 1), the infrastructure that supports it by consolidating them (Part 2), and the story of how an environment intended for humans merges with one for AI (Part 3).

What ran through it all was a singular direction: investing in development infrastructure for the AI era was about systematically removing internal ambiguities and chaos to create an environment where humans and AI could work on the same foundation. It wasn't about flashy models, but about diligent groundwork.

Finally, a point I personally find amusing. Creating an AX-conscious environment strips away our expectation that "they should just know." And what's more, the AI remembers once you tell it — there's a sense of security that you won't have to repeat the same explanation multiple times. This, in turn, makes us want to explain things thoroughly from the start. It's quite interesting how AI, while we're trying to make it work comfortably, actually improves our own way of explaining things.

Not many companies can build a single "World" on their own. However, leaving decisions where AI can read them, letting AI validate, and having humans review what AI has written—this habit can be started today, regardless of scale. The question is how diligently we can cultivate this habit, both within and outside the contractual boundaries. We believe that the practical work of the next few years hinges on this.

References/Sources

• Under the River (Shopify Engineering, 2026)
• Netlify CTO Dana Lawson: Writing code is no longer the job (The New Stack)
• Agent Experience (Netlify)
• Building a Public AI Agent Workspace for Organizational Learning (ZenML LLMOps Database)
• How to Make AI Work Visible at Scale: Lessons from Shopify's River Agent (MindStudio)
• Shopify's Public AI Agents Expose What Private Tools Get Wrong (AskSurf.ai)
• Should You Use a Monorepo? Trade-offs, Tooling, and Review (CodeRabbit)

The information in this article is current as of July 2026. Among River's operational figures, the performance for the most recent 30 days (3,536 merged PRs, approximately 12.5% of total) is based on officially released Shopify data, while the merge rate "36%→77%" is a reference value based on reports from third-party media.