智能体工程课walkinglabs/learn-harness-engineering

Learn Harness Engineering

一门基于项目的课程，讲解如何构建让 AI 编码智能体可靠工作的环境、状态管理、验证与控制机制。

🌍 本课程提供 15 种语言：英语、简体中文、繁體中文、日本語、한국어、Español、Français、Русский、Deutsch、العربية、Tiếng Việt、Oʻzbekcha、Türkçe、Portuguese (BR)、Українська。请从上方徽章中选择你的语言。

🆕 最新动态 — 2026 年 8 月

前沿 Harness 设计拆解 — 新章节（4 篇拆解）

| 内容 | 详情 |
|------|---------|
| 新章节 | 前沿 Harness 设计拆解 — 运用课程的五子系统框架（指令、工具、环境、状态、反馈）逆向工程四个前沿产品如何构建真实的 harness。 |
| Pi | Pi 如何构建其 harness — 极简内核、可编程扩展，以及“让 Pi 构建你想要的东西”背后的上下文工程。 |
| Claude Code | Claude Code 如何构建其 harness — 四层记忆、五级压缩、钩子，以及子代理隔离。 |
| Codex | Codex 如何构建其 harness — 以仓库为事实来源、以 AGENTS.md 为目录页，以及 worktree 隔离。 |
| DeepSeek | DeepSeek 如何构建其 harness — “一切皆插件”、能力接缝，以及事件管道。 |
| 全部 15 种语言 | 所有支持语言的完整翻译覆盖。 |

核心思想： 课程为你提供框架；这些拆解向你展示同样的原则在生产级 harness 中实际如何体现。

图工程更新 — 1 节新课程，1 个新项目

| 内容 | 详情 |
|------|---------|
| 第 14 讲 | 从单循环到图工程 — 为什么单循环会演化为图：四个堆叠层级（提示词 → 上下文 → 循环 → 图）以及 harness 在该栈中的位置，图的四个部分（节点、边、共享状态、路由），为什么循环内检查点无法修复规模化下的三种结构性失败（古德哈特定律、向上盲区、冲突），一个与框架无关的六步演练，用于构建你的第一个图，图与工作流的对比，锚点，哪些开源“图工程”项目在该名称出现之前就已存在、哪些是在之后出现的，编排税，以及何时真正值得绘制一个图。 |
| 项目 08 | 将你的工作流绘制为图 — 三个渐进式实验：将你的 maker-checker 循环绘制为显式图，添加一个并行扇出/扇入节点，然后添加一条条件回滚边和一个人类审批节点。 |

核心思想： 循环就是只有一个节点的图。当你的任务需要专业化、并行、共享状态、验证和恢复时——它就不再是一个循环了。它是一个图。

🆕 最新动态 — 2026 年 7 月

循环工程更新 — 1 节新课程，1 个新项目

| 内容 | 详情 |
|------|---------|
| 第 13 讲 | 为什么你需要停止给你的智能体写提示词 —— 从 /goal 到循环工程的六大原语（自动化、工作树、技能、连接器、子智能体、外部状态）、生成器/评估器分离、四种隐性成本，以及构建你的第一个循环的分步指南。 |
| 项目 07 | 构建你的第一个自动化循环 —— 三个渐进式实验：目标循环、定时器循环和制作者-检查者循环。比较手动与自动化，衡量干预减少量，并学会跳出循环之外。 |
| 代码模板 | goal-template.md、loop-state-template.md、maker-prompt.md、checker-prompt.md —— 可直接使用的模板，帮助你立即构建循环。 |
| 全部 15 种语言 | 覆盖所有支持语言的完整翻译。 |

核心思想： Harness 工程打造车辆。循环工程设计它行驶的道路——而你要从车外设计这条道路。

Learn Harness Engineering 是一门专注于 AI 编码智能体工程的课程。我们深入研究并综合了业界最先进的 Harness Engineering 理论与实践。我们的核心参考资料包括：

- OpenAI: Harness engineering: leveraging Codex in an agent-first world
- Anthropic: Effective harnesses for long-running agents
- Anthropic: Harness design for long-running application development
- Awesome Harness Engineering

想要快速开始？ skills/harness-creator/ 技能可以帮助你在几分钟内为你的项目搭建一个生产级 harness（AGENTS.md、功能列表、init.sh、验证工作流）。

目录

- 🆕 最新内容
- ✨ 视觉预览
- Harness Engineering 的真正含义
- 快速开始：今天就改进你的智能体
- 顶点项目：一个真实应用
- 学习路径
- 课程大纲
- 技能
- 其他课程

✨ 视觉预览

🏠 课程主页
全面的课程大纲和核心理念介绍，提供清晰的入门路径。

课程主页预览

📖 沉浸式讲座
深入探讨真实世界的痛点和动手项目（如项目 01），带来沉浸式学习体验。

课程讲座预览

🗂️ 即用型资源库
用于解决多轮 AI 智能体开发中常见陷阱（如上下文丢失和任务过早完成）的模板和参考配置。

资源库预览

PDF 教材

该仓库现在包含课程内容的 PDF 构建流水线。

- 运行 npm run pdf:build 以在本地生成当前配置的 PDF 教材。
- 输出文件写入 artifacts/pdfs/。
- 如果你想刷新 README 预览图片，请运行 npm run screenshots:readme。
- GitHub Actions 工作流 release-course-pdfs.yml 可以构建 PDF 并将其发布到 GitHub Releases。

模型很聪明，但让它可靠的是运行框架

有一个大多数人都是吃了苦头才明白的残酷事实：如果你不在它周围构建一个合适的环境，世界上最强大的模型在真实工程任务上仍然会失败。

你很可能亲眼见过这种情况。你在自己的仓库里给 Claude 或 GPT 一个任务。它一开始表现不错——读取文件、编写代码，看起来很有成效。然后出了问题。它跳过了一个步骤。它弄坏了一个测试。它说“完成了”，但实际上什么都不工作。你花在收拾烂摊子上的时间比你自己做还要多。

这不是模型的问题。这是运行框架的问题。

证据很明确。Anthropic 进行了一项对照实验：相同的模型（Opus 4.5），相同的提示词（“构建一个 2D 复古游戏编辑器”）。没有运行框架时，它在 20 分钟内花费了 9 美元，产出的东西却无法运行。有了完整的运行框架（规划器 + 生成器 + 评估器），它在 6 小时内花费了 200 美元，构建出了一个你真正能玩的游戏。模型没有变。变的是运行框架。

OpenAI 在 Codex 上也报告了同样的情况：在一个配置良好的仓库中，同一个模型从“不可靠”变为“可靠”。这不是边际改进——而是质的转变。

本课程教你如何构建那个环境。

运行框架模式
====================

你 --> 给出任务 --> 智能体读取运行框架文件 --> 智能体执行
|
运行框架管理每一步：
|
+--> 指令：做什么，按什么顺序
+--> 范围：一次一个功能，不越界
+--> 状态：进度日志、功能列表、git 历史
+--> 验证：测试、lint、类型检查、冒烟运行
+--> 生命周期：开始时初始化，结束时清理状态
|
v
智能体仅在
验证通过

Harness Engineering 的真正含义

Harness engineering 的核心是在模型周围构建一个完整的工作环境，使其产出可靠的结果。它不是关于编写更好的提示词。它是关于设计模型所运行于其中的系统。

一个 harness 有五个子系统：

┌────────────────────────────────────────────────────────────────┐
│                          THE HARNESS                           │
│                                                                │
│   ┌──────────────┐  ┌──────────────┐  ┌────────────────────┐   │
│   │ Instructions │  │    State     │  │   Verification     │   │
│   │              │  │              │  │                    │   │
│   │ AGENTS.md    │  │ progress.md  │  │ tests + lint       │   │
│   │ CLAUDE.md    │  │ feature_list │  │ type-check         │   │
│   │ feature_list │  │ git log      │  │ smoke runs         │   │
│   │ docs/        │  │ session hand │  │ e2e pipeline       │   │
│   └──────────────┘  └──────────────┘  └────────────────────┘   │
│                                                                │
│   ┌──────────────┐  ┌──────────────────────────────────────┐   │
│   │    Scope     │  │         Session Lifecycle            │   │
│   │              │  │                                      │   │
│   │ one feature  │  │ init.sh at start                     │   │
│   │ at a time    │  │ clean-state checklist at end         │   │
│   │ definition   │  │ handoff note for next session        │   │
│   │ of done      │  │ commit only when safe to resume      │   │
│   └──────────────┘  └──────────────────────────────────────┘   │
│                                                                │
└────────────────────────────────────────────────────────────────┘

The MODEL decides what code to write.
The HARNESS governs when, where, and how it writes it.
The harness doesn't make the model smarter.
It makes the model's output reliable.

每个子系统只承担一项职责：

- Instructions — 告诉 agent 要做什么、以什么顺序做，以及开始前要阅读什么。不是一个巨大的文件；而是一个渐进式披露结构，agent 按需浏览。
- State — 跟踪已完成的内容、进行中的内容以及下一步要做的内容。持久化到磁盘，以便下一个会话能从上一次结束的地方精确继续。
- Verification — 只有通过的测试套件才算作证据。agent 无法在没有可运行证明的情况下宣布胜利。
- Scope — 将 agent 限制为一次只处理一个功能。不过度扩张。不半途完成三件事。不重写功能列表来隐藏未完成的工作。
- Session Lifecycle — 开始时初始化。结束时清理。为下一个会话留下干净的重新启动路径。

为什么存在这门课程
问题不在于“模型能写代码吗？”它们能。问题是：它们能否在真实仓库中、跨多个会话、在没有持续人工监督的情况下，可靠地完成真实的工程任务？

目前，答案是：没有套具就不行。

没有套具                                    有套具
==============                             ============

会话 1：智能体写代码                        会话 1：智能体阅读指令
智能体破坏测试                              智能体运行 init.sh
智能体说“完成”                              智能体处理一个功能
你手动修复                                  智能体在声称完成前先验证
智能体更新进度日志
会话 2：智能体从头开始                                智能体提交干净状态
智能体没有记忆
不知道之前发生了什么              会话 2：智能体阅读进度日志
智能体重做工作                              智能体从上次中断处准确继续
或者做了完全不同的事情                      智能体继续未完成的功能
你再次修复                                  你审查，而不是补救

结果：你花更多时间                        结果：智能体做工作，
清理烂摊子，而不是                        你验证结果
自己动手做

这门课程真正关心的问题：

- 哪些套具设计能提高任务完成率？
- 哪些设计能减少返工和不正确的完成？
- 哪些机制能让长时间运行的任务稳步推进？
- 哪些结构能让系统在多次智能体运行后仍保持可维护性？

课程大纲与文档

如需完整的课程材料，请访问 文档网站。

课程分为三个部分：

1. 讲座：13 个概念单元，讲解套具工程背后的理论。
2. 项目：7 个动手项目，让你从零开始构建一个智能体工作区。
3. 资源库：可直接复制的模板（AGENTS.md、feature_list.json、init.sh 等），今天就能在你自己的仓库中使用。

快速开始：今天就改进你的智能体

你不需要读完所有 14 讲才能开始获得价值。如果你已经在真实项目中使用编码智能体，以下是如何立即改进它。

思路很简单：不要只是写提示词，而是给你的智能体一组结构化文件，定义要做什么、已经做了什么，以及如何验证工作。这些文件存放在你的仓库中，因此每个会话都从相同的状态开始。

你的项目根目录
├── AGENTS.md              <-- 智能体的操作手册
├── CLAUDE.md              <-- （替代方案，如果使用 Claude Code）
├── init.sh                <-- 运行 install + verify + start
├── feature_list.json      <-- 存在哪些功能，哪些已完成
├── claude-progress.md     <-- 会话进度（历史文件名；与 agent 无关）
└── src/                   <-- 你的实际代码

从资源库获取起始模板，并将它们放入你的项目中。就这样。四个文件，你的 agent 会话就会比仅靠提示词运行时稳定得多。

claude-progress.md 是一个通用的、仓库本地的会话进度日志；
保留该名称是为了与课程示例兼容。它不绑定到
Claude Code，也不会被任何 agent 自动更新。Codex、OpenHands、
Antigravity 以及其他编码 agent 都可以使用同一个文件，只要它们的根
指令告诉它们在启动时读取该文件，并在交接前更新它。

顶点项目：一个真实应用

所有六个课程项目都围绕同一个产品：一个基于 Electron 的个人知识库桌面应用。

┌──────────────────────────────────────────────────────┐
│             Knowledge Base Desktop App               │
│                                                      │
│  ┌──────────────┐  ┌──────────────────────────────┐  │
│  │ Document List│  │       Q&A Panel              │  │
│  │              │  │                              │  │
│  │ doc-001.md   │  │  Q: What is harness eng?     │  │
│  │ doc-002.md   │  │  A: The environment built    │  │
│  │ doc-003.md   │  │     around an agent model... │  │
│  │ ...          │  │     [citation: doc-002.md]   │  │
│  └──────────────┘  └──────────────────────────────┘  │
│                                                      │
│  ┌─────────────────────────────────────────────────┐ │
│  │ Status Bar: 42 docs | 38 indexed | last sync 3m │ │
│  └─────────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────┘

Core features:
├── Import local documents
├── Manage a document library
├── Process and index documents
├── Run AI-powered Q&A over imported content
└── Return grounded answers with citations

选择这个项目，是因为它结合了很强的实用价值、足够的真实产品复杂度，以及一个适合观察 harness 改进前后效果的良好场景。

每个课程项目的 starter/solution 都是这个 Electron 应用在相应演进阶段的一份完整副本。P(N+1) 的 starter 源自 P(N) 的 solution——随着你的 harness 技能增长，这个应用也在演进。

学习路径

本课程设计为按顺序完成。每个阶段都建立在前一个阶段之上。

Phase 1: SEE THE PROBLEM              Phase 2: STRUCTURE THE REPO
========================              ==========================
L01  强模型 ≠ 可靠         L03  仓库作为单一
执行                              事实来源
L02  harness 的真正含义
L04  将指令拆分到多个
|                                     文件，而非一个巨大文件
v
P01  仅提示词 vs.                       |
规则优先对比                        v
P02  智能体可读的工作区

阶段 3：连接会话                        阶段 4：反馈与范围
==========================            =========================

L05  跨会话保持上下文                   L07  划定清晰的任务边界
持续存活
L08  将功能列表作为 harness
L06  在每次智能体会话前                    原语
进行初始化
|
|                                     v
v                                     P04  运行时反馈以
P03  多会话连续性                               纠正智能体行为

阶段 5：验证                          阶段 6：整合全部
=====================                 ============================

L09  阻止智能体过早                     L11  让智能体的运行时
宣称胜利                               可观测

L10  全流程运行 =                      L12  在每次会话结束时
真正的验证                             干净交接

|                                     |
v                                     v
P05  智能体验证自己的工作                P06  构建完整的 harness
（顶点项目）

阶段 7：自动化循环
==========================

L13  停止提示你的智能体——
改为设计循环

|
v
P07  构建你的第一个自动化循环
（目标循环、定时循环、制作者-检查者）

阶段 8：构建系统结构
=============================

L14  将系统绘制为图——
节点、边、共享状态、路由

|
v
P08  将你的工作流绘制为图
（显式图、并行扇出/扇入、
回滚边、人在回路中）

如果你兼职学习，每个阶段大约需要一周。如果你想更快，阶段 1–3 可以在一个长周末内完成。

教学大纲

讲座——14 个概念单元，每个单元回答一个核心问题

在文档网站上阅读每场讲座的全文。

| 场次 | 问题 | 核心思想 |
|---------|----------|-----------|
| L01 | 为什么强模型在真实任务上仍然会失败？ | 基准测试与真实工程之间的能力差距 |
| L02 | “harness”到底是什么意思？ | 五个子系统：指令、状态、验证、范围、生命周期 |
| L03 | 为什么仓库必须成为唯一事实来源？ | 如果 agent 看不到它，它就不存在 |
| L04 | 为什么一个巨大的指令文件会失败？ | 渐进式披露：给一张地图，而不是一本百科全书 |
| L05 | 为什么长时间运行的任务会失去连续性？ | 将进度持久化到磁盘；从上次中断的地方继续 |
| L06 | 为什么初始化需要自己的阶段？ | 在 agent 开始工作前验证环境是否健康 |
| L07 | 为什么 agent 会做过头又完成不足？ | 一次只做一个功能；明确定义完成标准 |
| L08 | 为什么功能列表是 harness 原语？ | agent 无法忽略的机器可读范围边界 |
| L09 | 为什么 agent 会过早宣布胜利？ | 验证缺口：自信 ≠ 正确 |
| L10 | 为什么端到端测试会改变结果？ | 只有完整流水线运行才算真实验证 |
| L11 | 为什么可观测性属于 harness 内部？ | 如果你看不到 agent 做了什么，就无法修复它弄坏的东西 |
| L12 | 为什么每个会话都必须留下干净状态？ | 下一个会话的成功取决于本次会话的清理 |
| L13 | 为什么你需要停止提示你的 agent？ | 从手动驾驶到自动化循环——目标循环、定时循环，以及 maker-checker 分离 |
| L14 | 为什么单个循环会成长为图？ | 从单循环到图工程——节点、边、共享状态、路由，以及什么时候图才真正值得画 |

项目 — 8 个动手项目，将讲座方法应用到同一个 Electron 应用

| 项目 | 你要做什么 | Harness 机制 |
|---------|------------|-------------------|
| P01 | 将同一个任务运行两次：仅提示 vs. 规则优先 | 最小 harness：AGENTS.md + init.sh + feature_list.json |
| P02 | 重构仓库，让智能体能够读取它 | 智能体可读工作区 + 持久化状态文件 |
| P03 | 让智能体从上次中断的地方继续 | 进度日志 + 会话交接 + 多会话连续性 |
| P04 | 阻止智能体做得太多或太少 | 运行时反馈 + 范围控制 + 增量索引 |
| P05 | 让智能体验证自己的工作 | 自我验证 + 有据可依的问答 + 基于证据的完成 |
| P06 | 从零构建完整的 harness（顶点项目） | 完整 harness：所有机制 + 可观测性 + 消融研究 |
| P07 | 构建你的第一个自动化循环 | 目标循环、定时器循环、maker-checker 分离、循环状态管理 |
| P08 | 将你的工作流绘制为图 | 显式节点/边/状态/路由、并行扇出/扇入、回滚边、人在回路审批 |
text
PROJECT EVOLUTION
=================

P01  Prompt-only vs. rules-first       You see the problem
|
v
P02  Agent-readable workspace          You restructure the repo
|
v
P03  Multi-session continuity          You connect sessions
|
v
P04  Runtime feedback & scope          You add feedback loops
|
v
P05  Self-verification                 You make the agent check itself
|
v
P06  Complete harness (capstone)       You build the full system
|
v
P07  Your first automated loop        You step outside the loop
|
v
P08  Draw your workflow as a graph    You draw the system as a graph

Each project's solution becomes the next project's starter.
The app evolves. Your harness skills grow with it.

资源库

- English — 模板、清单和方法参考
- 简体中文 — 中文模板、清单和方法参考
- 繁體中文 — 繁體中文範本、清單和方法參考
- 日本語 — テンプレート、チェックリスト、方法リファレンス
- 한국어 — 템플릿, 체크리스트, 방법 참고 자료
- Español — plantillas, listas de verificación y referencias
- Français — modèles, listes de contrôle et références
- Русский — 模板、检查清单和参考手册
- Deutsch — 模板、检查清单和参考资料
- العربية — 模板、检查清单和参考资料
- Tiếng Việt — 模板、检查清单和参考资料
- Oʻzbekcha — 模板、检查清单和参考手册
- Türkçe — 模板、检查清单和参考资料
- Português (BR) — 模板、检查清单和方法参考

智能体会话生命周期

本课程的核心思想之一：智能体的会话应遵循结构化的生命周期，而不是随意进行。 具体如下：
text
AGENT SESSION LIFECYCLE
======================

┌──────────────────────────────────────────────────────────────────┐
│  START                                                           │
│                                                                  │
│  1. Agent reads AGENTS.md / CLAUDE.md                            │
│  2. Agent runs init.sh (install, verify, health check)           │
│  3. Agent reads claude-progress.md (what happened last time)     │
│  4. Agent reads feature_list.json (what's done, what's next)     │
│  5. Agent checks git log (recent changes)                        │
│                                                                  │
│  SELECT                                                          │
│                                                                  │
│  6. Agent picks exactly ONE unfinished feature                   │
│  7. Agent works only on that feature                             │
│                                                                  │
│  EXECUTE                                                         │
│                                                                  │
│  8. Agent implements the feature                                 │
│  9. Agent runs verification (tests, lint, type-check)            │
│  10. If verification fails: fix and re-run                       │
│  11. If verification passes: record evidence                     │
│                                                                  │
│  WRAP UP                                                         │
│                                                                  │
│  12. Agent updates claude-progress.md                            │
│  13. Agent updates feature_list.json                             │
│  14. Agent 记录哪些内容仍然损坏或未验证             │
│  15. Agent 提交（仅在可安全恢复时）                    │
│  16. Agent 为下一次会话留下干净的重新启动路径            │
│                                                                  │
└──────────────────────────────────────────────────────────────────┘

该 harness 管控此生命周期中的每一次转换。
模型决定每一步要编写什么代码。
没有 harness，第 9 步就变成“agent 说看起来没问题”。
有了 harness，第 9 步就是“测试通过、lint 干净、类型检查通过”。

本课程适合谁

本课程适合：

- 已经在使用编码 agent、并希望获得更好稳定性和质量的工程师
- 希望系统理解 harness 设计的研究人员或构建者
- 需要理解环境设计如何影响 agent 表现的技术负责人

本课程不适合：

- 寻找零代码 AI 入门的人
- 只关心提示词、不打算构建真实实现的人
- 没有准备好让 agent 在真实仓库中工作的学习者

要求

这是一门你实际运行编码 agent 的课程。

你至少需要以下工具之一：

- Claude Code
- Codex
- 另一个支持文件编辑、命令执行和多步任务的 IDE 或 CLI 编码 agent

本课程假设你可以：

- 打开本地仓库
- 允许 agent 编辑文件
- 允许 agent 运行命令
- 检查输出并重新运行任务

如果你没有这样的工具，你仍然可以阅读课程内容，但无法按预期完成项目。

本地预览

本仓库使用 VitePress 作为文档查看器。
sh
npm install
npm run docs:dev        # 带热重载的开发服务器
npm run docs:build      # 生产构建
npm run docs:preview    # 预览构建后的站点

然后在浏览器中打开 VitePress 输出的本地 URL。

先决条件

必需：

- 熟悉终端、git 和本地开发环境
- 能够使用至少一种常见应用技术栈读写代码
- 基本的软件调试经验（阅读日志、测试和运行时行为）
- 有足够时间投入以实现为重点的课程作业

有帮助但非必需：

- 有 Electron、桌面应用或本地优先工具的经验
- 有测试、日志或软件架构方面的背景
- 之前接触过 Codex、Claude Code 或类似的编码 agent

核心参考

主要：

- OpenAI: Harness engineering: leveraging Codex in an agent-first world
- Anthropic: Effective harnesses for long-running agents
- Anthropic: Harness design for long-running application development
- OpenAI：展开 Codex 智能体循环
- Anthropic：揭开 AI 智能体评估的神秘面纱
- LangChain：通过 harness 工程改进深度智能体
- Thoughtworks / Martin Fowler：面向编码智能体用户的 harness 工程
- Cursor：持续改进我们的智能体 harness

请参阅 docs/en/resources/reference/ 中的完整分层参考列表。

仓库结构
text
learn-harness-engineering/
├── docs/                          # VitePress 文档站点
│   ├── lectures/                  # 14 讲（index.md + code/ 示例）
│   │   ├── lecture-01-/
│   │   └── ...（共 14 讲）
│   ├── projects/                  # 8 个项目说明
│   │   ├── project-01-/
│   │   └── ...（共 8 个）
│   └── resources/                 # 多语言模板与参考资料（14 种语言）
│       ├── en/
│       └── ...（共 14 种）
├── projects/
│   ├── shared/                    # 共享的 Electron + TypeScript + React 基础
│   └── project-NN/                # 每个项目的 starter/ 和 solution/ 目录
├── skills/                        # 可复用的 AI 智能体技能
│   └── harness-creator/           # Harness 工程技能
├── tools/                         # 零依赖 shell 工具
│   └── audit-harness.sh           # 基于 shell 的 harness 审计（L03–L12，无需 Node.js）
├── package.json                   # VitePress + 开发工具
└── CLAUDE.md                      # 本仓库的 Claude Code 说明

课程如何组织

- 每一讲聚焦一个问题
- 课程包含 8 个项目
- 每个项目都要求智能体完成真实工作
- 每个项目都会对比弱 harness 与强 harness 的结果
- 重要的是可衡量的差异，而不是写了多少文档

技能

本仓库还包含可复用的 AI 智能体技能，你可以直接安装到 IDE 或智能体工作区中。

- harness-creator：一项技能，帮助你在几分钟内为自己的项目搭建生产级 harness。

工具

无需安装 Node.js 即可运行的零依赖实用工具。

- audit-harness.sh：一个基于 shell 的审计脚本，按照全部五个 harness 子系统（L03–L12）检查现有仓库。当所有 CRITICAL 项通过时以 0 退出。无需 Node.js——它补充了 harness-creator 的 validate-harness.mjs。
bash
直接在任何仓库上运行
curl -fsSL https://raw.githubusercontent.com/walkinglabs/learn-harness-engineering/main/tools/audit-harness.sh | bash -s -- /path/to/your/repo

或在克隆之后
bash tools/audit-harness.sh /path/to/your/repo

其他课程

我们的团队还创建了其他课程！来看看吧：

Hands-on Modern RL

Hands-on Modern RL：一个开源、实践导向的课程，弥合从基础 RL 概念到 LLM 对齐、RLVR 和高级 Agentic 系统之间的差距。

Modern LLM Notebook

Modern LLM Notebook：一门使用 PyTorch 从零开始构建现代 LLM 的实践课程，包含 23 个可运行的 Jupyter Notebook，涵盖分词器、注意力机制、MoE、RLHF、推理、评估和蒸馏。

致谢

本课程的灵感来源于 learn-claude-code，并借鉴了其中的理念——这是一份从零开始构建 agent 的渐进式指南，从单一循环到隔离的自主执行。