# The Claude Code Setup Behind Shopify's 23,000 Engineers (Exact Config You Can Copy)
**作者**: darkzodchi
**日期**: 2026-05-18T10:21:36.000Z
**来源**: [https://x.com/zodchiii/status/2056319284641460626](https://x.com/zodchiii/status/2056319284641460626)
---
Shopify's 23,000 engineers are racing to automate 96% of their coding by Q3 this year.
They run multiple Claude Code agents in parallel, each handling a different part of the codebase while engineers just review and merge.
Bessemer published their full AI-first playbook.
Here's their exact setup, and you can copy in 5 minutes 👇
## The infrastructure layer (why their setup works)
Shopify didn't standardize on one AI tool. They standardized the layer underneath it.
They built an internal LLM proxy that routes every AI request through one gateway. Claude Code, GitHub Copilot, Cursor, all of them flow through the same infrastructure.
```
Shopify's LLM Proxy Architecture:
Engineer → Claude Code / Copilot / Cursor
↓
LLM Proxy (centralized gateway)
↓
OpenAI / Anthropic / Google models
↓
Usage analytics + cost control + model routing
```
This gives them centralized cost control, usage analytics, and the ability to swap models without changing any engineer's workflow.
The lesson for smaller teams: don't pick one tool and go all-in. Build the infrastructure so you can experiment with multiple tools while keeping control of costs and data.
## Pattern 1: Parallel agents, not single chat
Shopify's senior engineers don't use Claude Code as a single-prompt-single-response tool.
They launch multiple agents simultaneously working on different parts of the codebase.
One agent refactors the auth module. Another writes tests. A third updates documentation. The engineer reviews outputs, discards what doesn't work, merges what does.
```
# Terminal 1: Agent working on auth refactor
claude -p "refactor src/auth/ to use the new session handler"
# Terminal 2: Agent writing tests
claude -p "write integration tests for the payment flow"
# Terminal 3: Agent updating docs
claude -p "update API documentation for all changed endpoints"
```
The engineer's job shifts from writing code to reviewing and merging agent outputs. Farhan Thawar (VP Engineering) calls this "orchestrating intelligent systems."
## Pattern 2: Extended critique loops
Not every task benefits from parallelism. For complex architectural decisions, Shopify engineers run a single agent through extended critique loops.
The agent generates an answer, evaluates it, revises it, and continues refining over long reasoning cycles.
Instead of accepting the first output, they force the agent to argue with itself.
```
Prompt pattern:
"Propose an architecture for [X].
Then critique your own proposal: what breaks at scale?
Then revise based on your critique.
Then critique the revision.
Give me the final version with confidence levels for each decision."
```
This produces dramatically better results than a single prompt because Claude catches its own mistakes before you have to.
## Pattern 3: The Shopify AI Toolkit (MCP)
In April 2026, Shopify released an open-source MCP server that connects Claude Code directly to Shopify's documentation, GraphQL API schemas, and live store operations.
One command to install:
```
claude mcp add --transport stdio shopify-dev-mcp -- npx -y @shopify/dev-mcp@latest
```
This gives Claude Code 7 tools:
- Search current Shopify docs (not stale training data)
- Validate GraphQL queries against live schemas
- Execute store operations through Shopify CLI
- Create products, manage metafields, modify themes
- Run bulk operations with natural language
Without this, Claude hallucinates API fields and invents component patterns. With it, Claude works with real platform data.
## Pattern 4: CLAUDE.md as team infrastructure
Shopify doesn't treat CLAUDE.md as personal config. It's team infrastructure committed to git and shared across all 23,000 engineers.
Their approach from the conference:
```
# CLAUDE.md (Shopify internal pattern)
## Stack
Ruby on Rails, React, GraphQL, MySQL
## Commands
- Dev: `dev up && dev server`
- Test: `dev test [path]`
- Lint: `dev style`
- Type check: `bin/srb tc`
## Architecture
- app/models/ → ActiveRecord models, business logic
- app/controllers/ → thin controllers, delegate to services
- app/services/ → service objects for complex operations
- app/graphql/ → GraphQL types, mutations, resolvers
## Rules
- NEVER bypass Sorbet type checking
- All new code must have type signatures
- Database queries only through established patterns
- IMPORTANT: run `dev test` after every change
```
Key insight from the conference: stuffing CLAUDE.md with every standard and convention makes performance worse, not better.
You pay for all of it on every turn.
## Pattern 5: Strategy-first validation
Here's where Shopify's approach diverges from most teams.
In 2024, engineers spent 70% of time on execution and 30% on strategy.
In 2026, Shopify flipped that ratio.
Because AI handles most of the coding, engineers now spend 70% of time on strategy: mapping user flows, validating market demand, choosing the right architecture. Only 30% on execution.
```
2024 workflow:
Strategy: 30% → Execution: 70%
2026 workflow (Shopify):
Strategy: 70% → Execution: 30%
The AI writes the code.
The engineer decides what code should exist.
```
Farhan's team estimates roughly 20% productivity improvement. Not from writing more code, but from testing 10 approaches instead of 2, faster prototyping, and higher-fidelity deliverables.
## Pattern 6: Safe autonomy with guardrails
Shopify doesn't let agents run wild. Their guardrail setup:
```
{
"permissions": {
"allow": [
"Read", "Glob", "Grep", "LS", "Edit",
"Bash(dev test *)",
"Bash(dev style *)",
"Bash(git status)",
"Bash(git diff *)",
"Bash(git add *)",
"Bash(git commit *)"
],
"deny": [
"Read(**/.env*)",
"Bash(git push *)",
"Bash(dev deploy *)",
"Bash(bin/rails db:drop *)",
"Bash(rm -rf *)"
],
"defaultMode": "acceptEdits"
}
}
```
Agents can read, write, test, and commit. They cannot push to remote, deploy to production, drop databases, or read secrets.
Human stays in the loop for anything irreversible.
## The setup you can copy today
You don't need 23,000 engineers to use these patterns. Here's the starter version:
## Step 1: Standardize your CLAUDE.md
```
Keep it under 60 lines. Stack, commands, architecture, rules.
Commit to git. Share with your team.
```
## Step 2: Set up parallel agents
```
# Run 2-3 agents in separate terminals for larger tasks
# Each agent works on a different part of the codebase
```
## Step 3: Install relevant MCP servers
```
# Shopify teams:
claude mcp add --transport stdio shopify-dev-mcp -- npx -y @shopify/dev-mcp@latest
# Everyone else: connect your stack's MCP servers
# GitHub, Slack, database, whatever you use daily
```
## Step 4: Add guardrails
Allow: read, write, test, lint, commit
Deny: push, deploy, delete, secrets
Default mode: acceptEdits
## Step 5: Flip the ratio
Stop spending 70% on execution.
Let the agent write the code.
Spend your time deciding what code should exist.
## The number that matters
Shopify's 20% productivity gain doesn't come from writing more code. It comes from exploring 10 approaches instead of 2, prototyping faster, and catching mistakes earlier.
The teams getting the most out of Claude Code aren't the ones with the best prompts. They're the ones who built the infrastructure to let agents work safely, in parallel, on real codebases.
90% autonomous coding by Q3 2026. That's not a vision statement. That's a deadline with 23,000 engineers working toward it.
Step 4: Add guardrails
Allow: read, write, test, lint, commit
Deny: push, deploy, delete, secrets
Default mode: acceptEditsI share daily notes on AI, finance, and vibe coding in my Telegram channel: https://t.me/zodchixquant
Ghb
## 相关链接
- [darkzodchi](https://x.com/zodchiii)
- [@zodchiii](https://x.com/zodchiii)
- [41K](https://x.com/zodchiii/status/2056319284641460626/analytics)
- [https://t.me/zodchixquant](https://t.me/zodchixquant)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [6:21 PM · May 18, 2026](https://x.com/zodchiii/status/2056319284641460626)
- [41.2K Views](https://x.com/zodchiii/status/2056319284641460626/analytics)
- [View quotes](https://x.com/zodchiii/status/2056319284641460626/quotes)
---
*导出时间: 2026/5/19 09:19:51*
---
## 中文翻译
# Shopify 23,000 名工程师背后的 Claude Code 设置（可直接复用的配置）
**作者**: darkzodchi
**日期**: 2026-05-18T10:21:36.000Z
**来源**: [https://x.com/zodchiii/status/2056319284641460626](https://x.com/zodchiii/status/2056319284641460626)
---
Shopify 的 23,000 名工程师正竞相争取在今年第三季度前自动化 96% 的代码编写工作。
他们并行运行多个 Claude Code 代理，每个代理处理代码库的不同部分，而工程师只需审查和合并代码。
Bessemer 发布了他们完整的 AI 优先实战手册。
下面是他们的具体设置，你可以在 5 分钟内直接复用 👇
## 基础设施层（他们的设置为何有效）
Shopify 并没有强制标准化某一种 AI 工具。他们标准化的是其下方的基础层。
他们构建了一个内部 LLM 代理，将每个 AI 请求通过一个网关进行路由。Claude Code、GitHub Copilot、Cursor，所有工具都通过同一套基础设施流动。
```
Shopify 的 LLM 代理架构：
工程师 → Claude Code / Copilot / Cursor
↓
LLM 代理（集中式网关）
↓
OpenAI / Anthropic / Google 模型
↓
使用分析 + 成本控制 + 模型路由
```
这为他们带来了集中的成本控制、使用分析能力，以及在不改变任何工程师工作流的情况下更换模型的能力。
这对于较小团队的启示是：不要只选择一个工具然后孤注一掷。构建好基础设施，这样你就可以在保持成本和数据可控的同时，尝试多种工具。
## 模式 1：并行代理，而非单一聊天
Shopify 的资深工程师不把 Claude Code 当作单次提示、单次响应的工具来使用。
他们同时启动多个代理，在代码库的不同部分协同工作。
一个代理重构认证模块。另一个编写测试。第三个更新文档。工程师审查输出，丢弃无效部分，合并有效部分。
```
# 终端 1：负责认证重构的代理
claude -p "refactor src/auth/ to use the new session handler"
# 终端 2：编写测试的代理
claude -p "write integration tests for the payment flow"
# 终端 3：更新文档的代理
claude -p "update API documentation for all changed endpoints"
```
工程师的工作从编写代码转变为审查和合并代理的输出。工程副总裁 Farhan Thawar 将其称为“编排智能系统”。
## 模式 2：扩展的批判循环
并非每项任务都受益于并行处理。对于复杂的架构决策，Shopify 工程师会让单个代理经历扩展的批判循环。
代理生成答案，评估答案，修订答案，并在漫长的推理周期中持续改进。
他们不是接受第一个输出，而是强制代理与自己辩论。
```
提示词模式：
“为 [X] 提出一个架构方案。
然后批判你自己的方案：在规模化时会出现什么问题？
然后根据你的批判进行修订。
然后批判修订后的方案。
给我最终版本，并对每个决策给出置信度。”
```
这比单次提示产生的结果要好得多，因为 Claude 会在你指出错误之前自己发现它们。
## 模式 3：Shopify AI 工具包 (MCP)
2026 年 4 月，Shopify 发布了一个开源 MCP 服务器，将 Claude Code 直接连接到 Shopify 的文档、GraphQL API 模式和实时店铺操作。
只需一条命令即可安装：
```
claude mcp add --transport stdio shopify-dev-mcp -- npx -y @shopify/dev-mcp@latest
```
这为 Claude Code 提供了 7 个工具：
- 搜索当前的 Shopify 文档（而不是陈旧的训练数据）
- 根据实时模式验证 GraphQL 查询
- 通过 Shopify CLI 执行店铺操作
- 创建产品、管理元字段、修改主题
- 使用自然语言运行批量操作
如果没有这个，Claude 会产生 API 字段的幻觉并编造组件模式。有了它，Claude 就能处理真实的平台数据。
## 模式 4：将 CLAUDE.md 作为团队基础设施
Shopify 不把 CLAUDE.md 视为个人配置。它是提交到 git 并在所有 23,000 名工程师之间共享的团队基础设施。
他们在大会上的分享方法：
```
# CLAUDE.md（Shopify 内部模式）
## 技术栈
Ruby on Rails, React, GraphQL, MySQL
## 命令
- 开发: `dev up && dev server`
- 测试: `dev test [path]`
- 代码检查: `dev style`
- 类型检查: `bin/srb tc`
## 架构
- app/models/ → ActiveRecord 模型，业务逻辑
- app/controllers/ → 精简控制器，委托给服务层
- app/services/ → 用于复杂操作的服务对象
- app/graphql/ → GraphQL 类型、变更、解析器
## 规则
- 绝不绕过 Sorbet 类型检查
- 所有新代码必须有类型签名
- 数据库查询只能通过既定模式
- 重要：每次更改后运行 `dev test`
```
大会上的一个关键见解：把每一条标准和惯例都塞进 CLAUDE.md 会降低性能，而不是提升。
因为在每一轮对话中你都要为此付出代价。
## 模式 5：策略优先的验证
这就是 Shopify 的方法与大多数团队分道扬镳的地方。
在 2024 年，工程师将 70% 的时间用于执行，30% 用于策略。
在 2026 年，Shopify 颠倒了这一比例。
因为 AI 处理了大部分编码工作，工程师现在将 70% 的时间用于策略：绘制用户流程图、验证市场需求、选择正确的架构。只有 30% 用于执行。
```
2024 年的工作流：
策略：30% → 执行：70%
2026 年的工作流：
策略：70% → 执行：30%
AI 编写代码。
工程师决定应该存在什么代码。
```
Farhan 的团队估计生产力大约提高了 20%。这并非来自编写更多代码，而是来自测试 10 种方法而不是 2 种、更快的原型制作以及更高保真度的交付成果。
## 模式 6：具有防护栏的安全自主权
Shopify 不会让代理无限制地运行。他们的防护栏设置：
```
{
"permissions": {
"allow": [
"Read", "Glob", "Grep", "LS", "Edit",
"Bash(dev test *)",
"Bash(dev style *)",
"Bash(git status)",
"Bash(git diff *)",
"Bash(git add *)",
"Bash(git commit *)"
],
"deny": [
"Read(**/.env*)",
"Bash(git push *)",
"Bash(dev deploy *)",
"Bash(bin/rails db:drop *)",
"Bash(rm -rf *)"
],
"defaultMode": "acceptEdits"
}
}
```
代理可以读取、写入、测试和提交。它们不能推送到远程、部署到生产环境、删除数据库或读取密钥。
对于任何不可逆的操作，人类仍然在掌控之中。
## 你今天就可以复用的设置
你不需要 23,000 名工程师也能使用这些模式。这是入门版本：
## 第 1 步：标准化你的 CLAUDE.md
```
控制在 60 行以内。包括技术栈、命令、架构、规则。
提交到 git。与你的团队共享。
```
## 第 2 步：设置并行代理
```
# 对于较大的任务，在单独的终端中运行 2-3 个代理
# 每个代理负责代码库的不同部分
```
## 第 3 步：安装相关的 MCP 服务器
```
# Shopify 团队：
claude mcp add --transport stdio shopify-dev-mcp -- npx -y @shopify/dev-mcp@latest
# 其他人：连接你技术栈的 MCP 服务器
# GitHub、Slack、数据库，任何你日常使用的工具
```
## 第 4 步：添加防护栏
允许：读取、写入、测试、代码检查、提交
拒绝：推送、部署、删除、密钥
默认模式：acceptEdits
## 第 5 步：翻转比例
停止在执行上花费 70% 的时间。
让代理编写代码。
把你的时间花在决定应该存在什么代码上。
## 关键数据
Shopify 20% 的生产力提升并非来自编写更多代码。它来自探索 10 种方法而不是 2 种、更快的原型制作以及更早地发现错误。
那些最充分利用 Claude Code 的团队，不是拥有最佳提示词的团队。而是那些构建了基础设施，让代理能够安全、并行地在真实代码库上工作的团队。
到 2026 年第三季度实现 90% 的自主编码。这不是愿景声明。这是一个由 23,000 名工程师为之努力奋斗的截止日期。
第 4 步：添加防护栏
允许：读取、写入、测试、代码检查、提交
拒绝：推送、部署、删除、密钥
默认模式：acceptEditsI 我在我的 Telegram 频道中分享关于 AI、金融和氛围编码的每日笔记：https://t.me/zodchixquant
Ghb
## 相关链接
- [darkzodchi](https://x.com/zodchiii)
- [@zodchiii](https://x.com/zodchiii)
- [41K](https://x.com/zodchiii/status/2056319284641460626/analytics)
- [https://t.me/zodchixquant](https://t.me/zodchixquant)
- [升级到 Premium](https://x.com/i/premium_sign_up)
- [6:21 PM · May 18, 2026](https://x.com/zodchiii/status/2056319284641460626)
- [41.2K Views](https://x.com/zodchiii/status/2056319284641460626/analytics)
- [查看引用](https://x.com/zodchiii/status/2056319284641460626/quotes)
---
*导出时间: 2026/5/19 09:19:51*