1

2

3

如果你是纯小白 ──→ 从头到尾按顺序阅读，每个练习都跟着做

如果你有点基础 ──→ 可以跳过第 3 章，从第 5 章开始

如果你想快速上手 ──→ 直接看第 7 章和第 10 章

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

┌─────────────────────────────────────────────────────────┐

│                    你（人类）                             │

│   "帮我写一个计算器程序"                                  │

│   "这段代码为什么报错？"                                  │

│   "把我的项目打包部署"                                    │

└─────────────────────┬───────────────────────────────────┘

                      │

                      │ 你只需要用中文说话

                      ▼

┌─────────────────────────────────────────────────────────┐

│                 Claude Code（AI 助手）                    │

│                                                         │

│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  │

│  │ 理解你的需求  │  │ 读取项目文件  │  │ 执行命令     │  │

│  │              │  │              │  │              │  │

│  │ "他想做计算器"│  │ "我来看看    │  │ "mvn compile"│  │

│  │ "需要加减乘除"│  │  现有代码"   │  │  编译项目    │  │

│  └──────┬───────┘  └──────┬───────┘  └──────┬───────┘  │

│         │                 │                 │           │

│         └─────────────────┼─────────────────┘           │

│                           │                             │

│                           ▼                             │

│              ┌──────────────────────┐                   │

│              │  生成代码 / 修复 Bug  │                   │

│              │  运行测试 / 部署项目  │                   │

│              └──────────────────────┘                   │

└─────────────────────────────────────────────────────────┘

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

Claude Code 的能力全景图

═══════════════════════════════════════════════════════════

  ???? 读取与搜索               ?? 编写与修改

  ┌─────────────────┐       ┌─────────────────┐

  │ • 读取任何文件    │       │ • 创建新文件     │

  │ • 搜索代码内容    │       │ • 精确修改代码   │

  │ • 文件模式匹配    │       │ • 批量替换内容   │

  │ • 理解项目结构    │       │ • 重构整个项目   │

  └─────────────────┘       └─────────────────┘

  ? 执行与运行               ???? 思考与规划

  ┌─────────────────┐       ┌─────────────────┐

  │ • 运行终端命令    │       │ • 分析需求      │

  │ • 编译项目       │       │ • 设计方案      │

  │ • 运行测试       │       │ • 解释代码      │

  │ • 安装依赖       │       │ • 教学指导      │

  │ • Git 操作       │       │ • Debug 分析    │

  └─────────────────┘       └─────────────────┘

  ???? 扩展能力（高级）         ???? 自动化（高级）

  ┌─────────────────┐       ┌─────────────────┐

  │ • MCP 工具集成   │       │ • 定时任务      │

  │ • 自定义技能     │       │ • 工作流编排    │

  │ • 多模型切换     │       │ • 批量处理      │

  │ • 第三方服务连接  │       │ • 自动部署      │

  └─────────────────┘       └─────────────────┘

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

安装流程图

═══════════════════════════════════════════════════════════

  开始

   │

   ▼

┌──────────────────┐

│ 步骤1：安装 Node.js │  ← 这是 Claude Code 的运行环境

│ (版本 ≥ 18.0)     │    就像手机需要操作系统一样

└──────┬───────────┘

       │

       ▼

┌──────────────────┐

│ 步骤2：安装       │  ← 在终端里输入一行命令即可

│ Claude Code      │

└──────┬───────────┘

       │

       ▼

┌──────────────────┐

│ 步骤3：验证安装   │  ← 确认安装成功

└──────┬───────────┘

       │

       ▼

  完成！开始使用

1

2

3

4

5

6

7

8

9

10

11

# 1. 打开浏览器，访问 https://nodejs.org

# 2. 下载 LTS 版本（长期支持版，更稳定）

# 3. 双击安装包，一路点击"下一步"即可

# 4. 安装完成后，打开终端（Win+R，输入 cmd，回车）

# 5. 输入以下命令验证安装是否成功：

node --version

# 如果安装成功，你会看到类似这样的输出：

# v20.11.0  （版本号可能不同，只要 ≥ 18.0 就没问题）

npm --version

# 如果安装成功，你会看到类似这样的输出：

# 10.2.4   （npm 是 Node.js 自带的包管理工具）

1

2

3

4

5

# 使用 npm 全局安装 Claude Code

# -g 表示"全局安装"，意味着你可以在电脑的任何位置使用它

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

# 安装过程大约需要 1-2 分钟，你会看到很多行安装日志在滚动

# 这是正常的，不用担心里面的技术细节

1

2

# 方法1：使用国内镜像源（推荐，速度更快）

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

1

2

3

4

# 在终端输入以下命令：

claude --version

# 如果看到版本号输出，说明安装成功！

# 类似：Claude Code v2.0.0

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

获取 API Key 的流程

═══════════════════════════════════════════════════════════

  访问 console.anthropic.com

   │

   ▼

  注册 / 登录账号

   │

   ▼

  进入 API Keys 页面

   │

   ▼

  点击 "Create Key" 创建新 Key

   │

   ▼

  ?? 复制并保存好 Key！（只显示一次）

   │

   ▼

  在终端配置 Key

1

2

3

4

5

# 在 Git Bash 终端中输入（Windows用户推荐这种方式）

# 把下面的 "sk-ant-xxxxx" 替换成你自己的真实的 API Key

export ANTHROPIC_API_KEY="sk-ant-your-actual-api-key-here"

# 注意：这种方式只在当前终端窗口有效，关闭窗口后需要重新设置

# 如果你想让这个配置永久生效，继续往下看

1

2

3

4

5

6

7

8

# Windows PowerShell 用户

# 以管理员身份打开 PowerShell，执行：

[Environment]::SetEnvironmentVariable("ANTHROPIC_API_KEY", "sk-ant-your-key-here", "User")

# Git Bash / Mac / Linux 用户

# 把下面这行加到你的 ~/.bashrc 或 ~/.zshrc 文件末尾

echo 'export ANTHROPIC_API_KEY="sk-ant-your-key-here"' >> ~/.bashrc

# 让配置立即生效

source ~/.bashrc

1

2

3

4

# 如果你已经有 Anthropic 账号，可以直接用这个命令登录

claude login

# 这会打开浏览器，让你通过网页完成认证

# 认证成功后，Claude Code 会自动保存你的凭证

1

2

3

4

5

6

7

8

9

10

# 在终端输入：

claude

# 如果一切配置正确，你会进入 Claude Code 的交互界面

# 你会看到一个类似这样的提示符，表示可以开始对话了：

#

# ╭────────────────────────────────────────────╮

# │  ? Claude Code v2.0.0                      │

# │  Ready to help you build amazing things!    │

# ╰────────────────────────────────────────────╯

# >

1

2

3

4

5

# 进入你的项目目录（如果还没有项目，先创建一个空目录）

mkdir my-first-project      # 创建一个名为 my-first-project 的文件夹

cd my-first-project          # 进入这个文件夹

# 启动 Claude Code

claude

1

2

3

# 不进入交互界面，直接执行一条指令

# -p 参数表示 "print"，意思是直接打印结果

claude -p "写一个 Hello World 的 Python 程序"

1

> 你好！请用中文回复我。请解释一下你是什么，你能帮我做什么？

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

┌─────────────────────────────────────────────────────────┐

│                    交互模式的工作流程                      │

├─────────────────────────────────────────────────────────┤

│                                                         │

│   你输入问题                                             │

│   ┌──────────────────────┐                              │

│   │ > 帮我写一个计算器     │                              │

│   └──────────┬───────────┘                              │

│              │                                           │

│              ▼                                           │

│   ┌──────────────────────┐                              │

│   │ Claude Code 分析你的  │  ← AI 理解你的意图             │

│   │ 需求，读取项目文件    │                              │

│   └──────────┬───────────┘                              │

│              │                                           │

│              ▼                                           │

│   ┌──────────────────────┐                              │

│   │ Claude Code 生成代码  │  ← AI 创建或修改文件           │

│   │ 或执行相关操作        │                              │

│   └──────────┬───────────┘                              │

│              │                                           │

│              ▼                                           │

│   ┌──────────────────────┐                              │

│   │ Claude Code 展示结果  │  ← AI 告诉你做了什么           │

│   │ 等待你的下一步指令    │                              │

│   └──────────────────────┘                              │

│              │                                           │

│              ▼                                           │

│         继续对话……                                       │

│                                                         │

└─────────────────────────────────────────────────────────┘

1

2

3

4

5

6

7

> 帮我用 Python 写一个计算器程序，要求支持加减乘除四种运算。

   用户输入两个数字和运算符，程序输出计算结果。

   代码要包含详细的中文注释。

> 这段代码运行时报错了，错误信息是：

   "NameError: name 'result' is not defined"

   帮我分析一下原因并修复。

> 我的项目里有 5 个 Java 文件，帮我找一下哪个文件里定义了 UserService 类。

1

2

3

4

5

6

> 写代码

   ← 太模糊了，AI 不知道你想要什么

> 修复错误

   ← 没说是什么错误，AI 无法定位问题

> 帮我做个东西

   ← 没有具体描述，AI 会困惑

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

# ─── 基础命令 ───

/help              # 显示帮助信息，列出所有可用命令

# 用法：直接输入 /help 即可

# 作用：查看 Claude Code 支持的所有功能和快捷命令

/clear             # 清空当前对话历史，开始新的话题

# 用法：当你想切换话题或之前的对话太长时使用

# 注意：这不会删除任何文件，只是清空对话记录

/compact           # 压缩对话历史，释放上下文空间

# 用法：当对话很长，AI 响应变慢时使用

# 作用：保留关键信息，删除冗余内容，让 AI 重新"聚焦"

# ─── 会话管理 ───

/status            # 查看当前会话状态

# 显示：当前模型、对话长度、文件变更等信息

/context           # 查看当前上下文包含的内容

# 显示：AI 当前"看到"了哪些信息

# ─── 文件与项目 ───

/init              # 初始化项目，创建 CLAUDE.md 项目说明文件

# 用法：在项目根目录执行 /init

# 作用：让 Claude Code 更好地理解你的项目结构和规则

/add-dir           # 添加一个目录到工作区

# 用法：/add-dir src/   （将 src 目录加入关注范围）

# ─── 配置与管理 ───

/config            # 查看和修改 Claude Code 的设置

# 用法：/config 进入设置页面

/model             # 切换使用的 AI 模型

# 用法：/model opus    （切换到 Opus 模型，能力最强）

#       /model sonnet  （切换到 Sonnet 模型，速度更快）

# ─── 费用与用量 ───

/cost              # 查看当前会话的费用消耗

# 用法：/cost    显示本次对话花了多少钱

/usage             # 查看 Token 使用量

# Token 是 AI 处理文本的计量单位，类似电话的"分钟"

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

上下文窗口示意图

═══════════════════════════════════════════════════════════

  ┌─────────────────────────────────────────────────────┐

  │              上下文窗口（Context Window）             │

  │              Claude Opus 最大支持 100 万 Token        │

  │                                                     │

  │  ┌──────────────────────┐                           │

  │  │  系统提示词           │  ← 定义 AI 的角色和行为     │

  │  │  (System Prompt)     │     如"你是一个编程助手"   │

  │  ├──────────────────────┤                           │

  │  │                      │                           │

  │  │  对话历史             │  ← 你和 AI 你来我往的记录   │

  │  │  (Conversation)      │     每一轮对话都在这里     │

  │  │                      │                           │

  │  │  • 你：帮我写代码     │                           │

  │  │  • AI：好的，这是代码  │                           │

  │  │  • 你：有个错误……    │                           │

  │  │  • AI：我来修复……    │                           │

  │  ├──────────────────────┤                           │

  │  │  当前请求             │  ← 你最新输入的问题         │

  │  │  (Current Request)   │                           │

  │  └──────────────────────┘                           │

  └─────────────────────────────────────────────────────┘

  当上下文满了 → AI 可能会"忘记"早期的对话内容

  解决方法 → /compact 命令压缩对话 或 /clear 清空重新开始

1

2

3

4

5

6

# 查看当前使用了多少上下文

/context

# 如果对话太长，压缩上下文（保留关键信息，删除冗余）

/compact

# 完全开始新话题

/clear

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

Token 的直观理解

═══════════════════════════════════════════════════════════

  中文："你好世界"           ≈ 4 个 Token

  英文："Hello World"        ≈ 2 个 Token

  一句普通的中文问句          ≈ 20-50 个 Token

  一个 100 行的 Python 文件   ≈ 800-1500 个 Token

  一个中等规模的项目（100个文件） ≈ 50万-200万 Token

  费用参考（以 Claude Opus 为例）：

  ┌─────────────────────────────────────────────┐

  │  输入（你发给 AI 的内容）：$5 / 100万 Token    │

  │  输出（AI 回复的内容）：  $25 / 100万 Token   │

  │                                             │

  │  换句话说：                                  │

  │  • 问一个问题 ≈ 几分钱                        │

  │  • 写一个完整功能 ≈ 几毛钱                     │

  │  • 完成一个项目 ≈ 几块钱到几十块钱              │

  └─────────────────────────────────────────────┘

1

2

3

4

5

6

# 在 Claude Code 中随时查看当前会话的费用

/cost

# 输出示例：

# Total cost:     $0.42

# Input tokens:   45,230

# Output tokens:  2,156

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

Claude Code 的内置工具一览

═══════════════════════════════════════════════════════════

  ┌─────────────────────────────────────────────────────────┐

  │                      工具清单                            │

  ├───────────────┬─────────────────────────────────────────┤

  │ 工具名称       │ 作用（用人话解释）                        │

  ├───────────────┼─────────────────────────────────────────┤

  │ Read          │ "读文件"——就像你打开文件查看内容           │

  │               │ 可以读代码、读文档、读图片、读 PDF         │

  ├───────────────┼─────────────────────────────────────────┤

  │ Write         │ "写文件"——创建新文件或覆盖已有文件         │

  │               │ 就像你在编辑器里新建文件并写入内容          │

  ├───────────────┼─────────────────────────────────────────┤

  │ Edit          │ "改文件"——精确修改文件中的某段内容         │

  │               │ 不是整个重写，而是精准替换                 │

  ├───────────────┼─────────────────────────────────────────┤

  │ Bash          │ "执行命令"——在终端里运行指令               │

  │               │ 可以编译代码、安装依赖、运行测试            │

  ├───────────────┼─────────────────────────────────────────┤

  │ Glob          │ "找文件"——按文件名模式搜索                 │

  │               │ 比如找所有 .java 文件或所有 test*.js      │

  ├───────────────┼─────────────────────────────────────────┤

  │ Grep          │ "搜内容"——在文件内容中搜索关键词           │

  │               │ 比如找所有包含"password"的代码行          │

  ├───────────────┼─────────────────────────────────────────┤

  │ WebFetch      │ "抓网页"——获取网页内容                    │

  │               │ 可以读取在线文档、API 说明等               │

  ├───────────────┼─────────────────────────────────────────┤

  │ WebSearch     │ "搜网页"——搜索互联网                      │

  │               │ 查找最新信息、技术方案等                   │

  ├───────────────┼─────────────────────────────────────────┤

  │ Task          │ "多任务"——同时处理多个独立工作             │

  │               │ 比如同时搜索多个目录或处理多个文件          │

  └───────────────┴─────────────────────────────────────────┘

1

2

3

4

5

6

7

8

9

10

11

你说："帮我把项目里所有的 TODO 注释找出来"

                     │

                     ▼

Claude Code 内部自动执行：

┌──────────────────────────────────────┐

│ 1. 分析需求："找 TODO 注释"          │

│ 2. 选择工具：用 Grep 工具搜索        │

│ 3. 执行：grep "TODO" 遍历所有文件     │

│ 4. 整理结果：把找到的 TODO 列给你看   │

│ 5. 回复："找到了 12 个 TODO……"       │

└──────────────────────────────────────┘

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

权限级别说明

═══════════════════════════════════════════════════════════

  ┌─────────────────────────────────────────────────────────┐

  │  操作类型            │  是否需要你确认  │  示例           │

  ├──────────────────────┼─────────────────┼────────────────┤

  │  读文件              │  不需要（自动）  │  "看看这个文件"  │

  │  搜索内容            │  不需要（自动）  │  "搜一下 TODO"  │

  │  写新文件            │  需要确认        │  "创建一个文件"  │

  │  修改已有文件         │  需要确认        │  "修改这行代码"  │

  │  执行命令            │  需要确认        │  "运行 npm test"│

  │  访问外部网站         │  需要确认        │  "查看这个网页"  │

  │  删除文件            │  需要确认        │  "删除这个文件"  │

  └──────────────────────┴─────────────────┴────────────────┘

  你可以选择：

  • 允许（Allow）          —— 仅这次

  • 总是允许（Always Allow）—— 同类型操作不再询问

  • 拒绝（Deny）            —— 不允许执行

1

2

3

4

5

6

7

8

场景：你刚接手一个项目，想了解某个文件做了什么

你：帮我看看 src/main/java/com/example/UserController.java 这个文件，

   解释一下每个方法是做什么的，用中文说明。

Claude Code 会：

1. 自动使用 Read 工具读取文件

2. 分析代码结构

3. 用通俗的中文解释每个方法的作用

4. 可能还会指出潜在的问题或改进建议

1

2

3

4

5

6

7

场景：产品经理给了你一张 UI 设计图，让你实现

你：看看这张设计图 design.png，告诉我这是一个什么样的页面布局。

Claude Code 会：

1. 读取图片文件

2. 分析图片中的 UI 元素

3. 描述布局结构

4. 甚至可以帮你生成对应的 HTML/CSS 代码

1

2

3

4

5

6

7

场景：你想找到所有调用了 getUserById 方法的地方

你：帮我在整个项目中搜索所有调用 getUserById 的地方，

   列出文件名和行号。

Claude Code 会：

1. 自动使用 Grep 工具搜索

2. 返回所有匹配的行及其位置

3. 你可以点击行号直接跳转

1

2

3

4

5

场景：你记得有个文件名叫 UserService 但忘了在哪个目录

你：帮我找到所有文件名包含 UserService 的 Java 文件。

Claude Code 会：

1. 使用 Glob 工具按文件名模式匹配

2. 列出所有匹配的文件路径

1

2

3

4

5

6

7

8

9

10

场景：你想给 UserService 类添加一个新方法

你：在 src/main/java/com/example/UserService.java 中

   添加一个 findByEmail 方法，参数是 String email，

   返回 Optional<User>。

Claude Code 会：

1. 读取 UserService.java 的内容

2. 分析类的结构

3. 在合适的位置插入新方法

4. 确保代码格式和项目风格一致

5. 展示修改后的结果让你确认

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

// ========== 修改前 ==========

public class UserService {

    public Optional<User> findById(Long id) {

        // 根据 ID 查找用户

        return userRepository.findById(id);

    }

}

// ========== 修改后 ==========

public class UserService {

    public Optional<User> findById(Long id) {

        // 根据 ID 查找用户

        return userRepository.findById(id);

    }

    // 【新增方法】根据邮箱地址查找用户

    // @param email 用户的邮箱地址

    // @return 包含用户的 Optional 对象，如果找不到则为空

    public Optional<User> findByEmail(String email) {

        // 调用 Repository 层的 findByEmail 方法查询数据库

        return userRepository.findByEmail(email);

    }

}

1

2

3

4

5

6

7

8

# 场景：你想编译一个 Java 项目

# 传统方式（你需要记住命令）：

mvn clean compile -DskipTests

# Claude Code 方式（说人话就行）：

> 帮我编译这个 Java 项目，跳过测试。

# Claude Code 会自动执行：

# mvn clean compile -DskipTests

# 然后把编译结果翻译成你能看懂的中文告诉你

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

你说："帮我看看这个 Spring Boot 项目能不能正常启动"

                         │

                         ▼

┌─────────────────────────────────────────────────────────┐

│  Claude Code 内部处理流程                                │

│                                                         │

│  1. 分析项目类型                                         │

│     → 发现 pom.xml → 判定为 Maven 管理的 Spring Boot 项目 │

│                                                         │

│  2. 确定启动命令                                         │

│     → mvn spring-boot:run                               │

│                                                         │

│  3. 请求你的确认                                         │

│     → "我将执行 mvn spring-boot:run，是否允许？"          │

│                                                         │

│  4. 执行命令并捕获输出                                    │

│     → 启动日志会显示在终端                               │

│                                                         │

│  5. 分析结果                                             │

│     → 如果启动成功：告诉你端口号和访问地址                 │

│     → 如果启动失败：帮你分析错误原因并修复                 │

└─────────────────────────────────────────────────────────┘

1

2

3

4

5

# 1. 创建项目文件夹

mkdir my-homepage

cd my-homepage

# 2. 启动 Claude Code

claude

1

2

3

4

5

6

7

8

9

10

11

12

> 帮我创建一个个人主页，要求：

  1. 只用一个 index.html 文件（把 CSS 和 JS 都写在里面）

  2. 设计要简洁大方，使用现代的设计风格

  3. 包含以下内容：

     - 顶部导航栏：首页、关于我、技能、联系方式

     - 主页横幅区：我的名字（张三）、一句话介绍

     - 关于我区域：一段个人简介

     - 技能展示区：用卡片展示我会的技能

     - 联系方式区：邮箱、GitHub、微信

     - 底部版权信息

  4. 颜色方案用蓝色系

  5. 代码中加上详细的中文注释，我是初学者

1

2

# Claude Code 写完后，帮我在浏览器里打开看看

> 帮我在浏览器里打开这个 index.html 文件

1

2

3

> 我觉得背景色太深了，帮我改成浅蓝色

> 导航栏的字体再大一些

> 把技能卡片改成 3 列布局，现在太宽了

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

<!DOCTYPE html>

<!-- 这行告诉浏览器：这是一个 HTML5 文档 -->

<html lang="zh-CN">

<!-- lang="zh-CN" 表示页面主要语言是简体中文 -->

<head>

    <!-- head 标签包含页面的"元信息"——用户看不到，但浏览器需要 -->

    <meta charset="UTF-8">

    <!-- 设置字符编码为 UTF-8，这样中文才能正常显示 -->

    <meta name="viewport" content="width=device-width, initial-scale=1.0">

    <!-- 让页面在手机上也能正常显示（响应式设计的基础） -->

    <title>张三 - 个人主页</title>

    <!-- 浏览器标签页上显示的标题 -->

    <style>

        /* ========== 全局样式 ========== */

        /* * 是通配符，选中所有元素 */

        * {

            margin: 0;

            /* 清除默认的外边距 */

            padding: 0;

            /* 清除默认的内边距 */

            box-sizing: border-box;

            /* 让宽高计算方式更直观 */

        }

        /* body 是页面主体，所有可见内容都在里面 */

        body {

            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;

            /* 设置字体，从前往后依次尝试 */

            line-height: 1.6;

            /* 行高 1.6 倍，让文字不拥挤 */

            color: #333;

            /* 文字颜色：深灰色（比纯黑柔和） */

            background-color: #f0f4f8;

            /* 背景色：浅蓝灰色 */

        }

        /* ========== 导航栏样式 ========== */

        /* nav 是 HTML5 的语义化标签，表示导航区域 */

        nav {

            background-color: #1a56db;

            /* 导航栏背景：深蓝色 */

            padding: 16px 0;

            /* 上下内边距 16px，左右 0 */

            position: sticky;

            /* 粘性定位：滚动时导航栏固定在顶部 */

            top: 0;

            /* 距离顶部 0px */

            z-index: 100;

            /* 层级最高，确保不被其他元素遮挡 */

        }

        /* 导航栏内部的容器，用于控制内容宽度 */

        nav .container {

            max-width: 1000px;

            /* 最大宽度 1000px */

            margin: 0 auto;

            /* 上下 0，左右自动（居中） */

            display: flex;

            /* 使用弹性布局 */

            justify-content: space-between;

            /* 子元素两端对齐 */

            align-items: center;

            /* 子元素垂直居中 */

        }

        /* 网站 Logo/标题 */

        nav .logo {

            color: white;

            /* 文字白色 */

            font-size: 22px;

            /* 字体大小 */

            font-weight: bold;

            /* 加粗 */

        }

        /* 导航链接列表 */

        nav ul {

            list-style: none;

            /* 去掉列表的小圆点 */

            display: flex;

            /* 让列表项横向排列 */

            gap: 24px;

            /* 每项之间的间距 */

        }

        /* 导航链接样式 */

        nav ul li a {

            color: rgba(255, 255, 255, 0.85);

            /* 半透明白色 */

            text-decoration: none;

            /* 去掉下划线 */

            font-size: 15px;

            transition: color 0.3s;

            /* 颜色变化有 0.3 秒过渡动画 */

        }

        /* 鼠标悬停在导航链接上时的效果 */

        nav ul li a:hover {

            color: white;

            /* 变为纯白色 */

        }

        /* ========== 横幅区样式 ========== */

        .hero {

            background: linear-gradient(135deg, #1a56db 0%, #4f8cf7 100%);

            /* 渐变背景：从深蓝到浅蓝，135度角 */

            color: white;

            padding: 80px 0;

            /* 上下 80px 的内边距，让横幅更高 */

            text-align: center;

            /* 文字居中 */

        }

        .hero h1 {

            font-size: 40px;

            /* 主标题大号字体 */

            margin-bottom: 12px;

        }

        .hero p {

            font-size: 18px;

            opacity: 0.9;

            /* 略微透明 */

        }

        /* ========== 通用容器和区块样式 ========== */

        .container {

            max-width: 1000px;

            margin: 0 auto;

            padding: 0 20px;

            /* 左右保留 20px 安全距离 */

        }

        section {

            padding: 60px 0;

            /* 每个区块上下 60px 间距 */

        }

        section h2 {

            text-align: center;

            font-size: 28px;

            margin-bottom: 36px;

            color: #1a56db;

        }

        /* ========== 关于我区域 ========== */

        .about p {

            font-size: 16px;

            text-align: center;

            max-width: 680px;

            margin: 0 auto;

            /* 段落居中，最大宽度 680px，阅读更舒适 */

        }

        /* ========== 技能卡片区域 ========== */

        .skills-grid {

            display: grid;

            /* 使用网格布局 */

            grid-template-columns: repeat(3, 1fr);

            /* 3 列，每列等宽 */

            gap: 20px;

            /* 卡片之间的间距 */

        }

        /* 单个技能卡片 */

        .skill-card {

            background: white;

            /* 白色背景 */

            padding: 28px;

            border-radius: 10px;

            /* 圆角 */

            text-align: center;

            box-shadow: 0 2px 10px rgba(0, 0, 0, 0.08);

            /* 投影阴影：水平0 垂直2px 模糊10px 黑色8%透明度 */

            transition: transform 0.3s;

            /* 悬停动画 */

        }

        .skill-card:hover {

            transform: translateY(-4px);

            /* 鼠标悬停时向上移动 4px，有"浮起来"的感觉 */

        }

        .skill-card .icon {

            font-size: 36px;

            /* 图标（emoji）的尺寸 */

            margin-bottom: 12px;

        }

        .skill-card h3 {

            margin-bottom: 8px;

            color: #1a56db;

        }

        /* ========== 联系方式区域 ========== */

        .contact-info {

            text-align: center;

            font-size: 16px;

        }

        .contact-info p {

            margin-bottom: 8px;

        }

        /* ========== 页脚样式 ========== */

        footer {

            background-color: #1a2938;

            /* 深色背景 */

            color: #9ca3af;

            /* 灰色文字 */

            text-align: center;

            padding: 20px 0;

            font-size: 14px;

        }

    </style>

</head>

<body>

    <!-- ========== 导航栏 ========== -->

    <nav>

        <div class="container">

            <!-- 左侧 Logo -->

            <span class="logo">张三</span>

            <!-- 右侧导航链接 -->

            <ul>

                <!-- href="#" 表示点击后跳转到当前页面的指定位置 -->

                <li><a href="#home">首页</a></li>

                <li><a href="#about">关于我</a></li>

                <li><a href="#skills">技能</a></li>

                <li><a href="#contact">联系方式</a></li>

            </ul>

        </div>

    </nav>

    <!-- ========== 主页横幅 ========== -->

    <section class="hero" id="home">

        <h1>张三</h1>

        <p>热爱技术的全栈开发者 | 终身学习者 | 开源爱好者</p>

    </section>

    <!-- ========== 关于我 ========== -->

    <section class="about" id="about">

        <div class="container">

            <h2>关于我</h2>

            <p>

                你好！我是张三，一名拥有 3 年经验的全栈开发者。

                我热爱用代码创造有价值的软件产品，喜欢学习新技术。

                工作之余，我活跃在 GitHub 开源社区，参与过多个知名项目的贡献。

                我相信技术的力量可以让世界变得更好。

            </p>

        </div>

    </section>

    <!-- ========== 技能展示 ========== -->

    <section id="skills">

        <div class="container">

            <h2>我的技能</h2>

            <div class="skills-grid">

                <!-- 技能卡片 1 -->

                <div class="skill-card">

                    <div class="icon">?</div>

                    <h3>Java</h3>

                    <p>精通 Java 后端开发，Spring Boot 框架</p>

                </div>

                <!-- 技能卡片 2 -->

                <div class="skill-card">

                    <div class="icon">????</div>

                    <h3>Python</h3>

                    <p>熟练使用 Python 进行数据处理和 Web 开发</p>

                </div>

                <!-- 技能卡片 3 -->

                <div class="skill-card">

                    <div class="icon">????</div>

                    <h3>前端开发</h3>

                    <p>掌握 HTML、CSS、JavaScript 和 Vue.js</p>

                </div>

            </div>

        </div>

    </section>

    <!-- ========== 联系方式 ========== -->

    <section id="contact">

        <div class="container">

            <h2>联系我</h2>

            <div class="contact-info">

                <p>???? 邮箱：zhangsan@example.com</p>

                <p>???? GitHub：github.com/zhangsan</p>

                <p>???? 微信：zhangsan_dev</p>

            </div>

        </div>

    </section>

    <!-- ========== 页脚 ========== -->

    <footer>

        <div class="container">

            <p>&copy; 2026 张三 | 保留所有权利</p>

            <!-- &copy; 是版权符号 © -->

        </div>

    </footer>

</body>

</html>

1

2

3

# 在项目根目录下执行

claude

> /init

1

2

3

4

5

6

7

8

9

10

# OCP 电商平台项目

## 项目简介

这是一个基于 Spring Boot 的在线商城系统，提供商品浏览、购物车、下单等功能。

## 技术栈

- 后端框架：Spring Boot 2.7.x

- 构建工具：Maven

- 数据库：MySQL 8.0 + MyBatis-Plus

- 缓存：Redis

- Java 版本：JDK 11

## 项目结构

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

## 编码规范

- 类名使用大驼峰命名法，如 UserController

- 方法名和变量名使用小驼峰命名法，如 findUserById

- 所有 public 方法必须有 Javadoc 注释

- Controller 层只做参数校验和转发，不写业务逻辑

- 使用 Lombok 简化 getter/setter

## 运行方式

?```bash

# 编译

mvn clean compile

# 运行测试

mvn test

# 启动项目

mvn spring-boot:run

# 启动后访问 http://localhost:8080

1

2

### 8.2 项目中 Claude Code 的日常工作流

有了 CLAUDE.md 后，Claude Code 就"认识"你的项目了。下面是日常工作中最常用的几种交互模式：

1

2

3

### 8.3 实际工作场景演示

让我们模拟几个真实的开发场景：

**场景一：添加新功能**

1

2

3

4

5

1. 在 UserController 中添加 POST /api/users/register 接口

2. 在 UserService 中添加 register 方法

3. 注册时校验邮箱格式和密码长度（至少6位）

4. 密码需要用 BCrypt 加密后存储

5. 返回格式统一使用 Result 类包装

1

**场景二：修复 Bug**

1

**场景三：代码重构**

1

2

### 8.4 Git 版本管理

Claude Code 可以帮助你管理代码版本（使用 Git），即使你完全不懂 Git 命令：

1

2

3

4

5

6

7

---

## 9. 高级功能：让 Claude Code 更强大

当你掌握了基础功能后，这些高级功能可以帮助你进一步提升效率。

### 9.1 MCP（模型上下文协议）—— 连接外部世界

**概念解释：**

MCP 的全称是 Model Context Protocol（模型上下文协议）。用人话来说——**它是让 Claude Code 能连接各种外部工具和服务的"万能插头"**。

> **比喻**：你的手机只有一个充电口，但是通过不同的转接头，你可以连 U 盘、显示器、键盘…… MCP 就是 AI 世界的那个"万能转接头"。

1

2

3

4

5

6

7

8

9

10

11

**MCP 的常见应用：**

| MCP 服务 | 能让 Claude Code 做什么 |

|---------|------------------------|

| GitHub MCP | 创建 Issue、提交 PR、查看代码变更 |

| 数据库 MCP | 直接查询数据库、执行 SQL |

| Jira MCP | 查看/创建/更新任务 |

| Slack MCP | 发送消息到频道 |

| 文件系统 MCP | 访问远程服务器上的文件 |

### 9.2 Skills（技能）—— 给 AI 安装"专业插件"

**概念解释：**

Skills 就像给 Claude Code 安装的各种"专业 App"。比如说，默认的 Claude Code 什么都能做，但如果你要处理 Excel 文件，装了 "xlsx" 这个 Skill 后，它会变得更专业。

1

2

3

4

5

6

7

8

9

10

11

**如何在 Claude Code 中使用 Skills：**

Skills 的配置存储在 `.claude/settings.json` 文件中。你可以在这个文件中声明要启用的 Skills：

?```json

{

  "skills": [

    "xlsx",     // Excel 处理技能

    "docx",     // Word 处理技能

    "pptx",     // PowerPoint 处理技能

    "pdf"       // PDF 处理技能

  ]

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

// 在 .claude/settings.json 中配置

{

  "hooks": {

    // PostToolUse：在 AI 使用某个工具后触发

    "PostToolUse": [

      {

        // 匹配器：当 AI 修改了 Java 文件时触发

        "matcher": "Edit",

        // 钩子：自动格式化代码

        "hooks": [

          {

            "type": "command",

            // 执行这个命令来格式化刚修改的 Java 代码

            "command": "mvn spotless:apply"

          }

        ]

      }

    ]

  }

}

1

2

3

4

5

6

7

8

9

10

场景对照表

═══════════════════════════════════════════════════════════

  触发时机          │  可以做什么

  ──────────────────┼─────────────────────────────────────

  对话开始时         │  加载项目信息、检查环境

  工具使用前         │  额外安全检查、记录日志

  工具使用后         │  自动格式化、运行测试、记录变更

  AI 回复后          │  发送通知、触发 CI/CD

  对话结束时         │  清理临时文件、生成工作报告

  文件被修改前       │  自动备份原文件

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

模型选择指南

═══════════════════════════════════════════════════════════

  ┌─────────────────────────────────────────────────────────┐

  │  模型          │  适合场景           │  特点             │

  ├────────────────┼────────────────────┼──────────────────┤

  │  Opus 4.8      │  最复杂的任务        │  最聪明、最贵     │

  │  （旗舰模型）    │  大型项目重构        │  适合"深度思考"   │

  │                │  复杂架构设计        │                  │

  ├────────────────┼────────────────────┼──────────────────┤

  │  Sonnet 4.6    │  日常开发            │  智能与速度的平衡  │

  │  （推荐日常用）  │  写代码、修 Bug      │  性价比最高       │

  │                │  中小型项目          │                  │

  ├────────────────┼────────────────────┼──────────────────┤

  │  Haiku 4.5     │  简单任务            │  最快、最便宜     │

  │  （轻量模型）    │  代码分类、格式化     │  适合高频简单操作  │

  │                │  简单问答            │                  │

  └────────────────┴────────────────────┴──────────────────┘

  切换命令：

  /model opus      → 切换到 Opus（处理复杂任务时）

  /model sonnet    → 切换到 Sonnet（日常开发，默认推荐）

  /model haiku     → 切换到 Haiku（执行简单重复任务时）

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

单个 AI 处理大项目：

┌────────────────────────────────────────────────────┐

│  AI 一个人干活                                       │

│  任务1 → 任务2 → 任务3 → 任务4 → 任务5              │

│  耗时：所有任务的时间之和                              │

└────────────────────────────────────────────────────┘

Workflow 多 AI 并行：

┌────────────────────────────────────────────────────┐

│  AI-1 → 任务1                                      │

│  AI-2 → 任务2     ← 所有 AI 同时工作                 │

│  AI-3 → 任务3                                      │

│  AI-4 → 任务4                                      │

│  AI-5 → 任务5                                      │

│  耗时：最慢的一个任务的时间                            │

└────────────────────────────────────────────────────┘

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

OCP 项目架构概览

═══════════════════════════════════════════════════════════

  ┌─────────────────────────────────────────────────────────┐

  │                    浏览器（前端）                         │

  │              HTML + CSS + JavaScript                    │

  └────────────────────────┬────────────────────────────────┘

                           │ HTTP 请求

                           ▼

  ┌─────────────────────────────────────────────────────────┐

  │                 Spring Boot 后端                         │

  │  ┌──────────┐  ┌──────────┐  ┌──────────┐             │

  │  │Controller│→│ Service  │→│  Mapper  │              │

  │  │ 接收请求  │  │ 处理业务  │  │ 访问数据库│              │

  │  └──────────┘  └──────────┘  └────┬─────┘             │

  └────────────────────────────────────┼────────────────────┘

                                       │

                           ┌───────────┴───────────┐

                           ▼                       ▼

                    ┌─────────────┐         ┌─────────────┐

                    │   MySQL     │         │   Redis     │

                    │  数据库      │         │  缓存       │

                    │  存数据      │         │  加速访问    │

                    └─────────────┘         └─────────────┘

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

# 在 Claude Code 中输入以下内容：

> 帮我创建一个标准的 Spring Boot 项目骨架，使用 Maven 管理。

  项目名为 ocp-platform，包名为 com.example.ocp。

  要求：

  1. Java 版本使用 JDK 11

  2. Spring Boot 版本使用 2.7.x

  3. 包含以下依赖：

     - Spring Web（用于开发 REST API）

     - MyBatis-Plus（简化数据库操作）

     - MySQL Connector（连接 MySQL 数据库）

     - Lombok（简化 Java 代码）

     - Spring Boot Validation（参数校验）

  4. 创建标准的项目目录结构

  5. 创建基础的配置文件 application.yml

  6. 创建基础的工具类（如统一的响应格式 Result 类）

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

ocp-platform/

├── pom.xml                          # Maven 项目配置文件

├── CLAUDE.md                        # Claude Code 项目说明书

├── src/

│   ├── main/

│   │   ├── java/com/example/ocp/

│   │   │   ├── OcpApplication.java  # Spring Boot 启动类

│   │   │   ├── controller/          # 控制器包

│   │   │   ├── service/             # 服务层包

│   │   │   │   └── impl/            # 服务实现类

│   │   │   ├── mapper/              # 数据访问层

│   │   │   ├── entity/              # 数据库实体类

│   │   │   ├── dto/                 # 数据传输对象

│   │   │   ├── common/              # 公共类

│   │   │   │   └── Result.java      # 统一响应格式

│   │   │   └── config/              # 配置类

│   │   └── resources/

│   │       ├── application.yml      # 主配置文件

│   │       └── mapper/              # MyBatis XML 映射

│   └── test/

│       └── java/com/example/ocp/    # 测试代码

1

> /init

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

## OCP 项目开发规范补充

### API 设计规范

- 所有 API 路径以 /api 开头

- 使用 RESTful 风格：

  - GET /api/users —— 查询用户列表

  - GET /api/users/{id} —— 查询单个用户

  - POST /api/users —— 创建用户

  - PUT /api/users/{id} —— 更新用户

  - DELETE /api/users/{id} —— 删除用户

### 数据库规范

- 表名使用小写字母和下划线，如 user_order

- 字段名使用小写字母和下划线，如 create_time

- 每张表必须有 id（主键）、create_time、update_time 字段

### 测试规范

- Service 层必须写单元测试

- Controller 层写集成测试

- 测试覆盖率目标：Service 层 ≥ 80%

1

2

3

4

5

6

7

8

9

10

> 帮我实现用户管理模块，包括以下功能：

  1. 用户注册（账号 + 密码 + 邮箱）

  2. 用户登录（返回 JWT Token）

  3. 根据 ID 查询用户信息

  4. 更新用户信息（昵称、头像等）

  5. 密码加密存储（使用 BCrypt）

  6. 注册时校验邮箱格式和密码强度

  请在 Controller、Service、Mapper 层分别实现。

  所有方法都必须有详细的中文注释。

  为 Service 层编写单元测试。

1

2

3

4

5

6

7

8

> 帮我实现商品管理模块：

  1. 商品实体包含：商品名、描述、价格、库存、分类、图片URL

  2. 支持商品列表的分页查询（可按分类筛选、按价格排序）

  3. 支持商品详情查询

  4. 支持商品搜索（根据名称模糊搜索）

  5. 管理员可以新增、修改、下架商品

  同样实现 Controller、Service、Mapper 三层。

  包含详细注释和单元测试。

1

2

3

4

5

6

7

8

> 帮我实现购物车模块：

  1. 用户可以把商品加入购物车（指定数量）

  2. 用户可以修改购物车中商品的数量

  3. 用户可以从购物车中删除商品

  4. 用户可以查看自己的购物车列表

  5. 购物车数据存储在 Redis 中

  6. 同一个商品重复添加时，数量累加

  需要配置 Redis 连接，实现 Redis 操作的工具类。

1

2

3

4

5

6

7

8

> 帮我实现订单模块：

  1. 用户可以从购物车生成订单

  2. 订单包含：订单号、用户ID、商品列表、总金额、状态

  3. 订单状态流转：待支付 → 已支付 → 已发货 → 已完成 → 已取消

  4. 用户可以查看自己的订单列表

  5. 用户可以取消待支付的订单

  6. 生成订单时自动扣减库存（使用数据库事务确保数据一致性）

  7. 使用 @Transactional 注解管理事务

1

2

3

4

5

6

7

8

9

> 帮我实现全局异常处理：

  1. 创建自定义业务异常类 BusinessException

  2. 使用 @ControllerAdvice 实现全局异常拦截

  3. 不同的异常类型返回对应的 HTTP 状态码和错误信息

  4. 常见异常的处理：

     - 参数校验失败 → 400

     - 资源不存在 → 404

     - 业务逻辑错误 → 422

     - 服务器内部错误 → 500

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

Bug 处理流程图

═══════════════════════════════════════════════════════════

  发现 Bug（启动报错 / 功能不正常 / 测试失败）

       │

       ▼

┌──────────────────┐

│ 把错误信息完整地  │  ← 复制粘贴，不要遗漏任何信息

│ 复制给 Claude Code │

└──────┬───────────┘

       │

       ▼

┌──────────────────┐

│ Claude Code 分析  │

│ 错误原因          │

└──────┬───────────┘

       │

       ▼

┌──────────────────┐

│ Claude Code 提出  │

│ 修复方案          │

└──────┬───────────┘

       │

       ▼

┌──────────────────┐

│ 你确认 → 修复     │

└──────┬───────────┘

       │

       ▼

┌──────────────────┐

│ Claude Code 运行  │

│ 测试验证修复       │

└──────┬───────────┘

       │

       ▼

  测试通过？

   │    │

  是   否 → 返回分析步骤，重新调试

   │

   ▼

  Bug 已修复！

1

2

3

4

5

6

7

8

9

10

11

> 帮我部署这个 OCP 项目。我的服务器环境是：

  - 操作系统：Linux (Ubuntu 20.04)

  - 已安装 Docker 和 Docker Compose

  - 数据库：MySQL 8.0

  - 需要配置 Nginx 反向代理

  请帮我：

  1. 创建 Dockerfile（把项目打包成 Docker 镜像）

  2. 创建 docker-compose.yml（编排 MySQL + Redis + 应用）

  3. 创建 Nginx 配置文件

  4. 生成部署脚本 deploy.sh

  5. 写出详细的部署步骤文档 DEPLOY.md

1

2

3

4

5

6

7

8

9

10

11

# Dockerfile —— 把 Java 应用打包成容器镜像

# 使用官方的 OpenJDK 11 镜像作为基础

FROM openjdk:11-jre-slim

# 设置容器内的工作目录

WORKDIR /app

# 把编译好的 jar 包复制到容器中

COPY target/ocp-platform-1.0.0.jar app.jar

# 暴露 8080 端口（Spring Boot 默认端口）

EXPOSE 8080

# 容器启动时执行的命令

ENTRYPOINT ["java", "-jar", "app.jar"]

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

OCP 项目从零到部署的完整对话流程

═══════════════════════════════════════════════════════════

  第 1 步：创建项目骨架

  "帮我创建一个标准的 Spring Boot 项目骨架……"

                    │

                    ▼

  第 2 步：初始化 CLAUDE.md

  /init（让 Claude Code 理解你的项目）

                    │

                    ▼

  第 3 步：逐个实现功能模块

  ┌─────────────────────────────────────┐

  │ 用户模块 → 商品模块 → 购物车模块       │

  │ → 订单模块 → 异常处理 → 日志配置       │

  └─────────────────────────────────────┘

  每完成一个模块，运行测试验证

                    │

                    ▼

  第 4 步：集成测试

  "帮我写一个端到端的集成测试……"

                    │

                    ▼

  第 5 步：部署上线

  "帮我创建 Dockerfile 和部署脚本……"

                    │

                    ▼

  ? 项目完成！

1

2

3

4

5

6

7

8

9

10

11

12

学习成果检查清单

═══════════════════════════════════════════════════════════

  □ 理解 Claude Code 是什么，能做什么

  □ 独立完成 Claude Code 的安装和配置

  □ 掌握基础的对话和指令技巧

  □ 理解上下文（Context）、Token、工具（Tools）等核心概念

  □ 能够用自然语言让 AI 读取、搜索、修改代码文件

  □ 理解 CLAUDE.md 文件的作用

  □ 能够管理一个完整的多文件项目

  □ 了解 MCP、Skills、Hooks 等高级功能

  □ 能够从零开始完成一个 OCP 项目的开发

  □ 知道遇到问题该如何排查

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

Claude Code 五条黄金法则

════════════════════════════════════════════════════════════

  1??  你是导演，AI 是演员

      你负责告诉 AI "要演什么"，AI 负责具体的"表演"

      你不需要知道怎么写代码，但需要清楚地描述你想要的结果

  2??  越具体，结果越好

      "帮我写个用户登录功能" 不如

      "帮我写一个用户登录接口，接收用户名和密码，

       验证成功后返回 JWT Token，失败返回错误信息"

  3??  迭代比一次完美更重要

      先让 AI 做出一个能用的版本，然后再逐步优化

      不要试图第一次就把所有细节都说清楚

  4??  善用 AI 的眼睛

      让 AI 帮你读代码、搜代码、分析代码

      你只需要做决策

  5??  保持"人在回路中"

      AI 是强大的工具，但最终的决定权在你手里

      审查 AI 的修改，理解 AI 的逻辑，做出自己的判断

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

进阶学习路径

═══════════════════════════════════════════════════════════

  初学者 ──→ 本教程 ──→ 用 Claude Code 做一个小项目

                            │

                            ▼

                    阅读 Claude Code 官方文档

                    了解更高级的配置选项

                            │

                            ▼

                    学习 MCP 协议

                    连接 GitHub、数据库等外部服务

                            │

                            ▼

                    编写自定义 Skills

                    让 Claude Code 更适配你的工作流

                            │

                            ▼

                    配置 Hooks

                    实现自动化工作流

                            │

                            ▼

                    掌握 Workflow

                    实现多 AI 并行处理复杂任务