Claude Code 的能力远超你的想象

当我开始使用 Claude Code 时，我把它当成聊天工具来用。

我会提出需求，它会给出回应，然后就此结束。

这确实有效，但随着时间的推移，我开始意识到我并没有完全发挥它的潜力。

我重复着同样的提示，执行着同样的命令。我不清楚如何才能充分利用它。

于是，我停下来问了自己一个问题：

Claude Code 内部到底是如何运作的？

我开始阅读文档，进行实验和测试。

我发现的答案是：

它并非魔法。它是由具体的、各司其职的组件构建而成的。当你理解了它们，一切就都变得清晰了。

→ 如果你总是重复同样的指令，就把它们变成一个技能。

→ 如果在处理长任务时思路断了，就委托给 SubAgent。

→ 如果有重复的手动步骤，就用 Hooks 来自动化它们。

理解基本原理，才能让你知道用什么、何时用以及为何用。

如今，我拥有超过 100 个技能，实现了过去需要耗时数小时流程的自动化，还有用于代码审查和研究我感兴趣主题的 Agent。

我写这篇文章是为了与你分享我学到的一切。

让我们开始吧。

Agent 循环：Claude Code 的核心

Claude Code 是一个 Agent。

一个你赋予它目标，它就会一直工作直到达成的系统。

这与聊天不同。在聊天中，你问 "如何为我的应用添加身份验证？"，它会解释步骤。

但你需要自己去项目里修改代码，并测试是否有效。

工作由你来完成。

使用 Claude Code，你告诉它 "为我的应用添加身份验证"，它就会负责处理。

它会读取代码、选择库、编写更改，并在完成后通知你。

它有一个目标：添加身份验证。

然后它会一直工作直到达成目标。

但是，它如何知道每一步之后该做什么？它如何知道某件事是否有效？它需要一个东西来协调这些决策。

这就是循环。

一个不断重复的周期。

Claude Code 执行一个动作，观察结果，决定下一步做什么，然后重新开始。它在目标达成之前不会停止。

如果某事失败，它会回溯、修正并继续。

循环分为 3 个阶段：

收集上下文 → 理解它需要做什么。读取文件、分析代码、探索项目结构。

执行动作 → 实施更改。编辑文件、运行命令、安装依赖。

验证结果 → 检查所做的工作是否有效。运行测试、审查错误、如果出现问题则进行修正。

这个循环会根据你的要求进行调整。

一个简单的问题可能只需要收集上下文。修复一个 bug 可能会经历所有三个阶段数次。

Claude Code 根据前一步学到的知识决定每一步需要什么。同时，你也是这个循环的一部分。

你可以随时中断，以重新引导它、添加上下文，或要求它尝试其他方法。

这是 Claude Code 的核心。

所有后续功能都旨在让这个循环更加强大。

工具：Claude Code 如何在现实中行动

LLM 的设计本质上是只处理文本。

它接收文本并生成文本。它无法访问你的文件系统，不能执行命令，也不知道你项目中有什么。

它是孤立的。

那么，Claude Code 如何打开或修改文件呢？

它使用工具。

工具是 Claude Code 可以调用的函数，用于与现实世界交互。

把它想象成手机应用。手机本身什么也做不了：是应用赋予了它特定功能：拍照、发送消息、导航。

工具对 Claude Code 来说也是一样。

每次使用工具时，它都会向系统发送一个包含其需求信息的请求。系统执行该请求并返回结果。

Claude Code 利用这个结果来决定下一步做什么。

1你的请求
2    ↓
3Claude Code 决定使用哪个工具
4    ↓
5┌─────────────────────────────────┐
6│  读取 · 编辑 · 写入 · Bash      │
7│  Grep · Glob · WebFetch · WebSearch │
8└─────────────────────────────────┘
9    ↓
10系统执行工具
11    ↓
12结果返回给 Claude Code
13    ↓
14完成？ → 否 → 使用另一个工具
15             是 → 响应

Claude Code 自带用于最常见操作的原生工具：

读取 / 编辑 / 写入 → 读取、修改和创建文件。最常用。每次 Claude Code "理解你的代码"或"进行更改"时，都在使用这三个工具。

Bash → 完全访问终端。如果你能通过命令行完成，Claude Code 也能：安装依赖、运行测试、提交代码。

Grep 和 Glob → 在项目中搜索。Glob 按名称或模式查找文件。Grep 在文件中搜索特定内容。

WebFetch 和 WebSearch → 互联网访问。查阅文档、读取 API、调查它从未见过的错误。

回到登录按钮 bug 的例子。

当 Claude Code 处理这个问题时，它会同时使用多个工具：

→ 它使用 Glob 查找组件文件

→ 它使用 Read 读取代码并理解发生了什么

→ 它使用 Edit 修复错误

→ 它使用 Bash 运行测试并验证是否成功

所有这些都无需你干预。这就是聊天和 Agent 的区别。

上下文与记忆：Claude Code 记得什么

Claude Code 工作、执行动作、获取结果，并决定下一步做什么。

但是，它如何知道自己在进行过程中做了什么？

这一切都归功于上下文。

上下文是 Claude Code 在那一刻掌握的信息。每次执行动作，结果都会累积其中。

不仅是你的初始提示，还包括它发现的一切：打开的文件、在代码中发现的线索、它执行的动作及其结果。

这就是为什么它能串联步骤、自我修正，并独自完成任务。

这个上下文有两个问题。

1. 容量有限。 如果会话很长，上下文会被填满，Claude Code 会开始忘记之前发生的事情。稍后你会看到 SubAgents 如何解决这个问题。

2. 每次打开新对话时都会清空。 Claude Code 不知道你在哪个项目中、你的团队如何工作，或者他们已做出了哪些决策。如果你不告诉它，它会推断或询问你。

记忆解决了第二个问题。

它是一个 Markdown 文件系统，你可以在里面保存 Claude Code 需要知道的一切：你的技术栈、团队约定、项目结构。

Claude Code 会在每次会话开始时读取它们，并在你写下第一行内容之前，将这些信息注入到上下文中。

没有记忆时：你告诉它"添加一个创建用户的端点"，Claude Code 会问你："你用什么框架？有配置好的数据库吗？路由结构是怎样的？"

有记忆时：你告诉它同样的事情，它已经知道你在用 Express 和 Prisma，路由放在 /src/routes 里，错误由集中式中间件处理。它不需要问就开始工作。

Claude Code 有 2 个记忆系统：

→ CLAUDE.md — 你编写的 Markdown 文件，包含 Claude Code 需要知道的一切。它们可以存在于不同层级：

→ ~/.claude/CLAUDE.md — 适用于你所有的项目。存放你的个人偏好：你希望它如何编写代码，你始终使用的约定。指令必须具体： "使用 2 个空格缩进"比"格式化好代码"更清晰。

→ /你的项目/CLAUDE.md — 特定于仓库。存放架构、团队约定和重要命令。当你启动新项目时，运行 /init，Claude Code 会自动生成它。保持在 200 行以内：如果它变得太大，Claude Code 会开始忽略指令。而且如果你将它提交到仓库，整个团队就能共享相同的上下文。

→ .claude/rules/ — 根据文件类型激活的模块化规则。当项目变大，你不想把一切都放在单个文件中时，这非常有用。

自动记忆 — Claude Code 自己构建的记忆。随着你工作，它会自行记录笔记：它检测到的模式、你做出的更正、你们共同做出的决定。它保存在

~/.claude/projects/<project>/memory/ 中，并在每次会话开始时加载。

经常审查它：Claude Code 可能在你没意识到的情况下保存了不良实践。

提示：你可以运行 /memory 来查看和编辑 Claude Code 记住的所有内容。

Hooks 和技能：掌控一切

1. Hooks

Claude Code 能自主工作。

它执行动作，做出决策，持续推进。

但这种自主性有一个不常被提及的侧面：Claude Code 会在每一步都做它认为正确的事情。

如果出了问题，或者它做了你不希望它做的事，那已经发生了。

你如何控制它？用 Hooks。

Hook 是一个命令，在循环的特定点自动运行。在 Claude Code 使用工具之前，在它使用工具之后，在会话结束时。

你可以定义每个时刻发生什么。

关键在于 Hooks 是确定性的。

它们不依赖 Claude Code "记住"去做某事。它们总是被执行，无一例外。

四个主要的 Hook 是：

PreToolUse — 在 Claude Code 使用工具前运行。它是唯一能阻止动作的 Hook。示例：阻止任何试图修改 .env 文件的命令。

PostToolUse — 在 Claude Code 使用工具后运行。示例：每次 Claude Code 编辑文件时自动运行 Prettier。

Notification — 当 Claude Code 需要你关注时运行。示例：当 Claude Code 完成一项耗时任务时，在你的 Mac 上接收通知。

Stop — 当 Claude Code 完成响应时运行。示例：Agent 完成后自动推送到暂存环境。

它们在 .claude/settings.json 中配置：

1{
2  "hooks": {
3    "PostToolUse": [
4      {
5        "matcher": "Edit|Write",
6        "hooks": [
7          {
8            "type": "command",
9            "command": "npx prettier --write $file_path"
10          }
11        ]
12      }
13    ]
14  }
15}

这个 Hook 会在 Claude Code 每次编辑或创建文件时自动运行 Prettier。

无需你要求。无需 Claude Code 记住。

没有 Hook：Claude Code 编辑文件，代码保持未格式化状态，你在下一次提交时才发现。

有 Hook：Claude Code 编辑文件，PostToolUse 自动触发，Prettier 格式化文件，代码始终保持整洁。

Hooks 让你能在 Agent 的循环中添加有保证的行为。不是建议，不是模型可能忽略的指令。是始终会执行的规则。

2. 技能

还有另一个问题：一致性。

你两次要求执行相同的任务，却得到不同的结果。每次打开新对话，Claude Code 都会从头开始，不知道你上次是如何做的。

你如何解决它？用技能。

一个技能是一个 Markdown 文件，你在其中向 Claude Code 解释完成某个任务的确切流程：审查什么、按什么顺序、使用什么格式、忽略什么。

每次该任务出现时，Claude Code 都会遵循这些指令。

没有技能：你要求它记录 API 文档，它生成了内容，但每次格式都不同。有时有示例，有时没有。

有技能：你要求它记录 API 文档，它遵循你定义的确切流程。始终是相同的步骤、相同的格式、相同的标准。每次都一样。

要创建一个技能，你需要定义一个包含以下结构的文件夹：

1my-skill/
2├── SKILL.md          # 主要指令（必需）
3├── template.md       # Claude 要填写的模板
4├── examples/
5│   └── sample.md    # 预期输出示例
6└── scripts/
7    └── validate.sh  # Claude 可执行的脚本

唯一必需的文件是 SKILL.md。其余都是可选的，你根据任务需要添加。

SKILL.md 有 2 个部分：

前端数据 — 一个包含名称和描述的 YAML 块。名称是手动调用它的命令。描述是 Claude Code 用来决定何时自动激活它的依据。

主体 — Markdown 格式的指令。工作流程、标准、输出格式。

1---
2name: api-docs
3description: 记录 API 端点。当用户要求记录 API 或提及 "swagger" 或 "endpoints" 时使用
4---
5
6## 流程
71. 识别所有端点
82. 对于每个端点：方法、路径、参数、预期响应
93. 包含一个请求和响应示例
104. 以摘要表格结束

创建后，你可以通过两种方式调用它。

直接在聊天中输入 /api-docs，或者用自然语言向 Claude Code 提问。

如果描述与你要求的内容匹配，它会自动激活。

你可以为任何你重复执行且有清晰流程的任务创建技能：API 文档、更新日志、会议摘要、代码迁移。

SubAgents：当问题变大时进行委派

我们已经看到上下文容量有限。

会话时间越长，上下文就越满。而当它满了之后，Claude Code 就会开始丢失之前发生的事情的信息。

想象你让它审查整个项目的安全问题。它读取数十个文件，分析代码，生成一份详细的报告。

所有这些都会迅速填满上下文。

而且在这个过程中，你的主对话会被阻塞。

你如何解决它？ 用 SubAgents。

SubAgent 是 Claude Code 的单独实例，它有自己的上下文。

主 Agent 将任务委派给它，SubAgent 独立执行，完成后，它会发送一个包含结果的摘要。

主 Agent 的上下文不会被整个过程填满，只会保留结论。

1主 Agent
2    ↓
3"审查项目的安全问题"
4    ↓
5┌─────────────────────────────┐
6│    SubAgent: security-reviewer    │
7│                             │
8│  读取项目文件               │
9│  分析代码                   │
10│  检测漏洞                   │
11│  生成报告                   │
12└─────────────────────────────┘
13    ↓
14将摘要返回给主 Agent
15    ↓
16主 Agent 继续循环

不仅如此。

SubAgents 可以并行运行。

Claude Code 可以同时委派三个任务，而不是顺序分析代码的三个部分。

过去需要几分钟的事情，现在可能只需几秒钟。

1主 Agent
2    ↓
3将工作分解为独立任务
4    ↓
5┌──────────────┐  ┌──────────────┐  ┌──────────────┐
6│  SubAgent 1  │  │  SubAgent 2  │  │  SubAgent 3  │
7│              │  │              │  │              │
8│ 审查认证     │  │ 审查数据库   │  │ 审查外部     │
9│              │  │              │  │ API          │
10└──────────────┘  └──────────────┘  └──────────────┘
11        ↓                 ↓                 ↓
12        主 Agent 收到三个摘要
13                          ↓
14                继续循环

Claude Code 有 3 个原生 SubAgents，它会自动使用它们：

→ Explore — 一个快速的、只读的 Agent，专门用于搜索和分析项目。结果保留在 SubAgent 的上下文中，而不是你的上下文中。

→ Plan — 在计划模式下激活。在向你呈现计划之前，Claude Code 会将项目调查委派给这个 Agent。

→ 通用型 — 用于需要探索和修改的复杂任务。

你也可以创建自己的 SubAgents。

SubAgents 在 Markdown 文件中定义，包含 YAML 前端数据，并保存在 .claude/agents/ 中。

1---
2name: security-reviewer
3description: 审查代码的安全漏洞。
4             当用户要求进行安全审查时使用。
5tools: Read, Grep, Glob
6---
7
8你是一名安全专家。分析代码中是否存在：
9- SQL 注入
10- 敏感数据暴露
11- 身份验证漏洞
12
13最后，按严重程度排序并总结发现。

注意，在前端数据中，我们将工具限制为 Read、Grep 和 Glob。

这个 Agent 可以分析但绝不能修改任何东西。

当你需要精细控制每个 Agent 能做什么时，这种工具限制是关键。

创建后，Claude Code 会自动根据描述检测到它，并在任务匹配时调用它。或者你可以显式地调用它："使用 security-reviewer agent 来审查这个 PR。"

何时使用 SubAgents，何时不使用？

当任务很长且会产生大量输出时，当你可以将工作分解成独立的并行部分时，或者当你需要一个带有有限工具的专门 Agent 时，使用 SubAgents 是有意义的。

对于不会填满上下文的短任务来说，这不值得。 协调 SubAgents 会增加复杂性，如果主 Agent 能在两分钟内解决任务，这就没有必要了。

MCP：将 Agent 与外部世界连接起来

工具让 Claude Code 能够在你机器上行动。

但有一个限制：所有发生的事都在机器内部发生。

它不能打开 GitHub PR、查询生产数据库，或在 Jira 中创建工单。要做到这些，你之前必须离开 Agent 手动完成。

你如何解决它？ 用 MCP。

MCP（模型上下文协议） 是一个开放协议，定义了 Claude Code 如何与外部服务连接。

它采用客户端-服务器架构：Claude Code 是客户端，每个外部服务都有自己暴露其能力的 MCP 服务器。

当你连接一个 MCP 服务器时，Claude Code 会收到一个包含可用工具列表及其名称和描述的信息。

之后，它使用它们的方式与使用原生工具完全相同。唯一的区别是动作发生在外部服务上，而不是你的机器上。

1Claude Code
2    ↓
3决定使用来自 GitHub MCP 服务器的工具
4    ↓
5┌─────────────────────────────┐
6│      GitHub MCP 服务器      │
7│                             │
8│   打开 PR                   │
9│   分配审查者                │
10│   返回确认                  │
11└─────────────────────────────┘
12    ↓
13Claude Code 接收结果并继续

没有 MCP：你告诉它"我完成了修改，打开 PR"，但 Claude Code 做不到。你必须去 GitHub，填写表单，分配审查者，然后自己合并。

有 MCP：你告诉它同样的事情，Claude Code 就会打开 PR，编写描述，分配审查者，并在准备就绪时通知你。所有这些都不需要你离开 Agent。

你现在可以连接的一些 MCP 服务器：

→ GitHub — PR、审查、议题

→ Postgres / Supabase — 查询和修改数据库

→ Slack — 消息和频道

→ Jira — 工单和项目

本机工具用于你的本地环境。MCP 用于外部世界。

所有部分如何协同工作

Claude Code 是一个 Agent：一个接收目标并自主循环运行直到达成的系统。

你在本文中看到的每个部分都是为了增强这个循环而存在的。但理解它们的最佳方式是看它们如何协同工作。

案例 1：审查并合并一个 PR

你告诉 Claude Code："审查 PR #42，如果一切顺利，就合并它。"

→ 它使用 GitHub MCP 读取修改后的文件并理解更改

→ 它将安全分析委派给专门的 SubAgent，以免填满主上下文

→ 一个 Hook 在本地运行测试并验证一切通过

→ 如果测试通过，它使用 GitHub MCP 执行合并，你无需触碰界面

你写了一行代码。Claude Code 协调了四个系统。

案例 2：记录 API 文档并通知团队

你告诉 Claude Code："记录新的端点并让团队知道。"

→ 它激活一个文档技能，该技能定义了精确的格式：包含什么、如何结构化、添加哪些示例

→ 它使用工具读取代码并提取端点

→ 一个 Hook 在保存前格式化输出

→ 它使用 Slack MCP 将摘要发送到团队频道

每次你这样做，结果都会相同。没有变化，无需你做任何解释。

一切都围绕着循环展开。

记忆用于在每次会话开始时提供信息。工具用于行动。Hooks 用于控制。技能用于标准化。SubAgents 用于扩展。MCP 用于连接外部世界。

当你理解了这一点，你就理解了 Claude Code。

而且不仅仅是 Claude Code：Cursor、Copilot 以及你从现在开始使用的任何 Agent，都基于相同的基础。

名称变了，界面变了，但循环是一样的。

AI 进展很快。

每周都有新东西。但基础不会经常变化。清楚理解这些基础能让你更快地适应，并从未来获得更多。

不要仅仅为了提问而使用 Claude Code。关注它底层发生的事。那里才是机会所在。

一些今天就可以开始的起点：

→ 审查你的自动记忆，并改进 Claude Code 保存的内容

→ 为你的项目创建一个 CLAUDE.md（如果你还没有的话）

→ 连接 GitHub MCP

→ 为那些会填满上下文的任务构建一个 SubAgent

→ 配置一个在每次更改后运行测试的 Hook

以上就是全部内容，明天见。

Marcus