Claude Code 完整学习手册
文章目录
- [Claude Code 完整学习手册](#Claude Code 完整学习手册)
- [第一章：AI 黑话入门（必须先看懂）](#第一章：AI 黑话入门（必须先看懂）)
-
- [1.1 AI 是什么？](#1.1 AI 是什么？)
- [1.2 LLM 是什么？](#1.2 LLM 是什么？)
- [1.3 Token 是什么？](#1.3 Token 是什么？)
- [1.4 Prompt 是什么？](#1.4 Prompt 是什么？)
-
- [为什么 Prompt 重要？](#为什么 Prompt 重要？)
- [好 Prompt 的公式](#好 Prompt 的公式)
- [坏 Prompt vs 好 Prompt](#坏 Prompt vs 好 Prompt)
- [常用 Prompt 技巧](#常用 Prompt 技巧)
- [1.5 Context 是什么？](#1.5 Context 是什么？)
- [1.6 Temperature 是什么？](#1.6 Temperature 是什么？)
- [1.7 Hallucination 是什么？](#1.7 Hallucination 是什么？)
- [1.8 Agent 是什么？](#1.8 Agent 是什么？)
-
- [LLM vs Agent](#LLM vs Agent)
- [Agent 的三件套](#Agent 的三件套)
- [Agent 能做什么？](#Agent 能做什么？)
- [1.9 RAG 是什么？](#1.9 RAG 是什么？)
-
- 解决什么问题？
- [RAG 工作原理](#RAG 工作原理)
- [RAG 适用场景](#RAG 适用场景)
- [1.10 Embedding 是什么？](#1.10 Embedding 是什么？)
-
- 解决什么问题？
- [Embedding 的原理](#Embedding 的原理)
- [Embedding 的应用](#Embedding 的应用)
- [1.11 Fine-tuning 是什么？](#1.11 Fine-tuning 是什么？)
-
- 对比理解
- [Fine-tuning vs Prompt Engineering](#Fine-tuning vs Prompt Engineering)
- [什么时候用 Fine-tuning？](#什么时候用 Fine-tuning？)
- [第二章：Claude Code 是什么](#第二章：Claude Code 是什么)
-
- [2.1 一句话定位](#2.1 一句话定位)
- [2.2 Claude Code 能做什么？](#2.2 Claude Code 能做什么？)
- [2.3 Claude Code 的核心优势](#2.3 Claude Code 的核心优势)
- [2.4 Claude Code 工作原理](#2.4 Claude Code 工作原理)
- [2.5 Claude Code 工具一览](#2.5 Claude Code 工具一览)
- 第三章：核心概念深度理解
-
- [3.1 为什么 Claude Code 是 Agent？](#3.1 为什么 Claude Code 是 Agent？)
- [3.2 Claude Code 的记忆机制](#3.2 Claude Code 的记忆机制)
- [3.3 Claude Code 的规划能力](#3.3 Claude Code 的规划能力)
- [3.4 Claude Code 的自我纠错](#3.4 Claude Code 的自我纠错)
- 第四章：终端实战操作
- [第五章：IDE 整合](#第五章：IDE 整合)
-
- [5.1 为什么要在 IDE 中用？](#5.1 为什么要在 IDE 中用？)
- [5.2 安装 Claude for IntelliJ IDEA](#5.2 安装 Claude for IntelliJ IDEA)
- [5.3 IDE 核心功能](#5.3 IDE 核心功能)
-
- [5.3.1 代码补全（Inline Completion）](#5.3.1 代码补全（Inline Completion）)
- [5.3.2 代码生成](#5.3.2 代码生成)
- [5.3.3 代码解释](#5.3.3 代码解释)
- [5.3.4 代码审查](#5.3.4 代码审查)
- [5.3.5 Bug 修复](#5.3.5 Bug 修复)
- [5.4 快捷键速查](#5.4 快捷键速查)
- [5.5 组合工作流（推荐）](#5.5 组合工作流（推荐）)
- 第六章：高级技巧与最佳实践
-
- [6.1 编写优秀 Prompt 的技巧](#6.1 编写优秀 Prompt 的技巧)
-
- [6.1.1 包含足够的上下文](#6.1.1 包含足够的上下文)
- [6.1.2 指定输出格式](#6.1.2 指定输出格式)
- [6.1.3 让它一步步思考](#6.1.3 让它一步步思考)
- [6.2 管理长对话](#6.2 管理长对话)
-
- [6.2.1 主动总结](#6.2.1 主动总结)
- [6.2.2 分解成多个会话](#6.2.2 分解成多个会话)
- [6.3 处理敏感信息](#6.3 处理敏感信息)
- [6.4 验证 AI 的输出](#6.4 验证 AI 的输出)
- 第七章：故障排查
-
- [7.1 常见问题](#7.1 常见问题)
- [7.2 遇到 API Error: 529](#7.2 遇到 API Error: 529)
- [7.3 上下文满了](#7.3 上下文满了)
- 第八章：学习路径与练习计划
-
- [8.1 四阶段学习路径](#8.1 四阶段学习路径)
- [8.2 练习任务清单](#8.2 练习任务清单)
- [8.3 每天 30 分钟练习法](#8.3 每天 30 分钟练习法)
- [8.4 学习资源推荐](#8.4 学习资源推荐)
- 附录：名词速查表
- 附录：命令速查
从零玩转 AI 编程，一册通关
目录
- [第一章：AI 黑话入门（必须先看懂）](#第一章：AI 黑话入门（必须先看懂）)
- [第二章：Claude Code 是什么](#第二章：Claude Code 是什么)
- 第三章：核心概念深度理解
- 第四章：终端实战操作
- [第五章：IDE 整合](#第五章：IDE 整合)
- 第六章：高级技巧与最佳实践
- 第七章：故障排查
- 第八章：学习路径与练习计划
第一章：AI 黑话入门（必须先看懂）
1.1 AI 是什么？
AI = Artificial Intelligence，人工智能
简单说：让机器具备类似人的思考和决策能力
传统程序：IF ELSE → 写死规则 → 固定输出
AI程序： 训练学习 → 自己找规律 → 智能输出AI 能做什么？
- 识别图片（猫狗分类）
- 听懂语音（Siri、小爱）
- 读懂文字（翻译、摘要）
- 生成内容（写作、画图、编程）
1.2 LLM 是什么？
LLM = Large Language Model，大语言模型
一句话理解
把 LLM 想象成一个读完了整个互联网的人
它不会真的"思考"，而是根据见过的内容，预测下一个最可能出现的字
举个例子
你输入："今天天气真"
它思考：下一个字最可能是什么？
- "好" → 概率 80%
- "糟" → 概率 15%
- "不" → 概率 5%
它选概率最高的，所以输出 "好"这就是"文字接龙"
输入：今天天气真
输出：好
输入：今天天气真好
输出：，适合出去
输入：今天天气真好， 适合出去
输出：踏青
...LLM 就是这样，一个字一个字地往外接。
常见 LLM 模型
| 模型 | 公司 | 特点 | 费用 |
|---|---|---|---|
| GPT-4 | OpenAI | 能力强，生态好 | 收费 |
| GPT-3.5 | OpenAI | 免费但能力有限 | 免费 |
| Claude 3 | Anthropic | 长上下文、安全性强 | 收费 |
| Gemini | 多模态、谷歌生态 | 收费 | |
| 通义千问 | 阿里 | 中文友好 | 部分免费 |
| 文心一言 | 百度 | 中文友好 | 部分免费 |
GPT 和 Claude 的区别
GPT-4：
- 生态好，插件多
- 训练数据更新
- 创意能力更强
Claude：
- 长文本更强（能处理更长的代码）
- 安全性更高（不容易乱说）
- 代码能力更强
- 适合复杂代码分析1.3 Token 是什么？
Token = 文字的"计量单位"
为什么要有 Token？
人：按"字"或"词"理解文字
机器：按"数字"理解文字
Token 就是把文字转换成数字的中间单位Token 怎么计算？
1个中文汉字 ≈ 1-2 个 Token
1个英文单词 ≈ 1.5 个 Token
1段话（100字） ≈ 50-150 个 Token实际例子
"Hello, world!"
→ Hello (1) , (1) world (1) ! (1)
→ 4 个 Token
"你好，世界！"
→ 你 (1) 好 (1) ， (1) 世 (1) 界 (1) ！ (1)
→ 6 个 Token
"我想学习 Claude Code"
→ 我 (1) 想 (1) 学 (1) 习 (1) (1) (1)
→ 7 个 Token为什么重要？
1. API 按 Token 收费
输入 Token + 输出 Token = 账单
2. 上下文有上限
GPT-4: 128K Token（≈ 10万字）
Claude 3: 200K Token（≈ 15万字）
3. 控制成本
写简洁的 Prompt 能省钱1.4 Prompt 是什么？
Prompt = 给 AI 的"指令"
为什么 Prompt 重要？
你 → Prompt → AI
↓
Prompt 写得好 = AI 输出质量高
Prompt 写得差 = AI 输出垃圾好 Prompt 的公式
好 Prompt = 角色 + 任务 + 要求 + 例子（可选）
示例：
┌─────────────────────────────────────────────────┐
│ 你是一个有着10年经验的Java架构师（角色） │
│ │
│ 帮我审查这段代码（任务） │
│ │
│ 重点关注： │
│ 1. 是否有线程安全问题 │
│ 2. 是否有性能隐患 │
│ 3. 是否有安全隐患 │
│ （要求） │
└─────────────────────────────────────────────────┘坏 Prompt vs 好 Prompt
❌ 坏 Prompt：
"帮我看看这个代码有什么问题"
✅ 好 Prompt：
"帮我看看 /src/service/UserService.java 这个文件
重点检查：
1. 第 45-60 行的 saveUser 方法是否有线程安全问题
2. 数据库连接是否正确关闭
3. 是否有 SQL 注入风险
请逐条列出问题，并给出修复建议"常用 Prompt 技巧
| 技巧 | 说明 | 例子 |
|---|---|---|
| Zero-shot | 不给例子，直接下命令 | "翻译成英文" |
| Few-shot | 给例子，让它学习 | "apple=苹果, banana=?" |
| Chain-of-Thought | 一步步思考 | "请一步步推理" |
| Role-assignment | 指定角色 | "你是一个资深架构师" |
1.5 Context 是什么？
Context = 对话的记忆/上下文
类比理解
人的记忆：
短期记忆 → 记住刚才说的话
长期记忆 → 记住很久以前的事
AI 的 Context：
就是它的"短期记忆"
只能记住当前对话中的内容上下文窗口
就像手机的运行内存：
- RAM 越大 → 能同时开更多 App
- Context 越大 → 能记住更多内容
GPT-4: 128K Token
Claude 3: 200K Token
相当于：
- GPT-4 能记住约 10 万字
- Claude 3 能记住约 15 万字上下文用完会怎样？
上下文快满时：
AI 会自动"忘记"早期的内容
举个例子：
你让它看一个大项目（10万行代码）
它看完后面的，可能就忘了前面1.6 Temperature 是什么？
Temperature = AI 的"创造力"/"随机性"
一句话理解
低温度（0-0.3）：严谨、保守、答案稳定
→ 1+1=2 （每次都是 2）
高温度（0.7-1.0）：创意、随机、答案多样
→ 1+1=2、王、爱、心意、无限可能...温度怎么选？
| 场景 | 推荐温度 | 原因 |
|---|---|---|
| 写代码 | 0.0-0.3 | 需要精确，不能随机 |
| 回答事实 | 0.0-0.3 | 需要准确，不能编造 |
| 写邮件 | 0.3-0.5 | 正式但可稍有创意 |
| 写文案 | 0.5-0.7 | 需要吸引力 |
| 头脑风暴 | 0.7-1.0 | 需要多样性 |
| 写小说 | 0.7-1.0 | 需要创意 |
1.7 Hallucination 是什么？
Hallucination = AI "一本正经地胡说八道"
为什么会有幻觉？
AI 的训练目标：让输出"听起来正确"
而不是：让输出"事实正确"
所以当它不确定答案时，
它会"编"一个看起来合理的答案幻觉的例子
你：红楼梦的作者是谁？
AI：刘德华
你：不对吧？
AI：哦抱歉，是曹雪芹。如何避免幻觉？
1. 要求提供来源/引用
"请给出你的答案的参考依据"
2. 交叉验证
"这个结论还有其他资料支持吗？"
3. 用 RAG（检索增强）
先查资料库，再回答（后面会讲）
4. 重要信息，自己核实
AI 说的不能全信1.8 Agent 是什么？
Agent = 智能体，能自主行动的 AI
LLM vs Agent
LLM（大脑）：
输入文字 → 输出文字
只能"想"，不能"做"
Agent（大脑+手脚）：
输入文字 → 思考 → 调用工具 → 执行动作 → 反馈结果
不仅能"想"，还能"做"Agent 的三件套
┌─────────────────────────────────────────────────┐
│ Agent 架构 │
├─────────────────────────────────────────────────┤
│ │
│ 🧠 规划 (Planning) │
│ 把大任务拆成小步骤 │
│ 例如："写个APP" → 拆成 → 设计→编码→测试 │
│ │
│ 🔧 工具 (Tools) │
│ 调用各种工具完成任务 │
│ 搜索、计算、读写文件、执行命令 │
│ │
│ 📝 记忆 (Memory) │
│ 记住之前的操作和结果 │
│ 短期记忆（当前对话） │
│ 长期记忆（积累的经验） │
│ │
└─────────────────────────────────────────────────┘Agent 能做什么？
| 能力 | 说明 | 例子 |
|---|---|---|
| 自主规划 | 自动拆解任务 | "升级项目" → 分析 → 改配置 → 验证 |
| 调用工具 | 使用搜索/代码等 | 查资料、跑测试、改代码 |
| 自我纠错 | 错了能修正 | 报错 → 分析原因 → 重试 |
| 多步骤执行 | 完成复杂任务 | 写→测→改→测→交付 |
1.9 RAG 是什么？
RAG = Retrieval-Augmented Generation，检索增强生成
解决什么问题？
问题：大模型的知识有截止日期，可能过时/错误
例如：
你问："iPhone 15 什么时候发布的？"
AI（知识截止2023年）："我不确定..."
解决方案：先查最新资料，再回答RAG 工作原理
┌─────────────────────────────────────────────────┐
│ RAG 工作流程 │
├─────────────────────────────────────────────────┤
│ │
│ 用户问题："iPhone 15 有什么新功能？" │
│ ↓ │
│ ┌─────────────────────────────────────────┐ │
│ │ 1️⃣ 检索 │ │
│ │ 从资料库中查找相关信息 │ │
│ │ 找到：iPhone 15 发布信息、新功能列表 │ │
│ └─────────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────────┐ │
│ │ 2️⃣ 生成 │ │
│ │ 把查到的资料和问题一起给 AI │ │
│ │ "根据以下资料回答：..." │ │
│ └─────────────────────────────────────────┘ │
│ ↓ │
│ AI 给出现答案 │
│ │
└─────────────────────────────────────────────────┘RAG 适用场景
✅ 适用：
- 企业内部知识库问答
- 需要最新信息的场景（新闻、股价）
- 专业领域（法律、医疗）需要准确答案
❌ 不适用：
- 开放式创意写作
- 通用知识问答（事实类）1.10 Embedding 是什么？
Embedding = 把文字变成"坐标"
解决什么问题？
让电脑理解"哪些词意思相近"
例如：
"苹果"和"香蕉" → 距离近 → 都是水果
"苹果"和"手机" → 距离中等 → 有关系但不同
"苹果"和"火车" → 距离远 → 没关系Embedding 的原理
文字 → 转换成数字向量 → 在坐标系中找位置
苹果 → (0.8, 0.2, 0.1, 0.5...)
香蕉 → (0.7, 0.3, 0.2, 0.4...)
火车 → (0.1, 0.1, 0.9, 0.2...)
苹果和香蕉：距离 0.1 → 意思相近
苹果和火车：距离 0.8 → 意思不同Embedding 的应用
| 应用 | 说明 |
|---|---|
| 相似文章推荐 | 找到内容相似的文章 |
| 智能客服 | 理解用户问的是哪类问题 |
| 内容分类 | 自动把文章归类 |
| 搜索增强 | 语义搜索（不只是关键词） |
1.11 Fine-tuning 是什么？
Fine-tuning = 给大模型做"特训"
对比理解
通用大模型（通才）：
什么都会一点，但不精通
例如：GPT-4 能写代码、写文章、做翻译
Fine-tuning（专才）：
在通用基础上，专门训练某个领域
例如：专门训练医学知识 → 医疗AI
专门训练法律知识 → 法律AIFine-tuning vs Prompt Engineering
| Fine-tuning | Prompt Engineering | |
|---|---|---|
| 成本 | 高（需要训练） | 低（改文字） |
| 周期 | 几天到几周 | 立刻 |
| 效果 | 永久改变 | 每次对话要重复 |
| 适用 | 大量相似场景 | 灵活多变的场景 |
什么时候用 Fine-tuning？
用 Prompt Engineering：
- 场景变化多
- 数据量少
- 需要快速验证
用 Fine-tuning：
- 场景固定、数据量大
- 需要模型行为统一
- 长期成本考虑第二章：Claude Code 是什么
2.1 一句话定位
Claude Code = Claude（会思考）+ 工具（会执行）
= 能读代码、能写代码、能跑代码的智能助手2.2 Claude Code 能做什么？
┌─────────────────────────────────────────────────┐
│ Claude Code 能力矩阵 │
├─────────────────────────────────────────────────┤
│ │
│ 📖 读代码 │
│ • 理解项目结构 │
│ • 读懂代码逻辑 │
│ • 解释代码在干什么 │
│ │
│ ✍️ 写代码 │
│ • 生成新代码 │
│ • 补全代码 │
│ • 添加注释 │
│ │
│ 🔧 改代码 │
│ • 重构优化 │
│ • 修复 Bug │
│ • 性能优化 │
│ │
│ 🎯 做任务 │
│ • 拆解复杂需求 │
│ • 自动执行多步骤 │
│ • 自我纠错验证 │
│ │
│ 🔍 搜索 │
│ • 项目内搜索 │
│ • 定位文件 │
│ • 理解依赖关系 │
│ │
└─────────────────────────────────────────────────┘2.3 Claude Code 的核心优势
vs ChatGPT：
✅ 能直接操作文件
✅ 能执行终端命令
✅ 能在项目中搜索
✅ 不会打断你的工作流
vs 传统 IDE：
✅ 能理解业务逻辑
✅ 能解释复杂代码
✅ 能做代码审查
✅ 能帮你设计架构2.4 Claude Code 工作原理
┌─────────────────────────────────────────────────┐
│ Claude Code 工作原理 │
├─────────────────────────────────────────────────┤
│ │
│ 你：帮我把这个函数改成线程安全的 │
│ ↓ │
│ ┌─────────────────────────────────────────┐ │
│ │ 理解任务 │ │
│ │ "用户想让我修改某个函数的线程安全" │ │
│ └─────────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────────┐ │
│ │ 读取文件 │ │
│ │ 使用 Read 工具读取代码 │ │
│ └─────────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────────┐ │
│ │ 分析代码 │ │
│ │ 理解函数逻辑，找出线程安全问题 │ │
│ └─────────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────────┐ │
│ │ 生成修改 │ │
│ │ 使用 Edit 工具修改代码 │ │
│ └─────────────────────────────────────────┘ │
│ ↓ │
│ ┌─────────────────────────────────────────┐ │
│ │ 验证结果 │ │
│ │ 可选：运行测试验证修改正确 │ │
│ └─────────────────────────────────────────┘ │
│ ↓ │
│ 返回修改结果给用户 │
│ │
└─────────────────────────────────────────────────┘2.5 Claude Code 工具一览
| 工具 | 命令/用法 | 能做什么 |
|---|---|---|
| Read | 读取文件 | 看文件内容 |
| Edit | 修改文件 | 精确替换某处 |
| Write | 写文件 | 创建/覆盖文件 |
| Bash | 执行命令 | 运行终端命令 |
| Glob | 搜索文件 | 按模式找文件 |
| Grep | 搜索内容 | 在文件中找关键词 |
| WebFetch | 获取网页 | 抓取网页内容 |
第三章：核心概念深度理解
3.1 为什么 Claude Code 是 Agent？
Claude（LLM）：只能输入文字、输出文字
→ 像个"只会出主意的人"
Claude Code：Claude + Tools + Memory + Planning
→ 像个"能自己出去打仗的将军"
所以 Claude Code 是 Agent 的一种实现3.2 Claude Code 的记忆机制
┌─────────────────────────────────────────────────┐
│ Claude Code 记忆分层 │
├─────────────────────────────────────────────────┤
│ │
│ 🔵 瞬时记忆（当前输入） │
│ 你现在说的这句话 │
│ │
│ 🟢 短期记忆（对话上下文） │
│ 当前 Session 的对话历史 │
│ 约 200K Token │
│ │
│ 🟡 项目记忆（项目上下文） │
│ 项目结构、技术栈、之前的修改 │
│ 通过 Prompt 传递 │
│ │
│ 🔴 系统记忆（内置知识） │
│ 训练时学到的知识 │
│ 有截止日期 │
│ │
└─────────────────────────────────────────────────┘3.3 Claude Code 的规划能力
当你给一个大任务时：
"帮我把项目从 Java 8 升级到 Java 17"
Claude Code 的思考过程：
┌─────────────────────────────────────────────────┐
│ Step 1: 分析任务 │
│ "这是一个项目升级任务，需要分步执行" │
├─────────────────────────────────────────────────┤
│ Step 2: 拆解步骤 │
│ 1. 找到构建配置文件（pom.xml/build.gradle） │
│ 2. 检查 Java 版本配置 │
│ 3. 检查依赖兼容性 │
│ 4. 修改配置 │
│ 5. 运行测试验证 │
├─────────────────────────────────────────────────┤
│ Step 3: 逐个执行 │
│ → 执行每个步骤 │
├─────────────────────────────────────────────────┤
│ Step 4: 验证结果 │
│ 测试通过 → 升级完成 │
│ 测试失败 → 分析原因 → 修复 → 重新测试 │
└─────────────────────────────────────────────────┘3.4 Claude Code 的自我纠错
正常流程：
执行 → 成功 → 返回结果
纠错流程：
执行 → 报错 → 分析原因 → 修正 → 重试 → 成功
示例：
┌─────────────────────────────────────────────────┐
│ 你：运行 python main.py │
│ │
│ Claude：执行命令 │
│ ↓ │
│ 报错：ModuleNotFoundError: requests │
│ ↓ │
│ 分析：缺少 requests 库 │
│ ↓ │
│ 执行：pip install requests │
│ ↓ │
│ 再次运行：python main.py │
│ ↓ │
│ 成功！ │
└─────────────────────────────────────────────────┘第四章：终端实战操作
4.1 启动 Claude Code
bash
# 方式1：直接启动
claude
# 方式2：带着文件/文件夹启动
claude ./my-project
claude ./src/main/java/App.java
# 方式3：后台运行
claude &4.2 基本操作命令
| 命令 | 说明 |
|---|---|
/help |
查看帮助 |
/clear |
清除对话历史 |
exit |
退出 |
Ctrl+C |
取消当前操作 |
4.3 正确提问的方式
┌─────────────────────────────────────────────────┐
│ 正确提问公式 │
├─────────────────────────────────────────────────┤
│ │
│ 目标 + 路径/文件 + 具体要求 │
│ │
│ ✅ 好问题： │
│ "帮我看看 src/service/UserService.java │
│ 这个 saveUser 方法是否有线程安全问题" │
│ │
│ ❌ 差问题： │
│ "帮我看看这个代码" │
│ │
└─────────────────────────────────────────────────┘4.4 任务拆解法
❌ 一次说太多：
"帮我重构整个项目，从架构到代码全改了"
✅ 分步骤说：
"第一步：帮我分析项目当前的结构和依赖
第二步：列出需要重构的主要模块
第三步：先从 User 模块开始重构
第四步：完成后测试验证
..."4.5 指定角色和背景
✅ 有效提问：
"你是一个有10年经验的 Java 架构师
我们的项目使用 Spring Boot 2.7 + MySQL 8.0
帮我审查 src/service/OrderService.java
重点关注：
1. 事务使用是否正确
2. 是否有性能问题
3. 是否符合阿里巴巴开发规范"4.6 让 Claude 记住重要信息
在对话开始时说：
"记住：我们的项目是 Spring Boot 2.7 + MySQL 8.0 + Redis 6.0"
或者在项目中创建 .claude 文件存储项目信息4.7 黄金法则总结
法则1：说清楚，不要让它猜
法则2：给背景，别当搜索引擎用
法则3：大任务拆开说
法则4：重要信息让它记住
法则5：不确定就让它一步步思考4.8 常用场景示例
场景1：接手新项目
你：帮我了解一下这个项目，重点关注：
1. 用的什么技术栈
2. 核心业务逻辑在哪
3. 有没有文档或 README
4. 如何运行这个项目场景2：写新功能
你：帮我新增一个"用户头像上传"功能
技术栈：Spring Boot + OSS
要求：
1. 图片大小限制 5M
2. 只允许 jpg/png/webp
3. 生成缩略图
4. 返回 URL
先设计接口，确认后写代码场景3：代码审查
你：帮我 review 这个 PR 的改动
重点检查：
1. 是否有潜在 bug
2. 是否有安全隐患
3. 代码风格是否一致
4. 是否有性能问题场景4：调试问题
你：用户反馈支付接口偶发性超时
日志在 /var/logs/payment.log
帮我分析可能的原因第五章：IDE 整合
5.1 为什么要在 IDE 中用？
终端模式：
✅ 快速提问
✅ 执行多步骤任务
✅ 文件操作方便
❌ 代码需要复制粘贴
❌ 不能精准看到光标位置
IDE 插件模式：
✅ 代码直接补全
✅ 光标位置精准
✅ 直接在文件内修改
✅ 代码审查更直观
❌ 复杂任务不如终端5.2 安装 Claude for IntelliJ IDEA
步骤：
1. 打开 IntelliJ IDEA
2. Settings → Plugins
3. 搜索 "Claude"
4. 找到 "Claude for IntelliJ IDEA"
5. 点击 Install
6. 重启 IDEA
7. Settings → Tools → Claude → 配置 API Key5.3 IDE 核心功能
5.3.1 代码补全（Inline Completion）
你正在输入：
public String getUserName() {
return █
}
Claude 自动提示（灰色）：
public String getUserName() {
return userName;█
}
按 Tab 接受，Esc 拒绝5.3.2 代码生成
操作：
右键 → Generate → Claude
或快捷键：Ctrl+Shift+P (Win) / Cmd+Shift+P (Mac)
输入需求：
"生成一个根据 ID 查询用户的 Service 方法"
结果：
Claude 生成代码，插入光标位置5.3.3 代码解释
操作：
选中代码 → 右键 → Explain with Claude
结果：
弹出窗口显示：
"这个方法用于计算订单总价：
1. 遍历订单商品列表
2. 累加价格 × 数量
3. 应用折扣码（如果有）
4. 返回最终金额"5.3.4 代码审查
操作：
选中代码 → 右键 → Review with Claude
结果：
┌──────────────────────────────────────┐
│ ⚠️ 安全问题 │
│ 第45行：SQL拼接存在注入风险 │
│ 建议：使用预编译语句 │
├──────────────────────────────────────┤
│ ⚡ 性能问题 │
│ 第23行：N+1 查询问题 │
├──────────────────────────────────────┤
│ ✅ 代码规范 │
│ 整体结构清晰，命名规范 │
└──────────────────────────────────────┘5.3.5 Bug 修复
操作：
1. 代码有红色波浪线（编译错误）
2. 光标移到错误处
3. Alt+Enter (Win) / Option+Enter (Mac)
4. 选择 "Claude Fix"
结果：
Claude 分析错误原因
自动修复代码5.4 快捷键速查
| 功能 | Windows/Linux | Mac |
|---|---|---|
| 打开 Claude 对话 | Ctrl+Shift+P | Cmd+Shift+P |
| 代码补全接受 | Tab | Tab |
| 代码解释 | Ctrl+Shift+E | Cmd+Shift+E |
| 代码审查 | Ctrl+Shift+R | Cmd+Shift+R |
| Bug 修复 | Alt+Enter | Option+Enter |
5.5 组合工作流（推荐）
┌─────────────────────────────────────────────────┐
│ 黄金组合工作流 │
├─────────────────────────────────────────────────┤
│ │
│ 1️⃣ 终端 Claude Code：了解项目 │
│ "帮我分析这个项目的结构" │
│ │
│ 2️⃣ IDE 插件：写代码 │
│ 写业务逻辑、代码补全 │
│ │
│ 3️⃣ IDE 插件：遇到 Bug │
│ Alt+Enter → Claude Fix │
│ │
│ 4️⃣ IDE 插件：代码审查 │
│ 右键 → Review with Claude │
│ │
│ 5️⃣ 终端 Claude Code：大改动 │
│ 重构、迁移、批量修改 │
│ │
└─────────────────────────────────────────────────┘第六章：高级技巧与最佳实践
6.1 编写优秀 Prompt 的技巧
6.1.1 包含足够的上下文
❌ 差的 Prompt：
"帮我优化这个查询"
✅ 好的 Prompt：
"帮我优化这个 SQL 查询
当前执行时间：5秒
表结构：
- orders（订单表，1000万条数据）
- users（用户表，100万条数据）
当前 SQL：
SELECT * FROM orders o, users u
WHERE o.user_id = u.id AND u.level = 'VIP'
问题：没有索引，走了全表扫描
请优化并解释原因"6.1.2 指定输出格式
你：帮我写一个用户注册接口
要求返回：
1. 接口签名（参数、返回值）
2. 完整的 Java 代码
3. 代码注释
4. 单元测试示例
5. Postman 测试示例6.1.3 让它一步步思考
你：一步步思考，分析这个算法的时间复杂度和空间复杂度
Claude 思考过程：
1. 首先看循环结构...
2. 外层循环 O(n)...
3. 内层循环 O(n)...
4. 所以总复杂度是 O(n²)...6.2 管理长对话
6.2.1 主动总结
在长对话中间说：
"请总结一下我们之前讨论的内容，然后继续下一个话题"6.2.2 分解成多个会话
大型项目：
Session 1：了解项目结构
Session 2：做代码重构
Session 3：写新功能
Session 4：代码审查6.3 处理敏感信息
✅ 可以给：
- 代码逻辑
- 项目结构
- 业务需求
❌ 不要给：
- 密码、密钥
- API Key
- 用户隐私数据
- 商业机密6.4 验证 AI 的输出
重要操作的验证流程：
┌─────────────────────────────────────────────────┐
│ 1️⃣ 让 AI 生成修改 │
│ ↓ │
│ 2️⃣ 仔细检查修改内容是否正确 │
│ ↓ │
│ 3️⃣ 如果可能，运行测试验证 │
│ ↓ │
│ 4️⃣ 如果有问题，让 AI 修复 │
│ ↓ │
│ 5️⃣ 重复直到正确 │
└─────────────────────────────────────────────────┘第七章：故障排查
7.1 常见问题
| 问题 | 原因 | 解决 |
|---|---|---|
| 回答不相关 | Prompt 太模糊 | 说得更具体 |
| 代码有bug | AI 也会犯错 | 一定要测试验证 |
| 上下文丢失 | 对话太长 | 开启新会话 |
| 拒绝执行 | 危险操作 | 确认是否真的需要 |
| 运行报错 | 环境问题 | 检查环境配置 |
7.2 遇到 API Error: 529
错误：API Error: 529 - 服务集群负载较高
处理：自动重试（代码已配置）
如果持续出现：等待几分钟后重试7.3 上下文满了
现象：Claude 开始"忘记"之前的内容
解决：
1. 让它总结之前的内容："总结我们讨论的要点"
2. 开启新会话，把总结作为背景
3. 减少对话长度，一次性给更多上下文第八章：学习路径与练习计划
8.1 四阶段学习路径
┌─────────────────────────────────────────────────┐
│ Claude Code 学习路径 │
├─────────────────────────────────────────────────┤
│ │
│ 第一阶段：入门（1-2天） │
│ ├── 理解 LLM、Token、Prompt 基础概念 │
│ ├── 会启动 Claude Code │
│ ├── 能进行简单对话 │
│ └── 完成：让 AI 帮你解释一段代码 │
│ │
│ 第二阶段：会用（3-7天） │
│ ├── 熟练写好 Prompt │
│ ├── 能让它读写文件 │
│ ├── 能让它执行命令 │
│ ├── 完成：独立完成一个小功能开发 │
│ │
│ 第三阶段：熟练（1-2周） │
│ ├── 掌握 Agent 思维（拆解任务） │
│ ├── 能做代码审查 │
│ ├── 能调试和修复 Bug │
│ ├── 完成：在真实项目中使用 │
│ │
│ 第四阶段：精通（长期） │
│ ├── IDE 整合使用 │
│ ├── 复杂任务拆解 │
│ ├── 建立个人最佳实践 │
│ └── 总结自己的使用方法论 │
│ │
└─────────────────────────────────────────────────┘8.2 练习任务清单
Day 1-2：入门练习
□ 练习1：让 AI 解释你不熟悉的代码
□ 练习2：让 AI 帮你写一个简单函数
□ 练习3：了解 API Key 配置
Day 3-5：文件操作
□ 练习4：让 AI 读取并分析项目结构
□ 练习5：让 AI 创建新文件
□ 练习6：让 AI 修改现有文件
□ 练习7：让 AI 搜索项目中的关键词
Day 6-7：命令执行
□ 练习8：让 AI 运行测试命令
□ 练习9：让 AI 帮你执行 Git 操作
□ 练习10：让 AI 帮你分析错误日志
Week 2：综合实战
□ 练习11：让 AI 帮你重构一个模块
□ 练习12：让 AI 做 Code Review
□ 练习13：让 AI 帮你调试一个 Bug
□ 练习14：让 AI 帮你设计一个新功能
Week 3-4：IDE 整合
□ 练习15：安装 IDE 插件
□ 练习16：使用代码补全
□ 练习17：使用代码解释
□ 练习18：使用 Bug 修复
□ 练习19：使用代码审查
□ 练习20：组合工作流实战8.3 每天 30 分钟练习法
┌─────────────────────────────────────────────────┐
│ 每天 30 分钟练习计划 │
├─────────────────────────────────────────────────┤
│ │
│ 早上 10 分钟： │
│ → 让 AI 解释你昨天写的某段代码 │
│ │
│ 下午 10 分钟： │
│ → 用 AI 写一个小功能/工具类 │
│ │
│ 晚上 10 分钟： │
│ → 复盘：AI 帮了你什么？还能怎么用？ │
│ │
└─────────────────────────────────────────────────┘8.4 学习资源推荐
官方文档：
- Claude Code 官方文档
- Anthropic API 文档
社区：
- GitHub Issues（Claude Code）
- Reddit r/ClaudeAI
实践：
- 在真实项目中练习
- 尝试让 AI 帮你做不同类型的工作附录：名词速查表
| 缩写 | 全称 | 一句话 |
|---|---|---|
| AI | Artificial Intelligence | 人工智能 |
| LLM | Large Language Model | 大语言模型 |
| NLP | Natural Language Processing | 自然语言处理 |
| GPT | Generative Pre-trained Transformer | 生成式预训练模型 |
| API | Application Programming Interface | 程序接口 |
| Token | - | 文字计量单位 |
| Prompt | - | 给 AI 的指令 |
| Context | - | 对话上下文 |
| Temperature | - | 创造力/随机性 |
| Hallucination | - | AI 胡说八道 |
| Agent | - | 能自主行动的 AI |
| RAG | Retrieval-Augmented Generation | 检索增强生成 |
| Embedding | - | 文字变坐标 |
| Fine-tuning | - | 给 AI 特训 |
附录：命令速查
bash
# 终端启动
claude # 直接启动
claude ./project # 带项目启动
claude & # 后台运行
# 常用命令
/help # 查看帮助
/clear # 清除历史
exit # 退出
Ctrl+C # 取消最后记住
- LLM = 超级文字接龙高手（只会猜下一个字）
- Agent = 大脑 + 手脚（Claude Code = Agent）
- Prompt = 你跟 AI 说话的方式（说清楚很重要）
- 最好的学习方式 = 用！用它干活！
本手册完