Claude Code 完整使用教程

时效说明：本文内容以 2026 年 3 月为基准，当前版本 v2.1.86。Claude Code 更新极快，使用前建议查阅最新文档 code.claude.com/docs。

如果你是一名Java工程师，日常开发离不开终端、Maven、Git，但从来没用过命令行AI工具——这篇教程就是为你写的。

1.1 从"复制粘贴给ChatGPT"到Claude Code

你可能有过这种经历：写了一段Spring Boot的Controller，逻辑有点绕，想让AI帮忙看看。于是你打开浏览器，登录ChatGPT或者Claude网页版，把代码手动复制进去，然后描述问题，等AI给出建议，再把修改后的代码粘贴回IDE。

这个流程有几个让人抓狂的问题：首先，你只能给AI看一个文件，或者一个片段，它不知道这个方法被哪些地方调用，也不知道你项目里的其他Service是怎么写的；其次，AI给的建议你还要自己动手改，改完之后如果有新问题，你得重新描述，再粘贴，来来回回好几轮；最后，每次重新开聊天窗口，之前的上下文全没了。

Claude Code解决的正是这些问题。它不跑在浏览器里，而是跑在你的终端里，直接读取你本地的项目文件，能看到整个代码库。你说"帮我优化一下UserService里的分页查询"，它会自己找到这个文件，分析上下文，然后给你展示一个diff，你确认之后它直接改文件——不需要你手动复制粘贴任何东西。

1.2 Claude Code的本质：操作本地环境的AI Agent

很多人第一次接触Claude Code，容易把它理解成"更方便的ChatGPT"。这个理解不太准确。

Claude Code的本质是一个AI Agent，不是聊天工具。

两者的区别在于：聊天工具的职责到给出回答为止，而Agent还会执行后续操作。你问ChatGPT"这段代码怎么优化"，它告诉你答案，执行是你的事。但Claude Code不一样，它能调用工具：读文件、写文件、执行shell命令、调用git、运行测试。它有一个任务循环，在这个循环里它会自己判断下一步该做什么，直到任务完成。

打个你熟悉的比方：ChatGPT像是给你发邮件提建议的顾问，而Claude Code像是能SSH进你服务器的实习生——当然，在你确认之前它不会擅自动你的代码。

这也是为什么这门课专门写一篇关于Claude Code的教程。整个课程讲的是Agent开发，而Claude Code本身就是一个设计精良的Agent应用，你在用它的过程中，自然就能理解Agent的核心机制：工具调用、上下文管理、循环推理、人在回路。

1.3 Anthropic用Claude Code开发Claude Code本身

这一点值得单独说一下，因为它不只是个有趣的小知识。

Anthropic在开发Claude Code时，团队自己就在用Claude Code。工程师用它来写代码、跑测试、审查PR，模型在真实使用中暴露问题，然后被修复，再继续使用。这个自我迭代的闭环让Claude Code进步非常快——它不是一个实验室里做出来然后推出去的产品，而是在真实工程场景里磨出来的。

对你来说，这意味着什么？意味着Claude Code在理解工程化代码方面特别强，因为它的开发者就是工程师，用它干的活就是真实的工程任务。它对代码库结构、git工作流、单元测试这些场景的处理，明显比通用聊天AI更贴近实际。

1.4 后端程序员为什么特别适合用它

对于Java后端工程师来说，命令行本来就是家。你每天都在用mvn clean install、git commit、kubectl apply，终端不是陌生的地方。Claude Code跑在终端里，跟你原有的工作流融合起来很自然，不需要切换到另一个应用，不需要改变开发习惯。

还有一个原因：Java项目通常比较大。一个成熟的Spring Boot微服务，动辄几十个类、复杂的继承关系、多层的Service调用。这种项目扔给网页版AI根本看不全，但Claude Code能扫描整个项目目录，理解文件间的依赖关系，这才是真正有用的AI辅助。

1.5 和ChatGPT/Cursor/Copilot的定位区别

这几个工具经常被放在一起比较，但它们的定位其实差别挺大：

工具	使用方式	核心定位	最适合的场景
ChatGPT / Claude网页版	浏览器对话	通用问答助手	学概念、写文章、快速提问
GitHub Copilot	IDE内代码补全	智能输入法	写代码时实时补全，减少打字量
Cursor	基于VS Code的独立AI IDE	编辑器内AI	在编辑器里直接对话改代码
Claude Code	终端命令行工具	AI Agent	理解整个项目、大范围重构、工程任务

Copilot和Cursor是"你写代码时AI辅助你"，Claude Code是"你描述任务，AI来完成"。前者是输入增强，后者是任务委托。

如果你已经有Copilot，不用删掉它——两者不冲突。Copilot负责你写代码时的实时补全，Claude Code负责更复杂的任务：重构一个模块、给整个项目加单测、分析一个陌生的大仓库。

2.1 前置条件：Node.js 18+

Claude Code是一个npm包，所以你需要先装Node.js。很多后端Java开发者不一定装了Node，先检查一下：

bash

node --version

如果输出类似 v20.11.0 这样的版本号，说明已经有了。如果提示"command not found"，去 nodejs.org 下载LTS版本安装。Node.js 18是最低要求，建议直接装最新的LTS版本（当前LTS版本请查看 nodejs.org）。

2.2 安装Claude Code

方式一：npm安装（推荐，国内首选）

直接用npm全局安装，这是最通用的方式：

bash

npm install -g @anthropic-ai/claude-code

国内用户如果安装慢或者卡住，加上淘宝镜像源：

bash

npm install -g @anthropic-ai/claude-code --registry=https://registry.npmmirror.com

安装完之后验证一下：

bash

claude --version
# 输出类似：2.1.x (Claude Code)

方式二：官方脚本

官方提供了一键安装脚本：

注意：官方安装脚本需要访问 claude.ai，国内网络环境下通常无法访问。推荐直接使用上方的 npm 安装方式。

bash

# macOS / Linux / WSL
curl -fsSL https://claude.ai/install.sh | bash

# Windows PowerShell
irm https://claude.ai/install.ps1 | iex

2.3 常见安装问题

问题：permission denied

这是macOS/Linux上最常见的问题，原因是npm全局目录权限不够。不建议用sudo npm install，这会污染文件权限。更好的解决方式是让npm全局目录放到用户home下：

bash

# 创建用户级别的npm目录
mkdir ~/.npm-global
# 配置npm使用这个目录
npm config set prefix '~/.npm-global'
# 把这个目录加到PATH（加到你的 .zshrc 或 .bash_profile 里）
export PATH=~/.npm-global/bin:$PATH
# 重新加载配置
source ~/.zshrc
# 然后重新安装
npm install -g @anthropic-ai/claude-code

问题：安装很慢，长时间无响应

国内直连npm官方镜像慢很正常，加上镜像源解决：

bash

npm install -g @anthropic-ai/claude-code --registry=https://registry.npmmirror.com

也可以全局永久设置镜像：

bash

npm config set registry https://registry.npmmirror.com

2.4 登录方式

安装完之后，进入任意目录，运行claude，首次启动会引导你登录。

方式一：Claude订阅账号（Pro/Max/Teams）

如果你有Claude的付费订阅，可以直接用账号登录。Claude Code的用量包含在订阅额度里，不额外计费。Pro适合个人开发者，如果你每天用量很大，考虑Max计划。

在Claude Code的交互界面里输入：

code

/login

然后按提示，会打开浏览器完成OAuth授权，完成后回到终端就登录好了。

方式二：Console API Key

如果你是通过Anthropic Console购买的API额度，或者你用的是其他兼容Anthropic协议的模型服务（比如国内的DeepSeek），就用这种方式。把API Key配置成环境变量即可，下一章会详细说。

2.5 第一次启动看到什么

登录之后，在任意项目目录运行claude，你会看到类似这样的欢迎界面：

code

╭─────────────────────────────────────────╮
│ ✻ Welcome to Claude Code!               │
│                                         │
│   /help for help, /status to check      │
│   your connection                       │
╰─────────────────────────────────────────╯

✔ Logged in as: your@email.com

> _

底部的>是输入提示符，你可以直接用中文输入任务。输入/help可以看到所有可用命令，输入/status可以检查连接状态和当前使用的模型。

3.1 为什么国内用户需要额外配置

直接使用Anthropic官方的Claude API，国内有两个现实问题：第一，访问稳定性差，需要代理；第二，费用相对较高。Claude 的定价随版本不同而变化，具体以 Anthropic 官方定价页为准，不在文中写死数字。

好消息是Claude Code支持任何兼容Anthropic消息格式的API端点，只需要改两个环境变量就可以切换到其他服务。目前国内主流的选择是DeepSeek，性价比非常高，效果也不错。

3.2 配置原理

Claude Code通过以下三个环境变量控制它连接哪个模型服务：

ANTHROPIC_BASE_URL：API的根地址，默认是Anthropic官方地址
ANTHROPIC_AUTH_TOKEN：用于认证的API Key
ANTHROPIC_MODEL：指定使用哪个模型（可选，有默认值）

修改这三个变量，就能无缝切换到任何兼容服务。

3.3 接入DeepSeek（推荐）

DeepSeek提供了兼容Anthropic消息格式的API端点，切换非常简单。

首先去 platform.deepseek.com 注册并获取API Key。

然后设置环境变量：

bash

# 临时设置（只在当前终端会话有效）
export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
export ANTHROPIC_AUTH_TOKEN=sk-你的DeepSeek_API_KEY
export ANTHROPIC_MODEL=deepseek-chat

注意：请以 DeepSeek 官方文档为准确认最新端点地址。

设置完之后直接运行claude就会走DeepSeek的接口了。

如果你想永久生效，把这三行加到你的shell配置文件里：

bash

# 如果用zsh，加到 ~/.zshrc
# 如果用bash，加到 ~/.bash_profile 或 ~/.bashrc
echo 'export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic' >> ~/.zshrc
echo 'export ANTHROPIC_AUTH_TOKEN=sk-你的DeepSeek_API_KEY' >> ~/.zshrc
echo 'export ANTHROPIC_MODEL=deepseek-chat' >> ~/.zshrc
source ~/.zshrc

3.4 阿里云百炼接入（适合重度用户）

阿里云百炼平台提供了包月套餐，如果你用量很大，包月比按量计费划算很多。百炼也支持Anthropic兼容接口：

bash

export ANTHROPIC_BASE_URL=https://dashscope.aliyuncs.com/compatible-mode/v1/anthropic
export ANTHROPIC_AUTH_TOKEN=你的百炼_API_KEY
export ANTHROPIC_MODEL=qwen-max  # 或者其他支持的模型

具体支持的模型列表和最新的接入地址，以百炼官方文档为准，因为这类配置会随平台更新变化。

3.5 智谱GLM接入

智谱AI的GLM系列模型也有Anthropic兼容端点：

bash

export ANTHROPIC_BASE_URL=https://open.bigmodel.cn/api/anthropic
export ANTHROPIC_AUTH_TOKEN=你的智谱_API_KEY
export ANTHROPIC_MODEL=glm-4-plus

注意：请以智谱开放平台官方文档为准确认最新端点地址。

3.6 通过settings.json永久配置（推荐方式）

比环境变量更推荐的方式是用Claude Code的配置文件。这样配置跟着项目走，不依赖你的shell环境，更稳定，也更容易在不同机器间同步。

Claude Code的配置文件位于：

全局配置：~/.claude/settings.json
项目级配置：项目根目录/.claude/settings.json

推荐用全局配置，这样所有项目都生效：

bash

# 创建目录（如果不存在）
mkdir -p ~/.claude

然后创建或编辑 ~/.claude/settings.json：

json

{
  "env": {
    "ANTHROPIC_AUTH_TOKEN": "sk-你的DeepSeek_API_KEY",
    "ANTHROPIC_BASE_URL": "https://api.deepseek.com/anthropic",
    "ANTHROPIC_MODEL": "deepseek-chat"
  }
}

这里的env字段会在Claude Code启动时自动注入这些环境变量，不需要你每次手动export。

3.7 验证配置是否成功

启动Claude Code之后，输入：

code

/status

你会看到类似这样的输出：

code

● Claude Code Status
  Model:    deepseek-chat
  API URL:  https://api.deepseek.com/anthropic
  Auth:     API Key configured
  Version:  2.x.x

如果Model和API URL显示的是你配置的值，说明配置已经生效。如果看到连接错误，检查API Key是否正确，以及BASE_URL的格式是否跟服务商要求一致。

4.1 在项目目录里启动

Claude Code需要在你的项目目录里启动，因为它要读取当前目录下的文件。

假设你有一个Spring Boot项目：

bash

# 进入你的项目根目录
cd /path/to/your/spring-boot-project

# 启动Claude Code
claude

Claude Code会自动扫描当前目录的文件结构，建立初始上下文。第一次在某个项目里启动，它会问你是否信任这个目录（跟IDE第一次打开项目差不多），输入yes确认就行。

4.2 第一个任务：让它解释代码

最简单的入门任务是让它解释代码，不涉及文件修改，没有任何风险。

假设你项目里有个复杂的查询方法，你不确定它的逻辑，直接用中文问：

code

解释一下 UserService 里的 findActiveUsersWithOrders 方法是干什么的

Claude Code会自动找到这个文件，读取相关代码，然后用人话解释。不需要你告诉它文件在哪里，不需要你粘贴代码。

你也可以问架构级别的问题：

code

这个项目的整体架构是什么？主要有哪些模块，它们之间是怎么交互的？

它会扫描项目结构，分析各个包和类的关系，给你一个概览。这对于接手陌生项目特别有用。

4.3 让它修改代码的完整流程

当你让Claude Code修改代码时，它不会立刻动文件，而是先给你看它打算怎么改。

比如你说：

code

给 UserController 的所有接口方法加上参数校验，用 @Valid 注解，然后添加统一的 BindingResult 处理

Claude Code会分析代码，然后展示一个类似git diff的界面：

code

● Edit UserController.java
  ┌─ Before ──────────────────────────────────────────
  │  @PostMapping("/register")
  │  public ResponseEntity<User> register(@RequestBody UserDTO dto) {
  │      return ResponseEntity.ok(userService.register(dto));
  │  }
  └───────────────────────────────────────────────────
  ┌─ After ───────────────────────────────────────────
  │  @PostMapping("/register")
  │  public ResponseEntity<?> register(@Valid @RequestBody UserDTO dto,
  │                                     BindingResult result) {
  │      if (result.hasErrors()) {
  │          return ResponseEntity.badRequest()
  │              .body(result.getAllErrors());
  │      }
  │      return ResponseEntity.ok(userService.register(dto));
  │  }
  └───────────────────────────────────────────────────

  Apply this change? [y/n/a]

y：确认这一处修改
n：跳过这一处
a：全部确认，不再逐个询问

这个设计非常重要：AI提建议，你做决定，改动可追踪。你不用担心它悄悄修改了什么你不知道的地方。

4.4 VS Code集成

如果你用VS Code开发，可以装Claude Code的官方插件，这样你不用切出终端，直接在VS Code的侧边栏就能用Claude Code。

在VS Code的扩展商店搜索"Claude Code"，安装官方的Anthropic插件。安装后，侧边栏会多一个Claude Code的图标，点进去就是熟悉的对话界面，修改文件时diff也会直接显示在编辑器里。

如果你更习惯在终端里工作，也可以直接用VS Code内置的终端（Ctrl+反引号打开），在里面运行claude，效果一样。

4.5 Spring Boot项目实战示例

下面用一个具体的场景，走一遍完整流程。

假设你有一个Spring Boot项目，要给它加接口限流功能。以前你需要搜文档、找示例、手动写配置类。现在这样做：

bash

# 进入项目
cd ~/workspace/my-spring-boot-project

# 启动Claude Code
claude

然后输入任务：

code

帮我给这个项目加上接口限流功能。
要求：
1. 用 Resilience4j 实现
2. 限流规则：每秒最多10个请求
3. 超出限制返回429状态码和友好的提示信息
4. 给 UserController 和 OrderController 都加上

Claude Code会开始工作：先读取pom.xml看看现有依赖，再看Controller的代码，然后告诉你它打算做什么：

code

● 我会执行以下步骤：
  1. 在 pom.xml 添加 resilience4j-spring-boot2 依赖
  2. 在 application.yml 添加限流配置
  3. 创建 RateLimitConfig.java 配置类
  4. 给 UserController 和 OrderController 加上 @RateLimiter 注解
  5. 创建全局异常处理器处理 RequestNotPermitted 异常

  继续？[y/n]

你确认之后，它会一步一步展示每个文件的改动，你逐个确认。整个过程大概两三分钟，如果手动做可能要半小时。

改完之后你可以接着问：

code

帮我写一个测试，验证限流功能是否正常工作

它会给你写JUnit测试，包括正常情况和超出限制的情况。

这就是Claude Code的基本面貌。接下来介绍它的核心功能：CLAUDE.md项目规范文件、Hooks自动化、MCP外部工具集成，以及如何在团队中共享AI工作流规范。

5.1 Agent循环：Claude是怎么干活的

很多人把Claude Code当成一个"高级自动补全"，其实不对。它是一个真正的Agent，运行的是一个循环：收集上下文 → 采取行动 → 验证结果 → 继续循环。

拿一个具体例子说明。你说"帮我找一下为什么登录接口有时候会返回500"，Claude Code会：

收集上下文：读你的项目文件、查找登录相关的Controller和Service代码、查看最近的Git提交记录、看有没有CLAUDE.md里写的背景说明
采取行动：可能先用grep搜索异常日志，再打开对应的文件，分析堆栈
验证结果：判断找到的原因是否合理，如果不确定就继续查
报告结论：给出定位结果，或者提出下一步建议

这和你在IDEA里Alt+Click找定义是完全不同的逻辑——IDEA是被动响应，Claude Code是主动推理。

5.2 Claude能访问什么

Claude Code在你的项目里有相当大的权限，具体包括：

文件系统：整个项目目录下的所有文件，包括配置文件、SQL脚本、测试代码，它都能读。如果你不想让它碰某些目录（比如包含密钥的.env），需要在权限配置里明确排除。

Git历史：它会用git log、git diff、git blame这些命令。这很有用——你问它"这个方法上周为什么改了"，它能直接翻历史记录给你答案。

CLAUDE.md文件：这个文件里写的内容会在每次会话开始时自动注入给Claude，相当于给它的"项目简报"。后面会专门讲这个文件怎么写。

终端命令：它可以执行shell命令，比如运行测试、执行Maven构建、启动服务。当然，执行命令之前会征求你的同意（除非你开了自动模式）。

5.3 上下文窗口：为什么会话越长越慢

Claude的大脑有容量限制，技术上叫"上下文窗口"。你可以理解成它的工作内存——塞进去的内容越多，处理起来越慢，费用也越高，而且超出限制之后早期的内容会被截断。

上下文使用量会在 Claude Code 会话状态栏自动显示，或在接近限制时自动提示。（/context 命令用于管理允许访问的目录路径，不是查看 token 用量的命令。）

当上下文用得比较多时，可以用/compact命令压缩：

code

/compact

这个命令会让Claude把当前会话的内容概括成一个摘要，用摘要替换掉详细的对话历史，释放出大量空间。代价是它会"忘掉"一些细节，但核心进展会保留。

类比一下：就像你做一个大需求，开了几十个标签页查资料，过了几天你会把重要结论整理到笔记里，然后把标签页关掉。/compact做的就是这件事。

5.4 会话管理：跨终端、跨会话怎么用

Claude Code的会话是持久化的。关掉终端窗口，下次打开还能接着聊。

继续上次会话：

bash

claude -c

加上-c参数，Claude Code会自动恢复最近一次的会话。如果你早上做到一半、下午接着做，就用这个。

分叉会话（--fork-session）：

这是一个很实用的功能，类似Git的分支。假设你在讨论一个架构方案，想同时探索两个不同的方向，但不想让两条路互相干扰：

bash

# 当前在会话A，讨论"用Redis缓存"方案
# 想试试"用本地缓存"方案，但不想破坏A的上下文
# 从当前会话fork出一个新会话（必须配合--continue使用）
claude --continue --fork-session
# 现在在会话B，是A的一个克隆，可以放心试验

注意：这条命令需要在新开的终端窗口中运行，而不是在已有的会话内部输入。

会话B是从会话A当前状态克隆出来的，你在B里做的所有事情不会影响A。如果新方向走不通，丢掉B回到A就行。

多终端共享同一会话的坑：

不要在两个终端窗口里同时打开同一个会话。Claude Code不支持并发访问，两个窗口同时操作会导致上下文混乱，输出结果乱序，严重时会让它误解当前任务状态。如果需要并行处理多个任务，每个任务开一个独立会话，别共享。

5.5 三种权限模式

按Shift+Tab可以在三种模式间循环切换，右上角会显示当前模式。

默认模式（每次都问）：执行任何文件修改或命令都会弹出确认。适合刚开始用，或者在做高风险操作时。

自动接受编辑：修改文件时不再询问，但执行shell命令仍然会确认。这是大多数人的日常模式——你信任它改代码，但不想让它随便跑命令。

Plan模式（只分析不动手）：Claude只会告诉你它打算怎么做，但不会真的执行任何操作。适合先评审方案，确认没问题后再切回执行模式。

6.1 Ask模式——只问不改

Claude Code有三种使用姿势，分别对应不同的场景。很多人只用其中一种，其实三种模式组合起来才是最高效的工作流。

Ask模式是纯只读的。Claude Code在这个模式下绝对不会修改任何文件，也不会执行任何写操作。它的任务就是帮你理解代码、定位问题、解释逻辑。

什么时候用Ask模式？

你接手了一个老项目，看到一段复杂的SQL，不知道它在干什么——用Ask模式让Claude解释。你发现一个NullPointerException，但堆栈太深，不知道根本原因在哪——用Ask模式让Claude帮你推理。你想知道某个接口的完整调用链——用Ask模式让Claude追踪。

示例对话：

code

你：这段代码里的 synchronized 锁的粒度怎么样？有没有性能问题？

Claude：这里锁的是整个方法，每次调用都会阻塞。根据我看到的调用频率和你
       的业务场景，建议改成ConcurrentHashMap + computeIfAbsent，
       可以把锁粒度降到key级别...（继续分析）

Ask模式不是Claude Code的默认状态，但你可以在对话里明确说"不要修改任何文件，只帮我分析"，Claude会遵守这个约束。

6.2 Plan模式——先规划再执行

Plan模式下，Claude会先给你一份详细的执行计划，等你确认之后才开始真正动手。

这个模式在以下情况特别有价值：多个文件需要联动修改时；你不确定改动范围有多大时；涉及数据库Schema变更等高风险操作时；架构调整前需要对齐思路时。

用法示例：

code

你：我想在订单服务里加一个Redis缓存层，先给我一个方案

Claude：好的，我来规划一下：
        第一步：在pom.xml里添加spring-boot-starter-data-redis依赖
        第二步：创建RedisConfig.java，配置序列化方式
        第三步：在OrderService里给getOrderById方法加@Cacheable注解
        第四步：修改application.yml，添加Redis连接配置
        第五步：更新OrderServiceTest，加缓存失效的测试用例

        预估影响文件：5个。要继续吗？

你：第三步用注解的方式合适吗？订单数据量比较大，我担心缓存粒度太粗

Claude：你的担心有道理。如果订单数据量大，@Cacheable注解是按方法粒度
       缓存，可能缓存整个列表。建议改为手动在Service里控制缓存逻辑...

在Plan模式下，你可以和Claude来回讨论方案，调整细节，直到你满意了再说"好，开始执行"。这样大大降低了"Claude改了一堆文件但方向不对"的风险。

可以通过Shift+Tab切换到Plan模式，也可以在提问时直接说"先给我一个计划，不要动代码"。

6.3 Edit模式——直接执行

Edit模式是最直接的，你说改什么，Claude就改什么。在它真正写入文件之前，会展示一个diff让你确认：

code

你：把登录接口的成功响应码从200改为201

Claude：我将修改 UserController.java：

- return ResponseEntity.ok(result);
+ return ResponseEntity.status(HttpStatus.CREATED).body(result);

确认修改吗？[y/N]

你看到diff没问题，按y确认，文件才会真正被改。如果改得不对，直接回复"不对，xxx地方有问题"，Claude会重新给出修改方案。

Edit模式适合你已经非常清楚要改什么的情况——不需要分析、不需要规划，直接告诉它目标，让它执行。

6.4 三种模式的组合工作流

实际工作中，这三种模式应该串联使用：

Ask → Plan → Edit 是一个完整的问题解决流程。

举个真实场景：某个接口偶发性超时，你不知道为什么。

第一阶段用Ask模式：让Claude分析相关代码，找出可能的性能瓶颈。Claude告诉你是某个数据库查询没有走索引，每次全表扫描。

第二阶段用Plan模式：让Claude给出优化方案——加索引、改查询方式、加缓存。Claude给出步骤列表，你和它讨论每一步的利弊，最后敲定方案。

第三阶段用Edit模式：让Claude按确认的方案执行修改。每个文件的改动你都能看到diff，确认无误后才写入。

这个流程避免了两个极端：一种是完全不让Claude动手，自己手动改，累；另一种是直接让Claude"帮我修这个Bug"，结果它改了十个文件但根本没搞清楚问题在哪，越改越乱。

7.1 CLAUDE.md——它是什么，为什么重要

每次你在某个项目里启动Claude Code，它都会自动读取项目里的CLAUDE.md文件，把内容注入到上下文里。这相当于你在每次会话开始前，先给Claude做了一个项目背景汇报。

没有CLAUDE.md，Claude只能靠推断——它看到Spring Boot的代码，能猜出大概是个Web服务，但不知道你们的接口命名规范、不知道某些看起来奇怪的代码其实是有意为之、不知道测试要求。有了CLAUDE.md，这些背景信息就不用每次重复说了。

类比一下：CLAUDE.md相当于你们团队Wiki里的"项目README"，但专门写给Claude看的版本——你会把那些"新来的程序员必须知道但代码里看不出来"的东西都写进去。

7.2 文件层级

CLAUDE.md有三个层级，优先级从低到高：

全局：~/.claude/CLAUDE.md，对所有项目生效。适合写你的个人偏好，比如"总是用中文回复"、"代码注释用中文"。

项目根目录：/your-project/CLAUDE.md，对整个项目生效。这是最常用的层级，应该提交到Git，团队共享。

子目录：比如/your-project/backend/CLAUDE.md，只对这个子目录里的操作生效。适合monorepo，不同模块有不同的规范。

当Claude在某个子目录里工作时，它会从当前目录向上逐层读取所有CLAUDE.md文件，合并生效。

7.3 用/init自动生成

不知道从哪里下手？在项目根目录执行：

bash

/init

Claude Code会分析你的项目结构，自动生成一份CLAUDE.md草稿。内容包括：检测到的技术栈、发现的构建命令、推断出的项目结构。

这份草稿不会很完整，但能帮你快速建立起一个框架，然后你在上面补充真正重要的信息。

7.4 一份好的CLAUDE.md该写什么

从三个维度来想：

WHAT（项目是什么）：技术栈、版本号、项目背景。不用太啰嗦，但关键信息要准确。

WHY（为什么这么做）：解释那些看起来奇怪、但其实有原因的设计决策。比如"这个接口故意返回200而不是201，因为某个老版本的客户端不支持"。这类信息是最值得写进去的，因为这是Claude最容易犯错的地方。

HOW（怎么做事）：代码规范、命名约定、测试要求、提交规范、构建命令。

7.5 Spring Boot项目示例

markdown

# 订单服务（order-service）项目说明

## 项目概述

电商平台的核心订单服务，负责订单全生命周期管理。
技术栈：Spring Boot 3.2 + MyBatis-Plus + MySQL 8.0 + Redis 7 + RocketMQ

## 构建与运行

```bash
# 编译并跳过测试（日常开发用）
mvn clean package -DskipTests

# 运行所有测试
mvn test

# 启动服务（需要本地MySQL和Redis）
mvn spring-boot:run -Dspring-boot.run.profiles=local

代码规范

Controller层只做参数校验和响应封装，禁止写业务逻辑
Service层禁止直接用@Autowired，统一用构造器注入
所有接口响应用统一的 Result<T> 包装，不要直接返回业务对象
错误码统一在 ErrorCode 枚举里定义，不要在代码里写魔法数字

重要背景（请务必读）

订单金额字段全部用 BigDecimal 存储，绝对不能用 double 或 float
OrderStatus 枚举值和数据库里的整数映射关系见 OrderStatus.java 注释
支付回调接口（/api/payment/callback）有幂等逻辑，修改前先看懂再动
测试环境的RocketMQ地址和生产不一样，配置在 application-local.yml 里

测试要求

新增Service方法必须有对应的单元测试
涉及数据库操作的测试用 @Transactional + @Rollback，不要污染测试数据
Controller测试用 MockMvc，不要用真实HTTP

不要做的事

不要修改 BaseEntity 基类，它被所有实体继承
不要在代码里写日志密码或密钥，用配置文件
不要直接操作 order 表，所有写操作必须经过 OrderService

code


## 7.6 用#前缀实时更新记忆

在对话过程中，你可以用`#`前缀向Claude说话，它会把这条信息记录下来而不是作为普通对话处理：

我们刚讨论决定，分页查询统一用游标分页而不是offset分页

code


`#` 前缀会将内容写入 `CLAUDE.local.md`（个人本地记忆，不提交git）。如需更新团队共享的规范，请手动编辑 `CLAUDE.md`。这对于记录"正在进行中的决策"很有用，不用手动去编辑文件。

## 7.7 最佳实践：保持精简

CLAUDE.md不是什么都往里堆的地方。几个原则：

不要把CLAUDE.md当代码规范文档用。规范太多，Claude会忘记执行；而且规范执行应该靠linter和checkstyle来保证，不是靠Claude记住。

只写Claude容易犯错的地方。那些"在代码里一眼就能看出来"的东西不用写，Claude自己能推断。只写那些"没有背景知识会搞错"的东西。

定期清理过期信息。项目迭代了，CLAUDE.md里写的信息可能已经不准确了，过期信息比没有信息更有害。

---

## 8.1 项目目录结构一览

一个充分利用Claude Code能力的项目，目录结构大概是这样：

your-project/
├── CLAUDE.md # 团队共享的项目说明，提交到Git
├── CLAUDE.local.md # 个人偏好覆盖，不提交Git（加入.gitignore）
└── .claude/
├── settings.json # 团队共享的权限配置，提交到Git
├── settings.local.json # 个人权限覆盖，不提交Git
├── commands/ # 自定义斜杠命令
│ ├── review.md # → /project:review
│ └── fix-issue.md # → /project:fix-issue
├── rules/ # 模块化规则文件（被CLAUDE.md引用）
│ ├── code-style.md # 代码风格规范
│ └── api-conventions.md # 接口设计规范
├── skills/ # 自动调用的工作流
│ └── security-review/
│ └── SKILL.md
└── agents/ # 子代理角色定义
└── code-reviewer.md

code


提交到Git的文件（团队共享）：`CLAUDE.md`、`.claude/settings.json`、`.claude/commands/`目录。

不提交Git的文件（个人使用）：`CLAUDE.local.md`、`.claude/settings.local.json`。记得把它们加到`.gitignore`里。

## 8.2 settings.json：权限配置

`settings.json`控制Claude Code能执行哪些操作、不能执行哪些操作。这是团队层面的安全边界配置。

```json
{
  "permissions": {
    "allow": [
      "Bash(git *)",
      "Bash(mvn *)",
      "Bash(npm *)",
      "Bash(grep *)",
      "Bash(find *)"
    ],
    "deny": [
      "Bash(rm -rf *)",
      "Bash(curl * | bash *)",
      "Bash(wget * | bash *)",
      "WebFetch(domain:*.internal-corp.com)"
    ]
  }
}

allow列表里是明确允许执行的命令模式，deny列表里是明确禁止的。支持通配符。

建议的做法：deny里写那些危险操作——删除文件、向外部发送数据、执行下载下来的脚本。allow里写常用的构建工具命令，免得每次都要手动确认。

settings.local.json格式相同，里面的配置会覆盖settings.json。适合你个人需要额外开放某些权限，但不想影响整个团队的场景。

8.3 commands/目录：自定义斜杠命令

.claude/commands/目录里的每个.md文件，会自动变成一个/project:文件名命令。

比如创建.claude/commands/review.md，内容如下：

markdown

请对以下改动做代码审查：

$ARGUMENTS

审查维度：
1. 是否有安全漏洞（SQL注入、XSS、权限绕过）
2. 异常处理是否完整
3. 是否有明显的性能问题
4. 是否符合项目代码规范（见CLAUDE.md）

用中文给出具体的改进建议，标注严重程度（P0/P1/P2）。

这样在对话里输入/project:review就能直接触发这个审查流程。$ARGUMENTS是一个占位符，你在命令后面跟的内容会替换进去：

code

/project:review UserController.java中新增的登录方法

Claude会把"UserController.java中新增的登录方法"代入$ARGUMENTS，然后执行审查。

这个功能特别适合把团队里高频重复的任务固化下来。比如/project:fix-issue用来处理Jira里的Bug单，/project:add-test用来给指定方法补测试用例，/project:write-migration用来生成数据库迁移脚本。这些命令提交到Git，整个团队共享，新人接手也能快速上手。

到这里，你应该对Claude Code的工作机制有了比较完整的认识。接下来讲进阶的工程化集成——包括 Hooks 事件钩子、MCP 外部工具连接、Skills 和子代理。

9.1 Hooks——把AI嵌进工程流程

Hooks是Claude Code里的事件驱动钩子系统。简单说就是：你在某个时机点挂一段脚本，Claude每次触发这个时机就自动跑一遍。

这个概念对Java开发者来说非常熟悉。Spring的@Before、@AfterAOP切面，Maven的pre-test、post-package生命周期钩子，git的pre-commit、pre-push脚本——Hooks干的是同一件事，只不过切面对象变成了AI的操作行为。

为什么要用Hooks？因为很多工程质量保障的事，你不想靠自觉，也不想每次手动触发。让AI改完代码自动跑Checkstyle，让AI准备push前自动跑单测，这些流程嵌进去之后你就不用操心了。

9.2 支持哪些事件

Claude Code目前支持约15种事件，最常用的三个是：

PreToolUse：Claude即将调用某个工具之前触发。这是最有用的一个，因为它可以拦截——你的脚本如果返回deny，Claude就会放弃这次工具调用。适合做危险操作拦截、权限检查。

PostToolUse：工具调用完成之后触发。用来做后置检查，比如Claude修改了文件之后自动跑静态分析。

UserPromptSubmit：用户提交prompt的时候触发。可以在这里注入上下文，或者做内容审核。

9.3 三种Hook类型

Hook本身有三种执行方式。

command类型直接跑一段Shell脚本，这是最常用的。脚本能读环境变量，也能拿到Claude的操作上下文（以JSON格式通过stdin传入）。

prompt类型是让另一个LLM来判断，适合需要语义理解的场景，比如"检查这个改动是否符合公司安全规范"——规则太复杂没法写成脚本，就交给LLM来判断。

agent类型是启动一个完整的子Agent来做验证，适合需要多步骤检查的重型场景，代价是耗时更长，一般只在CI/CD流程里用。

9.4 实战配置示例

Hooks配置在 .claude/settings.json 或 ~/.claude/settings.json 中。下面是几个Java项目里真实有用的场景。

场景一：改完Java文件自动跑Checkstyle

以下配置保存在 .claude/settings.json。每次Claude用 Write 工具写入 .java 文件之后，自动跑Checkstyle检查，输出的最后20行会显示给Claude，如果有违规Claude会主动提出修复。

json

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": {
          "tool_name": "Write",
          "file_pattern": "**/*.java"
        },
        "type": "command",
        "command": "mvn checkstyle:check -q 2>&1 | tail -20"
      }
    ]
  }
}

这个配置的意思是：每次Claude用Write工具写入.java文件之后，自动跑Checkstyle检查。输出的最后20行会显示给Claude看，如果有违规Claude会主动提出修复。

场景二：拦截危险的rm命令

脚本通过stdin接收JSON格式的工具调用信息，检查命令是否包含危险操作，如果是则输出 deny。

json

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": {
          "tool_name": "Bash"
        },
        "type": "command",
        "command": "python3 -c \"\nimport json, sys\ndata = json.load(sys.stdin)\ncmd = data.get('input', {}).get('command', '')\ndangerous = ['rm -rf /', 'rm -rf ~', 'DROP DATABASE', 'truncate table']\nif any(d in cmd for d in dangerous):\n    print(json.dumps({'action': 'deny', 'reason': '危险命令被拦截，请确认后手动执行'}))\n\""
      }
    ]
  }
}

场景三：push前跑单元测试

更实用的方式是配合git hooks联动，但如果你想让Claude在执行git push前先验证测试通过：

先跑测试，如果失败就拒绝 push：

json

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": {
          "tool_name": "Bash",
          "command_pattern": "git push.*"
        },
        "type": "command",
        "command": "mvn test -q && echo '{}' || echo '{\"action\": \"deny\", \"reason\": \"单元测试未通过，push已拦截\"}'"
      }
    ]
  }
}

9.5 PreToolUse的特殊能力

PreToolUse除了能deny拦截，还能做一件更有意思的事：修改Claude的输入。你的脚本可以返回updatedInput字段，Claude会用你修改过的参数来执行工具，而不是原始的参数。

比如Claude想创建一个文件，你可以在Hook里自动把文件路径调整到符合项目目录规范的位置，或者自动给文件名加上时间戳前缀——这种无感的参数改写，对规范化项目结构很有用。

10.1 MCP——让Claude连接外部工具

MCP全称Model Context Protocol，是Anthropic推出的一个开放协议，定义了AI模型和外部工具之间怎么通信。你可以把它理解成AI世界的JDBC——JDBC定义了Java程序和数据库怎么通信，MCP定义了AI和各种外部服务怎么通信。

协议本身是开放的，已经有大量第三方实现了各种MCP Server：GitHub、PostgreSQL、MySQL、Sentry、Slack、Jira……这些Server暴露出来的能力，Claude可以直接调用。

10.2 为什么需要MCP

在没有MCP之前，你想让Claude帮你分析一个GitHub PR，流程是这样的：你自己去GitHub复制PR的diff，粘贴到对话里，Claude分析完给你建议，你再回去GitHub做操作。

有了MCP之后，你直接说"帮我看一下#234这个PR有什么问题，然后写一条review评论"，Claude自己去拉PR内容，分析完直接调用GitHub API提交评论，整个过程你不用动手。

对Java后端开发者来说，最有价值的几个连接是：GitHub（代码仓库操作）、数据库（直接查生产数据）、Sentry（直接看报错堆栈）。这三个覆盖了日常排查问题80%的信息需求。

10.3 配置方式

命令行添加是最快的方式：

bash

# 添加GitHub MCP（通过npx运行）
claude mcp add github -- npx @modelcontextprotocol/server-github

# 添加MySQL MCP
claude mcp add mysql -- npx @modelcontextprotocol/server-mysql

# 添加HTTP类型的MCP
claude mcp add --transport http myserver https://mcp.example.com

注意：claude mcp add 命令中，名称后面必须跟命令或URL参数（用 -- 分隔），不支持仅凭名称自动发现服务。命令行配置只存在你本地，团队协作的时候更推荐用项目级配置文件.mcp.json，提交到git仓库，所有人共享同一套工具配置。

10.4 .mcp.json完整示例

将以下配置文件放在项目根目录，命名为 .mcp.json，提交到git后团队共享。每个 mcpServers 条目通过 command 字段指定 MCP Server 的启动命令（通过npx直接运行）；敏感的 Token 和密码通过 ${ENV_VAR} 引用环境变量，不要硬编码在配置文件里。生产数据库强烈建议使用只读账号，并将 INSERT/UPDATE/DELETE 权限关闭。

json

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    },
    "mysql": {
      "command": "npx",
      "args": [
        "-y",
        "@benborla29/mcp-server-mysql"
      ],
      "env": {
        "MYSQL_HOST": "localhost",
        "MYSQL_PORT": "3306",
        "MYSQL_USER": "readonly_user",
        "MYSQL_PASSWORD": "${DB_PASSWORD}",
        "MYSQL_DATABASE": "myapp_prod",
        "MYSQL_ALLOW_INSERT_OPERATION": "false",
        "MYSQL_ALLOW_UPDATE_OPERATION": "false",
        "MYSQL_ALLOW_DELETE_OPERATION": "false"
      }
    },
    "sentry": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sentry"],
      "env": {
        "SENTRY_AUTH_TOKEN": "${SENTRY_TOKEN}",
        "SENTRY_ORG": "your-org-slug"
      }
    }
  }
}

配置好之后，在Claude里直接说"帮我查一下今天Sentry上最新的5个Java异常"或者"去数据库里查一下昨天下午3点到4点的订单数量"，Claude就能直接操作了。

10.5 安全注意事项

MCP工具的每次调用，默认都需要你手动批准。Claude不会静默地自己去操作你的数据库或者GitHub，每次调用都会弹出提示让你确认。

生产数据库只给只读账号，这是必须的。配置里的密码不要明文写在.mcp.json里——这个文件会提交到git，用${ENV_VAR}的形式引用环境变量，密码本身通过本地的.env文件或者CI/CD的密钥管理来注入。

11.1 Skills——可复用的工作流指令包

11.1.1 Skills是什么

Skills是你封装好的一套工作流指令，可以通过斜杠命令/skill-name手动调用，也可以由Claude根据上下文自动判断是否需要触发。

和普通的CLAUDE.md指令不同的地方在于：CLAUDE.md是全局生效的背景规则，Skills是按需激活的专项能力。类比到Java里，CLAUDE.md像是Spring的全局拦截器，Skills像是你定义的各种@Service——只有调用到的时候才激活。

11.1.2 目录结构

code

你的项目/
└── .claude/
    └── skills/
        ├── java-code-review/
        │   └── SKILL.md
        ├── api-design-check/
        │   └── SKILL.md
        └── sql-optimize/
            └── SKILL.md

11.1.3 Java Code Review的SKILL.md示例

markdown

# Java Code Review Skill

## description
当用户要求做代码审查、code review，或者提交PR之前需要检查代码质量时触发。

## 触发方式
- 手动：/java-code-review
- 自动：当用户说"帮我review一下"、"提交前检查一下"时自动激活

## 执行步骤

### 第一步：理解改动范围
先用 `git diff HEAD` 查看本次所有改动，确认影响的文件和模块。

### 第二步：代码质量检查
针对每个改动的Java文件，检查以下维度：

**可读性**
- 方法名和变量名是否语义清晰，能直接说明用途
- 复杂逻辑是否有必要的注释
- 单个方法是否超过50行（超过需要考虑拆分）

**健壮性**
- 是否正确处理null值（用Optional还是直接判断）
- 数据库操作是否有事务注解
- 对外接口的参数是否有@Valid校验

**性能**
- 循环内是否有重复的数据库查询（N+1问题）
- 集合初始化是否指定了合理的初始容量
- 大对象是否及时释放

**安全**
- SQL是否用了参数化查询，有没有拼接风险
- 日志里是否打印了密码、手机号等敏感字段

### 第三步：输出报告
按 P0（阻断上线）/ P1（本次修复）/ P2（建议优化）三个级别给出反馈，
P0问题必须列出具体行号和修复建议。

写好这个SKILL.md之后，下次你说"帮我看看这次改动能不能合并"，Claude会自动识别出这是一个code review的需求，自动触发这个Skill，按照里面定义的步骤走完整个流程。

11.2 子代理——派遣专业助手

11.2.1 子代理是什么

子代理（Subagent）是主Claude可以派遣出去、在独立上下文里工作的专业Agent。主Claude负责任务拆分和结果汇总，子代理专注于某个专业方向的执行。

这个模式在Claude Code里的价值是：上下文隔离。每个子代理只关注自己的职责，不会被整个项目的背景信息干扰，输出往往比让主Claude一脑门全干要精准。

11.2.2 配置文件位置

code

.claude/
└── agents/
    ├── code-reviewer.md
    ├── security-auditor.md
    └── db-optimizer.md

11.2.3 code-reviewer.md示例

markdown

---
name: code-reviewer
description: 专注于Java代码质量审查的子代理，当主任务需要对代码质量做深度分析时调用
---

# 角色设定

你是一位有10年Java开发经验的技术Lead，负责对代码改动做严格的质量把关。
你的风格是：直接指出问题，给出具体的修改建议，不做无意义的夸赞。

# 工作范围

你只负责代码质量审查，不负责功能正确性验证（那是测试的活）。
重点关注：可维护性、健壮性、性能陷阱、安全漏洞。

# 输出格式

每个问题用以下格式输出：

**[P0/P1/P2] 文件名:行号**
问题描述（一句话说清楚）
建议改法（给出代码片段）

# 约束

- 不评论测试代码的覆盖率（那不是你的职责范围）
- 不建议引入新的依赖库，除非现有代码里已经有了
- 发现P0问题立刻标红，不要等到报告末尾才提

在实际使用中，你可以直接告诉主Claude："用code-reviewer子代理来分析这次的改动"，或者在自定义Skill里定义什么时候自动派遣子代理。

12.1 常用斜杠命令速查

斜杠命令是Claude Code内置的功能快捷键，分几类来看。

会话管理方面，/clear清空当前对话上下文重新开始，适合做完一个任务切换到新任务时用；/compact是压缩上下文，把历史对话总结成摘要保留关键信息，在长时间工作会话里省Token；/resume [session-id] 用于在已启动的会话内通过 session ID 恢复指定的历史对话（区别于 CLI 参数 claude -c，后者是在终端启动时恢复最近会话）。

配置类命令里，/model切换使用的模型（比如在Claude Opus和Sonnet之间切换，Sonnet更快更便宜，Opus更强但更贵）；/status查看当前会话状态，包括上下文使用量；/config打开配置界面，可以设置自动批准级别、颜色主题等。

功能类命令里，/init是第一次在新项目里用时跑一遍，Claude会扫描项目结构然后生成初始的CLAUDE.md；/memory查看和编辑当前CLAUDE.md的内容；/cost查看这次会话消耗了多少Token和费用。

项目自定义命令通过在.claude/commands/目录下创建Markdown文件来定义，文件名就是命令名。比如创建.claude/commands/deploy-check.md，里面写好部署前需要检查的所有步骤，之后直接/project:deploy-check就能一键触发。/review也属于项目自定义命令（需在 .claude/commands/review.md 中定义后，通过 /project:review 调用），并非内置命令。

13.1 输入框的四种前缀

Claude Code的输入框支持四种特殊前缀，这是新手最容易错过的功能。

/开头是调用斜杠命令，这个大家基本都知道。

@开头是引用文件或目录。@src/main/java/UserService.java可以把这个文件的内容直接注入到上下文，@src/可以引用整个目录的文件树。对比手动把代码粘贴进来，这个方式更精准，Claude知道这是一个来自项目里的具体文件，上下文理解会更好。

!开头是直接执行Shell命令。!git status、!mvn test、!ls -la，结果会直接显示在对话里，可以接着让Claude分析命令输出。相当于你直接跳出去开一个终端，跑完命令再把结果贴进来，只不过更快。

#开头是写入记忆，内容会被写入 CLAUDE.local.md（个人本地记忆，不提交git）。比如# 我们项目的数据库是MySQL 8.0，禁止用存储过程，这条规则就持久化了，之后每次对话Claude都会遵守。如需更新团队共享的规范，请手动编辑 CLAUDE.md。

13.2 三条来自官方的新手建议

官方文档里有三条建议，实际用起来确实管用。

第一条：先问问题再写代码。对于不太确定需求的任务，先让Claude说说它打算怎么做，你确认思路对了再让它开始写。比直接让它撸代码然后发现方向不对再推翻要省很多时间。

第二条：任务按难度分级处理。简单的改动（加个字段、改个配置）直接让Claude做；中等难度的任务（重构一个模块、接入一个新中间件）先让Claude给个方案，你review后再执行；复杂的任务（架构调整、核心流程重写）Claude提建议，你来主导节奏，每个小步骤单独确认。

第三条：把常用规则写进CLAUDE.md一劳永逸。团队的代码规范、项目用的框架版本、禁止使用的某些API、特殊的部署流程——这些背景信息每次都解释一遍太费劲，写进CLAUDE.md之后所有会话自动生效。

13.3 快捷键速查

快捷键	功能
`Ctrl+C`	中断Claude当前操作
`Ctrl+L`	清屏但保留上下文
`↑ / ↓`	翻历史输入
`Esc`	取消当前输入
`Tab`	自动补全文件路径（@引用时）
`Ctrl+R`	搜索历史命令
`Shift+Enter`	输入换行（不提交）
`Ctrl+K`	清空当前输入行
`Ctrl+W`	删除光标前一个词
`Alt+Enter`	提交（macOS下可能是Option+Enter）

13.4 成本控制

Claude Code按Token计费，长时间复杂任务消耗会比较大。几个控制成本的实用方法：

/cost命令随时查看当前会话的费用。做完一个大任务后看一眼，有个直觉认知哪类操作费用高。

/compact在上下文积累很长之后用一次，把历史对话压缩成摘要。上下文越长，每次对话消耗的Token越多，定期compact可以降低后续对话的单价。

如果你访问的是Claude的API接口，可以在/model里切换到Sonnet模型——价格是Opus的五分之一，对于代码生成、解释这类任务效果差距不大。国内如果用DeepSeek或者千问的API接入，成本还能再降一个数量级。

最后一个思路：用 Shift+Tab 切换到 Plan 模式，或在对话中说明"先给我一个计划"，让Claude制定计划，你review没问题再执行，避免Claude走错方向白耗Token。方向对了做事，比反复修正要省。