AI 生成代码质量评估：怎么判断 AI 写的是不是好代码

Simi 收录于 AI

2025-11-15 约 1014 字预计阅读 3 分钟

背景

AI 写代码已经一年多了。从最初的玩具到现在每天主力工具，这个转变比我预期的快。

但有一个问题始终没被很好回答：怎么判断 AI 写的代码质量好不好？

简单地说"让 human review"不够。Reviewer 也不知道该用什么标准判断 AI 代码。AI 代码往往看起来很对，但实际上有隐藏问题。

这篇文章给出我实际使用的评估框架。

评估维度

1. 正确性（最重要）

AI 代码最大的问题是：看起来对，但运行结果不对。

评估方法：

        
        
        
    
# 给 AI 的任务：写一个快速排序
def quicksort(arr):
    """
    Returns sorted array using quicksort.
    """
    # AI 生成了代码，看起来很对
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)

# 正确性测试
assert quicksort([3, 1, 4, 1, 5, 9, 2, 6]) == [1, 1, 2, 3, 4, 5, 6, 9]
assert quicksort([1]) == [1]
assert quicksort([]) == []
assert quicksort([2, 2, 2]) == [2, 2, 2]

核心问题：AI 经常在边界条件上出错。你的测试用例必须覆盖：

空数组
单元素数组
全相同元素
已排序数组
逆序数组
超大数组

2. 复杂度

AI 经常写出时间/空间复杂度不优的代码。

        
        
        
    
# AI 写的：O(n²)
def find_duplicates_bad(arr):
    duplicates = []
    for i in range(len(arr)):
        for j in range(i+1, len(arr)):
            if arr[i] == arr[j] and arr[i] not in duplicates:
                duplicates.append(arr[i])
    return duplicates

# 更好的：O(n)
def find_duplicates_good(arr):
    seen = set()
    duplicates = set()
    for num in arr:
        if num in seen:
            duplicates.add(num)
        seen.add(num)
    return list(duplicates)

问 AI：“这个算法复杂度是多少？” —— 如果 AI 说不清楚，说明它自己没想清楚。

3. 可读性

AI 代码经常"能跑但看不懂"。

评估问题：

        
# AI 写的：简洁但晦涩
def p(x): return x and (x > 0) and (x % 2 == 0)

# 更好的：
def is_positive_even(x: int) -> bool:
    """Check if x is a positive even number."""
    return x > 0 and x % 2 == 0

评估清单：

变量名有意义吗？
有 docstring 吗？
复杂逻辑有注释吗？
函数单一职责吗？

4. 可维护性

        
        
        
    
# AI 写的：耦合严重，难以测试
class UserService:
    def __init__(self, db_connection_string):
        self.db = connect(db_connection_string)
        self.emailer = EmailService()
        self.logger = Logger()
    
    def register(self, email, password):
        # 硬编码了所有依赖，无法单独测试 register 逻辑
        ...

# 更好的：依赖注入
class UserService:
    def __init__(self, db, emailer, logger):
        self.db = db
        self.emailer = emailer
        self.logger = logger

评估问题：

依赖是显式注入的吗？
函数/类有单一职责吗？
修改一个地方会意外破坏其他地方吗？

实际工作流

我现在的 AI 代码评估流程：

1. AI 生成代码
   ↓
2. 运行测试套件（必须有测试）
   ↓
3. 问 AI：这段代码的复杂度是多少？
   ↓
4. 问 AI：这个函数/类的职责是什么？是否符合单一职责？
   ↓
5. 代码审查（重点看边界条件和依赖注入）
   ↓
6. 手动跑几个边界 case

结论

评估 AI 代码的核心：

正确性：必须有测试，覆盖边界条件
复杂度：问 AI 复杂度，说不清的代码不能用
可读性：自己能解释这段代码在干什么
可维护性：依赖注入了吗？单一职责了吗？

AI 是工具，不是替代品。AI 写的代码仍然需要人来评估质量。

把 AI 当成一个初级工程师：可以干活，但必须 review。

目录