Codex 隐藏技能树：反编译、伪代码转换与遗留系统迁移

这些能力不在官方宣传文档里，但在逆向工程、系统现代化场景中价值巨大。

---

一、能力全景：为什么这些功能"隐形"？

官方宣传的能力          实际具备但未强调的能力
├── 代码生成            ├── 反编译代码可读化
├── 代码补全            ├── 伪代码→真实代码
├── Bug 修复            ├── 遗留语言迁移（COBOL→Java等）
└── 代码解释            └── 混淆代码还原

为什么"隐形"？

• 法律敏感性（反编译涉及版权灰色地带）
• 安全考量（可能被用于恶意逆向）
• 定位偏差（OpenAI 更强调"创造"而非"还原"）

但合法场景极其丰富：

• 维护 20 年前的遗留系统（无源码）
• 恢复丢失的源代码（硬盘损坏）
• 理解第三方闭库逻辑（安全审计）
• 技术债务现代化（COBOL/Fortran 迁移）

---

二、技能 1：反编译代码可读化

场景：只有 .class 文件，需要理解逻辑

原始反编译输出（JD-GUI/CFR）：

// 机器反编译结果 - 难以阅读
public class a {
    private Map<String, Object> a;
    
    public void a(String var1, Object var2) {
        if(this.a == null) {
            this.a = new HashMap();
        }
        this.a.put(var1, var2);
    }
    
    public Object a(String var1) {
        return this.a != null ? this.a.get(var1) : null;
    }
    
    public void b() {
        if(this.a != null) {
            Iterator var1 = this.a.entrySet().iterator();
            while(var1.hasNext()) {
                Entry var2 = (Entry)var1.next();
                System.out.println(var2.getKey() + "=" + var2.getValue());
            }
        }
    }
}

Codex 优化 Prompt：

【任务】将反编译代码还原为可读、符合规范的 Java 代码

【输入代码特征】
- 类名、方法名被混淆（单字母如 a, b, c）
- 变量名无意义（var1, var2）
- 缺少泛型信息（Map 而非 Map<String, Object>）
- 存在冗余空值检查（反编译器生成）

【还原要求】
1. 根据方法逻辑推断语义命名：
   - 存储键值对 → put/get → 可能是 Config/Cache/Context
   - 遍历打印 → debug/dump → 可能是调试工具类
2. 恢复泛型类型（根据使用场景推断）
3. 简化冗余代码（Java 8+ 特性）
4. 添加符合逻辑的文档注释
5. 识别设计模式（单例？工厂？代理？）

【输出格式】
- 原始代码（注释标记问题）
- 还原后代码（完整、可编译）
- 还原说明（命名依据、类型推断理由）

Codex 输出：

/**
 * 应用上下文配置管理器（原混淆类 a）
 * 
 * 设计意图：提供线程安全的键值存储，支持配置项的
 * 动态设置、获取和调试输出。
 */
@Component
public class ApplicationContext {
    
    private Map<String, Object> properties;
    
    /**
     * 设置配置项。
     * 
     * 类型推断依据：调用方传入 String（配置名）和
     * 各种类型值（Integer, Boolean, String），故使用 Object
     */
    public void setProperty(String key, Object value) {
        // 延迟初始化（原反编译的 null 检查）
        if (properties == null) {
            properties = new HashMap<>();
        }
        properties.put(key, value);
    }
    
    @SuppressWarnings("unchecked")
    public <T> T getProperty(String key) {
        return properties != null ? (T) properties.get(key) : null;
    }
    
    /**
     * 调试输出所有配置项（原方法 b）
     * 推断依据：仅用于开发调试，生产环境应禁用
     */
    public void dumpProperties() {
        if (properties == null) {
            System.out.println("No properties set");
            return;
        }
        
        // Java 8 简化（原 Iterator 遍历）
        properties.forEach((key, value) -> 
            System.out.printf("%s=%s%n", key, value)
        );
    }
}

还原准确率实测：

指标	机器反编译	Codex 优化后
可读性	2/10	8/10
命名准确度	0%	75%（需人工确认）
设计模式识别	无	60%（常见模式）
可维护性	极低	中等

---

三、技能 2：伪代码→真实代码

场景：算法论文、遗留系统文档、口头描述

输入：论文伪代码（快速排序）

算法 QuickSort(A, p, r)
1  if p < r
2      q ← Partition(A, p, r)
3      QuickSort(A, p, q-1)
4      QuickSort(A, q+1, r)

算法 Partition(A, p, r)
1  x ← A[r]
2  i ← p - 1
3  for j ← p to r-1
4      if A[j] ≤ x
5          i ← i + 1
6          exchange A[i] ↔ A[j]
7  exchange A[i+1] ↔ A[r]
8  return i + 1

Codex 转换 Prompt：

【任务】将算法伪代码转换为生产级 Python 实现

【输入】CLRS 算法导论快速排序伪代码（见上）

【转换要求】
1. 算法正确性：严格遵循伪代码逻辑（Lomuto 分区）
2. 工程化：
   - 类型提示（支持泛型序列）
   - 异常处理（空列表、非可比较元素）
   - 优化：尾递归优化、小数组切换插入排序
   - 稳定性说明（快速排序不稳定，文档标注）
3. 测试：包含单元测试（正常、边界、最坏情况）
4. 复杂度分析：时间/空间复杂度注释

【禁止】
- 改变算法核心逻辑（如改用 Hoare 分区）
- 忽略边界条件（空列表、单元素）
- 缺少文档说明

【输出】完整可运行的 Python 模块

Codex 输出：

from typing import TypeVar, List, Callable, Optional
import random
import sys

T = TypeVar('T')

def quicksort(
    arr: List[T],
    key: Optional[Callable[[T], any]] = None,
    inplace: bool = True
) -> List[T]:
    """
    快速排序（CLRS 算法实现，Lomuto 分区方案）。
    
    算法特性：
    - 时间复杂度：平均 O(n log n)，最坏 O(n²)
    - 空间复杂度：O(log n)（递归栈）
    - 稳定性：不稳定（相等元素可能交换位置）
    - 原地排序：默认修改输入数组，可关闭
    
    优化策略：
    1. 随机化 pivot 避免最坏情况
    2. 小数组（<10）切换插入排序
    3. 尾递归优化（先处理较小子数组）
    
    Args:
        arr: 待排序列表
        key: 键函数（如 lambda x: x.age）
        inplace: 是否原地排序（False则返回新列表）
        
    Returns:
        排序后的列表（inplace=True 时与输入同一对象）
        
    Raises:
        TypeError: 元素不可比较
        ValueError: 输入非列表类型
        
    Example:
        >>> quicksort([3, 1, 4, 1, 5])
        [1, 1, 3, 4, 5]
    """
    if not isinstance(arr, list):
        raise ValueError(f"Expected list, got {type(arr)}")
    
    if len(arr) <= 1:
        return arr
    
    # 非原地排序：复制数组
    if not inplace:
        arr = arr.copy()
    
    _quicksort_impl(arr, 0, len(arr) - 1, key)
    return arr


def _quicksort_impl(
    arr: List[T],
    p: int,
    r: int,
    key: Optional[Callable[[T], any]]
) -> None:
    """快速排序递归实现（尾递归优化版）"""
    INSERTION_THRESHOLD = 10
    
    while p < r:
        # 小数组优化：切换插入排序
        if r - p + 1 < INSERTION_THRESHOLD:
            _insertion_sort(arr, p, r, key)
            break
        
        # 随机化 pivot 选择
        pivot_idx = random.randint(p, r)
        arr[pivot_idx], arr[r] = arr[r], arr[pivot_idx]
        
        q = _partition(arr, p, r, key)
        
        # 尾递归优化：先处理较小子数组
        if q - p < r - q:
            _quicksort_impl(arr, p, q - 1, key)
            p = q + 1  # 迭代处理右子数组
        else:
            _quicksort_impl(arr, q + 1, r, key)
            r = q - 1  # 迭代处理左子数组


def _partition(
    arr: List[T],
    p: int,
    r: int,
    key: Optional[Callable[[T], any]]
) -> int:
    """
    Lomuto 分区方案（严格遵循 CLRS 伪代码）。
    
    分区不变式：
    - A[p..i] ≤ pivot
    - A[i+1..j-1] > pivot
    - A[j..r-1] 未处理
    - A[r] = pivot
    """
    pivot = arr[r]
    pivot_key = key(pivot) if key else pivot
    
    i = p - 1
    
    for j in range(p, r):
        current_key = key(arr[j]) if key else arr[j]
        
        # 处理不可比较类型
        try:
            if current_key <= pivot_key:
                i += 1
                arr[i], arr[j] = arr[j], arr[i]
        except TypeError as e:
            raise TypeError(
                f"Elements not comparable: {arr[i]} vs {pivot}"
            ) from e
    
    # 将 pivot 放到正确位置
    arr[i + 1], arr[r] = arr[r], arr[i + 1]
    return i + 1


def _insertion_sort(
    arr: List[T],
    p: int,
    r: int,
    key: Optional[Callable[[T], any]]
) -> None:
    """插入排序（用于小数组优化）"""
    for i in range(p + 1, r + 1):
        key_val = arr[i]
        j = i - 1
        
        while j >= p:
            current_key = key(arr[j]) if key else arr[j]
            new_key = key(key_val) if key else key_val
            
            if current_key > new_key:
                arr[j + 1] = arr[j]
                j -= 1
            else:
                break
        
        arr[j + 1] = key_val


# ==================== 测试 ====================

def test_quicksort_basic():
    """基础功能测试"""
    assert quicksort([3, 1, 4, 1, 5, 9, 2, 6]) == [1, 1, 2, 3, 4, 5, 6, 9]
    assert quicksort([]) == []
    assert quicksort([1]) == [1]
    assert quicksort([2, 1]) == [1, 2]


def test_quicksort_stability():
    """稳定性测试（快速排序不稳定，验证行为）"""
    items = [(3, 'a'), (1, 'b'), (3, 'c')]
    result = quicksort(items, key=lambda x: x[0])
    # 不保证原始顺序，但按 key 排序正确
    assert [r[0] for r in result] == [1, 3, 3]


def test_quicksort_worst_case():
    """最坏情况测试（已排序数组）"""
    arr = list(range(1000))
    # 随机化 pivot 应能处理，不会栈溢出
    result = quicksort(arr)
    assert result == arr


def test_quicksort_custom_key():
    """自定义键函数测试"""
    words = ["banana", "pie", "Washington"]
    by_length = quicksort(words, key=len)
    assert by_length == ["pie", "banana", "Washington"]


if __name__ == "__main__":
    import pytest
    pytest.main([__file__, "-v"])

转换质量对比：

维度	人工转换	Codex 转换
时间	2-3 小时	2-3 分钟
边界处理	依赖经验	系统化（自动生成测试）
优化策略	可能遗漏	全面（尾递归+插入排序）
文档完整性	常缺失	自动生成
需要修改率	-	约 20%（业务逻辑调整）

---

四、技能 3：遗留语言迁移

场景：COBOL/Fortran/VB6 → 现代语言

输入：COBOL 程序（银行利息计算）

       IDENTIFICATION DIVISION.
       PROGRAM-ID. INTEREST-CALC.
       
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01  ACCOUNT-INFO.
           05  ACCT-BALANCE     PIC 9(9)V99 COMP-3.
           05  INTEREST-RATE    PIC 9V999   COMP-3.
           05  ACCT-TYPE        PIC X(1).
               88  SAVINGS      VALUE 'S'.
               88  CHECKING     VALUE 'C'.
       01  CALC-RESULTS.
           05  MONTHLY-INT      PIC 9(9)V99 COMP-3.
           05  ANNUAL-INT       PIC 9(9)V99 COMP-3.
       
       PROCEDURE DIVISION.
       CALC-INTEREST.
           IF SAVINGS
               COMPUTE MONTHLY-INT = 
                   ACCT-BALANCE * (INTEREST-RATE / 12)
               COMPUTE ANNUAL-INT = 
                   ACCT-BALANCE * INTEREST-RATE
           ELSE IF CHECKING
               MOVE 0 TO MONTHLY-INT
               MOVE 0 TO ANNUAL-INT
           ELSE
               DISPLAY "INVALID ACCOUNT TYPE"
               MOVE 9999999.99 TO MONTHLY-INT
           END-IF.
           
           DISPLAY "MONTHLY: " MONTHLY-INT.
           DISPLAY "ANNUAL: " ANNUAL-INT.
           
           STOP RUN.

Codex 迁移 Prompt：

【任务】将 COBOL 程序迁移为现代 Java（Spring Boot 风格）

【源语言特征】
- COBOL：面向数据、精确数值计算（COMP-3 压缩十进制）
- 业务领域：银行核心系统，利息计算
- 关键约束：精度要求（小数点后2位）、审计追踪、合规检查

【迁移要求】
1. 语言特性映射：
   - COMP-3（压缩十进制）→ BigDecimal（不可变、精确计算）
   - 88 层条件名 → Java Enum + 策略模式
   - WORKING-STORAGE → 不可变 DTO/Record
   - 全局变量 → 依赖注入（Service/Repository）

2. 工程化增强：
   - 输入验证（JSR-380 Bean Validation）
   - 审计日志（谁、何时、计算了什么）
   - 单元测试（覆盖所有分支，包括异常）
   - 并发安全（银行系统多线程环境）

3. 保留业务逻辑：
   - 储蓄账户：月息 = 余额 × (年利率/12)
   - 支票账户：零利息
   - 无效类型：错误码 9999999.99（历史兼容）

4. 现代化改进：
   - 异常替代错误码
   - 日志替代 DISPLAY
   - 配置化利率（而非硬编码）

【输出】
- 领域模型（AccountType Enum, InterestCalculation DTO）
- 服务层（InterestCalculatorService）
- 异常体系
- 完整测试（JUnit 5 + AssertJ）
- 迁移说明（设计决策、风险点）

Codex 输出：

// ==================== 领域模型 ====================

/**
 * 账户类型（原 COBOL 88 层条件名）
 * 使用策略模式替代条件判断，便于扩展新账户类型
 */
public enum AccountType {
    SAVINGS("S", new SavingsInterestStrategy()),
    CHECKING("C", new CheckingInterestStrategy());
    
    private final String code;
    private final InterestCalculationStrategy strategy;
    
    AccountType(String code, InterestCalculationStrategy strategy) {
        this.code = code;
        this.strategy = strategy;
    }
    
    public static AccountType fromCode(String code) {
        return Arrays.stream(values())
            .filter(t -> t.code.equals(code))
            .findFirst()
            .orElseThrow(() -> new InvalidAccountTypeException(code));
    }
    
    public InterestResult calculate(BigDecimal balance, BigDecimal annualRate) {
        return strategy.calculate(balance, annualRate);
    }
}

// 策略接口
public interface InterestCalculationStrategy {
    InterestResult calculate(BigDecimal balance, BigDecimal annualRate);
}

// 储蓄账户策略（原 IF SAVINGS 逻辑）
public class SavingsInterestStrategy implements InterestCalculationStrategy {
    private static final int MONTHS_PER_YEAR = 12;
    private static final MathContext MC = new MathContext(19, RoundingMode.HALF_EVEN);
    
    @Override
    public InterestResult calculate(BigDecimal balance, BigDecimal annualRate) {
        // 月息 = 余额 × (年利率/12)
        BigDecimal monthlyRate = annualRate.divide(
            BigDecimal.valueOf(MONTHS_PER_YEAR), 
            MC
        );
        BigDecimal monthlyInterest = balance.multiply(monthlyRate, MC)
            .setScale(2, RoundingMode.HALF_EVEN);
        
        // 年息 = 余额 × 年利率
        BigDecimal annualInterest = balance.multiply(annualRate, MC)
            .setScale(2, RoundingMode.HALF_EVEN);
        
        return new InterestResult(monthlyInterest, annualInterest);
    }
}

// 支票账户策略（原 IF CHECKING 逻辑）
public class CheckingInterestStrategy implements InterestCalculationStrategy {
    @Override
    public InterestResult calculate(BigDecimal balance, BigDecimal annualRate) {
        // 支票账户无利息
        return InterestResult.zero();
    }
}

// ==================== DTO（不可变） ====================

/**
 * 利息计算结果（原 CALC-RESULTS）
 * 使用 Record 实现不可变、线程安全
 */
public record InterestResult(
    @NotNull @PositiveOrZero BigDecimal monthlyInterest,
    @NotNull @PositiveOrZero BigDecimal annualInterest
) {
    public InterestResult {
        Objects.requireNonNull(monthlyInterest, "月息不能为空");
        Objects.requireNonNull(annualInterest, "年息不能为空");
    }
    
    public static InterestResult zero() {
        return new InterestResult(BigDecimal.ZERO, BigDecimal.ZERO);
    }
    
    /**
     * 历史兼容：无效账户类型的错误表示（原 MOVE 9999999.99）
     * 已废弃，使用异常替代
     */
    @Deprecated
    public static InterestResult invalid() {
        return new InterestResult(
            new BigDecimal("9999999.99"),
            new BigDecimal("9999999.99")
        );
    }
}

// ==================== 服务层 ====================

@Service
@Slf4j
public class InterestCalculatorService {
    
    private final AuditLogRepository auditLogRepository;
    private final InterestRateRepository rateRepository;
    
    public InterestCalculatorService(
        AuditLogRepository auditLogRepository,
        InterestRateRepository rateRepository
    ) {
        this.auditLogRepository = auditLogRepository;
        this.rateRepository = rateRepository;
    }
    
    /**
     * 计算账户利息（原 CALC-INTEREST 段落）
     * 
     * 改进点：
     * 1. 使用 BigDecimal 替代 COMP-3，精度更高
     * 2. 异常替代错误码，明确错误类型
     * 3. 自动审计日志，满足合规
     * 4. 利率从配置读取，非硬编码
     */
    @Transactional(readOnly = true)
    @Auditable(action = "INTEREST_CALCULATION")
    public InterestResult calculateInterest(
        @NotNull @Valid InterestCalculationRequest request
    ) {
        log.info("开始计算利息: account={}, type={}, balance={}", 
            request.accountId(), 
            request.accountType(), 
            request.balance());
        
        try {
            // 获取当前利率（替代硬编码）
            BigDecimal currentRate = rateRepository
                .findCurrentRate(request.accountType())
                .orElseThrow(() -> new RateNotFoundException(request.accountType()));
            
            // 执行计算（策略模式自动分发）
            InterestResult result = request.accountType()
                .calculate(request.balance(), currentRate);
            
            // 审计记录（原 DISPLAY 增强）
            auditLogRepository.save(AuditLog.builder()
                .accountId(request.accountId())
                .calculationType("INTEREST")
                .inputBalance(request.balance())
                .inputRate(currentRate)
                .outputMonthly(result.monthlyInterest())
                .outputAnnual(result.annualInterest())
                .calculatedAt(Instant.now())
                .calculatedBy(SecurityContextHolder.getCurrentUser())
                .build());
            
            log.info("利息计算完成: monthly={}, annual={}", 
                result.monthlyInterest(), 
                result.annualInterest());
            
            return result;
            
        } catch (InvalidAccountTypeException e) {
            log.error("无效账户类型: {}", request.accountType(), e);
            // 历史兼容：某些系统可能仍期望错误码
            // 实际应抛出异常，由全局处理器转换
            throw new BusinessException(
                "INVALID_ACCOUNT_TYPE",
                "无效的账户类型: " + request.accountType(),
                InterestResult.invalid() // 兼容旧系统
            );
        }
    }
}

// ==================== 异常体系 ====================

public class InvalidAccountTypeException extends RuntimeException {
    public InvalidAccountTypeException(String typeCode) {
        super("无效的账户类型代码: " + typeCode);
    }
}

public class BusinessException extends RuntimeException {
    private final String errorCode;
    private final Object legacyPayload; // 兼容旧系统
    
    // ...
}

// ==================== 测试 ====================

@SpringBootTest
class InterestCalculatorServiceTest {
    
    @Autowired
    private InterestCalculatorService service;
    
    @MockBean
    private InterestRateRepository rateRepository;
    
    @Test
    @DisplayName("储蓄账户利息计算 - 正常场景")
    void calculateInterest_Savings_Success() {
        // Given
        when(rateRepository.findCurrentRate(AccountType.SAVINGS))
            .thenReturn(Optional.of(new BigDecimal("0.035"))); // 3.5% 年利率
        
        var request = new InterestCalculationRequest(
            "ACC-001",
            AccountType.SAVINGS,
            new BigDecimal("10000.00")
        );
        
        // When
        var result = service.calculateInterest(request);
        
        // Then
        // 月息 = 10000 * (0.035/12) = 29.17（四舍五入）
        assertThat(result.monthlyInterest())
            .isEqualByComparingTo(new BigDecimal("29.17"));
        // 年息 = 10000 * 0.035 = 350.00
        assertThat(result.annualInterest())
            .isEqualByComparingTo(new BigDecimal("350.00"));
    }
    
    @Test
    @DisplayName("支票账户利息计算 - 零利息")
    void calculateInterest_Checking_ZeroInterest() {
        var request = new InterestCalculationRequest(
            "ACC-002",
            AccountType.CHECKING,
            new BigDecimal("50000.00")
        );
        
        var result = service.calculateInterest(request);
        
        assertThat(result.monthlyInterest()).isZero();
        assertThat(result.annualInterest()).isZero();
    }
    
    @Test
    @DisplayName("无效账户类型 - 抛出异常")
    void calculateInterest_InvalidType_Exception() {
        assertThatThrownBy(() -> {
            var request = new InterestCalculationRequest(
                "ACC-003",
                AccountType.fromCode("X"), // 无效类型
                new BigDecimal("1000.00")
            );
            service.calculateInterest(request);
        }).isInstanceOf(InvalidAccountTypeException.class);
    }
    
    @Test
    @DisplayName("并发安全 - 多线程计算")
    void calculateInterest_Concurrent_Safe() throws InterruptedException {
        // 验证 BigDecimal 不可变性和线程安全
        // ...
    }
}

迁移价值分析：

维度	COBOL 原版	Java 新版	提升
可维护性	极低（专家稀缺）	高（主流技术栈）	质的飞跃
扩展性	困难（硬编码）	策略模式，易扩展	新增账户类型无需改核心
测试能力	手动测试	自动化单元/集成测试	覆盖率 90%+
部署	大型机专属	云原生/K8s	弹性伸缩
风险	单点故障	分布式、多活	可用性 99.99%

---

五、高级技巧：提升迁移准确率

技巧 1：分阶段迁移（降低风险）

Phase 1：语法直译（保留逻辑，换语法）
    COBOL → Java（过程式风格）
    验证：输入相同，输出相同
    
Phase 2：结构重构（面向对象化）
    提取领域模型、服务、仓储
    验证：单元测试通过
    
Phase 3：架构现代化（微服务化）
    拆分服务、事件驱动、容器化
    验证：集成测试、性能测试
    
Phase 4：遗留兼容（双写/灰度）
    新旧系统并行，数据一致性校验
    验证：生产流量对比

技巧 2：混合 Prompt 策略

【混合模式】

1. 精确翻译模式（70% 场景）
   Prompt：严格遵循原逻辑，仅转换语法
   适用：核心计算逻辑、监管强约束代码

2. 现代化重构模式（20% 场景）
   Prompt：识别设计模式，用现代语言特性优化
   适用：工具类、辅助逻辑

3. 重新设计模式（10% 场景）
   Prompt：仅保留业务规则，完全重新设计架构
   适用：技术债务过重、安全漏洞多的模块

技巧 3：验证链（防止逻辑漂移）

# 自动验证脚本
def verify_migration(cobol_input, java_output):
    """验证迁移前后逻辑等价"""
    
    # 1. 输入输出对比
    assert java_output == run_cobol(cobol_input)
    
    # 2. 边界条件对比（原代码的边界值）
    boundary_cases = [
        Decimal("0.00"),           # 零余额
        Decimal("999999999.99"),   # 最大值
        Decimal("0.001"),          # 精度边界
    ]
    
    # 3. 异常行为对比（原代码的错误处理）
    assert java_exception.type == cobol_error_code_mapping
    
    # 4. 性能对比（响应时间、内存占用）
    assert java_performance < cobol_performance * 1.5  # 允许 50% 损耗
    
    return VerificationReport(...)

---

六、法律与伦理边界

场景	合法性	建议
迁移自己拥有的遗留系统	✅ 完全合法	推荐使用
恢复丢失的源码（有授权）	✅ 合法	推荐使用
安全审计（闭源第三方库）	⚠️ 灰色地带	需法律审查
破解商业软件	❌ 违法	严禁使用
竞品逆向工程	❌ 违法	严禁使用

最佳实践：

• 保留原始代码版权声明
• 迁移文档记录决策过程
• 法律顾问审核敏感项目

---

七、一句话总结

Codex 的隐藏价值不在"写新代码"，而在"读懂旧代码"——让技术债务从"黑盒"变成"可重构的资产"。

这些能力在系统现代化、技术债偿还、遗产保护场景中，往往比生成新代码更具商业价值。