让 AI 替你写代码：Claude Code 完全配置与高效使用手册

你每天花多少时间在写重复代码、改 bug、查文档？如果有一个队友 24 小时在线、随叫随到、从不抱怨你写的烂代码，而且还能帮你写注释------你愿意试试吗？

---

一、Claude Code 是什么

它不是又一个聊天机器人

Claude Code 是 Anthropic 推出的终端 AI 编程助手。不是 Web 聊天界面里的玩具，而是直接跑在你终端里的开发队友------它能读你的代码、改你的文件、跑你的测试、提你的 PR。你只需要动嘴（其实是动键盘），它动手。

┌──────────────────────────────────────────────┐
│               你的终端                        │
│  ┌─────────────────────────────────────────┐ │
│  │ $ claude                                │ │
│  │ ─────────────────────────────────────── │ │
│  │ 你: 帮我看看这个项目结构                  │ │
│  │ Claude: 这是一个 React + Express 项目... │ │
│  │ 你: 帮我加一个用户注册接口                │ │
│  │ Claude: 好的，我新建了这些文件...         │ │
│  │ ─────────────────────────────────────── │ │
│  │ [✓] src/routes/register.ts 已创建       │ │
│  │ [✓] 测试通过                            │ │
│  └─────────────────────────────────────────┘ │
└──────────────────────────────────────────────┘

简单说，它就是 VS Code Copilot 的 Pro Max Ultra 版本。不是给你补全一行代码，而是帮你完成一整个功能。

在终端里敲 claude 就启动对话模式，像跟同事聊天一样说需求，它就开始干活了。

它能做什么

能力	说明	示例
读写文件	创建、编辑、删除代码文件	"把 logger 加上时间戳"
执行命令	在终端运行任何命令	"跑一下测试"
代码搜索	全局搜索、正则匹配	"找到所有用到旧 API 的地方"
Git 操作	commit、push、创建 PR	"帮我提一个 PR"
代码审查	review 改动、找 bug	"检查这次改动的安全性"
浏览器操作	截图、点击、填表单（需 MCP）	"截一下登录页"
并行任务	同时启动多个子 agent	"一边写 API，一边写测试"

---

二、安装：比别人多花 5 分钟，后面省 500 小时

安装条件

• 操作系统：macOS、Windows（WSL2）、Linux 都行
• Node.js 18+
• 一个 Anthropic 账号（有 Claude Pro 订阅或 API Key）

安装步骤

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

装完在终端敲：

claude

第一次启动会引导你登录：

$ claude
╭──────────────────────────────────────╮
│  Welcome to Claude Code!             │
│                                      │
│  Please authenticate:                │
│                                      │
│  1. Open https://claude.ai/code      │
│  2. Enter the code: XXXXX            │
│                                      │
│  Or paste your API key: [________]   │
╰──────────────────────────────────────╯

扫码或 Key 认证之后，你就拥有了一个 7x24 小时待命的程序员。

升级

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

开发团队两周一个版本，新功能跟得很快，时不时更新一下没坏处。

IDE 集成

Claude Code 也可以作为 VS Code / JetBrains 插件使用，在编辑器侧边栏直接对话，体验和终端一样，但能直接看到文件树和编辑中的代码。

---

三、快速上手：15 分钟从零到生产力

你的第一条指令

进入项目目录，启动 Claude Code：

cd your-project
claude

然后你就可以用自然语言下指令了：

"帮我看看这个项目怎么运行的，先读一下 package.json 和 README"

Claude Code 会自动读文件、理解项目结构，然后告诉你它发现了什么。

你: 帮我看看这个项目怎么运行的，先读一下 package.json 和 README

Claude: 我正在查看项目结构...

📦 项目概览: my-app
├── 框架: React 18 + TypeScript
├── 构建: Vite
├── 测试: Vitest
├── 后端: Express + Prisma + PostgreSQL
├── 主要命令:
│   ├── dev    → vite
│   ├── build  → tsc + vite build
│   ├── test   → vitest
│   └── lint   → eslint
└── 目录结构:
    ├── src/
    │   ├── components/    # UI 组件
    │   ├── pages/         # 页面
    │   ├── hooks/         # 自定义 Hook
    │   ├── api/           # API 封装
    │   └── utils/         # 工具函数
    ├── server/            # Express 后端
    └── prisma/            # 数据库模型

常用操作速览

读写文件：

• "帮我在 src/utils 下新建一个 formatDate.ts，把时间格式化函数放进去"
• "把 login.tsx 第 42 行的接口地址改成正式环境"
• "在 App.tsx 的第 15 行后面加一个路由"

调试：

• "npm run dev 报错了，帮我看看为什么"
• "这个 TypeError: Cannot read property 'data' of undefined 是什么原因"
• "帮我在这个函数里加几个 console.log 看一下参数值"

Git 操作：

• "帮我看看现在的 git 状态"
• "帮我写个 commit message，提交这些改动"
• "看看这个分支和 main 比有哪些不同"

跑测试：

• "运行一下 Login 相关的测试"
• "这个测试挂了，帮我看看为什么"
• "帮我补一下这个组件的单元测试"

交互模式

Claude Code 有两种交互方式：

1. 对话模式 --- 直接敲 claude 进入交互式对话，一问一答
2. 管道模式 --- 用管道传内容进去：

# 问代码相关问题
cat error.log | claude "帮我分析这个错误日志"

# 让 AI 检查配置文件
cat package.json | claude "这个依赖有没有安全漏洞"

# 把 diff 发给 AI review
git diff | claude "帮我 review 这些改动"

对话中插入命令

在对话过程中，如果你想自己跑个命令看看结果，可以用 ! 前缀：

你: 帮我看看项目里有没有 eslint 配置
Claude: 我找一下...

你: 等一下，我自己看看
     !ls .eslint*   ← 这会在当前终端执行，结果回到对话里
     .eslintrc.cjs  .eslintignore

你: 好的，帮我看看 .eslintrc.cjs 的内容

这个功能非常实用------你可以在不让 Claude 离开当前任务的前提下，临时插一条命令看看结果。

---

四、配置文件才是灵魂

很多人装完 Claude Code 直接用，就像买了一辆赛博卡车却只用来买菜------不是不行，但有点浪费。下面这几个配置文件，花半小时配好，后面效率翻倍。

配置文件关系图

项目根目录/
├── .claude/
│   ├── CLAUDE.md           ← 项目规范（最重要的一个）
│   ├── settings.json       ← 权限、环境变量、MCP 配置
│   ├── projects/           ← 子任务专用规则
│   │   ├── frontend.md
│   │   └── backend.md
│   └── scheduled_tasks.json ← 定时任务

用户目录/
└── .claude/
    ├── settings.json       ← 全局配置（所有项目通用）
    └── projects/
        └── memory/          ← 跨项目记忆

优先级：项目配置 > 用户全局配置。项目配了就用项目的，没配的用全局的。

CLAUDE.md：教 AI 懂你的项目

在项目根目录创建 .claude/CLAUDE.md，这是你给 Claude Code 的"入职手册"。有了它，Claude 不再需要从零摸索你的项目。

# 项目规范

## 技术栈
- 前端：React 18 + TypeScript + Tailwind CSS
- 后端：Node.js + Express + Prisma
- 数据库：PostgreSQL

## 代码风格
- 使用函数组件 + Hooks，不用 class 组件
- 别名用 @/ 映射 src/ 目录
- 导出统一用 named export，不要 default export
- 测试用 Vitest，写在 __tests__ 目录下

## 常用命令
- 启动：npm run dev
- 测试：npm run test
- 构建：npm run build
- Lint：npm run lint

## 注意事项
- API 请求都走 hooks/useApi.ts 封装
- 环境变量都在 .env.example 里有定义
- 数据库修改必须通过 Prisma migration

有了这个文件，Claude Code 就不会再猜你用的是什么测试框架、包管理工具是什么、代码风格是什么样的------它直接知道。效率提升不是 10%，是 50%。

更进一步的玩法：把公司内部的 API 文档关键信息也写进去，这样 Claude 调接口时不会发明不存在的参数。

项目记忆

CLAUDE.md 是静态规则，而 .claude/projects/ 下的记忆文件是动态知识库。当你完成一个重要的功能模块，或者发现某个特殊的坑，可以让 Claude 记下来。

---
name: auth-flow
description: 认证流程关键信息
---

用户认证流程：
1. 请求 /api/auth/login 获取 token
2. token 有效期 2 小时，用 axios 拦截器自动刷新
3. 登出时清掉 localStorage 并重定向到 /login

注意：刷新 token 时不要并发请求，用队列串行化

下次你再跟它讨论认证相关的问题，它会自动参考这些记忆。

记忆分四种类型，各有用途：

类型	用途	示例
user	你的角色、偏好、经验	"用户是前端开发者，习惯用 pnpm"
feedback	你纠正过的行为	"不要 mock 数据库，用真实连接测试"
project	项目背景和决策	"这个项目 3 月要上线，先做核心功能"
reference	外部资源位置	"Bug 跟踪在 Linear 的 INGEST 项目"

settings.json：定制行为

.claude/settings.json 可以配置权限、环境变量等全局行为：

{
  "permissions": {
    "allow": [
      "Bash: npm *",
      "Bash: git *",
      "Bash: npx *",
      "Bash: pnpm *"
    ]
  },
  "env": {
    "NODE_ENV": "development"
  }
}

配好之后，日常的 npm/git 操作不会再弹权限确认窗口。但注意，权限白名单只给常用的读操作和安全命令就行，删除类命令保留弹窗确认。

权限管理的三种模式

权限弹窗：每个操作都弹窗确认
    ↓ 安全但有点烦

白名单模式：常见操作直接放行，敏感操作弹窗
    ↓ 推荐大多数场景

黑名单模式：只禁止明确的危险操作，其他全部放行
    ↓ 适合信任 AI 的高级用户

Claude Code 默认是第一种，建议配置到第二种。

{
  "permissions": {
    "allow": ["Bash: npm run *", "Bash: git status"],
    "block": ["Bash: rm -rf *"]
  }
}

还有一个省事的方法：直接对 Claude 说"帮我把常见的 read-only 操作加到权限白名单"，它会扫描你的历史记录，自动整理出合理的允许清单。

---

五、核心技巧：从入门到把 AI 用出花来

1. 指令越具体，结果越靠谱

这不是玄学，是 Claude 的工作原理决定的------你的指令越清晰，它出好结果的概率越高。

❌ 反面教材：

帮我加个登录功能

结果：它会猜你要什么技术栈、什么 UI 库、什么验证规则，猜对了算你运气好。

✅ 正确姿势：

帮我在用户页面加一个邮箱密码登录的表单
- 验证规则：邮箱格式正确、密码至少 8 位
- UI：用 antd 的 Form 组件，风格和现有页面一致
- 提交后调用 /api/auth/login 接口
- 成功后跳转到 /dashboard
- 失败显示 antd 的 message.error 提示

结果：一次到位，几乎不用改。

指令模板（照着这个结构写，效果最好）：

帮我在 [位置] 加一个 [功能]
- 输入/输出：[具体数据]
- 样式/规范：[参考现有代码]
- 异常处理：[错误怎么处理]
- 测试：[要不要加测试]

2. 少说"怎么做"，多说"要什么"

一个常见的误区是试图指挥 AI 的实现细节。更高效的方式是告诉它目标，让它自己决定方案：

✅ "我想优化这个页面的加载性能，首屏加载太慢了，帮我想方案"

而不是：

❌ "把这个组件拆成三个，用 lazy load，再加个 loading 组件..."

让 AI 自己出方案，你不满意再改，通常比你自己一步步指挥快得多。

3. 善用"检查"类指令

Claude Code 一个被低估的能力是代码审查。开发中随时可以：

• "review 一下我这次改动，有没有 bug 或者改进空间"
• "检查一下这个组件有没有内存泄漏"
• "这个 PR 的安全性怎么样，有没有 SQL 注入风险"
• "帮我检查一下 TypeScript 类型有没有问题"

它就像你身边坐了一个 senior 工程师，随时帮你 code review。

4. 并行任务------多个 agent 同时干活

你 ───┬─── Agent A: 写用户管理 API
      ├─── Agent B: 写前端用户列表页面
      ├─── Agent C: 写 API 的单元测试
      └─── 你: 审查每个 agent 的输出

Claude Code 可以启动子 agent 并行工作。比如你同时需要写后端 API、写前端页面、写单元测试，可以让一个 agent 写 API，另一个准备测试数据，各自独立工作。

典型场景：你在实现一个大功能时，可以：

1. 主 agent 做整体协调和架构设计
2. 子 agent 1 去实现数据库模型和 migration
3. 子 agent 2 去写 API 路由
4. 子 agent 3 去写前端组件

你只需要检查每个子 agent 的输出是否符合设计。

5. /loop------重复性任务的救星

当你要频繁执行一个操作时（比如每 5 分钟检查一次部署状态），用 /loop：

/loop 5m "检查部署状态"

它会按设定时间间隔反复执行，直到你让它停。适合监控型任务。

应用场景：

场景	命令
盯着 CI 跑完	/loop 2m "检查 CI 状态"
监控部署进度	/loop 30s "查看部署日志"
定时跑测试	/loop 1h "跑一遍全量测试"
检查 API 健康	/loop 5m "curl 健康检查接口"

6. /fast------能跑就别走

默认 Claude Code 使用深思熟虑模式（默认模型），响应质量高但相对慢。如果你在做简单任务，用 /fast 切换到快速模式，响应更快。

什么场景用 /fast：

• 改个变量名、修个拼写错误
• 跑个简单命令看看结果
• 问一个简单的问题

什么场景切回来：

• 复杂的代码生成
• 大规模重构
• 安全性敏感的代码审查

7. 善用 /clear 重置上下文

对话开始 → 聊了 30 分钟 → 上下文快满了 → Claude 开始"失忆"
    ↓                                                      ↓
  质量好                                              回答开始变差
    ↓                                                      ↓
  用 /clear 清空，但 CLAUDE.md 和 memory 还在 ←──────────┘

对话太长时，Claude 的上下文窗口会被撑满，响应质量下降。如果发现它开始"失忆"了（忘记刚才说过什么），输入 /clear 清空历史对话，然后继续。上下文不在了，但记忆和配置还在。

8. 用管道模式批量处理

Claude Code 支持 Unix 管道，可以和其他命令组合使用：

# 把错误日志喂给 AI 分析
cat error.log | claude "分析这些错误，指出主要原因"

# 检查配置文件
cat package.json | claude "检查依赖版本有没有过时的"

# 批量 review
git diff --cached | claude "review 这些暂存的改动"

# 分析复杂的构建输出
npm run build 2>&1 | claude "构建失败了，帮我分析原因"

9. 用对话历史定位问题

如果 Claude 做了错误的修改，你可以：

你：回滚刚才对 login.tsx 的修改
Claude：好的，已经把 login.tsx 恢复到修改前的状态

Claude Code 记得它在这个对话里做了哪些修改，你可以随时让它回滚。

---

六、MCP：让 AI 长出"手"来

MCP 是什么

MCP（Model Context Protocol）是 Claude Code 连接外部世界的协议。你可以把它理解成 AI 应用的 USB 接口------接上什么，就能做什么。

┌──────────────────────────────────────┐
│            Claude Code                │
│          (大脑/决策中心)               │
└──────────┬───────────────┬───────────┘
           │               │
     ┌─────▼─────┐   ┌────▼────┐
     │  MCP 协议  │   │ 终端工具  │
     │ (USB 接口) │   │(默认能力) │
     └──┬──┬──┬──┘   └─────────┘
        │  │  │
   ┌────▼┐ │ ┌▼──────┐
   │GitHub│ │ │Database│
   └──────┘ │ └───────┘
           ┌▼────┐
           │Browser│
           └──────┘

没有 MCP 时，Claude Code 只能操作文件系统和执行命令。接上 MCP 后，它可以操作浏览器、数据库、GitHub、Slack......

常用的 MCP 服务器

MCP 服务器	用途	典型指令
Puppeteer MCP	操作浏览器、截图	"截一下登录页"
Filesystem MCP	精细文件控制	"把日志文件归档"
GitHub MCP	Issue/PR/Release	"建一个 Release"
Database MCP	执行 SQL	"查一下这个表的数据量"
Slack MCP	发消息查频道	"在群里发个部署通知"
Playwright MCP	E2E 测试	"跑一遍用户注册流程"
Docker MCP	容器管理	"重启这个服务"

配置一个 MCP 服务器

在 .claude/settings.json 中添加：

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@anthropic-ai/mcp-github"]
    },
    "playwright": {
      "command": "npx",
      "args": ["-y", "@anthropic-ai/mcp-playwright"]
    }
  }
}

配置好之后，这些能力就变成 Claude 的"日常技能"了：

你：帮我看看这个 repo 有多少个 open issue
Claude：[使用 GitHub MCP] 当前有 12 个 open issue...

你：帮我在测试环境跑一下用户注册流程
Claude：[使用 Playwright MCP] 打开浏览器 -> 填写表单 -> 提交 -> 截图

Claude Code 原本只能碰你本地的代码，接上 MCP 之后，它能碰的地方就远不止于此了。

写一个简单的 MCP 服务器

如果你有特殊需求，也可以自己写一个简单的 MCP 服务器。一个最小的示例（Node.js）：

import { Server } from "@modelcontextprotocol/sdk/server/index.js";

const server = new Server({
  name: "my-custom-mcp",
  version: "1.0.0"
});

server.setRequestHandler("tools/list", async () => ({
  tools: [{
    name: "weather",
    description: "获取天气信息",
    inputSchema: {
      type: "object",
      properties: { city: { type: "string" } }
    }
  }]
}));

server.setRequestHandler("tools/call", async (request) => {
  if (request.params.name === "weather") {
    const city = request.params.arguments.city;
    return { content: [{ type: "text", text: `${city} 今天晴天，23°C` }] };
  }
});

然后配置到 settings.json 里，Claude 就能调用你自定义的工具了。

---

七、工作流实战：一个完整功能的诞生

下面看一个完整的功能开发流程，感受一下 Claude Code 能帮你到什么程度：

场景：为一个电商项目添加"用户积分"功能

第 1 步：了解项目

你：先看看项目的技术栈和目录结构

Claude：[读文件]
📦 项目技术栈:
├── 前端: Next.js 14 + TypeScript + Tailwind CSS
├── 后端: Next.js API Routes
├── 数据库: PostgreSQL + Prisma ORM
├── 认证: NextAuth.js
└── 测试: Vitest

📁 目录结构:
├── src/
│   ├── app/          # Next.js App Router
│   ├── components/   # 共享组件
│   └── lib/          # 业务逻辑
├── prisma/
│   └── schema.prisma # 数据模型
└── __tests__/

第 2 步：设计数据模型

你：我想给用户加积分功能，帮我在 Prisma schema 里加点数字段

Claude：根据现有 schema，建议这样设计：

1. User 表增加 points 字段（Int，默认 0）
2. 新建 PointLog 表记录积分变动历史

model User {
  id     Int    @id @default(autoincrement())
  email  String @unique
  name   String?
  points Int    @default(0)
  orders Order[]
}

model PointLog {
  id        Int      @id @default(autoincrement())
  userId    Int
  user      User     @relation(fields: [userId], references: [id])
  points    Int      // 正数=增加，负数=消费
  reason    String   // 比如 "order_complete", "redeem"
  createdAt DateTime @default(now())
}

要这样改吗？

你：合理，执行

第 3 步：实现后端逻辑

你：帮我写一个 API，下单成功后给用户加积分，积分 = 订单金额 * 10%

Claude：我看看现有的订单完成逻辑在哪里......找到了，在 src/app/api/orders/[id]/complete/route.ts。
我来修改：

// 订单完成后调用
async function awardPoints(orderId: number) {
  const order = await prisma.order.findUnique({
    where: { id: orderId },
    include: { user: true }
  });

  const points = Math.floor(order.total * 0.1);

  await prisma.$transaction([
    prisma.user.update({
      where: { id: order.userId },
      data: { points: { increment: points } }
    }),
    prisma.pointLog.create({
      data: {
        userId: order.userId,
        points: points,
        reason: "order_complete"
      }
    })
  ]);

  return points;
}


用了事务，确保积分和日志一起成功或一起失败。

第 4 步：实现前端展示

你：在用户个人中心页面加上积分展示卡片，风格保持跟现有页面一致

Claude：找到了你的 profile 页面，现有的卡片风格是圆角白底+阴影。我来在个人信息下面加一个积分卡片：

```tsx
// 积分卡片组件
export function PointsCard({ points }: { points: number }) {
  return (
    <div className="rounded-xl bg-white p-6 shadow-sm">
      <h3 className="text-sm text-gray-500">我的积分</h3>
      <p className="mt-2 text-3xl font-bold text-blue-600">{points}</p>
      <p className="mt-1 text-xs text-gray-400">下单可获订单金额 10% 积分</p>
    </div>
  );
}

第 5 步：测试

你：帮我写积分相关的单元测试，覆盖下单加分、积分查询边界情况

Claude：

import { describe, it, expect, vi } from 'vitest';
import { awardPoints } from './points';

describe('用户积分', () => {
  it('订单完成后积分增加', async () => {
    const result = await awardPoints(1);
    expect(result).toBeGreaterThan(0);
  });

  it('积分 = 订单金额 * 10%，向下取整', async () => {
    const result = await awardPoints({ total: 99 } as any);
    expect(result).toBe(9); // Math.floor(99 * 0.1)
  });

  it('积分和日志在同个事务中', async () => {
    // 验证使用了 $transaction
    expect(prisma.$transaction).toHaveBeenCalled();
  });
});

第 6 步：验证

你：跑一下测试看看

Claude：[执行 npm run test]
✓ 订单完成后积分增加 (12ms)
✓ 积分 = 订单金额 * 10%，向下取整 (8ms)
✓ 积分和日志在同个事务中 (5ms)

全部通过！

整个过程下来，你做的核心工作其实是：确认需求和验收代码。代码大部分是 Claude 写的。

---

八、进阶技巧：让 Claude Code 成为你的瑞士军刀

1. CLAUDE.md 按需切分

当项目变大，一个 CLAUDE.md 文件会变得臃肿。这时可以分割：

项目根目录/
└── .claude/
    ├── CLAUDE.md                  ← 全局规则（技术栈、编码规范）
    └── projects/
        ├── frontend/
        │   └── CLAUDE.md          ← 前端专用规则（组件约定、UI 库）
        ├── backend/
        │   └── CLAUDE.md          ← 后端专用规则（API 风格、错误处理）
        └── database/
            └── CLAUDE.md          ← 数据库专用规则（命名规范、索引策略）

Claude Code 在处理不同子任务时会自动加载对应的规则文件。比如你在改前端代码时，它只会加载 frontend 规则，不会把后端规则也塞进上下文。

2. 使用隔离工作台（Worktree）

当你需要同时处理特性开发和 bug 修复，或者想在干净环境里验证一个想法，可以用工作台隔离：

# 在当前项目创建一个隔离的工作台
claude --worktree "试一下把数据库从 MySQL 换成 SQLite"

工作台的好处：

主分支 (main)
├── 正在开发的特性 A
└── 还没改完的代码

工作台 (worktree)
└── 干净环境，随便试，不影响主分支
     ├── 实验性修改
     └── 验证完可以保留或删除

工作台里的改动不会影响主分支，验证完后可以保留或一键清理。

3. 定时任务：让 AI 帮你盯着

你可以让 Claude Code 定时执行任务：

// .claude/scheduled_tasks.json
{
  "health-check": {
    "schedule": "0 9 * * 1-5",   // 工作日早 9 点
    "prompt": "检查 API 健康状态"
  },
  "daily-test": {
    "schedule": "0 18 * * *",    // 每天下午 6 点
    "prompt": "跑一遍回归测试"
  }
}

对于测试套件较大的项目，让它自动跑回归测试可以省很多心。

4. Memory 系统：让 AI 记住你

Claude Code 有记忆系统。当你跟它聊过某些偏好，它会记住并在后续对话中自动遵循。

它是怎么工作的：

你：以后都用 pnpm，不要用 npm
    ↓
Claude 写入 memory：
  ---
  name: package-manager
  description: 用户偏好使用 pnpm
  ---
    ↓
下次你让 Claude "装依赖" → 它自动用 pnpm install

记忆的类型：

记忆类型	内容	例子
user	你的身份和偏好	"习惯用 pnpm，喜欢 arrow function"
feedback	你纠正过的行为	"不要 mock 数据库，用真实连接"
project	项目背景和目标	"4 月要上线，先做核心功能"
reference	外部资源位置	"Bug 在 Linear 的 INGEST 项目"

这些记忆跨会话持久化，所以下次你打开 Claude Code，它还记得你是谁、你怎么做事的。

5. 自定义 Skill（技能）

如果某个任务你经常做（比如部署上线、代码审计），可以把它封装成一个 Skill。以后只需要 /deploy 或者 /audit，就能自动执行一系列操作。

典型场景：

你：/deploy
Claude 自动执行：
  1. 运行测试 → 2. 构建项目 → 3. 打包 → 4. 部署到服务器 → 5. 健康检查

相比每次手动输入"跑测试 -> 构建 -> 部署 -> 检查"，一次封装永久省事。

6. Workflow 自动化

结合 Git hooks 或 CI/CD，可以进一步自动化：

• pre-commit hook：提交前让 Claude Code 检查代码质量
• post-merge hook：合并后自动跑测试
• CI 集成：在 PR 上自动运行 Claude Code review

7. 多项目管理

如果你同时维护多个项目，每个项目配好各自的 .claude/CLAUDE.md，切换项目时 Claude 自动加载对应的规范，不需要你额外说明。

---

九、避坑指南

1. 不要对 AI 盲信

Claude Code 非常强，但它不是神。它有时候会：

"编造"不存在的 API：

你：用 dayjs 的 fromNow 方法
Claude：好的，dayjs.fromNow() 返回相对时间

实际上 dayjs 并没有 fromNow() 方法------它是 moment.js 的方法。Claude 把两个库搞混了。

解决方案：让它给你看源码或运行验证。对于冷门库，告诉它"先查一下这个库的 API 文档"。

过度删改：

你：重构这个文件
Claude：[把整个文件重写了]

本来只是想改一个函数，它把整个文件结构都变了。

解决方案：改之前让它先出 diff，你确认再执行。"先告诉我你打算怎么改，不要直接执行。"

忘记上下文： Claude Code 的上下文窗口虽然大（200K tokens），但也不是无限的。对话长了以后，开头说过的一些约定它可能会忘。

解决方案：关键信息写到 CLAUDE.md 里，别只靠对话交代。

2. PR / Code Review 的最佳实践

让 Claude 帮忙 review 时，注意以下几点：

好的 review 指令：
"帮我 review 这次改动，重点关注：
 1. 有没有逻辑错误
 2. 类型定义是否完整
 3. 有没有潜在的性能问题"

Claude 的 review 质量通常很不错，但对于大型 PR（超过 10 个文件），建议分模块 review，不要一次塞给它，它会漏。

3. 注意权限和安全

• 不要把 API Key、密码写到指令里------指令可能会被记录到日志中
• 对于敏感操作（删除文件、改数据库），保持权限弹窗或者设置 block 规则
• 使用 GitHub MCP 时注意操作范围，尤其是在有 org 权限的账号上
• 如果你在直播/录屏，注意 Claude Code 可能会展示文件内容

4. 什么时候不适合用 Claude Code

虽然 Claude Code 很强，但也有不适合的场景：

不适合的场景	原因
需要深度领域知识的专业代码	AI 的知识截止于训练数据，最新标准可能不掌握
极端性能敏感的代码	AI 擅长写可读代码，但最优化可能要靠人工
安全审计 / 加密实现	这类代码必须由领域专家审查
创意性的架构设计	AI 擅长执行，但整体架构设计还是人来做更好

5. 错误恢复

如果 Claude 做了错误的操作，不要慌：

你：回滚刚才的修改
Claude：好的，我恢复了这些文件：[列表]

Claude Code 在同一个对话中知道自己改了哪些文件，可以回滚。但如果已经 /clear 或新开对话，就需要靠 git 了。

---

十、从今天开始

给你的行动清单

如果你今天刚开始用 Claude Code，按这个顺序来：

1. 安装 → 跑一遍 npm install -g @anthropic-ai/claude-code
2. 创建 CLAUDE.md → 花 15 分钟写好项目规范（最重要的一步）
3. 试一条指令 → "帮我看看这个项目结构"
4. 配权限 → 把日常命令加进白名单
5. 做一个小功能 → 从简单的 CRUD 开始，感受工作流
6. 尝试 MCP → 接一个你常用的外部服务

你和 Claude Code 的关系

Claude Code 不是魔法，它只是一个非常擅长理解代码和执行指令的助手。你和它的关系更像是产品经理 + 工程师------你定需求、做决策、把关质量；它来执行、写代码、查资料。

你（产品经理/架构师）
    │
    ├── 定需求："我要一个用户注册功能"
    ├── 做决策："用邮箱注册，不要手机号"
    ├── 把关质量：review Claude 的输出
    │
    └── Claude Code（执行工程师）
        ├── 写代码
        ├── 跑测试
        ├── 查资料
        └── 反复修改直到你满意

刚开始用的时候会有点不习惯，不知道怎么表达才能让 AI 理解你的意图。但用上一两周，摸清了它的脾气，你就会发现：

以前是一个人带着电脑干活，现在是一个人带着一个团队干活。

差别就在这里。

---

附录

A. Slash 命令速查表

命令	作用	使用场景
/help	看帮助文档	初次上手
/clear	清空对话历史	上下文快满了，回答质量下降
/fast	切换到快速响应模式	简单任务，想快点拿到结果
/loop <interval> <cmd>	定时执行某个操作	监控部署、等待 CI
/<skill-name>	执行已安装的 Skill	部署、审计等自定义流程
/config	快速修改设置	换主题、换模型

B. 推荐指令模板

创建新功能：

帮我在 [位置] 加一个 [功能名]
功能描述：[几句话说明核心逻辑]
输入/输出：[数据格式]
样式：[参考什么现有组件]
异常处理：[出错时怎么办]

修改现有代码：

把 [文件] 里的 [函数/组件] 改成 [新行为]
保持 [哪些部分] 不变

调试：

[贴错误信息]
这个错误是什么原因？
怎么修？

代码审查：

帮我 review [文件/改动]
重点检查：[类型/性能/安全/逻辑]

C. 常见问题（FAQ）

Q：Claude Code 和 Copilot 有什么区别？ A：Copilot 是"补全工具"，你写一行它猜下一行。Claude Code 是"代理"，你告诉它要什么功能，它从头到尾帮你实现。

Q：费用怎么算？ A：Claude Code 使用你的 Claude Pro 订阅或 API Key。如果频繁使用，建议用 API Key 按量计费模式。

Q：对话历史存在哪里？ A：本地终端记录，不会上传到云端。隐私方面相对安全。

Q：支持中文吗？ A：天然支持中文输入，输出也会根据你的语言偏好用中文回复。

Q：可以离线使用吗？ A：不能，需要联网连接 Anthropic 的 API。

Q：能在 CI/CD 里用吗？ A：可以，通过 API 模式集成，适合自动化 Code Review 等场景。

---

文档版本：v2.0 | 最后更新：2026-05-22

如果你发现了新的好用法，或者有什么坑需要补充，欢迎一起完善这份手册。