Harness Engineering 实战：AI Agent 从辅助工具到一等工程公民的演进之路

OpenAI 在 2026 年 6 月发布的《Harness Engineering》博文中披露了一个惊人的数据：其内部工程团队已有 超过 70% 的 PR 由 AI Agent（Codex）参与审查，代码合并速度提升了 40%，而线上事故率反而下降了 15%。与此同时，Jane Street 的工程师公开表示「我用 Claude Code 做设计的时间已经超过了 Figma」。这两个信号共同指向一个趋势：AI Agent 正在从「代码补全工具」进化为「一等工程公民」，而驾驭这些 Agent 的能力——Harness Engineering——正在成为每个工程团队的必修课。

🔮 一、什么是 Harness Engineering？

1.1 从 Copilot 到 Harness 的范式转移

传统的 AI 辅助编程（Copilot 模式）本质上是单点增强：在你写代码的时候，AI 在光标处补全几行代码。这种模式的价值显而易见，但它的天花板也很明显——AI 只是你的「打字加速器」。

Harness Engineering 则是一个完全不同的范式。它把 AI Agent 视为团队成员而非工具，关注的是如何设计工程系统，让 Agent 能够自主地完成复杂的工程任务：

⚡ **关键结论：**Harness Engineering 的核心不是让 AI 写更多代码，而是设计一套工程系统，让 AI Agent 能够可靠、安全、高效地参与软件交付的全生命周期。

1.2 为什么现在是关键时刻？

三个技术条件在 2026 年同时成熟：

✅ 上下文窗口突破 — Claude 4 和 GPT-5 的上下文窗口已达到 500K+ tokens，足以理解中型代码库的完整上下文

✅ 工具调用标准化 — MCP（Model Context Protocol）和 Function Calling 让 Agent 能够可靠地调用外部工具（Git、CI、数据库）

✅ 推理能力跃升 — 新一代推理模型（o3、Claude 4 Opus）能够进行多步骤的复杂推理，而不仅仅是模式匹配

💡 **提示：**如果你的团队还在用 2024 年的模型做 AI 辅助编程，现在是升级的最佳时机。新模型在代码理解和生成质量上的提升是量级性的。

🔧 二、五大 Harness Engineering 实战模式

2.1 模式一：Agent 驱动的代码审查

这是最容易落地、ROI 最高的模式。核心思路是：让 Agent 在人类审查者介入之前，先完成一轮结构化的代码审查。

以下是一个基于 GitHub Actions + Claude API 的自动化代码审查系统的完整实现：

// src/review/agent-reviewer.ts
// AI Agent 代码审查器：自动分析 PR diff 并生成结构化审查意见

import Anthropic from '@anthropic-ai/sdk'
import { Octokit } from '@octokit/rest'

interface ReviewComment {
  file: string
  line: number
  severity: 'error' | 'warning' | 'info'
  category: 'bug' | 'security' | 'performance' | 'style' | 'architecture'
  message: string
  suggestion?: string
}

interface ReviewResult {
  summary: string
  comments: ReviewComment[]
  approved: boolean
  confidence: number
}

const REVIEW_SYSTEM_PROMPT = `你是一位资深代码审查专家。请分析以下 PR diff，按照以下要求输出 JSON：

1. summary: 一句话总结这个 PR 的变更（不超过 100 字）
2. comments: 审查意见数组，每条包含 file, line, severity, category, message, suggestion
3. approved: 是否建议通过（true/false）
4. confidence: 你对审查结果的信心程度（0-1）

审查重点：
- 安全漏洞（SQL 注入、XSS、硬编码密钥）
- 性能问题（N+1 查询、不必要的 re-render、内存泄漏）
- 逻辑错误（边界条件、竞态条件、错误处理缺失）
- 架构问题（违反 SOLID 原则、循环依赖）

只输出 JSON，不要输出其他内容。`

async function reviewPR(
  owner: string,
  repo: string,
  pullNumber: number
): Promise<ReviewResult> {
  const octokit = new Octokit({ auth: process.env.GITHUB_TOKEN })
  const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY })

  // 获取 PR diff
  const { data: files } = await octokit.pulls.listFiles({
    owner, repo, pull_number: pullNumber,
  })

  // 只审查代码文件，跳过 lock 文件和自动生成的文件
  const codeFiles = files.filter(f =>
    !f.filename.includes('lock') &&
    !f.filename.includes('.generated.') &&
    ['added', 'modified'].includes(f.status) &&
    /\.(ts|tsx|js|jsx|py|java|go|rs)$/.test(f.filename)
  )

  // 构建 diff 上下文（限制在 100K tokens 以内）
  const diffContext = codeFiles
    .map(f => `### ${f.filename} (${f.status})\n\`\`\`diff\n${f.patch}\n\`\`\``)
    .join('\n\n')
    .slice(0, 100_000)

  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 4096,
    system: REVIEW_SYSTEM_PROMPT,
    messages: [{ role: 'user', content: diffContext }],
  })

  const content = response.content[0]
  if (content.type !== 'text') throw new Error('Unexpected response type')

  return JSON.parse(content.text) as ReviewResult
}

// 将审查结果发布为 GitHub PR 评论
async function postReviewComment(
  owner: string,
  repo: string,
  pullNumber: number,
  review: ReviewResult
): Promise<void> {
  const octokit = new Octokit({ auth: process.env.GITHUB_TOKEN })

  const severityEmoji = { error: '🔴', warning: '🟡', info: '🔵' }
  const categoryEmoji = {
    bug: '🐛', security: '🔐', performance: '⚡',
    style: '🎨', architecture: '🏗️',
  }

  let body = `## 🤖 AI Agent 代码审查报告\n\n`
  body += `**总结：**${review.summary}\n\n`
  body += `**建议：**${review.approved ? '✅ 通过' : '❌ 需要修改'}`
  body += `（置信度: ${(review.confidence * 100).toFixed(0)}%）\n\n`

  if (review.comments.length > 0) {
    body += `### 发现 ${review.comments.length} 个问题\n\n`
    for (const c of review.comments) {
      body += `${severityEmoji[c.severity]} ${categoryEmoji[c.category]} `
      body += `**\`${c.file}:${c.line}\`** — ${c.message}\n`
      if (c.suggestion) {
        body += `> 💡 建议：${c.suggestion}\n`
      }
      body += '\n'
    }
  } else {
    body += '🎉 未发现明显问题，代码质量良好！\n'
  }

  await octokit.issues.createComment({
    owner, repo, issue_number: pullNumber, body,
  })
}

export { reviewPR, postReviewComment, type ReviewResult }

⚠️ **警告：**Agent 审查永远不能完全替代人工审查。建议采用「Agent 先审 + 人工抽检」的双保险模式，特别是涉及安全敏感代码时。

实际效果对比：

2.2 模式二：Agent 驱动的自动化测试生成

测试代码是最适合 Agent 生成的代码类型之一。原因很简单：测试代码的模式高度标准化，且通常不需要复杂的架构决策。

// src/testing/agent-test-generator.ts
// AI Agent 测试生成器：从源代码自动生成单元测试

import Anthropic from '@anthropic-ai/sdk'
import * as fs from 'fs/promises'
import * as path from 'path'

interface TestCase {
  name: string
  code: string
  coversEdgeCases: boolean
}

interface TestSuite {
  sourceFile: string
  testFile: string
  testCases: TestCase[]
  coverageEstimate: number
}

const TEST_GEN_PROMPT = `你是一位测试专家。请为以下 TypeScript 源代码生成完整的 Jest 单元测试。

要求：
1. 覆盖所有公开方法/函数
2. 包含正常路径测试（happy path）
3. 包含边界条件测试（空值、零值、极大值、极小值）
4. 包含错误处理测试（异常输入、类型错误）
5. 使用 describe/it 结构组织测试
6. Mock 外部依赖
7. 只输出测试代码，不要解释

使用以下格式：
\`\`\`typescript
// 生成的测试代码
\`\`\``

async function generateTests(sourceFilePath: string): Promise<TestSuite> {
  const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY })
  const sourceCode = await fs.readFile(sourceFilePath, 'utf-8')
  const fileName = path.basename(sourceFilePath, '.ts')

  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 8192,
    system: TEST_GEN_PROMPT,
    messages: [{
      role: 'user',
      content: `源文件: ${sourceFilePath}\n\n\`\`\`typescript\n${sourceCode}\n\`\`\``,
    }],
  })

  const content = response.content[0]
  if (content.type !== 'text') throw new Error('Unexpected response type')

  // 提取代码块
  const codeMatch = content.text.match(/```typescript\n([\s\S]*?)```/)
  const testCode = codeMatch ? codeMatch[1].trim() : content.text

  // 解析测试用例
  const testCases = parseTestCases(testCode)

  const testDir = path.join(path.dirname(sourceFilePath), '__tests__')
  const testFile = path.join(testDir, `${fileName}.test.ts`)

  return {
    sourceFile: sourceFilePath,
    testFile,
    testCases,
    coverageEstimate: estimateCoverage(sourceCode, testCode),
  }
}

function parseTestCases(code: string): TestCase[] {
  const cases: TestCase[] = []
  const itRegex = /it\(['"`](.+?)['"`]/g
  let match
  while ((match = itRegex.exec(code)) !== null) {
    cases.push({
      name: match[1],
      code: '', // 简化处理
      coversEdgeCases: /edge|boundary|empty|null|undefined|error/i.test(match[1]),
    })
  }
  return cases
}

function estimateCoverage(source: string, test: string): number {
  // 简单估算：检查源代码中的函数/方法是否在测试中被提及
  const funcRegex = /(?:export\s+)?(?:async\s+)?(?:function|const)\s+(\w+)/g
  const functions = new Set<string>()
  let match
  while ((match = funcRegex.exec(source)) !== null) {
    functions.add(match[1])
  }

  let covered = 0
  for (const fn of functions) {
    if (test.includes(fn)) covered++
  }

  return functions.size > 0 ? Math.round((covered / functions.size) * 100) : 0
}

export { generateTests, type TestSuite }

📌 **记住：**Agent 生成的测试代码通常需要人工微调。重点关注三个方面：Mock 是否正确、断言是否充分、测试隔离性是否良好。

2.3 模式三：Agent 驱动的 UI 设计到代码

Jane Street 的工程师分享了一个令人惊讶的工作流：他们用 Claude Code 替代 Figma 进行 UI 设计。核心流程是：

1. 用自然语言描述 UI 需求
2. Agent 生成 HTML/CSS 代码
3. 浏览器预览 → 截图 → 反馈给 Agent
4. Agent 根据反馈迭代修改
5. 直接产出生产级代码

// src/design/agent-designer.ts
// AI Agent UI 设计器：从自然语言描述生成 UI 代码

import Anthropic from '@anthropic-ai/sdk'
import * as fs from 'fs/promises'

interface DesignRequest {
  description: string
  framework: 'html' | 'react' | 'vue' | 'svelte'
  styleSystem: 'tailwind' | 'css-modules' | 'styled-components'
  responsive: boolean
  accessibility: boolean
}

interface DesignResult {
  code: string
  previewUrl?: string
  iterations: number
  tokenUsage: number
}

const DESIGN_PROMPT = `你是一位资深 UI/UX 设计师和前端工程师。请根据用户的描述生成高质量的 UI 代码。

设计原则：
1. 视觉层次清晰，间距使用 8px 网格系统
2. 颜色使用 CSS 自定义属性，支持明暗主题
3. 响应式设计：移动端优先
4. 无障碍访问：语义化 HTML + ARIA 标签
5. 动画使用 CSS transition，避免 JS 动画库

输出要求：
- 只输出完整的、可直接运行的代码
- 包含所有必要的样式
- 使用现代 CSS 特性（Grid、Flexbox、Container Queries）`

async function generateDesign(request: DesignRequest): Promise<DesignResult> {
  const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY })

  let prompt = `框架: ${request.framework}\n`
  prompt += `样式方案: ${request.styleSystem}\n`
  prompt += `响应式: ${request.responsive ? '是' : '否'}\n`
  prompt += `无障碍: ${request.accessibility ? '是' : '否'}\n\n`
  prompt += `需求描述：\n${request.description}`

  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 8192,
    system: DESIGN_PROMPT,
    messages: [{ role: 'user', content: prompt }],
  })

  const content = response.content[0]
  if (content.type !== 'text') throw new Error('Unexpected response type')

  // 提取代码
  const codeMatch = content.text.match(/```(?:html|tsx?|vue|svelte|css)\n([\s\S]*?)```/g)
  const code = codeMatch
    ? codeMatch.map(m => m.replace(/```\w*\n?/g, '').replace(/```$/g, '').trim()).join('\n\n')
    : content.text

  return {
    code,
    iterations: 1,
    tokenUsage: response.usage.input_tokens + response.usage.output_tokens,
  }
}

// 迭代优化：接收截图反馈并修改代码
async function iterateDesign(
  currentCode: string,
  feedback: string,
  screenshotBase64?: string
): Promise<DesignResult> {
  const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY })

  const messages: Anthropic.MessageParam[] = [{
    role: 'user',
    content: [
      {
        type: 'text',
        text: `当前代码：\n\`\`\`html\n${currentCode}\n\`\`\`\n\n修改要求：${feedback}`,
      },
      ...(screenshotBase64 ? [{
        type: 'image' as const,
        source: {
          type: 'base64' as const,
          media_type: 'image/png' as const,
          data: screenshotBase64,
        },
      }] : []),
    ],
  }]

  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 8192,
    system: DESIGN_PROMPT + '\n\n请根据用户提供的截图反馈和修改要求，优化当前代码。只输出修改后的完整代码。',
    messages,
  })

  const content = response.content[0]
  if (content.type !== 'text') throw new Error('Unexpected response type')

  const codeMatch = content.text.match(/```(?:html|tsx?|vue|svelte|css)\n([\s\S]*?)```/g)
  const code = codeMatch
    ? codeMatch.map(m => m.replace(/```\w*\n?/g, '').replace(/```$/g, '').trim()).join('\n\n')
    : content.text

  return {
    code,
    iterations: 1,
    tokenUsage: response.usage.input_tokens + response.usage.output_tokens,
  }
}

export { generateDesign, iterateDesign, type DesignRequest, type DesignResult }

💡 **提示：**截图反馈是 Agent UI 设计的核心差异化能力。相比纯文字描述，一张截图+简短的修改意见能让 Agent 的理解准确率从 60% 提升到 90% 以上。

2.4 模式四：Agent 驱动的 CI/CD 自修复

当 CI 流水线失败时，传统的流程是：开发者收到通知 → 查看日志 → 定位问题 → 修复代码 → 重新提交。Harness Engineering 的做法是：让 Agent 自动完成前 4 步。

# .github/workflows/agent-ci-fix.yml
# AI Agent CI/CD 自修复工作流

name: Agent CI Self-Healing
on:
  workflow_run:
    workflows: ["CI"]
    types: [completed]

jobs:
  agent-fix:
    if: ${{ github.event.workflow_run.conclusion == 'failure' }}
    runs-on: ubuntu-latest
    permissions:
      contents: write
      pull-requests: write
    steps:
      - uses: actions/checkout@v4
        with:
          ref: ${{ github.event.workflow_run.head_branch }}

      - name: Download CI logs
        uses: actions/download-artifact@v4
        with:
          run-id: ${{ github.event.workflow_run.id }}
          name: ci-logs
          path: ./ci-logs

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '22'

      - name: Install dependencies
        run: npm ci

      - name: Run Agent Fix
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          node scripts/agent-ci-fix.mjs \
            --logs ./ci-logs \
            --branch ${{ github.event.workflow_run.head_branch }} \
            --pr-number ${{ github.event.workflow_run.pull_requests[0].number }}

// scripts/agent-ci-fix.mjs
// Agent CI 自修复脚本：分析失败日志并自动提交修复

import Anthropic from '@anthropic-ai/sdk'
import { execSync } from 'child_process'
import * as fs from 'fs'
import * as path from 'path'

const args = process.argv.slice(2)
const logsDir = args[args.indexOf('--logs') + 1]

// 读取失败的 CI 日志
const logFiles = fs.readdirSync(logsDir)
  .filter(f => f.endsWith('.log'))
  .map(f => fs.readFileSync(path.join(logsDir, f), 'utf-8'))
  .join('\n---\n')
  .slice(-50_000) // 只取最后 50K 字符

const anthropic = new Anthropic()

const response = await anthropic.messages.create({
  model: 'claude-sonnet-4-20250514',
  max_tokens: 8192,
  system: `你是 CI/CD 修复专家。分析失败的 CI 日志，定位问题并生成修复方案。

输出格式（严格 JSON）：
{
  "diagnosis": "问题诊断",
  "rootCause": "根本原因",
  "fixes": [
    {
      "file": "文件路径",
      "description": "修改说明",
      "diff": "完整的 unified diff 格式的修改"
    }
  ],
  "confidence": 0.85
}

只修复明确的错误，不要猜测性修改。`,
  messages: [{
    role: 'user',
    content: `CI 失败日志：\n\n${logFiles}`,
  }],
})

const content = response.content[0]
if (content.type !== 'text') throw new Error('Unexpected response')

const result = JSON.parse(content.text)

if (result.confidence < 0.7) {
  console.log('⚠️ Agent 置信度过低，跳过自动修复')
  process.exit(0)
}

// 应用修复
for (const fix of result.fixes) {
  console.log(`🔧 修复: ${fix.file} — ${fix.description}`)

  const filePath = path.resolve(fix.file)
  if (fs.existsSync(filePath)) {
    // 使用 git apply 应用 diff
    const diffPath = `/tmp/fix-${Date.now()}.diff`
    fs.writeFileSync(diffPath, fix.diff)
    execSync(`git apply ${diffPath}`, { stdio: 'inherit' })
  }
}

// 提交并创建修复 PR
execSync('git checkout -b agent/ci-fix', { stdio: 'inherit' })
execSync('git add -A', { stdio: 'inherit' })
execSync(`git commit -m "fix: Agent 自动修复 CI 失败

诊断: ${result.diagnosis}
根本原因: ${result.rootCause}
置信度: ${(result.confidence * 100).toFixed(0)}%"`, { stdio: 'inherit' })
execSync('git push origin agent/ci-fix', { stdio: 'inherit' })

console.log('✅ Agent 修复已推送到 agent/ci-fix 分支')

2.5 模式五：Agent 驱动的文档同步

代码变更后文档过时是每个工程团队的痛点。Agent 可以自动检测代码变更并同步更新相关文档。

// src/docs/agent-doc-sync.ts
// Agent 文档同步器：检测代码变更并自动更新 API 文档

import Anthropic from '@anthropic-ai/sdk'
import { Octokit } from '@octokit/rest'
import * as fs from 'fs/promises'

interface DocUpdate {
  file: string
  originalContent: string
  updatedContent: string
  changeType: 'api-change' | 'new-feature' | 'deprecation' | 'breaking-change'
}

async function syncDocs(
  owner: string,
  repo: string,
  prNumber: number
): Promise<DocUpdate[]> {
  const octokit = new Octokit({ auth: process.env.GITHUB_TOKEN })
  const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY })

  // 获取 PR 变更的代码文件
  const { data: files } = await octokit.pulls.listFiles({
    owner, repo, pull_number: prNumber,
  })

  // 获取当前文档
  const docFiles = ['README.md', 'docs/API.md', 'docs/CHANGELOG.md']
  const docs: Record<string, string> = {}

  for (const docFile of docFiles) {
    try {
      const { data } = await octokit.repos.getContent({
        owner, repo, path: docFile,
      })
      if ('content' in data) {
        docs[docFile] = Buffer.from(data.content, 'base64').toString('utf-8')
      }
    } catch { /* 文件不存在时跳过 */ }
  }

  // 构建变更上下文
  const changes = files
    .filter(f => /\.(ts|tsx|js|jsx)$/.test(f.filename))
    .map(f => `${f.filename} (${f.status}):\n${f.patch}`)
    .join('\n\n')

  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 8192,
    system: `你是文档同步专家。分析代码变更，判断是否需要更新文档。

输出 JSON 数组，每项包含：
- file: 需要更新的文档文件路径
- originalContent: 原始内容
- updatedContent: 更新后的内容
- changeType: api-change | new-feature | deprecation | breaking-change

只在确实需要更新时才输出，不需要更新时输出空数组 []。`,
    messages: [{
      role: 'user',
      content: `代码变更：\n${changes}\n\n当前文档：\n${
        Object.entries(docs).map(([f, c]) => `### ${f}\n${c}`).join('\n\n')
      }`,
    }],
  })

  const content = response.content[0]
  if (content.type !== 'text') throw new Error('Unexpected response')

  return JSON.parse(content.text) as DocUpdate[]
}

export { syncDocs, type DocUpdate }

💰 三、成本、安全与最佳实践

3.1 Agent 运营成本分析

Harness Engineering 不是免费的。以下是真实的 Token 消耗数据：

⚡ **关键结论：**以一个 5 人团队为例，Harness Engineering 的月成本约 $119，但它节省的工程师时间（按平均每天 30 分钟计算）价值约 $2,500/月。ROI 超过 20 倍。

3.2 安全防护清单

⚠️ 必须实施的安全措施：

• ✅ Agent 的所有代码修改必须通过 PR 流程，不能直接推送到 main
• ✅ 设置 Token 消耗上限，防止 Agent 陷入循环消耗预算
• ✅ 对 Agent 的输出进行敏感信息扫描（API Key、密码、内部 URL）
• ✅ 限制 Agent 可以访问的仓库范围（最小权限原则）
• ❌ 不要让 Agent 处理包含用户隐私数据的文件
• ❌ 不要在 Agent 的 system prompt 中硬编码任何密钥

// src/security/agent-guard.ts
// Agent 安全护栏：检测敏感信息泄露

const SENSITIVE_PATTERNS = [
  /(?:api[_-]?key|secret|password|token)\s*[:=]\s*['"][^'"]{8,}['"]/gi,
  /(?:sk-|pk-|ghp_|gho_|AKIA)[A-Za-z0-9]{20,}/g,
  /-----BEGIN\s+(?:RSA\s+)?PRIVATE\s+KEY-----/g,
  /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/g, // IP 地址
]

function scanForSensitiveData(content: string): string[] {
  const findings: string[] = []
  for (const pattern of SENSITIVE_PATTERNS) {
    const matches = content.match(pattern)
    if (matches) {
      findings.push(...matches.map(m =>
        `发现敏感信息: ${m.slice(0, 20)}...（已截断）`
      ))
    }
  }
  return findings
}

3.3 落地建议

渐进式引入路线图：

1. 第一周 — 从代码审查模式开始，成本最低、见效最快
2. 第二周 — 加入测试生成模式，重点关注边界条件测试
3. 第一个月 — 引入 CI 自修复，只处理明确的编译错误和 lint 错误
4. 第二个月 — 尝试 Agent UI 设计，从内部工具页面开始
5. 持续优化 — 根据 Agent 的准确率调整 prompt 和触发条件

📌 **记住：**Harness Engineering 的核心不是让 Agent 做更多事，而是让 Agent 做得更可靠。宁可让 Agent 只做一件事做到 95% 准确率，也不要让它做十件事但只有 70% 准确率。

📊 四、工具生态对比

🎯 总结

Harness Engineering 不是又一个 buzzword，而是软件工程在 AI 时代的一次实质性演进。它的核心理念可以用一句话概括：不要问 AI 能帮你写什么代码，要问你如何设计工程系统让 AI 可靠地参与软件交付。

关键行动建议：

✅ 从代码审查开始 — ROI 最高、风险最低、最容易量化效果

✅ 设计反馈闭环 — Agent 的每一次输出都应该有质量度量，持续优化 prompt

✅ 保持人在回路 — Agent 是队友不是替代品，关键决策必须人工确认

✅ 关注成本效益 — 定期分析 Token 消耗，优化高频调用的 prompt 长度

相关工具推荐：

• Claude Code — 最强 CLI Agent
• MCP 协议 — Agent 工具调用标准
• LangSmith — Agent 可观测性平台
• jsjson.com 在线工具 — JSON 格式化、代码转换等开发工具