14 提示词工程的实战心得

你是否遇到过这些情况：

  • 同样的需求，不同的问法得到质量迥异的答案？
  • 想要 Claude Code 按特定风格编写代码，但结果总不理想？
  • 看到别人用 AI 编程效率很高，自己用起来却差强人意？

问题的核心往往不在工具，而在提示词（Prompt）。

使用 Claude Code 这段时间，我发现提示词工程是决定效果的关键因素。好的提示词能让 Claude Code 准确理解意图，生成高质量代码；而不好的提示词则可能导致模糊、错误的结果。

提示词的核心原则

清晰具体

模糊的提示词：

1
claude "写个函数"

问题很明显：什么语言？什么功能？什么参数？什么返回值？

清晰的提示词：

1
2
3
claude "用 Python 写一个函数，接收一个整数列表，
返回去重后的列表，保持原始顺序，
使用集合操作优化性能，包含类型提示和文档字符串"

这样 Claude Code 就知道：

  • 语言：Python
  • 功能：去重 + 保持顺序
  • 方法：集合操作
  • 要求：类型提示 + 文档

提供上下文

缺少上下文：

1
claude "修复这个 bug"

充足上下文：

1
2
3
4
claude "我的用户登录 API 返回 401 错误。
这是错误日志：[日志内容]
这是相关代码：[代码]
请帮我分析原因并提供修复方案"

结构化表达

我习惯用结构化的格式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
claude "请帮我完成以下任务：

【任务描述】
创建一个用户认证中间件

【技术要求】
- 框架：Express.js
- 认证方式：JWT
- 加密算法：bcrypt

【功能要求】
1. 验证请求头中的 token
2. 解析用户信息
3. 将用户信息添加到 req 对象
4. 处理错误情况

【输出格式】
完整的代码 + 使用示例"

Few-shot Learning 的威力

**Few-shot Learning（少样本学习）**是通过提供示例来引导 AI 理解任务的方法。

对比示例

Zero-shot（无示例）：

1
claude "创建一个用户验证函数"

结果是通用的，不一定符合需求。

One-shot（单个示例）：

1
2
3
4
5
6
7
8
9
10
11
claude "创建一个用户验证函数，类似这样的风格：

示例：
function validateEmail(email) {
  const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  if (!email) return { valid: false, error: '邮箱不能为空' };
  if (!regex.test(email)) return { valid: false, error: '邮箱格式错误' };
  return { valid: true };
}

请创建 validatePassword 函数，遵循相同的模式"

结果会和示例风格一致。

Few-shot（多个示例）：

1
2
3
4
5
6
7
claude "按照以下模式创建验证函数：

示例 1：validateEmail
示例 2：validatePhone
示例 3：validateAge

请创建 validateUsername 函数"

结果会高度一致地复现模式。

我的最佳实践

选择好的示例：

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 "参考这些示例创建 API 路由：

// 用户列表（GET）
app.get('/api/users', async (req, res) => {
  try {
    const users = await User.find();
    res.json({ success: true, data: users });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

// 用户详情（GET）
app.get('/api/users/:id', async (req, res) => {
  try {
    const user = await User.findById(req.params.id);
    if (!user) return res.status(404).json({ success: false, error: '未找到' });
    res.json({ success: true, data: user });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

// 创建用户（POST）
app.post('/api/users', async (req, res) => {
  try {
    const user = await User.create(req.body);
    res.status(201).json({ success: true, data: user });
  } catch (error) {
    res.status(400).json({ success: false, error: error.message });
  }
});

请创建更新用户（PUT）和删除用户（DELETE）的路由"

渐进式示例（简单 → 复杂）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
claude "参考这些示例：

示例 1（简单）：
function add(a, b) { return a + b; }

示例 2（中等）：
function sum(arr) {
  return arr.reduce((acc, val) => acc + val, 0);
}

示例 3（复杂）：
function sumBy(arr, key) {
  return arr.reduce((acc, obj) => acc + obj[key], 0);
}

请创建函数：groupBy(arr, key)"

Chain-of-Thought 的应用

**Chain-of-Thought（思维链）**是让 AI 展示推理过程的技术，能显著提高复杂任务的准确性。

基础应用

直接要求答案：

1
2
3
4
5
6
7
8
claude "这个函数的时间复杂度是多少？
function foo(arr) {
  for (let i = 0; i < arr.length; i++) {
    for (let j = 0; j < arr.length; j++) {
      console.log(arr[i], arr[j]);
    }
  }
}"

要求推理过程：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
claude "请分析这个函数的时间复杂度：
function foo(arr) {
  for (let i = 0; i < arr.length; i++) {
    for (let j = 0; j < arr.length; j++) {
      console.log(arr[i], arr[j]);
    }
  }
}

请按以下步骤分析：
1. 识别循环结构
2. 计算每个循环的迭代次数
3. 分析循环间的关系
4. 得出最终的时间复杂度"

输出会展示完整的推理过程，更加准确可靠。

结构化思维链

对于复杂任务，我使用结构化的思维链：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
claude "请帮我设计一个用户认证系统，请按以下步骤思考：

【步骤 1：需求分析】
系统需要支持什么？

【步骤 2：技术选型】
选择什么技术栈？

【步骤 3：架构设计】
如何组织代码？

【步骤 4：安全考虑】
需要注意什么？

【步骤 5：实现计划】
具体实现步骤"

角色扮演技巧

设定角色能让 AI 采用特定的视角、知识和表达方式。

基础角色设定

普通提问：

1
claude "如何优化这段代码？"

角色扮演：

1
2
3
4
5
6
7
8
claude "你是一个有 10 年经验的性能优化专家。
请审查这段代码，从以下角度分析：
1. 算法效率
2. 内存使用
3. 可维护性
4. 最佳实践

[代码内容]"

我常用的角色模板

架构师视角：

1
2
3
4
5
6
7
8
9
claude "作为系统架构师，请评估这个设计：
[设计描述]

从以下维度分析：
- 可扩展性
- 可维护性
- 性能
- 安全性
- 成本"

代码审查者：

1
2
3
4
5
6
7
8
9
10
claude "你是一个严格的代码审查者，
请审查这段 PR：
[代码内容]

关注点：
- 潜在 bug
- 代码规范
- 测试覆盖
- 文档完整性
- 性能问题"

安全专家：

1
2
3
4
5
6
7
8
9
10
claude "作为网络安全专家，
请审计这段代码的安全问题：
[代码内容]

检查：
- SQL 注入
- XSS 漏洞
- CSRF 防护
- 认证授权
- 敏感数据处理"

技术写作专家：

1
2
3
4
5
6
7
8
9
claude "你是技术文档写作专家，
请为这个 API 编写文档：
[代码内容]

要求：
- 清晰易懂
- 包含示例
- 说明参数和返回值
- 添加使用场景"

我的提示词模板库

经过长时间积累，我建立了一套提示词模板。

代码生成模板

函数生成模板：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
claude "【任务】生成一个函数

【语言】${LANGUAGE}

【功能】${FUNCTION_DESCRIPTION}

【输入】
- 参数：${PARAMETERS}
- 类型：${TYPES}

【输出】
- 返回值：${RETURN_VALUE}
- 类型：${RETURN_TYPE}

【要求】
- 包含错误处理
- 添加类型提示
- 编写文档字符串
- 遵循最佳实践"

代码审查模板

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
claude "【任务】代码审查

【角色】资深开发者 + 安全专家

【代码】
${CODE}

【审查维度】
1. 正确性（逻辑、边界、错误处理）
2. 性能（时间复杂度、空间复杂度）
3. 安全性（输入验证、注入风险）
4. 可维护性（代码风格、命名、注释）

【输出格式】
- 总体评分（1-10）
- 问题列表（按优先级）
- 改进建议
- 重构版本（如需要）"

调试模板

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
claude "【任务】调试帮助

【问题】${PROBLEM_DESCRIPTION}

【错误信息】
${ERROR_MESSAGE}

【相关代码】
${CODE}

【环境信息】
- 语言/框架：${TECH_STACK}
- 运行环境：${ENVIRONMENT}

【分析步骤】
1. 识别错误类型
2. 分析可能原因
3. 提供诊断方法
4. 给出解决方案"

重构模板

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
claude "【任务】代码重构

【当前代码】
${CODE}

【重构目标】
${REFACTOR_GOALS}

【约束条件】
- 保持功能不变
- 不破坏现有测试
- 遵循团队规范

【输出】
- 重构后的代码
- 改进说明
- 对比分析"

实战案例

创建 RESTful API

简单提问：

1
claude "创建一个用户 API"

结果是通用的。

结构化提示词：

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
claude "【角色】你是一个 Express.js 后端开发专家

【任务】创建一个完整的用户管理 API

【技术栈】
- 框架：Express.js 4.x
- 数据库：MongoDB + Mongoose
- 认证：JWT
- 验证：joi

【需要实现的端点】
1. POST   /api/users/register  - 用户注册
2. POST   /api/users/login     - 用户登录
3. GET    /api/users           - 获取用户列表（分页）
4. GET    /api/users/:id       - 获取用户详情
5. PUT    /api/users/:id       - 更新用户信息
6. DELETE /api/users/:id       - 删除用户

【要求】
1. 密码使用 bcrypt 加密
2. 使用 JWT 进行身份验证
3. 实现请求验证中间件
4. 统一的错误处理
5. 完整的代码注释

【数据模型】
{
  username: String (unique, required),
  email: String (unique, required),
  password: String (required),
  role: String (default: 'user')
}"

算法优化

模糊提问：

1
claude "优化这个函数"

详细指导：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
claude "【当前代码】
function findDuplicates(arr) {
  const duplicates = [];
  for (let i = 0; i < arr.length; i++) {
    for (let j = i + 1; j < arr.length; j++) {
      if (arr[i] === arr[j] && !duplicates.includes(arr[i])) {
        duplicates.push(arr[i]);
      }
    }
  }
  return duplicates;
}

【优化目标】
1. 降低时间复杂度
2. 提高代码可读性
3. 处理边界情况

【分析步骤】
1. 分析当前算法的时间复杂度
2. 识别性能瓶颈
3. 提出优化方案
4. 对比优化前后的性能"

常见陷阱

假设太多

错误示例：

1
2
claude "创建一个登录页面"
# 假设了框架、样式、功能...

正确做法：

1
2
claude "使用 React + Tailwind CSS 创建登录页面，
包含邮箱、密码输入和登录按钮"

指令矛盾

错误示例：

1
2
claude "创建一个简洁但功能全面的函数"
# "简洁"和"功能全面"可能矛盾

正确做法：

1
2
claude "创建一个函数，优先考虑简洁性，
在可读性和性能之间平衡"

缺少反馈循环

一次性完成：

1
claude "创建一个完整的电商系统"

迭代优化：

1
2
3
4
5
6
7
8
# 第一轮
claude "设计电商系统的数据模型"

# 第二轮
claude "基于上面的模型，实现商品列表 API"

# 第三轮
claude "为商品 API 添加搜索和筛选功能"

构建个人模板库

我按以下结构组织模板：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
~/.claude/prompts/
├── code-generation/
│   ├── function.md
│   ├── class.md
│   └── api.md
├── code-review/
│   ├── security.md
│   ├── performance.md
│   └── style.md
├── debugging/
│   ├── error-analysis.md
│   └── bug-fix.md
└── refactoring/
    ├── optimization.md
    └── modernization.md

使用时：

1
2
3
4
5
# 读取模板
cat ~/.claude/prompts/code-generation/function.md

# 替换变量后使用
claude "$(envsubst < template.md)"

提示词效果对比

提示词类型 准确率 适用场景
简单直接 60% 快速原型
清晰具体 80% 日常开发
Few-shot 90% 风格统一
CoT 95% 复杂推理
角色扮演 85% 特定视角

选择建议：

  • 简单任务 → 清晰具体
  • 风格统一 → Few-shot
  • 复杂推理 → Chain-of-Thought
  • 专业视角 → 角色扮演
  • 重复使用 → 模板库

总结

提示词工程是与 AI 有效沟通的关键：

  • 清晰具体是基础
  • Few-shot Learning 能统一风格
  • Chain-of-Thought 提高准确性
  • 角色扮演获取专业视角
  • 模板库提高复用性

掌握这些技巧后，你会发现 Claude Code 的效果大幅提升。

下一步，让我们探索多语言编程。

相关资源

继续加油！