💬 Claude Code 入门完全指南三（整合版）：提示词与代码生成前置知识建议先完成 Claude Code

前置知识

建议先完成 Claude Code 安装配置（参见 01-Claude Code 入门完全指南一：安装与首次体验）
本文适合想要系统学习 AI 辅助编程的开发者

📋 目录

为什么提示词决定代码质量
提示词核心技巧
代码生成的正确姿势
代码修改深度指南
从提示词到代码的完整工作流
实战案例：完整的 TODO 应用开发
最佳实践与常见问题

一、为什么提示词决定代码质量

1.1 提示词是需求的翻译器

当你对 Claude Code 说出「帮我写个排序算法」时，AI 必须猜测你的意图：

你说的	Claude Code 需要推断
「帮我写个排序算法」	什么语言？Python？JavaScript？Go？
	什么类型？快速排序？归并排序？冒泡排序？
	数据规模多大？100条？100万条？
	需要稳定排序吗？
	原位排序还是需要额外空间？
	有什么性能要求？
	边界情况如何处理？

模糊的提示词 → 猜测性的输出 → 需要大量修改

1.2 好的提示词 = 精准的需求文档

✅ 精准提示词示例：
用 JavaScript 实现一个针对 10 万条数据的排序算法，要求：
1. 时间复杂度 O(n log n)
2. 稳定排序
3. 支持自定义比较函数
4. 处理 null、undefined、NaN 等边界值
5. 包含单元测试

Claude Code 收到的完整信息：

信息项	内容
语言	JavaScript
场景	10万条大数据
算法	快速排序/归并排序（O(n log n)）
稳定性	需要
比较	支持自定义
边界	明确列出
交付物	代码 + 测试

精准的提示词 → 符合预期的输出 → 最小化修改

1.3 提示词与代码生成的映射关系

提示词质量	AI 理解	生成代码	你的工作量
❌ 模糊	猜测各种可能性	基础框架，需大量补充	高
⚠️ 一般	理解主要意图	基本可用，需部分完善	中
✅ 清晰	精准理解	接近生产级代码	低
⭐ 优秀	理解深层需求	超出预期，考虑周全	极低

二、提示词核心技巧

2.1 提示词三要素

任何一个好的提示词都应该包含三个核心要素：

要素	作用	示例
🎯 目标	明确要做什么	「写一个用户认证中间件」
📋 规格	详细的功能要求	「使用 JWT，支持刷新令牌」
🔧 上下文	相关背景和约束	「Node.js + Express 项目」

2.2 基础提示词模式

模式一：简单任务型

适用场景：需求明确简单的任务

示例	说明
"写一个 Hello World 程序"	最简单的需求
"创建一个 CSS 按钮样式"	单一组件
"写一个冒泡排序算法"	基础算法
"用 Python 读取 CSV 文件并打印前 10 行"	完整的需求描述

使用技巧

对于简单明确的任务，直接描述需求即可。AI 能够理解常见的编程概念，不需要过多解释。

模式二：详细规格型

适用场景：复杂功能开发，需要详细规格说明

示例 - 文件加密工具：

用 Python 写一个文件加密工具，要求：

【功能需求】
- 使用 AES-256-GCM 加密算法
- 支持命令行参数：-e 加密文件，-d 解密文件
- 输入：文件路径、密码（至少 8 位）
- 输出：加密生成 .enc 文件，解密还原原文件

【错误处理】
- 文件不存在：提示 "文件不存在"
- 密码强度不足：提示 "密码强度不足，需要至少 8 位"
- 加密/解密失败：提示具体错误信息

【代码规范】
- 使用 argparse 解析命令行参数
- 使用 type hints 类型注解
- 包含完整的 docstring 文档
- 遵循 PEP 8 规范

输出效果：

#!/usr/bin/env python3
"""
文件加密工具
支持 AES-256-GCM 加密和解密
"""

import argparse
import os
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
from cryptography.hazmat.backends import default_backend


def derive_key(password: str) -> bytes:
    """从密码派生 256 位密钥"""
    ...


def encrypt_file(file_path: str, password: str) -> str:
    """加密文件"""
    ...


def decrypt_file(file_path: str, password: str) -> str:
    """解密文件"""
    ...


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="文件加密工具")
    parser.add_argument("-e", "--encrypt", help="加密文件")
    parser.add_argument("-d", "--decrypt", help="解密文件")
    parser.add_argument("-p", "--password", required=True, help="密码")
    args = parser.parse_args()
    ...

模式三：问答解释型

适用场景：学习知识、理解概念、解释代码

示例	说明
"什么是 Python 的装饰器？请举例说明"	概念学习
"解释一下 React 的 useEffect 生命周期"	框架理解
"JavaScript 的 var、let、const 有什么区别？"	语法对比
"这段代码在做什么？请逐行解释"	代码解释

模式四：调试排错型

适用场景：Bug 排查、错误修复

❌ 低效提问	✅ 高效提问
"我的代码报错了，帮我看看"	"这个 Python 代码运行报错：NameError: name 'x' is not defined

	代码：
	def calculate():
	result = x + 1
	return result
	calculate()

	请分析错误原因并提供修复方案"

2.3 进阶提示词技巧

技巧一：指定编程语言和框架

❌ 模糊写法	✅ 明确写法
"写一个 Web 服务器"	"用 Node.js + Express 写一个 REST API 服务器"
	"用 Flask 写一个简单的后端服务"
	"用 Go + Gin 框架写一个 HTTP 服务"

为什么重要？

不同语言和框架有截然不同的语法、库和最佳实践。明确指定可以让 AI 选择最适合的实现方式。

技巧二：指定代码风格和规范

用 Python 写一个函数，要求：

【代码规范】
- 使用类型注解（Type Hints）标注参数和返回值类型
- 遵循 PEP 8 规范（使用 Black 格式化）
- 包含 Google 风格的 docstring 文档
- 使用 Python 3.10+ 现代语法（match-case、walrus operator 等）

【示例风格】
def process_data(data: list[int]) -> dict[str, int]:
    '''处理数据并返回统计结果。
    
    Args:
        data: 输入的整数列表
        
    Returns:
        包含统计信息的字典
    '''
    return {"sum": sum(data), "count": len(data)}

技巧三：提供参考代码风格

参考以下代码风格，帮我写一个新的工具类：

【现有代码风格】
class FileHandler:
    """文件处理工具类"""
    
    def __init__(self, path: str):
        self.path = Path(path)
        
    def read(self) -> str:
        """读取文件内容"""
        if not self.path.exists():
            raise FileNotFoundError(f"文件不存在: {self.path}")
        return self.path.read_text(encoding='utf-8')
        
    def write(self, content: str) -> None:
        """写入文件内容"""
        self.path.parent.mkdir(parents=True, exist_ok=True)
        self.path.write_text(content, encoding='utf-8')

【要求】
- 保持相同的命名规范（驼峰命名）
- 使用相同的错误处理方式（抛出具体异常）
- 保持相同的文档风格
- 添加类似的验证逻辑

请帮我写一个 ConfigLoader 工具类

技巧四：分步骤请求

第一步：
"帮我设计一个用户数据结构，包含：用户名、邮箱、密码、注册时间、最后登录时间"

第二步：
"基于这个数据结构，写一个用户注册函数，需要：
- 验证邮箱格式
- 验证密码强度（至少 8 位，包含数字和字母）
- 密码使用 bcrypt 加密存储
- 返回用户 ID"

第三步：
"添加登录验证功能：
- 验证邮箱和密码
- 密码正确则返回 JWT token
- 记录最后登录时间
- 连续失败 5 次锁定账户 30 分钟"

注意

避免一次性提出过多要求
每一步确认后再进行下一步
可以用 /branch 创建分支尝试不同方案

技巧五：使用约束条件

用 JavaScript 写一个深拷贝函数，要求：

【功能要求】
1. 支持嵌套对象（任意层级深度）
2. 处理循环引用（防止无限递归）
3. 保持原始类型（Date、RegExp、Map、Set 等）

【约束条件】
- 不使用第三方库（如 lodash）
- 使用 ES6+ 语法
- 包含 JSDoc 文档
- 时间复杂度 O(n)

【测试用例】
    const obj = {
      date: new Date(),
      regex: /test/i,
      map: new Map([['key', 'value']]),
      nested: {
        a: 1,
        b: { c: 2 }
      }
    };
    // 测试深拷贝

技巧六：明确输出格式

用 Python 写一个数据处理脚本，要求：

【输入】
- 读取 data/input.csv 文件
- CSV 包含列：name, age, city, salary

【输出】
- 生成 data/output.json 文件
- JSON 格式：
    {
      "summary": {
        "total_people": 100,
        "average_salary": 50000,
        "cities": ["北京", "上海", "深圳"]
      },
      "people": [
        {"name": "张三", "age": 30, "city": "北京", "salary": 60000}
      ]
    }

【处理逻辑】
- 计算平均工资
- 提取所有城市列表（去重）
- 按工资从高到低排序

2.4 经典提示词模板库

模板一：代码生成

用 [语言] 写一个 [功能描述]，要求：

【功能列表】

[具体功能点1]

[具体功能点2]

[具体功能点3]

【约束条件】

[约束条件1]

[约束条件2]

【可选】参考现有代码：
[粘贴参考代码]

完整示例：

用 JavaScript 写一个深拷贝函数，要求：

【功能列表】
1. 支持嵌套对象（任意层级深度）
2. 处理循环引用（防止无限递归）
3. 保持原始类型（Date、RegExp、Map、Set、Error 等）
4. 处理函数（可选复制或保持引用）

【约束条件】
- 不使用第三方库（如 lodash、rfdc）
- 使用 ES6+ 语法
- 包含 JSDoc 类型注解
- 时间复杂度 O(n)

【测试用例】
    const original = {
      date: new Date('2024-01-01'),
      regex: /test/gi,
      map: new Map([['key', {nested: 'value'}]]),
      set: new Set([1, 2, 3]),
      nested: { a: 1, b: { c: [1, 2, {d: 4}] } },
      circular: {}
    };
    original.circular = original; // 循环引用
    
    const cloned = deepClone(original);

模板二：代码审查

请审查以下代码：

【代码】
[粘贴代码]

【审查要求】

性能问题分析

安全风险检查

代码规范问题

潜在 Bug 预警

改进建议（按优先级排序）

【可选】我关注的重点：

[重点1]

[重点2]

模板三：重构优化

请重构以下代码，使其：

更易读（清晰的命名和结构）

更高效（优化性能瓶颈）

更安全（修复安全漏洞）

符合最佳实践

【原始代码】
[粘贴代码]

【重构要求】

保持原有功能不变

尽量减少代码行数

添加必要的注释

如果有测试用例，请一并提供

模板四：Bug 修复

代码报错：【错误信息】

【代码】
[粘贴代码]

【请执行】

分析错误原因

提供修复方案（首选方案 + 备选方案）

解释为什么会出现这个错误

说明如何避免类似问题

模板五：技术方案设计

设计一个 [系统/功能]，要求：

【需求描述】

[需求1]

[需求2]

[需求3]

【技术约束】

技术栈：[如 Node.js + PostgreSQL + Redis]

性能要求：[如 QPS > 1000, 延迟 < 100ms]

扩展要求：[如支持水平扩展]

【请提供】

系统架构图（文字描述）

核心数据结构设计

API 接口设计

关键实现逻辑

潜在风险和应对方案

三、代码生成的正确姿势

3.1 生成流程

需求分析 → 提示词构建 → 代码生成 → 代码审查 → 迭代优化
   1️⃣          2️⃣          3️⃣          4️⃣          5️⃣

3.2 生成示例：从零开始

# 交互式模式
$ claude

> 用 React 写一个天气查询应用，要求：
> - 输入城市名称查询天气
> - 显示温度、天气状况、湿度
> - 使用 OpenWeatherMap API
> - 包含加载状态和错误处理

生成的代码结构

import React, { useState } from 'react';
import './App.css';

function App() {
  const [city, setCity] = useState('');
  const [weather, setWeather] = useState(null);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState('');

  const fetchWeather = async () => {
    // API 调用逻辑
  };

  return (
    // JSX 界面
  );
}

export default App;

3.3 代码生成最佳实践

实践一：指定完整的项目结构

创建一个 Node.js 项目结构，包含：
- src/
    controllers/    # 控制器
    models/        # 数据模型
    routes/       # 路由
    services/     # 业务逻辑
    utils/        # 工具函数
- tests/          # 测试文件
- config/         # 配置文件

每个文件需要基础的代码框架

实践二：生成完整的 CRUD API

用 Express + MongoDB 写一个用户管理的 RESTful API：
- GET /api/users        # 获取所有用户
- GET /api/users/:id    # 获取单个用户
- POST /api/users       # 创建用户
- PUT /api/users/:id   # 更新用户
- DELETE /api/users/:id # 删除用户

要求：中间件、错误处理、输入验证

实践三：生成测试代码

为以下函数生成单元测试：

    function sum(a, b) {
      return a + b;
    }

要求：
- 使用 Jest 框架
- 覆盖正常情况
- 覆盖边界情况
- 覆盖异常情况

3.4 快速代码生成命令

Claude Code 命令行用法

# 单次执行（最常用）
claude "帮我写一个排序算法"

# 指定模型执行
claude --model opus-4-6 "分析整个代码库"

# 指定项目目录
claude /path/to/project "审查代码"

# 打印结果到 stdout
claude -p "生成一个 React 组件"

# 最小化执行（跳过 hooks、插件）
claude --bare -p "快速生成"

# 设置会话名称
claude -n "my-session" "开始工作"

# 查看帮助
claude --help

常用生成命令一览

命令	功能
`claude "新建一个 React 组件"`	生成基础组件模板
`claude "写一个 Python 爬虫"`	生成爬虫框架代码
`claude "创建数据库模型"`	生成 ORM 模型
`claude "写一个算法"`	生成算法实现
`claude "生成表单验证"`	生成验证逻辑

实际使用示例

# 生成 React 组件
$ claude "生成一个 Modal 弹窗组件，包含：
- 标题、内容、底部按钮区域
- 显示/隐藏动画
- 点击遮罩关闭
- ESC 键关闭"

# 生成 Python 数据处理
$ claude "用 pandas 读取 CSV 文件，计算：
- 每列的平均值
- 每列的最大最小值
- 生成统计报告"

# 生成 SQL 查询
$ claude "写一个复杂的 SQL 查询：
- 三个表关联
- 多条件过滤
- 分页和排序"

# 批量操作
$ claude "把所有 .js 文件改成 .tsx"

3.5 代码生成质量对比

写法	生成的代码质量
❌ "写个排序"	随机选择排序算法，可能不符合场景
⚠️ "写排序算法"	能工作，但无优化
✅ "用 JavaScript 写一个针对大数据集的排序，需要考虑性能"	会选择适合的算法，包含优化
⭐ "写排序，对 100 万条数据排序，需要稳定排序且尽可能快"	选择合适的算法，包含性能优化和多线程考虑

四、代码修改深度指南

4.1 代码续写

当你想在现有代码基础上添加功能：

User: 在这个函数里添加参数验证

Claude Code: ✅ 已添加参数验证：

function createUser(name, email, age) {
  // 新增：参数验证
  if (!name || typeof name !== 'string') {
    throw new Error('Name is required and must be a string');
  }
  if (!email || !email.includes('@')) {
    throw new Error('Valid email is required');
  }
  if (age !== undefined && (typeof age !== 'number' || age < 0)) {
    throw new Error('Age must be a positive number');
  }
  
  // 原有的创建逻辑...
}

4.2 代码修复

遇到 bug 时，直接贴上错误信息：

User: 这个代码报错 TypeError: Cannot read property 'map' of undefined

Claude Code:
问题分析：

数据未加载时就尝试遍历

缺少空值检查

修复方案：
✅ 已添加防御性检查：
// 添加条件渲染
{users && users.length > 0 ? (
  users.map(user => <UserCard key={user.id} user={user} />)
) : (
  <p>暂无数据</p>
)}

4.3 代码重构

User: 把这个 class 组件改成函数式组件

Claude Code: ✅ 重构完成：

原 class 组件：
class Counter extends React.Component {
state = { count: 0 };
render() {
return

{this.state.count}

;
}
}

重构为函数式组件：
function Counter() {
const [count, setCount] = useState(0);
return

{count}

;
}

4.4 同时修改多个文件

User: 在所有 API 路由中添加统一的错误处理中间件

Claude Code: ✅ 已修改以下文件：

routes/users.js

routes/products.js

routes/orders.js

routes/auth.js

每个文件都添加了：

try-catch 块

错误响应格式化

统一的错误码

4.5 批量重命名

User: 把项目中所有的 userId 改成 user_id（蛇形命名）

Claude Code:
✅ 已扫描项目：42 个文件
✅ 已修改：28 个文件
✅ 保持不变：14 个文件（已是蛇形命名）

变更详情：

src/models/User.js : userId → user_id

src/routes/auth.js : userId → user_id

src/utils/helpers.js : userId → user_id

4.6 代码优化

User: 优化这段代码的性能

Claude Code: ✅ 优化完成：

原代码：
const users = [];
for (let i = 0; i < data.length; i++) {
if (data[i].active) {
users.push(data[i]);
}
}

优化后：
const users = data.filter(user => user.active);

性能提升：

代码行数：3行 → 1行

时间复杂度：O(n)

可读性大幅提升

五、从提示词到代码的完整工作流

5.1 核心工作流

graph LR
    A[需求分析] --> B[提示词构建]
    B --> C[代码生成]
    C --> D[代码审查]
    D --> E{通过?}
    E -->|否| B
    E -->|是| F[完成]
    
    B -.->|迭代优化| B
    D -.->|修改| C

5.2 步骤详解

步骤一：需求分析

在写提示词之前，先明确以下问题：

问题	示例回答
要实现什么功能？	用户登录验证
使用什么语言/框架？	Node.js + Express
有什么特殊要求？	使用 JWT，支持刷新令牌
有什么约束？	不使用第三方认证库
输出格式是什么？	完整的 Express 中间件

步骤二：提示词构建

使用前文学到的技巧构建提示词：

用 Node.js + Express 写一个用户认证中间件，要求：

【功能需求】
1. 验证用户邮箱和密码
2. 密码使用 bcrypt 加密比对
3. 登录成功返回 JWT token
4. 支持刷新令牌机制
5. 连续失败 5 次锁定账户 15 分钟

【约束条件】
- 不使用 passport.js 等第三方库
- JWT 过期时间设为 1 小时
- 刷新令牌过期时间设为 7 天
- 使用 TypeScript

【错误处理】
- 密码错误：返回 401
- 用户不存在：返回 401（不暴露用户是否存在）
- 账户锁定：返回 429
- 服务器错误：返回 500

步骤三：代码生成

Claude Code 会生成完整的代码。检查是否满足要求：

// 生成的代码示例
import { Request, Response, NextFunction } from 'express';
import bcrypt from 'bcrypt';
import jwt from 'jsonwebtoken';

interface TokenPayload {
  userId: string;
  email: string;
}

const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key';
const JWT_EXPIRES_IN = '1h';
const REFRESH_TOKEN_EXPIRES_IN = '7d';
const MAX_LOGIN_ATTEMPTS = 5;
const LOCKOUT_DURATION = 15 * 60 * 1000;

const loginAttempts: Map<string, { count: number; lockedUntil?: number }> = new Map();

export const login = async (
  req: Request,
  res: Response,
  next: NextFunction
) => {
  try {
    const { email, password } = req.body;

    const attempt = loginAttempts.get(email);
    if (attempt?.lockedUntil && Date.now() < attempt.lockedUntil) {
      const remainingMinutes = Math.ceil((attempt.lockedUntil - Date.now()) / 60000);
      return res.status(429).json({
        error: `账户已被锁定，请 ${remainingMinutes} 分钟后再试`
      });
    }

    const user = await User.findOne({ email });
    const isValid = user ? await bcrypt.compare(password, user.passwordHash) : false;

    if (!isValid) {
      const currentAttempt = loginAttempts.get(email) || { count: 0 };
      currentAttempt.count += 1;
      if (currentAttempt.count >= MAX_LOGIN_ATTEMPTS) {
        currentAttempt.lockedUntil = Date.now() + LOCKOUT_DURATION;
      }
      loginAttempts.set(email, currentAttempt);
      return res.status(401).json({ error: '邮箱或密码错误' });
    }

    loginAttempts.delete(email);

    const payload: TokenPayload = {
      userId: user!._id.toString(),
      email: user!.email
    };

    const accessToken = jwt.sign(payload, JWT_SECRET, { expiresIn: JWT_EXPIRES_IN });
    const refreshToken = jwt.sign(payload, JWT_SECRET, { expiresIn: REFRESH_TOKEN_EXPIRES_IN });

    res.json({ accessToken, refreshToken, expiresIn: JWT_EXPIRES_IN });
  } catch (error) {
    console.error('Login error:', error);
    res.status(500).json({ error: '服务器错误' });
  }
};

步骤四：代码审查

生成代码后，自己审查或让 Claude Code 审查：

请审查刚才生成的代码，重点关注：

安全性问题

性能考虑

代码规范

边界情况处理

步骤五：迭代优化

根据审查结果进行迭代：

User: 刚才的代码有一个问题：用户不存在时也会进行 bcrypt 耗时比对，这会导致时序攻击。

Claude Code: ✅ 已修复：
const isValid = await bcrypt.compare(
  password,
  user?.passwordHash || '$2b$10$dummyhashfortimingattack'
);
这样无论用户是否存在，比对耗时都相同

5.3 提示词质量检查清单

在发送提示词之前，检查以下项目：

检查项	✓/✗	说明
语言明确	☐	指定了编程语言
框架明确	☐	指定了使用的框架
功能清晰	☐	列出所有需要的功能
约束说明	☐	说明了限制条件
输出格式	☐	明确了期望的输出
错误处理	☐	说明了错误处理要求
代码规范	☐	指定了代码风格
测试要求	☐	是否需要包含测试

六、实战案例：完整的 TODO 应用开发

6.1 需求描述

做一个 TODO 应用，包含：
- 添加任务
- 标记完成/未完成
- 删除任务
- 页面刷新后数据保留
- 界面简洁美观

技术栈：React + localStorage

6.2 第一轮对话：项目初始化

User: 用 React + localStorage 做一个简单的 TODO 应用，需要：

添加任务

标记完成/未完成

删除任务

页面刷新后数据保留

界面简洁美观

Claude Code: 好的！我来为你创建一个 React TODO 应用。

【技术栈】

React 18 + Hooks

localStorage 持久化

CSS Modules 样式

✅ 已创建文件：

src/App.jsx # 主组件

src/components/TodoItem.jsx # 任务项组件

src/App.css # 样式文件

【项目结构】
src/
├── App.jsx
├── components/
│ └── TodoItem.jsx
├── App.css
└── index.jsx

【功能说明】

添加任务 - 输入框输入，按 Enter 或点击按钮添加

完成任务 - 点击任务项切换状态，显示删除线

删除任务 - 点击删除按钮移除

数据持久化 - 自动保存到 localStorage

【运行方式】
npm install
npm run dev

6.3 第二轮对话：功能增强

User: 很好！现在添加以下功能：

添加截止日期字段

添加优先级字段（高/中/低）

按优先级和截止日期排序显示

Claude Code: ✅ 已完成功能增强：

【新增功能】

截止日期：支持选择日期和时间

优先级：高（红色）、中（黄色）、低（绿色）

智能排序：优先级高 → 截止日期近 → 按添加顺序

【修改的文件】

src/App.jsx # 添加日期选择器、优先级选择器

src/components/TodoItem.jsx # 显示优先级标记和截止日期

src/App.css # 新增样式

6.4 第三轮对话：代码优化

User: 代码有点乱，请帮我重构，使代码更清晰、组件职责更分离

Claude Code: ✅ 重构完成：

【新的项目结构】
src/
├── App.jsx # 主应用组件
├── components/
│ ├── TodoList.jsx # 任务列表
│ ├── TodoItem.jsx # 单个任务项
│ ├── TodoForm.jsx # 添加/编辑表单
│ ├── TodoFilter.jsx # 筛选和排序
│ └── PriorityBadge.jsx # 优先级徽章
├── hooks/
│ └── useTodos.js # 自定义 Hook
├── utils/
│ └── storage.js # localStorage 工具
└── styles/
└── App.css

【重构要点】

提取 useTodos Hook 封装状态逻辑

分离 TodoForm 组件处理输入

分离 TodoFilter 组件处理筛选

提取 storage.js 封装存储逻辑

6.5 最终代码审查

User: 请审查最终的代码，给出改进建议

Claude Code: # 代码审查报告

✅ 做得好的地方

组件职责清晰 - 每个组件只做一件事

状态逻辑封装 - useTodos Hook 封装业务逻辑

数据持久化 - 正确处理了 localStorage

⚠️ 可以改进的地方

优先级问题建议
中缺少输入验证添加任务内容长度限制
低缺少动画添加过渡动画提升体验
低缺少分类功能添加标签/分类功能

优先级	问题	建议
中	缺少输入验证	添加任务内容长度限制
低	缺少动画	添加过渡动画提升体验
低	缺少分类功能	添加标签/分类功能

七、最佳实践与常见问题

7.1 最佳实践总结

阶段	最佳实践	具体做法
需求	先想清楚	明确功能、约束、验收标准
提示词	精准描述	包含目标 + 规格 + 上下文
生成	指定语言框架	避免 AI 猜测
审查	检查安全性	重点看漏洞和性能
修改	迭代进行	每次改一点，验证一点
测试	包含测试	让 AI 生成单元测试

7.2 常见问题与解决

Q1：提示词越长越好吗？

Answer

不是！ 提示词要简洁但完整，包含必要信息即可。

❌ 过长提示词的问题：

AI 可能忽略部分信息
增加理解难度
消耗更多 token

✅ 好的提示词：

包含必要信息（目标 + 要求 + 上下文）
结构清晰（分点列举）
不过度解释常识

Q2：AI 理解错了我的意思怎么办？

Answer

明确指出具体问题："不是这样的，我是说..."
提供更多上下文："在 XXX 场景下..."
拆分任务：分步骤完成复杂任务
压缩上下文：/compact 后重新描述
尝试分支：/branch 创建分支尝试不同方案

Q3：可以连续对话吗？

Answer

当然可以！ Claude Code 支持上下文连续对话：

追问细节
让 AI 解释代码
提出修改要求
继续完善功能
/resume 恢复之前的工作

Q4：对话太长变慢了怎么办？

Answer

/compact - 压缩上下文，保留关键信息
/clear - 清除对话历史，开始新对话
/branch - 创建分支会话

Q5：生成的代码不符合预期怎么办？

Answer

检查提示词：是否有歧义或遗漏？
提供示例：给出期望的输出格式示例
指定约束：强调必须满足的条件
分步验证：让 AI 一步步解释它的方案

Q6：生成的代码安全吗？

Answer

不一定！ AI 生成的代码需要人工审查：

检查是否有安全漏洞
检查输入验证是否充分
检查是否有 SQL 注入风险
检查密码存储是否安全

重要提醒

永远不要直接使用 AI 生成的代码用于生产环境，必须经过安全审查和测试。

7.3 提示词效果对比

等级	提示词示例	效果	评分
❌ 模糊	`"写个排序"`	输出随机，功能不定	⭐
⚠️ 一般	`"写一个排序算法"`	能工作，但可能不符合需求	⭐⭐
✅ 清晰	`"用 Python 写一个快速排序，要求原地排序、时间复杂度 O(n log n)"`	精准输出	⭐⭐⭐
⭐ 优秀	`"用 Python 写快速排序，原地排序、O(n log n)，包含单元测试和性能对比，参考现有代码风格..."`	超出预期	⭐⭐⭐⭐⭐

7.4 Claude Code 2.1.79 对话命令一览

命令	功能	示例
`/model <model>`	切换使用的模型	`/model opus-4-6`
`/help`	显示帮助信息	`/help`
`/quit`	退出当前会话	`/quit`
`/clear`	清除对话历史	`/clear`
`/compact`	压缩上下文，释放空间	`/compact`
`/context`	查看当前上下文状态	`/context`
`/resume`	恢复之前的工作	`/resume`
`/effort`	设置任务努力级别	`/effort high`
`/plan`	进入计划模式	`/plan`
`/branch`	创建分支会话	`/branch`
`/btw`	侧边问题回答	`/btw 顺便问下...`

7.5 模型选择建议

任务类型	推荐模型	原因
简单代码生成	Haiku / Sonnet	快速且足够
代码审查	Sonnet / Opus	需要一定推理
复杂架构设计	Opus 4.6	需要深度分析
超大代码库分析	Opus 4.6	1M token 上下文
学习解释概念	Sonnet / Opus	需要详细解释

🎉 总结

技能	要点
提示词	清晰、具体、完整
代码生成	指定语言和框架
代码审查	检查安全性和性能
迭代优化	多次对话完善
测试验证	确保代码可运行

💬 Claude Code 入门完全指南 三（整合版）：提示词与代码生成

📋 目录

一、为什么提示词决定代码质量

1.1 提示词是需求的翻译器

1.2 好的提示词 = 精准的需求文档

1.3 提示词与代码生成的映射关系

二、提示词核心技巧

2.1 提示词三要素

2.2 基础提示词模式

模式一：简单任务型

模式二：详细规格型

模式三：问答解释型

模式四：调试排错型

2.3 进阶提示词技巧

技巧一：指定编程语言和框架

技巧二：指定代码风格和规范

技巧三：提供参考代码风格

技巧四：分步骤请求

技巧五：使用约束条件

技巧六：明确输出格式

2.4 经典提示词模板库

模板一：代码生成

模板二：代码审查

模板三：重构优化

模板四：Bug 修复

模板五：技术方案设计

三、代码生成的正确姿势

3.1 生成流程

3.2 生成示例：从零开始

3.3 代码生成最佳实践

实践一：指定完整的项目结构

实践二：生成完整的 CRUD API

实践三：生成测试代码

3.4 快速代码生成命令

Claude Code 命令行用法

常用生成命令一览

实际使用示例

3.5 代码生成质量对比

四、代码修改深度指南

4.1 代码续写

4.2 代码修复

4.3 代码重构

4.4 同时修改多个文件

4.5 批量重命名

4.6 代码优化

五、从提示词到代码的完整工作流

5.1 核心工作流

5.2 步骤详解

步骤一：需求分析

步骤二：提示词构建

步骤三：代码生成

步骤四：代码审查

步骤五：迭代优化

5.3 提示词质量检查清单

六、实战案例：完整的 TODO 应用开发

6.1 需求描述

6.2 第一轮对话：项目初始化

6.3 第二轮对话：功能增强

6.4 第三轮对话：代码优化

6.5 最终代码审查

✅ 做得好的地方

⚠️ 可以改进的地方

七、最佳实践与常见问题

7.1 最佳实践总结

7.2 常见问题与解决

Q1：提示词越长越好吗？

Q2：AI 理解错了我的意思怎么办？

Q3：可以连续对话吗？

Q4：对话太长变慢了怎么办？

Q5：生成的代码不符合预期怎么办？

Q6：生成的代码安全吗？

7.3 提示词效果对比

7.4 Claude Code 2.1.79 对话命令一览

7.5 模型选择建议

🎉 总结

💬 Claude Code 入门完全指南三（整合版）：提示词与代码生成