# Harness Evolve

> 自我进化技能，实现技术债清理、迭代飞轮、持续改进，从错误中学习并优化系统

- Skill: `konglong87/harness-evolve` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add konglong87/harness-evolve`
- Raw SKILL.md: https://api.skillmd.com/api/skills/konglong87/harness-evolve/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: konglong87 (https://skillmd.com/u/konglong87)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/konglong87/harness-evolve

---


# harness-evolve 自我进化技能

## 核心能力
1. 检查前置条件（harness-diagnose-and-improve）
2. 读取错误学习和诊断报告
3. 识别技术债
4. 执行技术债清理
5. 更新迭代飞轮
6. 生成进化报告
7. 记录进化事件
8. 更新全局状态

## 前置条件
- harness-init 已完成
- harness-diagnose-and-improve 已完成
- .learnings/ERRORS.md 文件存在

## 执行步骤

### Step 1: 检查前置条件

使用 Read 工具读取：`.EnjoyHarness/SKILL_REGISTRY.md`

检查条件：
- harness-diagnose-and-improve 已标记为完成

如果未完成：
```
❌ 错误: 错误诊断未执行
💡 请先运行: harness-diagnose-and-improve
```

### Step 2: 读取错误学习记录

使用 Read 工具读取：`.learnings/ERRORS.md`

提取关键学习：
- 错误类型分布
- 根因分析结果
- 改进措施建议

### Step 3: 识别技术债

使用 Bash 工具扫描项目：

```bash
# 识别技术债指标
echo "=== 技术债识别 ==="
echo ""

# 1. TODO/FIXME标记
TODO_COUNT=$(grep -r "TODO" --include="*.go" --include="*.ts" --include="*.py" . | grep -v ".git" | wc -l)
FIXME_COUNT=$(grep -r "FIXME" --include="*.go" --include="*.ts" --include="*.py" . | grep -v ".git" | wc -l)

echo "📝 TODO标记: $TODO_COUNT个"
echo "🔧 FIXME标记: $FIXME_COUNT个"

# 2. 长文件/函数
LONG_FILES=$(find . -type f \( -name "*.go" -o -name "*.ts" -o -name "*.py" \) -exec wc -l {} + | awk '$1 > 500 {print $2}' | wc -l)

echo "📄 超长文件(>500行): $LONG_FILES个"

# 3. 重复代码（简化检测）
DUPLICATE_IMPORT=$(grep -r "^import" --include="*.go" . | grep -v ".git" | sort | uniq -c | awk '$1 > 5 {print $0}' | wc -l)

echo "🔁 重复导入模式: $DUPLICATE_IMPORT个"

# 4. 缺失文档
FILES_WITHOUT_DOCS=$(find . -type f \( -name "*.go" -o -name "*.ts" -o -name "*.py" \) -exec grep -L "package\|module\|class" {} \; | grep -v ".git" | wc -l)

echo "📚 缺失文档文件: $FILES_WITHOUT_DOCS个"

# 5. 错误记录中的问题
ERROR_PATTERNS=$(cat .learnings/ERRORS.md | grep -v "^#" | grep -v "^$" | wc -l)

echo "⚠️ 错误模式数: $ERROR_PATTERNS个"

echo ""
TOTAL_TECH_DEBT=$((TODO_COUNT + FIXME_COUNT + LONG_FILES + DUPLICATE_IMPORT + FILES_WITHOUT_DOCS + ERROR_PATTERNS))
echo "📊 技术债总分: $TOTAL_TECH_DEBT"
```

### Step 4: 分类技术债

使用 Write 工具创建文件：`.EnjoyHarness/TECH_DEBT_INVENTORY.md`

```markdown
---
generated_at: {当前时间}
total_debt: {总数}
priority_distribution: "{高}/{中}/{低}"
---

# 技术债清单

## 清单概况
- 生成时间: {当前时间}
- 技术债总数: {总数}
- 高优先级: {数量}
- 中优先级: {数量}
- 低优先级: {数量}

## 高优先级技术债（必须清理）

### 债务1: {名称}
- **类型**: {代码/架构/文档}
- **位置**: {文件路径}
- **描述**: {详细描述}
- **影响**: {对系统的影响}
- **清理成本**: {估算工作量}
- **清理方案**: {具体方案}
- **优先级**: P0

### 债务2: {名称}
{重复上述结构}

---

## 中优先级技术债（应该清理）

{同上结构}

---

## 低优先级技术债（建议清理）

{同上结构}

---

## 技术债趋势

### 历史对比
- 上次清理: {日期}
- 上次债务数: {数量}
- 当前债务数: {数量}
- 变化: {增加/减少} {数量}

### 趋势分析
- 趋势: {改善/持平/恶化}
- 预计清偿时间: {估算}

---

## 清理计划

### 立即清理（本周）
- [ ] {债务1}
- [ ] {债务2}

### 计划清理（本月）
- [ ] {债务1}
- [ ] {债务2}

### 长期清理（本季度）
- [ ] {债务1}
- [ ] {债务2}
```

### Step 5: 执行技术债清理

根据优先级清理：

#### P0 高优先级清理

```bash
# 示例：清理TODO标记
# 查找所有TODO
TODO_ITEMS=$(grep -rn "TODO" --include="*.go" --include="*.ts" --include="*.py" . | grep -v ".git" | head -5)

echo "清理高优先级TODO:"
echo "$TODO_ITEMS"

# 对每个TODO进行处理
while IFS= read -r item; do
  FILE=$(echo "$item" | cut -d':' -f1)
  LINE=$(echo "$item" | cut -d':' -f2)
  CONTENT=$(echo "$item" | cut -d':' -f3-)

  echo "处理: $FILE:$LINE"
  echo "内容: $CONTENT"

  # 根据TODO内容决定清理方式
  # 选项1: 实现功能
  # 选项2: 添加注释说明
  # 选项3: 移除TODO（如果不再需要）
done <<< "$TODO_ITEMS"
```

#### P1 中优先级清理

```bash
# 示例：重构超长文件
LONG_FILES=$(find . -type f \( -name "*.go" -o -name "*.ts" -o -name "*.py" \) -exec wc -l {} + | awk '$1 > 500 {print $2}')

echo "重构超长文件:"
echo "$LONG_FILES"

# 对每个长文件进行处理
for file in $LONG_FILES; do
  echo "分析: $file"

  # 统计文件行数
  LINES=$(wc -l < "$file")
  echo "行数: $LINES"

  # 建议拆分方案
  echo "建议: 将文件拆分为多个小文件，每个文件 < 500行"
done
```

#### P2 低优先级清理

```bash
# 示例：补充缺失文档
FILES_WITHOUT_DOCS=$(find . -type f \( -name "*.go" -o -name "*.ts" -o -name "*.py" \) -exec grep -L "package\|module\|class" {} \; | grep -v ".git" | head -10)

echo "补充文档:"
echo "$FILES_WITHOUT_DOCS"

# 对每个文件补充文档
for file in $FILES_WITHOUT_DOCS; do
  echo "补充: $file"

  # 使用Edit工具添加文档注释
done
```

### Step 6: 更新迭代飞轮

使用 Read 工具读取：`.EnjoyHarness/ITERATION_FLYWHEEL.md`

如果文件不存在，使用 Write 工具创建：

```markdown
---
created_at: {当前时间}
total_cycles: 0
improvements: 0
---

# EnjoyHarness 迭代飞轮

## 飞轮概念
迭代飞轮是一个持续改进的循环机制，每次循环都让系统变得更好。

## 飞轮循环

```
[执行任务] → [收集反馈] → [识别问题] → [分析根因]
    ↑                                          ↓
    ←←←←←←←←← [反哺规则] ←←←←←←←←←←←←←←←←←←←←←←←←←
```

## 当前循环数: {cycle}

### 循环 {cycle}: {日期}

#### 收集反馈
- 执行结果: {结果}
- 性能指标: {指标}
- 错误记录: {错误}

#### 识别问题
- 问题1: {问题描述}
- 问题2: {问题描述}

#### 分析根因
- 根因1: {根因分析}
- 根因2: {根因分析}

#### 反哺规则
- 规则1: {新增规则}
- 规则2: {新增规则}

#### 改进效果
- 性能提升: {百分比}%
- 错误减少: {百分比}%
- Token节省: {百分比}%

---

## 累计改进统计

### 性能改进
- 平均耗时: {历史平均值} → {当前值}
- 改进: {百分比}%

### Token效率
- 平均Token: {历史平均值} → {当前值}
- 改进: {百分比}%

### 成功率
- 历史成功率: {历史值}%
- 当前成功率: {当前值}%
- 提升: {百分比}%

### 技术债
- 历史债务: {历史值}
- 当前债务: {当前值}
- 减少: {数量}

---

## 下一次循环目标

### 目标1: {目标描述}
- 预期改进: {具体指标}
- 实施方案: {方案}

### 目标2: {目标描述}
- 预期改进: {具体指标}
- 实施方案: {方案}
```

使用 Edit 工具更新迭代飞轮：

```markdown
### 循环 {N+1}: {当前时间}

#### 收集反馈
- 执行结果: {本次执行结果}
- 性能指标: {本次指标}
- 错误记录: {本次错误}

#### 识别问题
- 问题1: {问题描述}

#### 分析根因
- 根因1: {根因分析}

#### 反哺规则
- 规则1: {新增规则}

#### 改进效果
- 性能提升: {百分比}%
- 错误减少: {数量}

---

## 累计改进统计更新
{更新累计统计}
```

### Step 7: 生成进化报告

使用 Write 工具创建文件：`.EnjoyHarness/EVOLUTION_REPORT.md`

```markdown
---
generated_at: {当前时间}
cycle_number: {循环数}
improvements_count: {改进数}
---

# 自我进化报告

## 进化概况
- 进化时间: {当前时间}
- 循环轮次: {循环数}
- 改进数量: {改进数}

## 本次进化内容

### 技术债清理
- 清理数量: {数量}
- 清理详情:
  - {债务1}: ✅ 已清理
  - {债务2}: ✅ 已清理
  - {债务3}: ⏳ 计划中

### 规则反哺
- 新增规则: {数量}
- 规则详情:
  - {RULE-XXX}: {规则名称}
  - {RULE-XXX}: {规则名称}

### 性能优化
- 优化项: {数量}
- 优化详情:
  - {优化1}: {效果}
  - {优化2}: {效果}

---

## 进化效果评估

### 时间效率
- 进化前: {数值}秒
- 进化后: {数值}秒
- 改进: {百分比}%

### Token效率
- 进化前: {数值}
- 进化后: {数值}
- 改进: {百分比}%

### 成功率
- 进化前: {百分比}%
- 进化后: {百分比}%
- 提升: {百分比}%

### 技术债
- 进化前: {数量}
- 进化后: {数量}
- 减少: {数量}

---

## 迭代飞轮状态

### 当前循环: {循环数}

#### 飞轮动量
- 加速中: ✅（改进幅度 > 10%）
- 稳定: ⚠️（改进幅度 5-10%）
- 减速: ❌（改进幅度 < 5%）

**当前状态**: {状态}

#### 飞轮健康度
- 优秀: ✅（技术债持续减少）
- 良好: ⚠️（技术债保持稳定）
- 需关注: ❌（技术债增加）

**当前健康度**: {健康度}

---

## 持续改进计划

### 下一步改进（短期）
- [ ] {改进项1}
- [ ] {改进项2}

### 中期改进（中期）
- [ ] {改进项1}
- [ ] {改进项2}

### 长期改进（长期）
- [ ] {改进项1}
- [ ] {改进项2}

---

## 经验总结

### 成功经验
- {经验1}: {描述}
- {经验2}: {描述}

### 失败教训
- {教训1}: {描述}
- {教训2}: {描述}

### 最佳实践
- {实践1}: {描述}
- {实践2}: {描述}

---

## 下次进化计划

### 进化目标
- 主要目标: {目标}
- 衡量标准: {标准}

### 进化路径
- Step 1: {步骤}
- Step 2: {步骤}
- Step 3: {步骤}

### 预期效果
- 性能改进: {预期}
- Token节省: {预期}
- 错误减少: {预期}
```

### Step 8: 记录进化事件

使用 Edit 工具追加内容到：`.EnjoyHarness/EVENT_LOG.md`

```markdown
{当前时间} | SELF_EVOLUTION | harness-evolve | 执行自我进化: 循环{循环数} | SUCCESS
{当前_time} | TECH_DEBT_CLEANUP | harness-evolve | 清理技术债: {数量}个 | SUCCESS
{当前时间} | RULE_FEEDBACK | harness-evolve | 反哺规则: {数量}条 | SUCCESS
{当前时间} | ITERATION_FLYWHEEL | harness-evolve | 更新飞轮: 循环{循环数} | SUCCESS
```

### Step 9: 更新全局状态

使用 Edit 工具更新：`.EnjoyHarness/GLOBAL_STATE.md`

```yaml
last_evolution: {当前时间}
evolution_cycle: {循环数}
tech_debt_cleaned: {数量}
rules_added: {数量}
improvements: {数量}
```

### Step 10: 更新事件计数

使用 Edit 工具更新：`.EnjoyHarness/EVENT_LOG.md`

old_string: `total_events: N`
new_string: `total_events: N+4`

### Step 11: 更新技能注册表

使用 Edit 工具更新：`.EnjoyHarness/SKILL_REGISTRY.md`

old_string: `- [ ] harness-evolve - 自我进化技能`
new_string: `- [x] harness-evolve - 自我进化技能 ✅`

### Step 12: 输出完成信息

使用 Bash 工具输出：

```bash
echo ""
echo "✅ harness-evolve 完成!"
echo ""
echo "🔄 进化结果:"
echo " - 循环轮次: {循环数}"
echo " - 技术债清理: {数量}个"
echo " - 规则反哺: {数量}条"
echo " - 改进项: {数量}个"
echo ""
echo "📊 进化效果:"
echo " - 性能改进: {百分比}%"
echo " - Token节省: {百分比}%"
echo " - 错误减少: {百分比}%"
echo ""
echo "📋 报告:"
echo " - 进化报告: .EnjoyHarness/EVOLUTION_REPORT.md"
echo " - 技术债清单: .EnjoyHarness/TECH_DEBT_INVENTORY.md"
echo " - 迭代飞轮: .EnjoyHarness/ITERATION_FLYWHEEL.md"
echo ""
echo "🎯 下一步:"
echo " - 继续执行任务"
echo " - 或触发下一轮进化"
echo ""
```

## 成功标准
- [ ] 读取错误学习记录
- [ ] 识别技术债
- [ ] 执行技术债清理
- [ ] 更新迭代飞轮
- [ ] 生成进化报告
- [ ] 记录进化事件
- [ ] 更新全局状态
- [ ] 更新事件日志
- [ ] 技能注册表已更新

## 失败兜底
- harness-diagnose-and-improve 未完成 → 终止执行，提示运行前置技能
- 无技术债 → 输出"暂无技术债需要清理"

## 联动关系
- 前置: harness-diagnose-and-improve
- 自动触发: 无（定期执行或手动触发）

## 迭代计数
本技能执行预计迭代次数: 约 15 次（Read 3次 + Write 3次 + Edit 6次 + Bash 3次）

## 测试用例

### 测试 1: 前置条件检查
**输入**: 在错误诊断未执行时运行
**期望输出**: 错误提示"错误诊断未执行"
**验证方式**: 删除诊断记录后运行

### 测试 2: 技术债识别
**输入**: 项目中存在TODO/FIXME标记
**期望输出**: 正确识别所有TODO/FIXME
**验证方式**: 手动统计验证

### 测试 3: 技术债清理
**输入**: 执行清理
**期望输出**: 技术债数量减少
**验证方式**: 对比清理前后数量

### 测试 4: 迭代飞轮更新
**输入**: 执行进化
**期望输出**: ITERATION_FLYWHEEL.md循环数增加
**验证方式**: `grep "当前循环数" .EnjoyHarness/ITERATION_FLYWHEEL.md`

### 测试 5: 进化报告生成
**输入**: 执行进化
**期望输出**: 生成 EVOLUTION_REPORT.md
**验证方式**: `ls .EnjoyHarness/EVOLUTION_REPORT.md`

### 测试 6: 全局状态更新
**输入**: 读取 GLOBAL_STATE.md
**期望输出**: evolution_cycle 增加
**验证方式**: `grep "evolution_cycle" .EnjoyHarness/GLOBAL_STATE.md`

### 测试 7: 事件日志记录
**输入**: 读取 EVENT_LOG.md
**期望输出**: 包含 SELF_EVOLUTION 事件
**验证方式**: `grep "SELF_EVOLUTION" .EnjoyHarness/EVENT_LOG.md`

### 测试 8: 无技术债情况
**输入**: 无技术债时运行
**期望输出**: 输出"暂无技术债需要清理"
**验证方式**: 清理所有技术债后运行

## 迭代飞轮机制详解

### 飞轮原理
```yaml
概念: 一个自我强化的循环，每次循环都让系统变得更好
结构:
  1. 执行任务 → 收集实际数据
  2. 收集反馈 → 识别问题和机会
  3. 分析根因 → 找到根本原因
  4. 反哺规则 → 改进系统
  5. 清理债务 → 减少阻力
  6. 回到步骤1 → 开始新一轮循环

关键指标:
  - 飞轮动量: 改进幅度
  - 飞轮健康度: 技术债趋势
  - 飞轮转速: 循环频率
```

### 飞轮加速策略

#### 策略 1: 减少阻力
```yaml
方法: 清理技术债
效果: 每次循环阻力减小，速度加快
实施:
  - 定期扫描技术债
  - 按优先级清理
  - 记录清理效果
```

#### 策略 2: 增加动力
```yaml
方法: 反哺高质量规则
效果: 每次循环动力增强，改进更大
实施:
  - 深度分析根因
  - 提炼通用规则
  - 验证规则效果
```

#### 策略 3: 优化路径
```yaml
方法: 简化循环步骤
效果: 每次循环路径缩短，效率提升
实施:
  - 自动化重复步骤
  - 优化执行流程
  - 减少不必要环节
```

## 技术债管理策略

### 技术债分类

#### 代码债务
```yaml
类型:
  - TODO/FIXME标记
  - 重复代码
  - 超长文件/函数
  - 复杂度过高

清理策略:
  - 定期扫描
  - 优先级排序
  - 逐步重构
```

#### 架构债务
```yaml
类型:
  - 分层违规
  - 循环依赖
  - 设计缺陷
  - 扩展性差

清理策略:
  - 架构评审
  - 渐进式重构
  - 增加护栏
```

#### 文档债务
```yaml
类型:
  - 缺失文档
  - 文档过时
  - 注释缺失
  - README不完整

清理策略:
  - 自动生成
  - 定期更新
  - 文档驱动开发
```

### 清理优先级

```yaml
P0（立即清理）:
  - 影响系统稳定性
  - 影响核心功能
  - 安全漏洞

P1（本周清理）:
  - 影响开发效率
  - 影响代码质量
  - 重复代码

P2（本月清理）:
  - 影响可维护性
  - 缺失文档
  - 性能优化

P3（长期计划）:
  - 技术选型优化
  - 架构重构
  - 工具升级
```

## 使用示例

### 示例 1: 首次进化
```yaml
循环数: 1
技术债: 15个
清理数量: 5个（P0优先级）
规则反哺: 3条
改进效果:
  - 性能提升: 12%
  - Token节省: 8%
  - 错误减少: 20%

飞轮状态: 加速中 ✅
```

### 示例 2: 持续进化
```yaml
循环数: 5
技术债: 8个（从15减少到8）
清理数量: 3个（P1优先级）
规则反哺: 2条
改进效果:
  - 性能提升: 8%
  - Token节省: 5%
  - 错误减少: 15%

飞轮状态: 稳定 ⚠️（改进幅度 < 10%）
建议: 增加动力，反哺更高质量规则
```

### 示例 3: 成熟进化
```yaml
循环数: 10
技术债: 3个（持续减少）
清理数量: 1个（P2优先级）
规则反哺: 1条
改进效果:
  - 性能提升: 5%
  - Token节省: 3%
  - 错误减少: 10%

飞轮状态: 优秀 ✅
健康度: 优秀 ✅（技术债持续减少）
```

## 与其他技能的协作

### 协作流程
```
harness-diagnose-and-improve（错误诊断）
↓
harness-evolve（自我进化）
↓
判断: 是否需要下一轮?
├─ 是 → 继续进化
└─ 否 → 等待下次触发
```

### 协作示例
```yaml
场景: 持续改进系统

阶段1: 错误诊断
- harness-diagnose-and-improve → 分析错误
  ├─ 识别问题: 5个
  ├─ 分析根因: 完成
  └─ 反哺规则: 3条

阶段2: 自我进化
- harness-evolve → 执行进化
  ├─ 技术债清理: 5个
  ├─ 规则应用: 3条
  └─ 飞轮更新: 循环+1

阶段3: 效果评估
- 检查改进效果
  ├─ 性能提升: 12%
  ├─ Token节省: 8%
  └─ 错误减少: 20%

阶段4: 持续循环
- 判断: 是否需要继续?
  ├─ 技术债 > 5 → 继续进化
  └─ 技术债 ≤ 5 → 等待下次触发
```