第2395篇：AI产品的快速原型——3天构建可验证的AI功能Demo

适读人群：需要快速验证AI功能可行性的工程师和技术负责人 | 阅读时长：约14分钟 | 核心价值：掌握3天内构建可验证AI原型的方法论和代码框架

「老张，老板让我们这周五前做个Demo，验证一下AI辅助代码审查的可行性，你觉得能做吗？」

周一早上9点，一个团队负责人在群里发了这条消息。

我看了下时间：4天，包含一个工作日的准备时间。

我的回复是：「能做，但你要想清楚Demo验证的是什么。」

这是关键的区别——原型不是产品的缩小版，原型是验证核心假设的最小实验。

很多团队在做AI Demo时走偏了：花了2周时间把UI做得很好看，但核心的AI能力根本没验证；或者把所有功能都塞进去，反而不知道哪里成立哪里不成立。

3天构建可验证AI原型，是一门需要刻意练习的工程技能。

---

原型的核心：验证什么假设？

在敲第一行代码之前，你需要回答一个问题：这个原型要验证的核心假设是什么？

AI功能通常有三类核心假设：

1. 技术可行性假设：这个AI能力在技术上是否成立？（准确率能不能达到可用标准？）
2. 用户价值假设：用户真的需要这个功能吗？他们愿意使用它吗？
3. 商业可行性假设：这个功能的成本和收益是否合理？

一个3天的原型，只能验证其中一类假设。试图同时验证三类假设，往往三类都验证不了。

以AI代码审查为例：

• 如果你的假设是「LLM能准确识别常见Java代码缺陷」→ 技术可行性假设，Demo应该聚焦在准确率测试上
• 如果你的假设是「开发者愿意在代码提交时等待AI审查」→ 用户价值假设，Demo应该聚焦在交互流程和等待体验上
• 如果你的假设是「AI审查能替代人工审查减少50%的review成本」→ 商业可行性假设，Demo应该聚焦在与人工审查的效果对比上

---

3天原型的时间分配

Day 1：核心能力验证

上午：收集10-20个真实的测试用例。这是最关键的一步，很多原型失败不是因为技术不行，而是用假数据验证了一个不存在的问题。

下午：专注于Prompt工程，让AI核心能力在这20个用例上达到可接受的表现。不要建数据库，不要做UI，就是命令行跑通。

Day 2：集成与流程打通

把Day 1验证的核心能力集成到一个可以端到端运行的流程中。加上必要的API接口，打通数据输入输出，处理常见异常。

Day 3：演示优化

加一个最简单的界面（哪怕是Swagger UI或者命令行交互），写好演示脚本，预演2-3遍，准备好常见问题的答案。

---

实战：AI代码审查原型（3天完整实现）

Day 1 核心：Prompt工程 + 能力验证

/**
 * Day 1 核心验证：AI代码审查能力测试
 * 目标：在20个真实代码样本上验证准确率是否达到70%以上
 */
@SpringBootApplication
public class CodeReviewPrototype {
    
    public static void main(String[] args) {
        SpringApplication.run(CodeReviewPrototype.class, args);
    }
}

@Service
public class CodeReviewService {
    
    private final ChatClient chatClient;
    
    private static final String REVIEW_PROMPT_TEMPLATE = """
        你是一个专业的Java代码审查员，专注于发现以下类别的代码问题：
        
        **安全问题**（优先级：HIGH）
        - SQL注入风险
        - XSS漏洞
        - 敏感信息硬编码
        - 不安全的反序列化
        
        **性能问题**（优先级：MEDIUM）
        - N+1查询
        - 不必要的对象创建
        - 未关闭的资源
        - 低效的集合操作
        
        **代码质量**（优先级：LOW）
        - 过长的方法（>50行）
        - 缺失的空值检查
        - 不合理的异常处理
        - 魔法数字
        
        请审查以下Java代码，以JSON格式返回发现的问题：
        
        ```java
        %s
        ```
        
        返回格式：
        {
          "issues": [
            {
              "line": 行号,
              "type": "SECURITY|PERFORMANCE|QUALITY",
              "priority": "HIGH|MEDIUM|LOW",
              "description": "问题描述",
              "suggestion": "修改建议"
            }
          ],
          "summary": "总体评价（1-2句话）",
          "score": 综合评分（0-100）
        }
        
        只返回JSON，不要其他内容。
        """;
    
    public CodeReviewResult review(String javaCode) {
        String prompt = REVIEW_PROMPT_TEMPLATE.formatted(javaCode);
        
        long startTime = System.currentTimeMillis();
        String response = chatClient.prompt()
            .user(prompt)
            .call()
            .content();
        long latency = System.currentTimeMillis() - startTime;
        
        CodeReviewResult result = parseReviewResult(response);
        result.setLatencyMs(latency);
        return result;
    }
    
    /**
     * Day 1 批量验证方法：在测试集上评估整体准确率
     */
    public ValidationReport runValidation(List<ReviewTestCase> testCases) {
        int truePositive = 0;  // 正确找到了真实问题
        int falsePositive = 0; // 报告了不存在的问题
        int falseNegative = 0; // 漏掉了真实问题
        List<String> failures = new ArrayList<>();
        
        for (ReviewTestCase tc : testCases) {
            CodeReviewResult result = review(tc.code());
            
            Set<String> foundIssueTypes = result.getIssues().stream()
                .map(issue -> issue.type() + ":" + issue.priority())
                .collect(Collectors.toSet());
            
            for (String expectedIssue : tc.expectedIssues()) {
                if (foundIssueTypes.contains(expectedIssue)) {
                    truePositive++;
                } else {
                    falseNegative++;
                    failures.add("漏检：" + tc.name() + " 应有 " + expectedIssue);
                }
            }
            
            for (String foundIssue : foundIssueTypes) {
                if (!tc.expectedIssues().contains(foundIssue)) {
                    falsePositive++;
                }
            }
        }
        
        double precision = (double) truePositive / (truePositive + falsePositive);
        double recall = (double) truePositive / (truePositive + falseNegative);
        double f1 = 2 * precision * recall / (precision + recall);
        
        System.out.printf("验证结果 - 精确率：%.1f%% 召回率：%.1f%% F1：%.3f%n",
            precision * 100, recall * 100, f1);
        failures.forEach(System.out::println);
        
        return new ValidationReport(precision, recall, f1, failures);
    }
}

Day 2 集成：Spring Boot API + 数据流打通

@RestController
@RequestMapping("/api/v1/review")
public class CodeReviewController {
    
    private final CodeReviewService reviewService;
    private final ReviewHistoryRepository historyRepo;
    
    @PostMapping
    public ResponseEntity<CodeReviewResponse> review(
            @RequestBody @Valid CodeReviewRequest request) {
        
        // 基础输入验证
        if (request.code().length() > 10_000) {
            return ResponseEntity.badRequest()
                .body(CodeReviewResponse.error("代码长度超过限制（最大10000字符）"));
        }
        
        try {
            CodeReviewResult result = reviewService.review(request.code());
            
            // 保存历史记录（用于演示统计数据）
            ReviewHistory history = new ReviewHistory(
                request.submitterId(),
                request.code(),
                result,
                LocalDateTime.now()
            );
            historyRepo.save(history);
            
            return ResponseEntity.ok(CodeReviewResponse.success(result));
            
        } catch (Exception e) {
            log.error("代码审查失败", e);
            return ResponseEntity.internalServerError()
                .body(CodeReviewResponse.error("AI服务暂时不可用，请稍后重试"));
        }
    }
    
    @GetMapping("/stats")
    public ReviewStats getStats() {
        List<ReviewHistory> recent = historyRepo.findRecentByDays(7);
        
        return new ReviewStats(
            recent.size(),
            recent.stream().mapToDouble(h -> h.getResult().score()).average().orElse(0),
            recent.stream().mapToLong(h -> h.getResult().latencyMs()).average().orElse(0),
            countIssuesByType(recent)
        );
    }
}

@Data
public class CodeReviewResult {
    private List<Issue> issues;
    private String summary;
    private int score;
    private long latencyMs;
    
    record Issue(int line, String type, String priority, 
                 String description, String suggestion) {}
}

record CodeReviewRequest(
    @NotBlank String code,
    String submitterId,
    String repositoryName
) {}

record CodeReviewResponse(boolean success, CodeReviewResult result, String error) {
    static CodeReviewResponse success(CodeReviewResult r) {
        return new CodeReviewResponse(true, r, null);
    }
    static CodeReviewResponse error(String msg) {
        return new CodeReviewResponse(false, null, msg);
    }
}

Day 3：演示优化 + 指标看板

/**
 * Day 3：添加简单的Web界面和演示脚本数据
 * 原型演示的关键是让观众能直观感受到AI的能力
 */
@Controller
public class DemoController {
    
    private final CodeReviewService reviewService;
    
    @GetMapping("/demo")
    public String demoPage(Model model) {
        // 预加载几个典型的演示用例，让演示更流畅
        model.addAttribute("demoExamples", getDemoExamples());
        return "demo";
    }
    
    /**
     * 精心准备的演示用例：每个用例都能清晰展示AI的某个能力
     */
    private List<DemoExample> getDemoExamples() {
        return List.of(
            new DemoExample(
                "SQL注入漏洞检测",
                """
                public User findUser(String userId) {
                    String sql = "SELECT * FROM users WHERE id = '" + userId + "'";
                    return jdbcTemplate.queryForObject(sql, User.class);
                }
                """,
                "演示AI检测SECURITY:HIGH级别问题"
            ),
            new DemoExample(
                "N+1查询问题",
                """
                public List<OrderDTO> getOrdersWithItems(List<Long> orderIds) {
                    List<Order> orders = orderRepo.findAllById(orderIds);
                    return orders.stream()
                        .map(order -> {
                            List<Item> items = itemRepo.findByOrderId(order.getId());
                            return new OrderDTO(order, items);
                        })
                        .collect(Collectors.toList());
                }
                """,
                "演示AI检测PERFORMANCE:MEDIUM级别问题"
            ),
            new DemoExample(
                "资源未关闭",
                """
                public String readConfig(String path) throws IOException {
                    FileInputStream fis = new FileInputStream(path);
                    byte[] bytes = fis.readAllBytes();
                    return new String(bytes, StandardCharsets.UTF_8);
                }
                """,
                "演示AI检测资源泄漏问题"
            )
        );
    }
    
    record DemoExample(String title, String code, String note) {}
}

---

原型演示的关键技巧

技巧一：准备「哇时刻」

每个原型演示都需要至少一个让观众眼睛发亮的时刻。对于代码审查原型，「哇时刻」可以是：让观众现场输入一段他们自己写的代码，AI实时给出审查意见。

现场感比提前录好的视频更有说服力。

技巧二：诚实地展示局限性

演示中主动说出AI的局限，反而增加可信度：「当前的准确率是72%，这意味着100个问题里会漏掉28个，所以这个版本定位是辅助工具，不是替代人工审查。」

这比一味吹嘘效果更让技术管理层信任。

技巧三：展示数字，不要展示感受

不要说「AI回答得很快」，要说「P95延迟是2.3秒」；不要说「准确率挺高的」，要说「在我们准备的20个测试用例上，精确率83%，召回率77%」。

数字是建立信任的基础。

---

原型完成后的决策框架

3天原型做完，需要回答三个问题：

原型的成功不是「Demo看起来很酷」，而是「我们对这个方向有了明确的结论」——无论结论是继续推进还是及时止损，都是有价值的。

---

总结

3天AI原型的本质是：用最小的投入，验证最关键的假设，做出是否继续的决策。

关键原则：

1. 先定义要验证的假设，再开始写代码
2. Day 1专注核心能力，不建数据库不做UI
3. 用真实数据（不用假数据）验证
4. 用数字说话，不用主观感受
5. 诚实展示局限性，比吹嘘效果更有价值

工程师做原型的最大优势是：我们可以在3天内写出可以测量的东西，而不只是画个原型图。这是和产品同学协作时最强的竞争力。