AI辅助技术债管理：自动识别、优先级排序、重构建议

AI辅助技术债管理：自动识别、优先级排序、重构建议

我们团队用AI分析了10万行代码的技术债，制定了重构计划。不是"AI代替人做重构"，而是"AI帮人找到最该重构的地方"。

背景：我们的技术债已经"债台高筑"

带9人技术团队，技术债一直是个头疼的问题。

现状：

• 项目跑了3年，代码量从2万行涨到10万行
• 谁都不敢轻易重构——怕改出bug
• 技术债列表（在TAPD里）有200+条，但没人知道先还哪笔债
• 新功能还在不断加，技术债越来越多

我当时想：有没有办法用AI分析代码，自动识别技术债、排优先级、给重构建议？

于是花了2周时间，做了一个"AI辅助技术债管理"的工具链。

效果：

• 从10万行代码里，自动识别了150+处技术债（准确率约80%）
• 用AI给技术债排了优先级（不是"先来先还"，而是"影响最大的先还"）
• 给每个技术债生成了重构建议（甚至生成了重构后的代码框架）

节省时间：从"人工review 2周"到"AI分析10分钟 + 人工复核2小时"。

---

技术债管理的三大痛点

要理解AI能帮什么，先得看传统技术债管理的问题。

痛点1：技术债"看不见"

很多技术债藏在代码里，不跑测试、不压测，根本发现不了。

举例：

// 这段代码能跑，但有大问题
public List<User> getUsers() {
    List<User> users = new Array List<>();
    // 每次调用都查全表（10万条数据）
    ResultSet rs = stmt.executeQuery("SELECT * FROM users");
    while (rs.next()) {
        users.add(new User(rs));
    }
    return users;
}

问题：

• 数据量少的时候（100条），响应时间50ms，没问题
• 数据量到了10万条，响应时间2000ms，生产事故
• 但"看不见"——你不压测、不review，根本不知道这里有问题

---

痛点2：技术债"优先级不清"

我们有200+条技术债，但不知道先还哪个。

传统方式：按"提交时间"排序（先提交的先还）。

问题：有些技术债"提交了2年前"，但影响很小（比如"某个不常用的API没加缓存"）；有些技术债"提交了1个月前"，但影响很大（比如"核心接口没做限流，容易被刷爆"）。

应该按"影响面"排序，但人工判断太慢（200+条技术债，review一遍要2周）。

---

痛点3：技术债"重构建议缺失"

就算找到了技术债，开发者也不知道怎么还。

举例：TAPD里有一条技术债——"UserService里有很多重复代码，应该抽成公共方法"。

问题：

• "很多重复代码"——到底是哪些？
• "抽成公共方法"——抽到哪里？怎么抽？
• 如果重构错了，会不会引入新bug？

开发者看到这种技术债，通常选择"下次再说"——然后就再也没有"下次"了。

---

我们的AI辅助技术债管理方案

基于上面的痛点，我设计了一套"AI辅助技术债管理"的工作流。

工作流总览

Step 1: AI自动识别技术债（扫代码）
   ↓
Step 2: AI给技术债排优先级（基于影响面、修复成本、风险等级）
   ↓
Step 3: AI生成重构建议（包含代码示例）
   ↓
Step 4: 人工复核（AI的建议是否合理？）
   ↓
Step 5: 生成技术债还款计划（排期）

核心：AI做"预筛选"，人做"最终决策"。

---

Step 1：AI自动识别技术债

工具选择

我们试了3个工具：

工具	原理	优点	缺点	识别准确率
SonarQube + AI插件	静态分析 + AI解释	集成方便，已有SonarQube的直接用	AI解释有时候太通用（"建议重构此方法"）	70%
Claude Opus 4.7（直接读代码）	把代码丢给Claude，让它找技术债	理解上下文能力强，能发现"业务逻辑级别的技术债"	需要手动操作（没有自动化），只适合小项目	85%
自研工具（基于Tree-sitter + Claude API）	解析AST → 找可疑代码块 → 丢给Claude判断	自动化，能批量处理大项目	需要自己开发（约3天）	80%

我们的最终选择：自研工具（基于Tree-sitter + Claude API）。

理由：虽然要自己开发，但一次开发，长期受益（每次跑10分钟，就能扫完10万行代码）。

---

实现细节（自研工具）

核心思路：

1. 用 Tree-sitter 解析代码（支持Java、Python、JavaScript）
2. 找"可疑代码块"（符合某些规则）
3. 把"可疑代码块"丢给 Claude API，让它判断是否技术债
4. 如果是技术债，让Claude给出：
   • 技术债类型（代码重复 / 性能问题 / 安全风险 / 可维护性差）
   • 严重等级（高 / 中 / 低）
   • 重构建议

代码片段（Python，核心逻辑）：

import tree_sitter_java as ts_java
from anthropic import Anthropic

# 1. 解析Java代码，找"可疑代码块"
def find_suspicious_blocks(java_code):
    parser = ts_java.Parser()
    tree = parser.parse(java_code.encode())
    
    suspicious = []
    
    # 规则1：方法超过50行 → 可能"方法过长"
    for method_node in tree.root_node.descendants_for_type('method_declaration'):
        if method_node.end_point[0] - method_node.start_point[0] > 50:
            suspicious.append({
                'type': 'long_method',
                'node': method_node,
                'code': method_node.text.decode()
            })
    
    # 规则2：嵌套if超过3层 → 可能"逻辑复杂"
    # 规则3：一个类超过500行 → 可能"职责不单一"
    # ...（省略其他规则）
    
    return suspicious

# 2. 丢给Claude，判断是否技术债
def analyze_with_ai(suspicious_block):
    client = Anthropic(api_key='your-api-key')
    
    prompt = f"""
    下面是一段Java代码，请判断是否包含技术债。
    
    代码：
    ```java
    {suspicious_block['code']}
    ```
    
    如果包含技术债，请输出JSON：
    {{
        "is_tech_debt": true,
        "debt_type": "代码重复 / 性能问题 / 安全风险 / 可维护性差",
        "severity": "high / medium / low",
        "description": "技术债的具体描述",
        "refactoring_suggestion": "重构建议（包含代码示例）"
    }}
    
    如果不包含技术债，请输出：
    {{
        "is_tech_debt": false
    }}
    """
    
    response = client.messages.create(
        model="claude-opus-4.7",
        max_tokens=1024,
        messages=[{"role": "user", "content": prompt}]
    )
    
    return json.loads(response.content[0].text)

# 3. 批量处理
def scan_project(project_path):
    tech_debts = []
    
    for java_file in Path(project_path).rglob('*.java'):
        code = java_file.read_text()
        suspicious_blocks = find_suspicious_blocks(code)
        
        for block in suspicious_blocks:
            result = analyze_with_ai(block)
            if result['is_tech_debt']:
                tech_debts.append({
                    'file': str(java_file),
                    'line': block['node'].start_point[0],
                    **result
                })
    
    return tech_debts

效果：

• 扫10万行Java代码（约500个文件），耗时约10分钟（Claude API并行调用）
• 识别出150+处技术债（人工复核后，确认120+处是真的，准确率约80%）
• 每个技术债都有类型、严重等级、重构建议

---

Step 2：AI给技术债排优先级

识别出技术债后，问题来了：先还哪个？

我们有150+处技术债，如果按"提交时间"排序，显然不合理。

正确的排序方式：按"影响面 × 修复成本 × 风险等级"排序。

优先级计算公式（AI辅助确定权重）

我让Claude帮我设计了一个优先级计算公式：

优先级得分 = (影响面权重 × 影响面评分) 
              + (修复成本权重 × 修复成本评分) 
              + (风险等级权重 × 风险等级评分)

权重确定（让Claude分析我们的业务场景后给出）：

• 影响面权重：0.5（最高，因为我们的系统是To B的，稳定性最重要）
• 修复成本权重：0.3（中等，因为我们有9人团队，修复成本相对可控）
• 风险等级权重：0.2（最低，但也要考虑）

评分标准（AI生成的）：

维度	评分标准	分值
影响面	核心功能（用户必用的）	3分
	常用功能（50%用户会用到的）	2分
	不常用功能（<10%用户会用到的）	1分
修复成本	需要重构>100行代码，或涉及多个模块	3分（成本高，优先级低）
	需要重构10-100行代码，或涉及单个模块	2分
	需要重构<10行代码，或只改一个方法	1分（成本低，优先级高）
风险等级	已经导致过生产事故	3分
	压测发现有问题，但还没在生产环境爆发	2分
	只是"代码不好看"，但不影响功能	1分

AI的应用：

把识别出的150+处技术债，让Claude自动打分：

def prioritize_tech_debts(tech_debts):
    client = Anthropic(api_key='your-api-key')
    
    results = []
    for debt in tech_debts:
        prompt = f"""
        请根据以下技术债信息，给出优先级得分（0-10分，分数越高，越应该优先还）。
        
        技术债信息：
        - 类型：{debt['debt_type']}
        - 严重等级：{debt['severity']}
        - 位置：{debt['file']}:{debt['line']}
        - 描述：{debt['description']}
        - 影响的功能：请猜测（因为你没有完整项目上下文）
        
        输出JSON：
        {{
            "impact_score": 1-3,
            "cost_score": 1-3（注意：成本越高，得分应该越低）,
            "risk_score": 1-3,
            "total_score": 0-10,
            "reason": "为什么给这个得分？"
        }}
        """
        
        response = client.messages.create(
            model="claude-opus-4.7",
            max_tokens=512,
            messages=[{"role": "user", "content": prompt}]
        )
        
        score = json.loads(response.content[0].text)
        results.append({'debt': debt, **score})
    
    # 按total_score降序排列
    return sorted(results, key=lambda x: x['total_score'], reverse=True)

效果：

• AI给150+处技术债打了分，前20处高优先级技术债，人工复核后，认为18处确实是应该优先还的（准确率90%）
• 原来"不知道先还哪个"，现在有明确的优先级列表

---

Step 3：AI生成重构建议

排完优先级后，开发者需要知道"怎么还"。

传统方式：技术债描述写成"UserService里有很多重复代码"，开发者看到后还是不知道怎么改。

AI方式：让Claude生成重构后的代码框架（不是完整代码，而是"重构方向"）。

实际案例

技术债描述（AI识别出的）：

文件：src/main/java/com/example/UserService.java
行号：125-180
类型：代码重复
描述：UserDto转User实体的代码，在3个地方重复出现（注册、更新用户信息、批量导入）
严重等级：medium
影响面：2分（常用功能）
修复成本：1分（<10行代码）
风险等级：1分（不影响功能，只是可维护性差）
优先级得分：6.5/10

让AI生成重构建议：

prompt = """
在UserService.java的125-180行，有代码重复问题。
请生成重构建议，包含：
1. 应该抽取什么方法？
2. 新方法应该放在哪里（哪个类）？
3. 重构后的代码示例（只需要核心部分，不需要完整代码）
"""

response = client.messages.create(
    model="claude-opus-4.7",
    max_tokens=1024,
    messages=[{"role": "user", "content": prompt}]
)

# AI的输出（解析后）：
{
    "refactoring_suggestion": {
        "extract_method": "UserDto.toEntity()",
        "location": "在UserDto类里加一个toEntity()方法",
        "code_example": """
            // 在UserDto里添加：
            public User toEntity() {
                User user = new User();
                user.setName(this.name);
                user.setEmail(this.email);
                user.setPhone(this.phone);
                return user;
            }
            
            // 然后在UserService里，把重复代码替换成：
            User user = userDto.toEntity();
            """
    }
}

开发者的反馈：

"看到AI生成的重构建议，我5分钟就完成了重构，而不用自己想'怎么抽方法'。"

---

Step 4：人工复核

AI识别、排序、生成建议后，必须有人工复核环节。

原因：

1. AI可能误判（比如把"故意写的复杂代码"判成"技术债"）
2. AI的优先级排序可能不符合业务实际（比如"影响面"评分，AI不知道你们的哪些功能是核心功能）
3. AI生成的重构建议可能需要调整（AI不知道你的项目架构约束）

我们的人工复核流程：

1. 我（技术负责人）复核高优先级技术债（前20处）—— 约30分钟
2. 模块负责人复核自己模块的中优先级技术债（21-50处）—— 每人约20分钟
3. 开发者自己复核低优先级技术债（51名以后）—— 每人约10分钟

总耗时：约2小时（vs 传统方式"人工review 2周"）

---

Step 5：生成技术债还款计划

复核完成后，需要排期（什么时候还？谁还？）。

让AI生成还款计划：

prompt = """
我们有50处技术债需要还，团队有9人（3前端、2后端、1UI、1产品、1测试、1我）。

请根据以下信息，生成未来3个月的技术债还款计划（Sprint排期）：
1. 每个Sprint 2周
2. 每个开发者在每个Sprint最多能还3处技术债（因为还要开发新功能）
3. 高优先级技术债应该排在前面（Sprint 1-2）
4. 考虑开发者的技能匹配（前端开发者不应该还后端的技术债）

输出格式：Markdown表格（Sprint、开发者、技术债列表）
"""

response = client.messages.create(
    model="claude-opus-4.7",
    max_tokens=2048,
    messages=[{"role": "user", "content": prompt}]
)

# AI会生成一个3个月的还款计划（按Sprint排期）

效果：

• 原来"200+条技术债，不知道从哪开始"
• 现在"未来3个月，每个月还15-20处技术债，3个月后技术债数量降到50-以下"

---

实战效果：2周后的变化

我们跑了2周（1个Sprint），还了15处高优先级技术债。

量化效果

指标	之前	之后	变化
技术债总数	200+	185+	↓ 15处
高优先级技术债	20处	5处	↓ 15处（已还清高优先级）
生产事故（因技术债导致）	过去3个月2次	过去2周0次	↓ 100%
代码重复率	12%	9%	↓ 3%
平均方法长度	35行	28行	↓ 7行

定性效果

开发者反馈：

• "以前看到技术债列表就头大，现在AI帮我排好了优先级，我只管照着做就行。"
• "AI生成的重构建议很有用，不是'应该怎么改'的空话，而是'具体代码应该怎么写'。"
• "最大的变化是：技术债不再'下次再说'了，而是'这周Sprint目标之一'。"

我的感受：

• 技术债管理从"看不见、理不清"到"看得清、还得快"
• 团队对技术债的态度，从"能不碰就不碰"到"有计划地还"
• 代码质量，从"只要能跑就行"到"主动关注可维护性"

---

AI辅助技术债管理的坑

当然，这个过程也不是一帆风顺的，我们踩了几个坑。

坑1：AI识别技术债的准确率只有80%

问题：AI识别出的150+处技术债，人工复核后发现20-30%是误判。

误判案例：

• AI认为"方法超过50行"就是技术债 → 但实际上这个方法逻辑很清晰，不需要拆分
• AI认为"嵌套if超过3层"就是技术债 → 但实际上这是业务逻辑的必然复杂度（比如"订单状态机"）

解决方法：

• 不要100%信任AI，必须有复核环节
• 调整识别规则（比如"方法超过50行"改成"方法超过80行"，降低误判率）
• 积累"白名单"（某些代码模式虽然是"技术债特征"，但是合理的，加入白名单让AI跳过）

---

坑2：AI的优先级排序可能"过度关注技术维度，忽略业务维度"

问题：AI给某个技术债打了"高优先级"（因为代码重复很严重），但实际上这个功能只有1%的用户用到，业务价值很低。

解决方法：

• 优先级排序时，加入"业务价值"维度（需要人工标注，AI不知道哪些功能用户常用）
• AI排序后，人工调整（把"技术债很严重但业务价值很低"的优先级调低）

---

坑3：AI生成的重构建议可能"过度重构"

问题：AI建议"用策略模式重构这段代码"，但实际上是过度设计（简单的if/else就够用，不需要上设计模式）。

解决方法：

• 让AI给出"最小重构"和"彻底重构"两个方案，由开发者选择
• 在Prompt里强调"避免过度设计"

---

工具开源：我们准备把工具开源

我们的"AI辅助技术债管理工具"，准备开源（基于Apache 2.0协议）。

包含功能：

1. 技术债自动识别（支持Java、Python、JavaScript）
2. 优先级自动排序（可配置权重）
3. 重构建议生成（基于Claude API）
4. 还款计划生成（导出为Markdown表格）

预计开源时间：2026年7月（需要再打磨2个月）。

如果你对这方面感兴趣，可以关注我的掘金账号，开源后我会发一篇详细的使用教程。

---

最后说一句

技术债管理，不是"一次性还清"，而是"持续地、有计划地还"。

AI能帮你"看见"技术债、"排定"优先级、"生成"重构建议，但最终还债的，还是人。

好的技术债管理，应该是：

1. 看得见（AI帮你识别，不再"看不见的技术债"）
2. 还得了（AI帮你排优先级，先还影响最大的）
3. 还得好（AI帮你生成重构建议，避免"越重构越烂"）

如果你也在为技术债头疼，可以试试AI辅助的方式——至少，你能知道"最该还的是哪笔债"。

---

互动时间

你们团队有技术债管理的流程吗？还是"能不碰就不碰"？

有没有试过用AI分析代码，自动找技术债？效果怎么样？

欢迎在评论区分享你的经验。

如果这篇对你有帮助，点个赞吧。

---

创作时间：2026-05-12
实战周期：2周（2026年4月下旬-5月上旬）
团队规模：9人技术团队
代码量：10万行（Java + Python + JavaScript）
技术债识别准确率：约80%（人工复核后）