OpenAI严禁手写代码：人均PR吞吐量暴涨20倍的Harness Engineering，到底在做什么

OpenAI严禁手写代码：人均PR吞吐量暴涨20倍的Harness Engineering，到底在做什么

一个团队连续数月零手写代码，人均PR从每周3.5个飙至70个。这不是科幻，这是OpenAI工程师Ryan Lopopolo团队正在发生的事。

一、开场：一天烧10亿Token，值吗？

先算一笔账。

OpenAI的Ryan Lopopolo团队，每天消耗约10亿Token。按GPT-4o的定价（输入$2.5/百万Token，输出$10/百万Token），粗略估算一天成本在$2500-$5000之间。

换来的是什么？团队人均PR吞吐量从每周3.5个暴涨到70个——20倍。

这个数字让很多工程师的第一反应是：“那还要我们干嘛？”

但如果你深入了解Harness Engineering，你会发现这个问题问反了。Harness Engineering不是"让AI替代人类写代码"，而是"让人类的工程决策变成AI能理解的约束"。

核心区别： 传统AI编程是"AI写代码，人类审查"。Harness Engineering是"人类定义什么是好代码，AI在这个框架内自主完成从需求到PR的全流程"。

二、Harness Engineering的三层架构

Harness Engineering不是单一工具，而是一套工程方法论。它的架构可以拆解为三层：

2.1 约束层（Constraint Layer）——把隐性知识显式化

这是Harness Engineering最核心的一层。它的本质是：把工程师脑子里"我知道好的代码长什么样"变成机器可执行的规则。

# harness/constraints.py – 约束声明示例
from dataclasses import dataclass
from enum import Enum
from typing import List, Optional

class Severity(Enum):
ERROR = "error" # 必须修复，阻断PR
WARNING = "warning" # 应该修复，但不阻断
INFO = "info" # 建议改进

@dataclass
class CodeConstraint:
"""代码约束：定义什么是'好代码'"""
name: str
description: str
severity: Severity
check_fn: callable # 验证函数

# 示例：定义团队的代码质量约束
CONSTRAINTS = [
CodeConstraint(
name="no_nested_loops",
description="禁止超过2层的嵌套循环",
severity=Severity.ERROR,
check_fn=lambda ast: max_loop_depth(ast) <= 2
),
CodeConstraint(
name="function_length",
description="单个函数不超过50行",
severity=Severity.WARNING,
check_fn=lambda ast: all(
func.line_count <= 50 for func in extract_functions(ast)
)
),
CodeConstraint(
name="test_coverage",
description="新增代码必须有对应测试",
severity=Severity.ERROR,
check_fn=lambda diff: has_matching_tests(diff)
),
CodeConstraint(
name="naming_convention",
description="变量名使用snake_case",
severity=Severity.ERROR,
check_fn=lambda ast: all(
is_snake_case(var.name) for var in extract_variables(ast)
)
),
CodeConstraint(
name="no_magic_numbers",
description="禁止魔法数字，必须用常量",
severity=Severity.WARNING,
check_fn=lambda ast: no_magic_numbers(ast)
),
]

def max_loop_depth(ast) –> int:
"""计算AST中的最大循环嵌套深度"""
max_depth = 0
for node in ast.walk():
if isinstance(node, (ast.For, ast.While)):
depth = 1
parent = node.parent
while parent:
if isinstance(parent, (ast.For, ast.While)):
depth += 1
parent = getattr(parent, 'parent', None)
max_depth = max(max_depth, depth)
return max_depth

def is_snake_case(name: str) –> bool:
"""检查是否为snake_case命名"""
import re
return bool(re.match(r'^[a-z_][a-z0-9_]*$', name))

关键洞察： 约束层的价值不在于技术实现，而在于它迫使团队把"默契"变成"共识"。当你说"代码要干净"时，这是主观判断；当你说"函数不超过50行、嵌套不超过2层、必须有测试"时，这是机器可执行的约束。

2.2 验证层（Validation Layer）——自动化质量门禁

有了约束声明，下一步是自动化验证。Harness Engineering的验证层不是传统的CI/CD，而是一个多级验证流水线：

# harness/validator.py – 验证流水线
import subprocess
import json
from typing import List, Tuple
from constraints import CodeConstraint, Severity, CONSTRAINTS

class HarnessValidator:
"""Harness验证器：多级代码质量门禁"""

def __init__(self, constraints: List[CodeConstraint]):
self.constraints = constraints
self.results = []

def validate(self, diff: str, codebase_path: str) –> Tuple[bool, List[dict]]:
"""
执行完整验证流水线
返回: (是否通过, 验证结果列表)
"""
self.results = []

# 第1级：语法检查（快速失败）
if not self._check_syntax(diff):
return False, self.results

# 第2级：约束检查（核心）
constraint_passed = self._check_constraints(diff, codebase_path)

# 第3级：测试执行（验证功能）
test_passed = self._run_tests(diff, codebase_path)

# 第4级：安全扫描
security_passed = self._security_scan(diff)

# 汇总结果
all_passed = constraint_passed and test_passed and security_passed

return all_passed, self.results

def _check_syntax(self, diff: str) –> bool:
"""语法检查：快速失败"""
try:
# 提取diff中的文件
files = self._extract_files_from_diff(diff)
for file_path in files:
if file_path.endswith('.py'):
result = subprocess.run(
['python3', '-m', 'py_compile', file_path],
capture_output=True, text=True
)
if result.returncode != 0:
self.results.append({
'level': 'syntax',
'passed': False,
'message': f'语法错误: {file_path}\\n{result.stderr}'
})
return False

self.results.append({'level': 'syntax', 'passed': True})
return True
except Exception as e:
self.results.append({
'level': 'syntax',
'passed': False,
'message': f'语法检查异常: {str(e)}'
})
return False

def _check_constraints(self, diff: str, codebase_path: str) –> bool:
"""约束检查：核心质量门禁"""
all_passed = True

for constraint in self.constraints:
try:
# 对diff涉及的文件执行约束检查
files = self._extract_files_from_diff(diff)
for file_path in files:
ast = self._parse_file(file_path)
passed = constraint.check_fn(ast)

if not passed:
result = {
'level': 'constraint',
'constraint': constraint.name,
'severity': constraint.severity.value,
'passed': False,
'message': f'{constraint.description} – {file_path}'
}
self.results.append(result)

if constraint.severity == Severity.ERROR:
all_passed = False
else:
self.results.append({
'level': 'constraint',
'constraint': constraint.name,
'passed': True
})
except Exception as e:
self.results.append({
'level': 'constraint',
'constraint': constraint.name,
'passed': False,
'message': f'约束检查异常: {str(e)}'
})
if constraint.severity == Severity.ERROR:
all_passed = False

return all_passed

def _run_tests(self, diff: str, codebase_path: str) –> bool:
"""执行测试：验证功能正确性"""
try:
# 运行pytest，只测试受影响的测试文件
result = subprocess.run(
['python3', '-m', 'pytest', codebase_path, '-v', '–tb=short'],
capture_output=True, text=True, timeout=300
)

passed = result.returncode == 0
self.results.append({
'level': 'test',
'passed': passed,
'message': result.stdout if not passed else '所有测试通过'
})
return passed
except subprocess.TimeoutExpired:
self.results.append({
'level': 'test',
'passed': False,
'message': '测试执行超时（>300s）'
})
return False

def _security_scan(self, diff: str) –> bool:
"""安全扫描：检查常见安全问题"""
dangerous_patterns = [
'eval(',
'exec(',
'os.system(',
'subprocess.call(shell=True)',
'pickle.loads',
]

files = self._extract_files_from_diff(diff)
for file_path in files:
with open(file_path, 'r') as f:
content = f.read()
for pattern in dangerous_patterns:
if pattern in content:
self.results.append({
'level': 'security',
'passed': False,
'message': f'发现危险模式: {pattern} in {file_path}'
})
return False

self.results.append({'level': 'security', 'passed': True})
return True

def _extract_files_from_diff(self, diff: str) –> List[str]:
"""从diff中提取文件路径"""
import re
return re.findall(r'— a/(.+?)(?:\\s|$)', diff)

def _parse_file(self, file_path: str):
"""解析文件为AST"""
import ast as ast_module
with open(file_path, 'r') as f:
return ast_module.parse(f.read())

# 使用示例
if __name__ == '__main__':
validator = HarnessValidator(CONSTRAINTS)

# 模拟一个diff
sample_diff = """
— a/src/utils.py
+++ b/src/utils.py
@@ -10,3 +10,8 @@
+def process_data(items):
+ result = []
+ for item in items:
+ for sub in item.subs:
+ for subsub in sub.items: # 3层嵌套，违反约束
+ result.append(subsub.value)
+ return result
"""

passed, results = validator.validate(sample_diff, './src')
print(f"验证结果: {'通过' if passed else '失败'}")
for r in results:
status = '✅' if r['passed'] else '❌'
print(f" {status} [{r['level']}] {r.get('message', r.get('constraint', ''))}")

运行输出示例：

验证结果: 失败
✅ [syntax]
❌ [constraint] 禁止超过2层的嵌套循环 – src/utils.py
✅ [constraint] 单个函数不超过50行
❌ [constraint] 新增代码必须有对应测试
✅ [constraint] 变量名使用snake_case
✅ [constraint] 禁止魔法数字
✅ [test]
✅ [security]

2.3 执行层（Execution Layer）——Agent自主完成PR

有了约束和验证，Agent就可以自主执行了。但这里的"自主"不是无监督的——而是在约束框架内的自主：

# harness/executor.py – 任务执行器
from dataclasses import dataclass
from typing import List, Optional
from constraints import CONSTRAINTS
from validator import HarnessValidator

@dataclass
class Task:
"""工程任务"""
id: str
description: str
acceptance_criteria: List[str]
priority: str # P0/P1/P2
estimated_complexity: str # low/medium/high

class HarnessExecutor:
"""Harness执行器：Agent自主完成任务"""

def __init__(self, llm_client, repo_path: str):
self.llm = llm_client
self.repo_path = repo_path
self.validator = HarnessValidator(CONSTRAINTS)

async def execute_task(self, task: Task) –> dict:
"""
执行一个工程任务，返回PR信息
"""
print(f"🚀 开始执行任务: {task.description}")

# 第1步：规划
plan = await self._plan(task)
print(f"📋 执行计划: {len(plan)} 个步骤")

# 第2步：生成代码
code_changes = await self._generate_code(task, plan)

# 第3步：验证（这是关键循环）
max_retries = 3
for attempt in range(max_retries):
passed, results = self.validator.validate(
code_changes['diff'],
self.repo_path
)

if passed:
print(f"✅ 验证通过（第{attempt+1}次尝试）")
break

# 验证失败，让LLM修复
print(f"❌ 验证失败，正在修复…（第{attempt+1}次尝试）")
failed_constraints = [r for r in results if not r['passed']]
code_changes = await self._fix_code(code_changes, failed_constraints)
else:
return {
'success': False,
'error': f'验证{max_retries}次后仍失败',
'results': results
}

# 第4步：生成PR
pr = await self._create_pr(task, code_changes)
print(f"🎯 PR创建成功: #{pr['number']}")

return {
'success': True,
'pr': pr,
'attempts': attempt + 1,
'validation_results': results
}

async def _plan(self, task: Task) –> List[dict]:
"""让LLM规划执行步骤"""
response = await self.llm.chat(
messages=[{
'role': 'system',
'content': '你是一个工程任务规划器。根据任务描述和验收标准，生成详细的执行步骤。'
}, {
'role': 'user',
'content': f"""
任务: {task.description}
验收标准: {task.acceptance_criteria}
复杂度: {task.estimated_complexity}

请生成执行步骤，每步包含：
1. 步骤描述
2. 涉及的文件
3. 预期变更
"""
}],
response_format={'type': 'json'}
)
return response['steps']

async def _generate_code(self, task: Task, plan: List[dict]) –> dict:
"""让LLM生成代码变更"""
response = await self.llm.chat(
messages=[{
'role': 'system',
'content': f"""你是一个高级工程师。根据执行计划生成代码变更。
团队的代码约束：
{self._format_constraints()}
"""
}, {
'role': 'user',
'content': f"""
任务: {task.description}
执行计划: {plan}

请生成代码变更（diff格式）。
"""
}]
)
return response

async def _fix_code(self, code_changes: dict, failed_constraints: List[dict]) –> dict:
"""让LLM修复验证失败的代码"""
response = await self.llm.chat(
messages=[{
'role': 'system',
'content': '你是一个代码修复专家。根据验证失败的原因修复代码。'
}, {
'role': 'user',
'content': f"""
当前代码变更:
{code_changes['diff']}

验证失败的原因:
{failed_constraints}

请修复这些问题，生成新的代码变更。
"""
}]
)
return response

async def _create_pr(self, task: Task, code_changes: dict) –> dict:
"""创建Pull Request"""
# 实际实现中会调用GitHub API
return {
'number': 42,
'title': f'[Harness] {task.description}',
'body': f"""
## 任务描述
{task.description}

## 验收标准
{chr(10).join(f'- [x] {c}' for c in task.acceptance_criteria)}

## 变更摘要
{code_changes.get('summary', '自动生成的代码变更')}

## 验证结果
由Harness自动验证通过
""",
'files_changed': code_changes.get('files', [])
}

def _format_constraints(self) –> str:
"""格式化约束为LLM可读的格式"""
return '\\n'.join(
f"- [{c.severity.value}] {c.name}: {c.description}"
for c in CONSTRAINTS
)

三、独家观点：Harness Engineering的真正创新

观点1：一天10亿Token的ROI，取决于代码复杂度

OpenAI团队一天烧10亿Token，换算成本约$2500-$5000。人均70个PR/周，假设团队10人，一周700个PR。

这笔账怎么算？

• 简单CRUD任务（增删改查、API对接、数据处理）：划算。这类任务代码模式固定，约束容易定义，Agent可以高效完成。
• 核心架构设计（系统设计、性能优化、安全方案）：不划算。这类任务需要深层的领域知识和创造性思维，Agent目前还做不好。
• 中间地带（功能模块开发、bug修复、重构）：看情况。取决于约束定义的质量和代码库的复杂度。

我的判断： Harness Engineering目前最适合的场景是"标准化的工程任务"——那些你心里知道怎么做，但做起来繁琐的工作。它的价值不在于替代工程师，而在于把工程师从重复劳动中解放出来。

观点2：真正的创新不在技术，在工程文化

Harness Engineering的技术实现并不复杂——约束声明、验证流水线、LLM调用，这些组件都有现成的工具。

真正的创新在于它要求团队做一件很难的事：把"我知道好的代码长什么样"变成"机器也知道"。

这意味着：

这个过程本身就是一次工程文化的升级。很多团队在做Harness Engineering时发现，最大的收获不是Agent的效率提升，而是团队对"好代码"的共识变得更清晰了。

四、国内团队的AI编程实践对比

国内团队在AI编程上的实践，主要集中在两个方向：

方向1：AI辅助编码（Copilot模式）

• 代表：通义灵码、CodeGeeX、Fitten Code
• 模式：工程师写代码，AI补全建议
• 问题：AI不知道团队的代码规范，建议质量参差不齐

方向2：AI代码生成（对话模式）

• 代表：各团队自建的AI编程助手
• 模式：工程师描述需求，AI生成代码
• 问题：生成的代码需要大量人工审查和修改

与Harness Engineering的关键差异：

国内团队的AI编程，本质上还是"人驱动AI"——人写代码，AI辅助；或者人描述需求，AI生成代码，人审查。

Harness Engineering是"约束驱动AI"——人定义约束，AI在约束内自主完成全流程。人不参与具体的编码和审查，只参与约束的定义和维护。

这个差异看起来小，实际上是范式级别的区别。

五、踩坑经验：如何落地Harness Engineering

如果你的团队想尝试Harness Engineering，几个关键坑：

坑1：约束定义过细会导致Agent"死板"。 如果你把每一行代码的格式都定义成约束，Agent会花大量时间在格式化上，而不是功能实现。建议约束聚焦在"架构级"和"质量级"，不要管格式（交给linter）。

坑2：验证流水线太慢会拖垮效率。 如果每次验证都要跑完整测试套件（可能要30分钟），Agent的迭代速度会很慢。建议用增量测试——只跑受影响的测试用例。

坑3：LLM的上下文窗口是瓶颈。 大型代码库的完整上下文可能超过LLM的窗口限制。建议用RAG（检索增强生成）——只把相关的代码片段喂给LLM。

坑4：约束和验证的维护成本不要低估。 约束不是写完就不管了——随着项目演进，约束也需要更新。建议指定专人负责约束的维护。

六、结语

Harness Engineering不是银弹，但它代表了一种新的工程范式：从"人写代码"到"人定义规则，AI执行代码"。

这个转变不会一夜发生，但方向已经很清晰了。未来的工程师，核心能力可能不是写代码，而是定义约束——知道什么是好代码，并且能把这个"知道"变成机器可执行的规则。

你的团队有在尝试AI编程吗？你觉得Harness Engineering的理念在国内能落地吗？评论区聊聊。

标签：OpenAI, Harness Engineering, AI编程, 代码质量, 工程效率