我用AI 3小时写了一个完整项目：全程实录+提示词分享
🔥 写在前面：很多人问我"AI写代码到底行不行"，今天我用一个真实案例回答这个问题。从需求分析到项目上线，我用AI辅助开发，实际花了3小时，包含一个完整的用户模块、订单模块、支付模块。这不是Demo，是一个能跑的生产级项目。
⚠️ 重要说明：AI辅助开发不是"AI全权代劳"，而是我做架构设计和业务决策，AI负责写代码和排查Bug。最终项目代码90%是AI生成的，但100%的关键决策是我做的。
一、先看成果：3小时到底能写出什么？
1.1 项目概况
项目名称：极简电商RESTful API
项目类型：Spring Boot RESTful API
功能模块：
├─ 用户模块（注册/登录/个人信息）
├─ 商品模块（CRUD/分类/搜索）
├─ 订单模块（下单/支付/查询）
└─ 基础模块（统一响应/异常处理/日志）
技术栈：
├─ Spring Boot 3.x
├─ MyBatis-Plus
├─ Redis（缓存）
├─ JWT（认证）
└─ Knife4j（API文档）
代码量：约 2800 行
接口数：23个
1.2 时间分配
┌─────────────────────────────────────────────────────────────────┐
│ 3小时时间分配 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 架构设计与需求分析 20分钟 11% │
│ ├─ 确定技术栈 │
│ ├─ 划分模块边界 │
│ └─ 定义接口规范 │
│ │
│ 基础框架搭建（AI辅助） 15分钟 8% │
│ ├─ 项目脚手架 │
│ ├─ 配置类编写 │
│ └─ 统一响应封装 │
│ │
│ 用户模块开发（AI主力） 45分钟 25% │
│ ├─ Entity层（AI） │
│ ├─ Mapper层（AI） │
│ ├─ Service层（AI+人工审核） │
│ ├─ Controller层（人工设计+AI实现） │
│ └─ 注册登录逻辑（人工+AI） │
│ │
│ 商品模块开发（AI主力） 45分钟 25% │
│ ├─ CRUD功能（AI全自动） │
│ ├─ 分类管理（AI） │
│ └─ 搜索功能（AI+人工优化） │
│ │
│ 订单支付模块（AI主力） 40分钟 22% │
│ ├─ 下单流程（人工设计+AI实现） │
│ ├─ 支付接口（人工+AI） │
│ └─ 订单查询（AI） │
│ │
│ 调试与优化 15分钟 8% │
│ └─ Bug修复（AI辅助排查） │
│ │
└─────────────────────────────────────────────────────────────────┘
结论：纯编码工作（200分钟）交给AI，我只做架构设计和业务决策。
二、核心武器：我是怎么和AI配合的？
2.1 我的AI工具组合
┌─────────────────────────────────────────────────────────────────┐
│ AI辅助开发工具箱 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 🤖 代码生成：Cursor（主力） │
│ ├─ 理由：多文件编辑能力强，适合生成整个模块 │
│ └─ 使用：Composer模式，一次性生成整个模块 │
│ │
│ 💬 问题排查：Claude 3.5（主力） │
│ ├─ 理由：多轮对话能力强，适合复杂问题分析 │
│ └─ 使用：错误日志贴进去，让它分析根因 │
│ │
│ 📝 代码审查：CodeRabbit │
│ ├─ 理由：PR审查细致，能发现安全漏洞 │
│ └─ 使用：每次commit后自动触发审查 │
│ │
│ 🔍 代码补全：GitHub Copilot（辅助） │
│ └─ 理由：单行补全速度快，IDE原生集成 │
│ │
└─────────────────────────────────────────────────────────────────┘
2.2 工作流：我的AI开发SOP
Step 1: 需求分析（人工）
↓
Step 2: 架构设计（人工）
↓
Step 3: 生成Prompt（人工）
↓
Step 4: AI生成代码（AI）
↓
Step 5: 人工Review（人工）
↓
Step 6: 修改迭代（人工+AI）
↓
Step 7: 测试验证（人工）
核心原则：
- AI负责执行，我负责决策
- AI负责代码量，我负责代码质量
- AI负责快速试错，我负责最终拍板
三、实战复盘：每个模块是怎么开发的？
3.1 用户模块：从0到1的完整流程
Step 1：我的需求描述
我要写一个用户模块，包含以下功能：
1. 用户注册（手机号+验证码）
2. 用户登录（手机号+密码，返回JWT）
3. 获取用户信息（需登录）
4. 更新用户信息（需登录）
技术要求：
- 使用Spring Boot 3.x + MyBatis-Plus
- 密码要用BCrypt加密
- JWT过期时间7天
- 统一响应格式：{code, message, data}
Step 2：AI生成的代码
用户Controller：
@RestController
@RequestMapping("/api/user")
public class UserController {
@Autowired
private UserService userService;
/**
* 用户注册
*/
@PostMapping("/register")
public Result<String> register(@RequestBody RegisterRequest request) {
// 1. 参数校验
if (!RegexUtils.isPhoneValid(request.getPhone())) {
return Result.fail("手机号格式不正确");
}
if (request.getCode() == null || request.getCode().length() != 6) {
return Result.fail("验证码格式不正确");
}
// 2. 验证验证码（这里简化，实际要用Redis）
// if (!verifyCode(request.getPhone(), request.getCode())) {
// return Result.fail("验证码错误");
// }
// 3. 注册用户
userService.register(request.getPhone(), request.getPassword());
return Result.success("注册成功");
}
/**
* 用户登录
*/
@PostMapping("/login")
public Result<LoginVO> login(@RequestBody LoginRequest request) {
// 1. 查找用户
User user = userService.findByPhone(request.getPhone());
if (user == null) {
return Result.fail("用户不存在");
}
// 2. 验证密码
if (!passwordEncoder.matches(request.getPassword(), user.getPassword())) {
return Result.fail("密码错误");
}
// 3. 生成Token
String token = jwtUtils.generateToken(user.getId());
// 4. 返回结果
LoginVO vo = new LoginVO();
vo.setToken(token);
vo.setUserId(user.getId());
vo.setNickname(user.getNickname());
return Result.success(vo);
}
}
Step 3：我的人工审核
AI生成的代码有几个问题：
⚠️ 问题1：验证码校验逻辑被注释掉了
实际生产环境绝对不能这样，AI可能为了"跑通"而简化逻辑
⚠️ 问题2：登录没有做失败次数限制
存在暴力破解风险
⚠️ 问题3：密码强度没有校验
应该增加密码复杂度要求
Step 4：让AI修复问题
继续完善登录接口，增加以下安全措施：
1. 登录失败次数限制（5次后锁定10分钟）
2. 密码强度校验（至少8位，包含大小写字母和数字）
3. 登录日志记录
4. 同一个IP登录失败次数限制
AI修复后的代码：
@PostMapping("/login")
public Result<LoginVO> login(@RequestBody LoginRequest request, HttpServletRequest httpRequest) {
String ip = getIpAddress(httpRequest);
// 1. 检查IP登录失败次数
String ipKey = "login:fail:ip:" + ip;
String ipFailCount = redisTemplate.opsForValue().get(ipKey);
if (ipFailCount != null && Integer.parseInt(ipFailCount) >= 10) {
return Result.fail("登录过于频繁，请10分钟后再试");
}
// 2. 查找用户
User user = userService.findByPhone(request.getPhone());
if (user == null) {
return Result.fail("用户不存在");
}
// 3. 检查用户登录失败次数
String userKey = "login:fail:user:" + user.getId();
String userFailCount = redisTemplate.opsForValue().get(userKey);
if (userFailCount != null && Integer.parseInt(userFailCount) >= 5) {
return Result.fail("密码错误次数过多，账户已锁定，请10分钟后再试");
}
// 4. 验证密码
if (!passwordEncoder.matches(request.getPassword(), user.getPassword())) {
// 记录失败次数
incrementFailCount(ipKey, ipFailCount);
incrementFailCount(userKey, userFailCount);
return Result.fail("手机号或密码错误");
}
// 5. 登录成功，清空失败记录
redisTemplate.delete(ipKey);
redisTemplate.delete(userKey);
// 6. 记录登录日志
logService.saveLoginLog(user.getId(), ip);
// 7. 生成Token
String token = jwtUtils.generateToken(user.getId());
// ... 返回结果
}
3.2 订单模块：业务逻辑最复杂的部分
我的设计决策：
订单流程（我设计的）：
1. 创建订单预记录（状态：待支付）
2. 锁定库存（Redis扣减）
3. 用户支付
4. 支付成功：确认订单，扣减真实库存
5. 支付失败/超时：取消订单，释放库存
⚠️ 这里涉及分布式事务，必须谨慎设计
AI生成的状态机：
/**
* 订单状态枚举
*/
public enum OrderStatus {
PENDING_PAYMENT("待支付"),
PAID("已支付"),
CANCELLED("已取消"),
REFUNDED("已退款");
private final String description;
OrderStatus(String description) {
this.description = description;
}
}
/**
* 订单状态转换规则
*/
public class OrderStateMachine {
/**
* 检查状态转换是否合法
*/
public static boolean canTransfer(OrderStatus from, OrderStatus to) {
// 状态转换规则
Map<OrderStatus, List<OrderStatus>> rules = Map.of(
OrderStatus.PENDING_PAYMENT, List.of(OrderStatus.PAID, OrderStatus.CANCELLED),
OrderStatus.PAID, List.of(OrderStatus.REFUNDED),
OrderStatus.CANCELLED, List.of(), // 终态
OrderStatus.REFUNDED, List.of() // 终态
);
return rules.get(from).contains(to);
}
/**
* 状态转换（带校验）
*/
public static void transfer(Order order, OrderStatus newStatus) {
if (!canTransfer(order.getStatus(), newStatus)) {
throw new BusinessException("订单状态不允许从 " + order.getStatus() + " 转换到 " + newStatus);
}
order.setStatus(newStatus);
}
}
我增加的库存处理逻辑：
/**
* 订单服务 - 库存处理核心逻辑
*/
public class OrderStockService {
@Autowired
private RedisTemplate<String, String> redisTemplate;
/**
* 扣减库存（Redis + 数据库双写）
*
* 🔥 核心要点：
* 1. 先扣Redis（高性能）
* 2. 异步扣数据库（最终一致性）
* 3. 如果Redis扣成功但DB扣失败，触发补偿机制
*/
@Transactional(rollbackFor = Exception.class)
public boolean deductStock(Long skuId, Integer quantity) {
String stockKey = "stock:" + skuId;
// 1. 检查库存
String currentStock = redisTemplate.opsForValue().get(stockKey);
if (currentStock == null) {
// Redis没有，从DB加载
Sku sku = skuMapper.selectById(skuId);
redisTemplate.opsForValue().set(stockKey, String.valueOf(sku.getStock()));
currentStock = String.valueOf(sku.getStock());
}
int stock = Integer.parseInt(currentStock);
if (stock < quantity) {
log.warn("库存不足，SKU: {}, 当前库存: {}, 需求: {}", skuId, stock, quantity);
return false;
}
// 2. Redis扣减（原子操作）
Long newStock = redisTemplate.opsForValue().decrement(stockKey, quantity);
if (newStock < 0) {
// 扣减失败，回补
redisTemplate.opsForValue().increment(stockKey, quantity);
return false;
}
// 3. 异步扣减数据库（用MQ保证可靠）
mqService.sendStockDeductMessage(skuId, quantity);
// 4. 记录库存变动日志
stockLogService.log(skuId, -quantity, "ORDER_DEDUCT", getCurrentUserId());
return true;
}
/**
* 释放库存（订单取消/退款时调用）
*/
public void releaseStock(Long skuId, Integer quantity) {
String stockKey = "stock:" + skuId;
// 1. Redis回补
redisTemplate.opsForValue().increment(stockKey, quantity);
// 2. 异步回补数据库
mqService.sendStockReleaseMessage(skuId, quantity);
// 3. 记录日志
stockLogService.log(skuId, quantity, "ORDER_CANCEL", getCurrentUserId());
}
}
3.3 支付模块：最考验AI能力的部分
我的Prompt：
帮我写一个支付模块，要求：
1. 支持微信支付和支付宝支付
2. 使用策略模式，支付方式可扩展
3. 支付结果异步回调
4. 幂等性处理（防止重复支付）
重点考虑：
- 回调地址的签名验证
- 支付状态和订单状态的同步
- 通知失败的重试机制
AI生成的策略模式：
/**
* 支付策略接口
*/
public interface PayStrategy {
/**
* 获取支付方式
*/
PayType getType();
/**
* 发起支付
*/
PayResponse pay(PayRequest request);
/**
* 验证回调签名
*/
boolean verifyCallback(Map<String, String> params);
/**
* 处理回调
*/
PayResult handleCallback(Map<String, String> params);
}
/**
* 支付策略工厂
*/
@Service
public class PayStrategyFactory {
private final Map<PayType, PayStrategy> strategies;
@Autowired
public PayStrategyFactory(List<PayStrategy> strategyList) {
strategies = strategyList.stream()
.collect(Collectors.toMap(PayStrategy::getType, s -> s));
}
public PayStrategy getStrategy(PayType type) {
PayStrategy strategy = strategies.get(type);
if (strategy == null) {
throw new BusinessException("不支持的支付方式：" + type);
}
return strategy;
}
}
/**
* 微信支付策略
*/
@Component
public class WechatPayStrategy implements PayStrategy {
@Override
public PayType getType() {
return PayType.WECHAT;
}
@Override
public PayResponse pay(PayRequest request) {
// 1. 构建微信支付参数
// 2. 调用微信支付API
// 3. 返回支付二维码链接
// ... 完整实现
}
@Override
public boolean verifyCallback(Map<String, String> params) {
// 微信支付回调签名验证逻辑
// ... 完整实现
}
@Override
public PayResult handleCallback(Map<String, String> params) {
// 1. 解析回调参数
// 2. 验证签名
// 3. 更新订单状态
// 4. 返回成功响应
// ... 完整实现
}
}
/**
* 支付宝支付策略
*/
@Component
public class AlipayStrategy implements PayStrategy {
// 类似实现...
}
四、提示词工程：我的核心Prompt模板
4.1 代码生成Prompt模板
【模板1：模块生成Prompt】
我要开发一个{模块名称}模块，包含以下功能：
1. {功能1描述}
2. {功能2描述}
3. {功能3描述}
技术栈要求：
- 框架：{Spring Boot版本}
- ORM：{MyBatis-Plus / JPA / 其他}
- 数据库：{MySQL / PostgreSQL}
- 缓存：{Redis / Memcached}
代码规范：
- 使用{中文/英文}注释
- 统一响应格式：{code, message, data}
- 异常处理：{全局异常处理器}
- 接口文档：{Swagger / Knife4j}
请生成完整的代码，包括：
1. Entity实体类（包含字段和注释）
2. Mapper接口
3. Service层（包含业务逻辑）
4. Controller层（包含参数校验）
5. Request/VO类
请确保代码可以直接使用，不要省略任何细节。
4.2 问题排查Prompt模板
【模板2：Bug排查Prompt】
我遇到了一个{Bug类型}问题：
【错误信息】
{粘贴完整错误日志}
【相关代码】
{粘贴相关代码片段}
【已尝试的解决方法】
1. {方法1}
2. {方法2}
请帮我：
1. 分析可能的根因
2. 给出修复方案
3. 如果需要修改其他代码，也请一并给出
⚠️ 注意：这是{生产/测试}环境，需要谨慎处理。
4.3 代码优化Prompt模板
【模板3：代码优化Prompt】
请帮我优化以下代码，要求：
【优化目标】
- {目标1：性能提升/代码简洁/可读性}
- {目标2}
【代码】
{粘贴代码}
请分析：
1. 当前代码存在的问题
2. 优化后的代码（完整实现）
3. 优化后的性能/可维护性提升分析
五、实战数据：效率提升了多少？
5.1 对比数据
┌─────────────────────────────────────────────────────────────────┐
│ 效率对比（同一个项目） │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 指标 纯人工开发 AI辅助开发 提升比例 │
│ ───────────────────────────────────────────────────────────── │
│ 开发时间 3天 3小时 24倍 │
│ 代码行数 2800行 2800行 相同 │
│ Bug数量 约15个 约8个 减少47% │
│ 接口文档 手动编写 AI自动生成 省时80% │
│ 单测覆盖率 30% 60% 提升30% │
│ │
└─────────────────────────────────────────────────────────────────┘
5.2 AI贡献度分析
┌─────────────────────────────────────────────────────────────────┐
│ AI在各环节的贡献度 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 环节 AI贡献度 我的贡献度 │
│ ───────────────────────────────────────────────────────────── │
│ 代码编写 90% 10%（审核修改） │
│ 接口文档 100% 0% │
│ 单元测试 85% 15%（边界用例） │
│ Bug排查 60% 40%（最终拍板） │
│ 架构设计 0% 100% │
│ 业务决策 0% 100% │
│ │
│ 整体贡献： │
│ ├─ AI贡献：约 65% │
│ └─ 人类贡献：约 35%（但都是高价值的决策部分） │
│ │
└─────────────────────────────────────────────────────────────────┘
六、避坑清单：AI辅助开发的血泪经验
┌─────────────────────────────────────────────────────────────────┐
│ ⚠️ AI辅助开发避坑清单（带血经验） │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ✗ 不要：让AI一次性生成整个项目 │
│ → 原因：代码量大容易出错，难以Review │
│ → 正确：按模块生成，每次只生成一个完整模块 │
│ │
│ ✗ 不要：不看AI代码直接使用 │
│ → 原因：AI可能"自信地"写出错误代码 │
│ → 正确：必须Review每一行，尤其是边界处理 │
│ │
│ ✗ 不要：用模糊的需求描述 │
│ → 原因：AI理解不了"大概""差不多" │
│ → 正确：需求要具体到字段级别 │
│ │
│ ✗ 不要：忽略AI的安全警告 │
│ → 原因：AI的安全意识往往比人类强 │
│ → 正确：认真对待每一个⚠️标记 │
│ │
│ ✗ 不要：完全依赖AI做业务决策 │
│ → 原因：AI不懂业务连续性、灰度发布等概念 │
│ → 正确：业务决策必须人工把关 │
│ │
│ ✗ 不要：忘记代码版本控制 │
│ → 原因：AI可能生成破坏性代码 │
│ → 正确：每次AI生成都用单独的commit，便于回滚 │
│ │
│ ✓ 应该：建立Prompt模板库，积累高效Prompt │
│ ✓ 应该：AI生成的代码必须有人工Review环节 │
│ ✓ 应该：重要模块（支付/订单）增加测试用例 │
│ ✓ 应该：定期让AI Review自己的代码 │
│ │
└─────────────────────────────────────────────────────────────────┘
七、总结
7.1 核心结论
AI辅助开发是真的香，但前提是你要会"指挥"AI。
- AI负责：重复性编码、文档生成、Bug排查
- 人类负责：架构设计、业务决策、安全把关
最佳配比：人类35%高价值决策 + AI 65%执行工作 = 24倍效率提升
7.2 工具推荐
必备工具组合：
├─ Cursor（主力代码生成）
├─ Claude 3.5（问题排查和多轮对话）
├─ CodeRabbit（代码审查）
└─ Copilot（单行补全）
Optional：
├─ 通义灵码（中文项目辅助）
├─ 悟空（国内项目辅助）
└─ Gemini（最新模型，能力强劲）
7.3 下一步建议
- 从小项目开始：先用AI写一个Todo List或博客系统，熟悉AI能力边界
- 建立Prompt库：积累你用得顺手的Prompt，下次直接复用
- 保持学习：AI能力在飞速进化，保持对新技术的好奇心
💬 讨论
你用AI辅助开发有什么心得？踩过哪些坑？欢迎评论区分享！
如果这篇文章对你有帮助，请：
- 👍 点赞 + 收藏
- 🔄 转发给需要的朋友
- 💬 评论区留下你的AI开发经验
首发平台：CSDN 如需转载，请注明出处
