How

Claude

Code

works

in

large

codebases:

Best

practices

and

where

to

start

Claude Code is running in production across multi-million-line monorepos, decades-old legacy systems, distributed architectures spanning dozens of repositories, and at organizations with thousands of developers. These environments present challenges that smaller, simpler codebases don’t, whether that’s build commands that differ across every subdirectory or legacy code spread across folders with no shared root.Claude Code 正在生产环境中运行，覆盖数百万行代码的单体仓库（monorepos）、数十年的遗留系统、横跨数十个仓库的分布式架构，以及拥有数千名开发人员的组织。这些环境带来了更小、更简单的代码库所不具备的挑战，无论是每个子目录下的构建命令各不相同，还是分散在没有共享根目录的文件夹中的遗留代码。

This article covers the patterns we've observed that have led to successful adoption of Claude Code at scale. We use “large codebase” to refer to a wide range of deployments: monorepos with millions of lines, legacy systems built over decades, dozens of microservices across separate repositories, or any combination of the above. That also includes codebases running on languages that teams don't always associate with AI coding tools, such as C, C++, C#, Java, PHP. (Claude Code performs better than most teams expect it to in those cases, particularly as of recent model releases.) While every large codebase deployment is shaped by its specific version control, team structure, and accumulated conventions, the patterns here generalize across them and are a good starting point for teams considering adopting Claude Code.本文涵盖了我们观察到的成功大规模采用 Claude Code 的模式。我们用“大型代码库”指代广泛的部署场景：数百万行代码的单体仓库、数十年来构建的遗留系统、分布在独立仓库中的数十个微服务，或上述任意组合。这也包括使用团队通常不会与 AI 编程工具关联的语言编写的代码库，例如 C、C++、C#、Java、PHP。（在这些场景下，Claude Code 的表现超出了大多数团队的预期，尤其是在最近的模型版本发布后。）尽管每个大型代码库的部署都受其特定版本控制、团队结构和累积惯例的影响，但本文的模式具有普遍适用性，是考虑采用 Claude Code 的团队的良好起点。

How Claude Code navigates large codebasesClaude Code 如何导航大型代码库

Claude Code navigates a codebase the way a software engineer would: it traverses the file system, reads files, uses grep to find exactly what it needs, and follows references across the codebase. It operates locally on the developer’s machine and doesn’t require a codebase index to be built, maintained, or uploaded to a server. Claude Code 导航代码库的方式与软件工程师一样：它遍历文件系统、读取文件、使用 grep 精确查找所需内容，并跟踪整个代码库中的引用。它在开发者的本地机器上运行，无需构建、维护或上传代码库索引到服务器。

RAG-powered AI coding tools work by embedding the entire codebase and retrieving relevant chunks at query time. At large scale, those systems can fail because embedding pipelines can’t keep up with active engineering teams. By the time a developer queries the index, it reflects the codebase as it previously existed weeks, days, or even hours before. Retrieval then returns a function the team renamed two weeks ago, or references a module that was deleted in the last sprint, with no indication that either is out of date.基于 RAG 的 AI 编程工具通过嵌入整个代码库并在查询时检索相关片段来工作。在大规模场景下，这些系统可能会失效，因为嵌入流水线无法跟上活跃的工程团队。当开发者查询索引时，它反映的是数周、数天甚至数小时之前的代码库状态。检索结果可能返回团队两周前重命名的函数，或引用上一个冲刺（sprint）中已删除的模块，却没有任何迹象表明这些内容已过时。

Agentic search avoids those failure modes. There's no embedding pipeline or centralized index to maintain as thousands of engineers commit new code. Each developer's instance works from the live codebase. 智能体搜索（Agentic search）避免了这些失效模式。当数千名工程师提交新代码时，无需维护嵌入流水线或集中式索引。每位开发者的实例都直接基于实时代码库工作。

But the approach has a tradeoff: it works best when Claude has enough starting context to know where to look. This means the quality of Claude's navigation is shaped by how well the codebase is set up, layering context with CLAUDE.md files and skills. If you ask it to find all instances of a vague pattern across a billion-line codebase, you’ll hit context-window limits before the work begins. Teams that invest in codebase setup see better results.但这种方法存在权衡：当 Claude 拥有足够的起始上下文以知道从哪里查找时，它的效果最好。这意味着 Claude 的导航质量取决于代码库的设置程度，以及通过 CLAUDE.md 文件和技能（skills）分层上下文的情况。如果你要求它在十亿行代码的代码库中查找某种模糊模式的所有实例，工作还没开始就会遇到上下文窗口限制。在代码库设置上投入的团队会看到更好的结果。

The harness matters as much as the model工具链（harness）与模型同等重要

One of the most common misconceptions about Claude Code is that its capabilities are solely defined by the model used. Teams focus on a model’s benchmarks and how it performs on test tasks. In practice, the ecosystem built around the model—the harness—determines how Claude Code performs more than the model alone.关于 Claude Code 最常见的误解之一是，它的能力完全由所使用的模型决定。团队关注模型的基准测试及其在测试任务中的表现。实际上，围绕模型构建的生态系统——即工具链（harness）——对 Claude Code 表现的决定作用大于模型本身。

The harness is built from five extension points—CLAUDE.md files, hooks, skills, plugins, and MCP servers—each serving a different function. The order in which teams build them matters, as each layer builds on what came before. Two additional capabilities, LSP integrations and subagents, round out the setup. Below, we explain what each of these components and capabilities do: 工具链由五个扩展点构建而成——CLAUDE.md 文件、hooks、skills、plugins 和 MCP 服务器——每个承担不同的功能。团队构建它们的顺序很重要，因为每一层都建立在前一层之上。另外两项能力，LSP 集成和子代理（subagents），完善了整体设置。下面，我们解释这些组件和能力各自的作用：

CLAUDE.md files come first. These are context files that Claude reads automatically at the start of every session: root file for the big picture, subdirectory files for local conventions. They give Claude the codebase knowledge it needs to do anything well. Because they load in every session regardless of the task, keeping them focused on what applies broadly will prevent them from becoming a drag on performance.CLAUDE.md 文件排在首位。这些是 Claude 在每次会话开始时自动读取的上下文文件：根文件（root file）提供全局概览，子目录文件提供本地约定。它们为 Claude 提供了做好任何工作所需的代码库知识。由于无论任务如何，它们都会在每次会话中加载，因此应让内容聚焦于广泛适用的信息，以免拖累性能。

Hooks make the setup self-improving. Most teams think of hooks as scripts that prevent Claude from doing something wrong, but their more valuable use is continuous improvement. A stop hook can reflect on what happened during a session and propose CLAUDE.md updates while the context is fresh. A start hook can load team-specific context dynamically so every developer gets the right setup for their module without manual configuration. For automated checks like linting and formatting, hooks enforce the rules deterministically and produce more consistent results than relying on Claude to remember an instruction.Hooks 使设置能够自我改进。大多数团队将 hooks 视为防止 Claude 做错事的脚本，但它们更有价值的用途是持续改进。停止 hook（stop hook）可以在会话结束后回顾发生的内容，并在上下文仍然新鲜时提出 CLAUDE.md 的更新建议。启动 hook（start hook）可以动态加载团队特定的上下文，使每位开发者无需手动配置即可获得适合其模块的设置。对于 linting 和格式化等自动化检查，hooks 以确定性方式强制执行规则，产生的结果比依赖 Claude 记住指令更为一致。

Skills keep the right expertise available on-demand without bloating every session. In a large codebase with dozens of task types, not all expertise needs to be present in every session. Skills solve this through progressive disclosure, offloading specialized workflows and domain knowledge that would otherwise compete for context space and loading them only when the task calls for it. For example, a security review skill loads when Claude is assessing code for vulnerabilities, while a document processing skill loads when a code change is made and documentation needs to be updated.Skills 让正确的专业知识按需可用，而不会膨胀每次会话。在拥有数十种任务类型的大型代码库中，并非所有专业知识都需要出现在每次会话中。Skills 通过渐进式披露解决了这一问题，将原本会争夺上下文空间的专业工作流和领域知识卸载出去，仅在任务需要时才加载。例如，当 Claude 评估代码漏洞时加载安全审查 skill，当代码发生变更且需要更新文档时加载文档处理 skill。

Skills can also be scoped to specific paths so they only activate in the relevant part of the codebase. A team that owns a payments service can bind their deployment skill to that directory, so it never auto-loads when someone is working elsewhere in the monorepo.Skills 还可以限定到特定路径，使其仅在代码库的相关部分激活。拥有支付服务的团队可以将其部署 skill 绑定到该目录，这样当有人在单体仓库的其他地方工作时，它永远不会自动加载。

Plugins distribute what works. One challenge with large codebases is that good setups can stay tribal. A plugin bundles skills, hooks, and MCP configurations into a single installable package, so when a new engineer installs that plugin on day one, they will immediately have the same context and capabilities as those who have been using Claude already. Plugin updates can be distributed across the organization through managed marketplaces. Plugins 分发已经验证有效的方案。大型代码库的一个挑战是，好的设置可能局限于小圈子。Plugin 将 skills、hooks 和 MCP 配置打包到一个可安装的包中，因此当新工程师在第一天安装该 plugin 时，他们将立即拥有与已使用 Claude 的人相同的上下文和能力。Plugin 更新可以通过托管市场在整个组织中分发。

For example, a large retail organization we work with built a skill connecting Claude to their internal analytics platform so that business analysts could pull performance data without leaving their workflow. They distributed it as a plugin before the broad rollout to the business.例如，我们合作的一家大型零售组织构建了一个 skill，将 Claude 连接到他们的内部分析平台，使业务分析师无需离开工作流即可拉取性能数据。他们在向业务部门广泛推广之前，将其作为 plugin 进行分发。

Language server protocol (LSP) integrations give Claude the same navigation a developer has in their IDE. Most large-codebase IDEs already have an LSP running, powering "go to definition" and "find all references." Surfacing this to Claude gives it symbol-level precision: it can follow a function call to its definition, trace references across files, and distinguish between identically named functions in different languages. Without it, Claude pattern-matches on text and can land on the wrong symbol. One enterprise software company we worked with deployed LSP integrations org-wide before their Claude Code rollout, specifically to make C and C++ navigation reliable at scale. For multi-language codebases, this is one of the highest-value investments.语言服务器协议（LSP）集成让 Claude 拥有与开发者在 IDE 中相同的导航能力。大多数大型代码库的 IDE 已经运行着 LSP，支持“跳转到定义”和“查找所有引用”。将其开放给 Claude 使用，可以提供符号级别的精度：它可以跟踪函数调用到其定义，跨文件追踪引用，并区分不同语言中同名函数。没有 LSP，Claude 只能基于文本进行模式匹配，可能会定位到错误的符号。我们合作过的一家企业软件公司在其 Claude Code 推广之前，就在整个组织内部署了 LSP 集成，专门为了在大规模场景下实现可靠的 C 和 C++ 导航。对于多语言代码库，这是最具价值的投资之一。

MCP servers extend everything. MCP servers are how Claude connects to internal tools, data sources, and APIs that it can't otherwise reach. The most sophisticated teams built MCP servers exposing structured search as a tool Claude can call directly. Others connect Claude to internal documentation, ticketing systems, or analytics platforms.MCP 服务器扩展了一切。MCP 服务器是 Claude 连接到其原本无法访问的内部工具、数据源和 API 的方式。最成熟的团队构建了 MCP 服务器，将结构化搜索作为 Claude 可以直接调用的工具。其他团队则将 Claude 连接到内部文档、工单系统或分析平台。

Subagents split exploration from editing. A subagent is an isolated Claude instance with its own context window that takes a task, does the work, and returns only the final result to the parent. Once the harness is in place, some teams spin up a read-only subagent to map a subsystem and write findings to a file, then have the main agent edit with the full picture. Subagents 将探索与编辑分离。Subagent 是一个独立的 Claude 实例，拥有自己的上下文窗口，它接收任务、执行工作，并仅向主代理（parent）返回最终结果。一旦工具链就位，一些团队会启动一个只读的 subagent 来映射子系统并将发现写入文件，然后让主代理基于完整的图景进行编辑。

The table below summarizes what each component does, when it loads, and the most common mistakes we see with each:下表总结了每个组件的作用、加载时机，以及我们在每个组件上观察到的最常见错误：

Three configuration patterns from successful deployments成功部署中的三种配置模式

How you configure Claude Code for a large codebase depends heavily on how that codebase is structured. Still, three patterns appeared consistently across the deployments we observed.如何为大型代码库配置 Claude Code 很大程度上取决于代码库的结构。尽管如此，在我们观察到的部署中，有三种模式始终出现。

Making the codebase navigable at scale让代码库具备大规模可导航性

Claude’s ability to help in a large codebase is bounded by its ability to find the right context. Too much context loaded into every session degrades performance, while too little context leaves Claude to navigate blind. The most effective deployments invest upfront in making the codebase legible to Claude. A few patterns appear consistently:Claude 在大型代码库中提供帮助的能力受限于其找到正确上下文的能力。每次会话加载过多上下文会降低性能，而上下文太少则会让 Claude 盲目导航。最有效的部署会在前期投入，使代码库对 Claude 而言清晰可读。以下几种模式始终出现：

• Keeping CLAUDE.md files lean and layered. Claude loads them additively as it moves through the codebase: root file for the big picture, subdirectory files for local conventions. The root file should be pointers and critical gotchas only; everything else drifts into noise.保持 CLAUDE.md 文件精简且分层。Claude 在遍历代码库时会叠加加载它们：根文件提供全局概览，子目录文件提供本地约定。根文件应只包含关键指针和注意事项；其他所有内容都会沦为噪音。
• Initializing in subdirectories, not at the repo root. Claude works best when it's scoped to the part of the codebase that's actually relevant to the task. In monorepos, this can feel counterintuitive because tooling often assumes root access, but Claude automatically walks up the directory tree and loads every CLAUDE.md file it finds along the way, so root-level context is never lost.在子目录而非仓库根目录初始化。当 Claude 的范围限定到与任务实际相关的代码库部分时，它的工作效果最好。在单体仓库中，这可能违反直觉，因为工具通常假设在根目录运行，但 Claude 会自动向上遍历目录树并沿途加载找到的每个 CLAUDE.md 文件，因此根级别的上下文永远不会丢失。
• Scoping test and lint commands per subdirectory. Running the full suite when Claude changed one service causes timeouts and wastes context on irrelevant output. CLAUDE.md files at the subdirectory level should specify the commands that apply to that part of the codebase. This works well for service-oriented codebases where each directory has its own test and build commands. In compiled-language monorepos with deep cross-directory dependencies, per-subdirectory scoping is harder to achieve and may require project-specific build configurations.按子目录限定测试和 lint 命令的范围。当 Claude 只更改了一个服务时运行完整套件会导致超时，并在无关的输出上浪费上下文。子目录级别的 CLAUDE.md 文件应指定适用于该部分代码库的命令。这对于每个目录都有自己的测试和构建命令的面向服务的代码库非常有效。在具有深层跨目录依赖的编译语言单体仓库中，按子目录限定范围更难实现，可能需要特定于项目的构建配置。
• Using .ignore files to exclude generated files, build artifacts, and third-party code. Committing permissions.deny rules in .claude/settings.json means the exclusions are version-controlled, so every developer on the team gets the same noise reduction without configuring it themselves. In some codebases, generated files are themselves the subject of development work. Developers who work on code generators can override project-level exclusions in their local settings without affecting the rest of the team.使用 .ignore 文件排除生成文件、构建产物和第三方代码。在 .claude/settings.json 中提交 permissions.deny 规则意味着排除项是版本控制的，因此团队中的每位开发者都无需自行配置即可获得相同的降噪效果。在某些代码库中，生成文件本身就是开发工作的对象。从事代码生成器开发的开发者可以在其本地设置中覆盖项目级别的排除项，而不会影响团队其他成员。
• Building codebase maps when the directory structure doesn’t do the work. For organizations where code isn’t consolidated in a conventional directory structure, a lightweight markdown file at the repo root listing each top-level folder with a one-line description of what lives there gives Claude a table of contents it can scan before opening files. For codebases with hundreds of top-level folders, this works best as a layered approach: the root file describes only the highest-level structure, and subdirectory CLAUDE.md files provide the next level of detail, loading on demand as Claude moves through the tree. For simpler cases, @-mentioning the specific files or directories Claude should reference can do the same job.当目录结构本身无法发挥作用时，构建代码库地图。对于代码未按常规目录结构整合的组织，在仓库根目录放置一个轻量级 Markdown 文件，列出每个顶级文件夹并附上一行描述，可以为 Claude 提供一个在打开文件前即可扫描的目录。对于拥有数百个顶级文件夹的代码库，最佳方式是分层处理：根文件仅描述最高层结构，子目录的 CLAUDE.md 文件提供下一级细节，在 Claude 遍历树时按需加载。对于更简单的情况，@提及其应参考的特定文件或目录也能起到相同作用。
• Running LSP servers so Claude searches by symbol, not by string. Grep for a common function name in a large codebase returns thousands of matches and Claude burns context opening files to figure out which matters. LSP returns only the references that point to the same symbol, so the filtering happens before Claude reads anything. Setting this up requires installing a code intelligence plugin for your language and the corresponding language server binary; the Claude Code documentation covers the available plugins and troubleshooting.运行 LSP 服务器，使 Claude 按符号而非字符串搜索。在大型代码库中对常见函数名执行 grep 会返回数千个匹配结果，Claude 会消耗上下文打开文件以确定哪些是重要的。LSP 仅返回指向同一符号的引用，因此过滤发生在 Claude 读取任何内容之前。设置此项需要为你的语言安装代码智能插件和相应的语言服务器二进制文件；Claude Code 文档涵盖了可用插件和故障排除。

One caveat: there are edge cases where even the hierarchical CLAUDE.md approach breaks down, for example codebases with hundreds of thousands of folders and millions of files, or legacy systems on non-git version control. We will address their challenges in future installments of this series.有一点需要注意：即使在某些极端情况下，分层 CLAUDE.md 方法也会失效，例如拥有数十万个文件夹和数百万个文件的代码库，或基于非 Git 版本控制的遗留系统。我们将在本系列的未来文章中探讨这些挑战。

Actively maintaining CLAUDE.md files as model intelligence evolves 随着模型智能的演进，主动维护 CLAUDE.md 文件

As models evolve, instructions written for your current model can work against a future one. CLAUDE.md files that guided Claude through patterns it used to struggle with may either become unnecessary or actively constraining when the next model ships. For example, a CLAUDE.md rule that tells Claude to break every refactor into single-file changes may have helped an earlier model stay on track but would prevent a newer one from making coordinated cross-file edits it handles well. 随着模型的演进，为当前模型编写的指令可能会与未来模型相悖。那些引导 Claude 克服过去困难的 CLAUDE.md 文件，在下一代模型发布时可能变得不再必要，甚至成为束缚。例如，一条告诉 Claude 将每次重构拆分为单文件变更的 CLAUDE.md 规则，可能帮助过早期模型保持正轨，却会阻止新模型进行其能很好处理的跨文件协调编辑。

Skills and hooks built to compensate for specific model limitations, whether in the model’s reasoning or in Claude Code’s own tooling, become overhead once those limitations no longer exist. A hook that intercepted file writes to enforce p4 edit in a Perforce codebase, for example, became redundant once Claude Code added native Perforce mode.为弥补特定模型局限性而构建的 skills 和 hooks——无论是在模型的推理能力还是 Claude Code 自身工具方面——一旦这些局限性不复存在，就会变成开销。例如，一个拦截文件写入以在 Perforce 代码库中强制执行 p4 edit 的 hook，在 Claude Code 添加原生 Perforce 模式后就变得多余了。

Teams should expect to do a meaningful configuration review every three to six months, but it's also worth doing one whenever performance feels like it's plateaued after major model releases. 团队应预期每三到六个月进行一次有意义的配置审查，但如果在主要模型发布之后感觉性能陷入停滞，也值得一查。

Assigning ownership for Claude Code management and adoption指定 Claude Code 管理与推广的负责人

Technical configuration alone doesn't drive adoption. The organizations that got it right invested in the organizational layer, too.仅靠技术配置无法推动采用。那些做得好的组织也在组织层面进行了投入。

The rollouts that spread fastest had a dedicated infrastructure investment before broad access. A small team, sometimes even just one person, wired up the tooling so Claude already fit developer workflows when they first touched it. At one company, a couple of engineers built a suite of plugins and MCPs that were available on day one. At another, an entire team focused on managing AI coding tools had the infrastructure in place before the rollout began. In both cases, developers' first experience was productive rather than frustrating, and adoption spread from there.推广最快的部署在开放给所有人之前都投入专门的基础设施。一个小团队，有时甚至只有一个人，提前做好工具配置，使开发者在第一次接触 Claude 时就已经融入其工作流。在一家公司，几位工程师构建了一套 plugins 和 MCPs，在第一天就可用。在另一家公司，一个专门负责管理 AI 编程工具的团队在推广开始前就已将基础设施准备就绪。在这两种情况下，开发者的第一次体验都是富有成效的而非令人沮丧的，采用由此蔓延开来。

The teams doing this work today tend to sit under developer experience or developer productivity, which is typically the function responsible for onboarding new engineers and building developer tooling. An emerging role in several organizations is an agent manager: a hybrid PM/engineer function dedicated to managing the Claude Code ecosystem. For organizations without a dedicated team, the minimum viable version is a DRI: one person with ownership over the Claude Code configuration, the authority to make calls on settings, permissions policy, the plugin marketplace, and CLAUDE.md conventions, and the responsibility to keep them current.如今负责这项工作的团队通常隶属于开发者体验或开发者生产力部门，这些部门通常负责新员工入职和开发者工具构建。一些组织中正在出现一个新兴角色：代理管理者（agent manager）——一种 PM/工程师混合角色，专门负责管理 Claude Code 生态系统。对于没有专门团队的组织来说，最低可行方案是设立一名 DRI（直接负责人）：一个人拥有 Claude Code 配置的所有权，有权决定设置、权限策略、plugin 市场和 CLAUDE.md 规范，并负责保持其时效性。

Bottoms-up adoption generates enthusiasm but can fragment without someone to centralize what works. You need to have an individual or a team assemble and evangelize the right Claude Code conventions (such as a standardized CLAUDE.md hierarchy or a curated set of skills and plugins). Without that work, knowledge will stay tribal and adoption will plateau. 自下而上的采用可以激发热情，但如果没有人集中整合有效的做法，可能会变得分散。你需要有一个个人或团队来整理并推广正确的 Claude Code 惯例（例如标准化的 CLAUDE.md 层级或精心策划的 skills 和 plugins 集合）。没有这些工作，知识将局限于小圈子，采用也会陷入停滞。

In large organizations, especially those in regulated industries, governance questions come up early, such as: who controls which skills and plugins are available, how do you prevent thousands of engineers from independently rebuilding the same thing, how do you make sure AI-generated code goes through the same review process as human-generated code? To address these early on, we suggest starting with a defined set of approved skills, required code review processes, and limited initial access, and expand as confidence builds. 在大型组织中，尤其是受监管行业的企业，治理问题会早早出现，例如：谁控制哪些 skills 和 plugins 可用、如何防止数千名工程师各自独立重复构建相同的东西、如何确保 AI 生成的代码与人类编写的代码经过相同的审查流程？为了尽早解决这些问题，我们建议从一组明确批准的 skills、必需的代码审查流程和有限的初始访问权限开始，并随着信心增强逐步扩大。

We’ve observed the smoothest deployments at organizations that establish cross-functional working groups early by bringing together engineering, information security, and governance representatives to define requirements together and build a rollout roadmap.我们观察到，那些尽早建立跨职能工作组的组织部署最为顺利，他们将工程、信息安全和治理部门的代表聚集在一起，共同定义需求并制定推广路线图。

Applying these patterns to your organization将这些模式应用于你的组织

Claude Code is designed around conventional software engineering environments where engineers are the primary codebase contributors, the repo uses Git, and code follows standard directory structures. Most large codebases fit this mold, but non-traditional setups such as game engines with large binary assets, environments with unconventional version control, or non-engineers contributing to the codebase require additional configuration work. Our guidance assumes a conventional setup and the patterns we’ve described have worked across many of our customers.  Any remaining complexity requires judgment specific to your codebase, tooling, and organization. That's where Anthropic's Applied AI team works directly with engineering teams to translate these patterns into your organization’s specific requirements.Claude Code 是围绕传统的软件工程环境设计的，工程师是代码库的主要贡献者，仓库使用 Git，代码遵循标准目录结构。大多数大型代码库都符合这种模式，但非传统设置——例如拥有大型二进制资产的游戏引擎、使用非常规版本控制的环境，或非工程师向代码库贡献内容——需要额外的配置工作。我们的指导假设是传统设置，我们描述的模式已在许多客户中得到验证。任何剩余的复杂性都需要针对你的代码库、工具和组织做出具体判断。这正是 Anthropic 的应用 AI 团队直接与工程团队合作，将这些模式转化为组织特定需求的地方。

Get started with Claude Code for Enterprise.开始使用面向企业的 Claude Code。

‍

Acknowledgements: Special thanks to Alon Krifcher, Charmaine Lee, Chris Concannon, Harsh Patel, Henrique Savelli, Jason Schwartz, Jonah Dueck and Kirby Kohlmorgen from Anthropic’s Applied AI team for sharing their experience deploying Claude Code at scale, and to Amit Navindgi at Zoox for providing feedback on this article.致谢：特别感谢 Anthropic 应用 AI 团队的 Alon Krifcher、Charmaine Lee、Chris Concannon、Harsh Patel、Henrique Savelli、Jason Schwartz、Jonah Dueck 和 Kirby Kohlmorgen 分享他们大规模部署 Claude Code 的经验，并感谢 Zoox 的 Amit Navindgi 对本文提供的反馈。

‍