Harness Engineering从入门到精通，Claude架构师经验看这篇就够了！

导读：当所有人都在追逐更强大的模型时，有一群人正在默默构建一个全新的工程学科。他们不训练模型，不优化提示词，却能让AI智能体的能力翻倍。这篇文章将颠覆你对AI智能体的所有认知。

一、一个令人震惊的事实：你的AI智能体可能根本不是智能体

2026年初，行业内部流传着一份名为《Harness Engineering》的技术报告，揭示了一个令人不安的真相：大多数所谓的"AI智能体"，不过是用if-else语句搭建的复杂壳子，里面塞着一个被浪费的大语言模型。

你见过这样的场景吗？

• • 某个"智能体"平台，拖拽节点画流程图，用硬编码规则路由LLM调用
• • 某个"自主AI"系统，层层嵌套的条件判断，模型只是文本补全节点
• • 某个"智能工作流"，复杂的决策树，却连最简单的意外情况都处理不了

这不是智能体，这是戴着LLM面具的过程式脚本。

而与此同时，Anthropic的Claude Code却展现出截然不同的能力：它能理解整个代码库，自主决定使用哪些工具，如何分解任务，甚至能和其他AI智能体协作完成复杂工程。

差距在哪里？

答案是一个全新的工程学科——Harness Engineering（智能体框架工程）。

今天，我们将通过深度解析Claude Code的架构，揭示构建真正AI智能体的核心技术。这篇文章将带你从零开始理解Harness Engineering的精髓。

二、颠覆性认知：模型就是智能体本身

2.1 什么是AI智能体？

在深入技术细节之前，我们必须回答一个根本问题：什么才是真正的AI智能体？

答案可能让你意外：智能体就是模型本身——一个经过训练的神经网络（Transformer），它被训练来感知环境、推理目标、并采取行动实现目标。

这个定义看似简单，却有着深远的历史依据：

• •2013年：DeepMind的DQN从原始像素学习玩Atari游戏，"智能体"就是那个神经网络
• •2019年：OpenAI Five在Dota 2中击败职业选手，经过45000年自我对弈，"智能体"仍是神经网络
• •2019年：DeepMind的AlphaStar在《星际争霸II》达到宗师级别，智能体=模型
• •2024-2026年：Claude、GPT、Gemini作为编码智能体，阅读代码库、编写实现、调试故障，智能体从来不是周围的代码，始终是模型本身

2.2 你不是在开发智能体，你是在开发框架

这个认知带来了一个革命性的转变：

作为工程师，你的职责不是"开发智能体"，而是"开发智能体运行的框架（Harness）"。

什么是Harness？

Harness = 工具 + 知识 + 观察 + 行动接口 + 权限控制工具： 文件I/O、Shell、网络、数据库、浏览器知识： 产品文档、领域参考、API规范、风格指南观察： Git差异、错误日志、浏览器状态、传感器数据行动： CLI命令、API调用、UI交互权限： 沙箱、审批流程、信任边界

模型负责决策，框架负责执行。模型负责推理，框架提供上下文。模型是驾驶员，框架是车辆。

这个区分至关重要。因为你无法通过添加更多路由逻辑让模型更聪明，你无法通过堆叠过程式规则产生自主行为。那些试图用GOFAI（老式符号AI）思维包装LLM的系统，注定是死胡同。

你的工作不是工程化智能，而是工程化智能运行的环境。

三、通用智能体模式：Claude Code的核心架构

3.1 最小可行智能体循环

所有真正的AI智能体，无论应用领域如何，都共享一个不变的结构,核心原则：

1. 模型决定何时调用工具，何时停止
2. 代码只执行模型要求的事情
3. 循环结构不变，变化的只是周围的框架机制

这是Claude Code的真实架构，也是每个值得关注的生产级编码智能体的核心。

3.2 Python实现：最简智能体循环

让我们看一个真实的代码示例：

#!/usr/bin/env python3"""s01: The Agent Loop — The Minimal while-Loop Pattern核心：一个while循环 + Bash工具 = 智能体的雏形"""import osfrom anthropic import Anthropicfrom dotenv import load_dotenvload_dotenv()client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))# 唯一的工具：BashTOOL_HANDLERS = { "bash": lambda cmd: os.popen(cmd).read()}defagent_loop(task: str): """最简智能体循环""" messages = [ {"role": "user", "content": task} ] whileTrue: # 1. 调用模型 response = client.messages.create( model="claude-3-5-sonnet-20241022", max_tokens=1024, messages=messages, tools=[{ "name": "bash", "description": "Execute bash command", "input_schema": { "type": "object", "properties": { "command": {"type": "string"} }, "required": ["command"] } }] ) # 2. 检查停止条件 if response.stop_reason == "tool_use": # 3. 执行工具 for content in response.content: if content.type == "tool_use": tool_name = content.name tool_input = content.input # 分发到对应的handler result = TOOL_HANDLERS[tool_name](**tool_input) # 4. 返回结果，继续循环 messages.append({ "role": "assistant", "content": response.content }) messages.append({ "role": "user", "content": [{ "type": "tool_result", "tool_use_id": content.id, "content": result }] }) else: # 5. 输出最终结果 for content in response.content: if content.type == "text": print(f"\n最终输出: {content.text}") breakif __name__ == "__main__": task = "列出当前目录下的所有文件" agent_loop(task)

关键洞察：

• • 只有一个工具（bash）
• • 只有一个循环（while True）
• •模型决定一切，代码只是执行

这就是Harness Engineering的起点。接下来的12个阶段，每个阶段都在不改变这个循环的前提下，增加一个框架机制。

四、12阶段渐进式架构：从单工具到自主团队

阶段一：赋予智能体双手（核心循环与工具使用）

Session 01: Agent Loop（智能体循环）

• •工具数：1个（bash）
• •核心模式：while循环 + 单一工具
• •技术要点：理解模型如何决定行动

Session 02: Tool Use（工具使用）—— 分发映射模式

这里引入了第一个关键架构模式：Dispatch Map Pattern（分发映射模式）。

tool_use text_output 模型响应 检查stop_reason 遍历content 提取tool_name TOOL_HANDLERS字典 执行对应handler 返回tool_result 追加到messages 输出结果

关键代码模式：

# 分发映射：添加新工具只需增加一个handlerTOOL_HANDLERS = { "bash": handle_bash, "read": handle_read, "write": handle_write, "edit": handle_edit,}# 统一的分发逻辑（不需要修改）if tool_name in TOOL_HANDLERS: result = TOOL_HANDLERS[tool_name](**tool_input)

架构优势：

• • 添加新工具不改变循环逻辑
• • 每个工具独立测试、独立维护
• • 模型通过工具描述自主决定使用哪个

阶段二：赋予智能体大脑（规划与知识）

Session 03: TodoWrite（可见计划）

数据洞察：引入可见计划后，任务完成率提升2倍。

def handle_todo_write(action: str, todos: list): """ 管理TODO列表的工具 - action: "add" | "mark_complete" | "list" - todos: 任务列表（包含id、content、status） """ # 持久化到文件，确保上下文压缩后仍可恢复 with open("TODO.md", "a") as f: f.write(f"- [{status}] {todo_content}\n")

心理学原理：当智能体"看见"自己的计划时，它能更好地保持任务连贯性，避免在长会话中迷失。

Session 04: Subagents（子智能体）—— 进程隔离实现上下文隔离

这是架构上的重大突破：为每个子任务创建全新的消息上下文。

spawn spawn spawn fresh messages fresh messages fresh messages 返回结果 返回结果 返回结果 主智能体 子智能体1 子智能体2 子智能体3 独立上下文1 独立上下文2 独立上下文3

技术实现：

def spawn_subagent(task: str, context: dict) -> str: """ 生成子智能体，每个子智能体获得： 1. 全新的messages数组（不包含父智能体的历史） 2. 仅必要的上下文信息（通过system prompt注入） 3. 独立的工具集（可以限制权限） """ subagent_messages = [ {"role": "system", "content": build_subagent_system_prompt(context)}, {"role": "user", "content": task} ] # 运行独立的agent loop result = run_agent_loop(subagent_messages, tools=SUBAGENT_TOOLS) return result

架构价值：

• • 避免上下文污染
• • 每个子任务从零开始思考
• • 防止长会话中的"注意力稀释"

Session 05: Skill Loading（技能加载）—— 按需知识注入

颠覆性设计：知识不通过system prompt预加载，而是通过tool_result动态注入。

def handle_load_skill(skill_name: str) -> str: """ 从skills/目录加载SKILL.md文件 返回的知识作为tool_result进入上下文 """ skill_path = f"skills/{skill_name}/SKILL.md" with open(skill_path, "r") as f: return f.read()# 使用示例# 用户：请按照代码审查标准review这个PR# 模型：调用load_skill("code-review")# 结果：审查标准作为tool_result进入上下文# 模型：基于刚加载的知识执行审查

优势对比：

Session 06: Context Compact（上下文压缩）—— 三层战略压缩

这是实现无限会话时长的关键技术。

Unsupported markdown: blockquote 是 否 是 否 完整上下文 检查token使用率 第一层：压缩tool_result 仍>80%? 第二层：摘要中间消息 仍>80%? 继续执行 第三层：保留关键消息 系统消息 + 最近5轮 + TODO

三层压缩策略：

def compress_context(messages: list, todo_state: str) -> list: """ 三层压缩策略： 1. Layer 1: 压缩tool_result为摘要 2. Layer 2: 将中间消息替换为"执行了X个bash命令" 3. Layer 3: 仅保留： - 系统消息（身份定义） - 最近5轮对话（保持连贯性） - TODO状态（任务进度） """ # Layer 1: 压缩tool_result compressed = [] for msg in messages: if msg["role"] == "user"and"tool_result"instr(msg): # 提取关键信息，丢弃详细输出 summary = extract_tool_summary(msg) compressed.append({"role": "user", "content": summary}) else: compressed.append(msg) # Layer 2: 摘要中间消息 iflen(compressed) > 50: middle_start = 5 middle_end = len(compressed) - 10 compressed[middle_start:middle_end] = [ {"role": "system", "content": f"[省略了{middle_end - middle_start}条中间消息]"} ] # Layer 3: 注入TODO状态 compressed.append({ "role": "system", "content": f"当前任务状态:\n{todo_state}" }) return compressed

阶段三：赋予智能体记忆（持久化系统）

Session 07: Task System（任务系统）—— 基于文件的任务板与依赖图

这是从"单次会话"到"长期任务管理"的跃迁。

核心数据结构：

# TASKS.jsonl - 每行一个任务{ "id": "task_001", "title": "实现用户认证模块", "status": "pending", # pending | in_progress | done "dependencies": ["task_000"], "assigned_to": "agent_main", "worktree": "worktrees/task_001", "created_at": "2026-03-28T10:00:00Z"}

depends_on depends_on depends_on depends_on blocked by blocks TASKS.jsonl task_001 🔄 task_002 ⏳ 任务ID: task_003 task_000 ✅

技术实现：

class TaskSystem: def__init__(self, tasks_file: str = "TASKS.jsonl"): self.tasks_file = tasks_file defcreate_task(self, title: str, dependencies: list = None) -> str: """创建任务，自动分配ID和依赖检查""" task_id = f"task_{self.get_next_id()}" task = { "id": task_id, "title": title, "status": "pending", "dependencies": dependencies or [], "assigned_to": None, "worktree": f"worktrees/{task_id}", "created_at": datetime.now().isoformat() } # 追加到JSONL文件（持久化） withopen(self.tasks_file, "a") as f: f.write(json.dumps(task) + "\n") return task_id defget_ready_tasks(self) -> list: """获取可执行任务（所有依赖已完成）""" tasks = self.load_all_tasks() ready = [] for task in tasks: if task["status"] != "pending": continue # 检查依赖 deps_completed = all( self.is_task_completed(dep_id) for dep_id in task["dependencies"] ) if deps_completed: ready.append(task) return ready defis_task_completed(self, task_id: str) -> bool: """检查任务是否完成""" tasks = self.load_all_tasks() task = next((t for t in tasks if t["id"] == task_id), None) return task and task["status"] == "done"

架构价值：

• •持久化：即使上下文压缩，任务状态仍保存在磁盘
• •依赖图：智能体可以理解任务间的先后关系
• •可恢复：进程重启后，从文件恢复任务板状态

Session 08: Background Tasks（后台任务）—— 非阻塞守护线程与通知队列

这是实现并发执行的关键。

import threadingfrom queue import QueueclassBackgroundTaskManager: def__init__(self): self.notification_queue = Queue() self.active_tasks = {} defspawn_background_task(self, task_id: str, command: str): """ 在后台线程执行长时间运行的任务 主智能体循环不受阻塞，继续处理其他任务 """ defrun_task(): try: result = os.popen(command).read() # 将结果放入通知队列 self.notification_queue.put({ "task_id": task_id, "status": "completed", "result": result }) except Exception as e: self.notification_queue.put({ "task_id": task_id, "status": "failed", "error": str(e) }) # 启动守护线程 thread = threading.Thread(target=run_task, daemon=True) thread.start() self.active_tasks[task_id] = thread returnf"Task {task_id} started in background" defcheck_notifications(self) -> list: """检查后台任务完成通知""" notifications = [] whilenotself.notification_queue.empty(): notifications.append(self.notification_queue.get()) return notifications

集成到主循环：

def agent_loop_with_background(task: str): messages = [{"role": "user", "content": task}] bg_manager = BackgroundTaskManager() # 添加检查后台任务的工具 TOOL_HANDLERS["spawn_background"] = bg_manager.spawn_background_task TOOL_HANDLERS["check_notifications"] = bg_manager.check_notifications whileTrue: # 主循环继续运行 response = call_llm(messages) if response.stop_reason == "tool_use": # 执行工具（可能是启动后台任务） result = execute_tool(response) messages.append_result(result) # 智能体可以决定检查通知 if"check_notifications"instr(response): notifications = bg_manager.check_notifications() for notif in notifications: messages.append({ "role": "system", "content": f"后台任务完成: {notif}" }) else: break

使用场景：

• • 长时间运行的测试套件
• • 大型数据迁移
• • 网络请求（避免阻塞主循环）

阶段四：赋予智能体同事（团队协作）

Session 09: Agent Teams（智能体团队）—— 持久化队友与JSONL异步邮箱

这是从"单智能体"到"多智能体协作"的跃迁。

🔍 审查智能体 🧪 测试智能体 👨‍💻 开发者智能体 📮 JSONL邮箱系统 👨‍💼 主智能体 🔍 审查智能体 🧪 测试智能体 👨‍💻 开发者智能体 📮 JSONL邮箱系统 👨‍💼 主智能体 发布任务到team_tasks.jsonl 轮询任务板 自动认领任务（claim） 在独立worktree执行 发送结果到dev_mailbox.jsonl 检查邮箱 发布测试任务 认领测试任务 执行测试 发送测试报告 发布审查任务 认领审查 提交审查意见

核心架构：

class AgentTeam: def__init__(self, team_name: str): self.team_name = team_name self.mailbox_file = f"teams/{team_name}/mailbox.jsonl" self.tasks_file = f"teams/{team_name}/tasks.jsonl" defsend_message(self, sender: str, recipient: str, content: dict): """ 异步消息传递（JSONL邮箱） """ message = { "id": generate_uuid(), "sender": sender, "recipient": recipient, "content": content, "timestamp": datetime.now().isoformat(), "read": False } withopen(self.mailbox_file, "a") as f: f.write(json.dumps(message) + "\n") defread_messages(self, recipient: str) -> list: """读取未读消息""" messages = [] withopen(self.mailbox_file, "r") as f: for line in f: msg = json.loads(line) if msg["recipient"] == recipient andnot msg["read"]: msg["read"] = True messages.append(msg) # 更新已读状态 self._update_mailbox(messages) return messages defspawn_teammate(self, role: str, identity: str) -> str: """ 生成队友智能体 - role: 角色（developer/tester/reviewer） - identity: 身份定义（system prompt） """ teammate_id = f"agent_{role}_{generate_uuid()}" # 创建队友的独立进程 subprocess.Popen([ "python", "agents/autonomous_agent.py", "--teammate-id", teammate_id, "--role", role, "--identity", identity, "--team", self.team_name ]) return teammate_id

队友智能体的自主循环：

# autonomous_agent.py - 队友智能体的主循环defautonomous_agent_loop(teammate_id: str, role: str, team_name: str): """ 自主智能体： 1. 持续轮询任务板 2. 自动认领可用任务 3. 在独立worktree执行 4. 通过邮箱汇报结果 """ team = AgentTeam(team_name) identity = load_identity(role) whileTrue: # 空闲周期：轮询任务板 available_tasks = team.get_available_tasks(role) if available_tasks: # 自动认领第一个任务 task = available_tasks[0] team.claim_task(task["id"], teammate_id) # 切换到任务的worktree os.chdir(task["worktree"]) # 执行任务（标准agent loop） result = run_agent_loop(task["description"], identity) # 通过邮箱发送结果 team.send_message( sender=teammate_id, recipient="main", content={ "type": "task_completed", "task_id": task["id"], "result": result } ) # 标记任务完成 team.complete_task(task["id"]) # 等待一段时间后再次轮询 time.sleep(5)

Session 10: Team Protocols（团队协议）—— 关闭握手与计划审批FSM

这是实现可靠协作的关键。

有限状态机（FSM）示例：

class TeamProtocol: """ 团队通信协议： 1. 计划审批FSM 2. 关闭握手FSM """ defrequest_plan_approval(self, requester: str, plan: dict) -> str: """ 计划审批流程（FSM） States: pending -> reviewing -> approved|rejected """ request_id = generate_uuid() # 发送审批请求 self.send_message( sender=requester, recipient="approver", content={ "type": "plan_approval_request", "request_id": request_id, "plan": plan } ) # 等待响应（带超时） response = self.wait_for_response(request_id, timeout=300) return response["status"] # "approved" or "rejected" defgraceful_shutdown(self, agent_id: str) -> bool: """ 优雅关闭握手 1. 发送shutdown请求 2. 等待当前任务完成 3. 保存状态 4. 确认关闭 """ self.send_message( sender="system", recipient=agent_id, content={"type": "shutdown_request"} ) # 等待确认 ack = self.wait_for_message(agent_id, "shutdown_ack", timeout=60) if ack: # 保存状态 self.save_agent_state(agent_id) returnTrue return False

Session 11: Autonomous Agents（自主智能体）—— 空闲周期、任务板轮询、自动认领

这是实现真正自主性的关键。

自主智能体的完整生命周期：

class AutonomousAgent: def__init__(self, agent_id: str, role: str, team: AgentTeam): self.agent_id = agent_id self.role = role self.team = team self.state = "idle"# idle | working | waiting self.current_task = None defrun(self): """自主智能体主循环""" whileTrue: ifself.state == "idle": # 空闲周期：主动寻找工作 self.idle_cycle() elifself.state == "working": # 执行当前任务 self.work_on_task() elifself.state == "waiting": # 等待依赖完成 self.check_dependencies() # 身份重新注入（防止遗忘） self.inject_identity() time.sleep(1) defidle_cycle(self): """ 空闲时的行为： 1. 轮询任务板 2. 检查邮箱 3. 自动认领任务 """ # 扫描任务板 tasks = self.team.get_task_board() # 过滤可执行任务 claimable = [ t for t in tasks if t["status"] == "pending" and t["role"] == self.role andself.dependencies_met(t) ] if claimable: # 自动认领最高优先级任务 task = max(claimable, key=lambda t: t["priority"]) self.claim_task(task) self.state = "working" else: # 继续等待 time.sleep(5) definject_identity(self): """ 定期重新注入身份定义 防止长会话中的身份漂移 """ if random.random() < 0.1: # 10%概率 self.messages.append({ "role": "system", "content": f"你是{self.role}，你的职责是..." })

Session 12: Worktree Isolation（工作树隔离）—— 目录级并行执行通道

这是实现真正并行的关键。

主智能体 任务task_001 任务task_002 任务task_003 worktrees/task_001/ worktrees/task_002/ worktrees/task_003/ 智能体A 智能体B 智能体C Git工作树1 Git工作树2 Git工作树3 自动合并

技术实现：

import subprocessimport osclassWorktreeManager: def__init__(self, repo_path: str): self.repo_path = repo_path self.worktrees_dir = os.path.join(repo_path, "worktrees") defcreate_worktree(self, task_id: str, branch: str = None) -> str: """ 为任务创建独立的Git工作树 每个工作树是完全独立的目录，可以并行修改代码 """ worktree_path = os.path.join(self.worktrees_dir, task_id) if branch: # 创建新分支的工作树 subprocess.run([ "git", "worktree", "add", "-b", f"task/{task_id}", worktree_path ], cwd=self.repo_path) else: # 基于当前HEAD创建工作树 subprocess.run([ "git", "worktree", "add", worktree_path ], cwd=self.repo_path) return worktree_path defexecute_in_worktree(self, task_id: str, command: str) -> str: """ 在指定工作树中执行命令 """ worktree_path = os.path.join(self.worktrees_dir, task_id) result = subprocess.run( command, shell=True, capture_output=True, text=True, cwd=worktree_path ) return result.stdout defmerge_worktree(self, task_id: str) -> bool: """ 合并工作树到主分支 """ worktree_path = os.path.join(self.worktrees_dir, task_id) # 提交工作树的更改 subprocess.run(["git", "add", "."], cwd=worktree_path) subprocess.run([ "git", "commit", "-m", f"Complete task {task_id}" ], cwd=worktree_path) # 合并到主分支 subprocess.run([ "git", "merge", f"task/{task_id}" ], cwd=self.repo_path) # 删除工作树 subprocess.run([ "git", "worktree", "remove", worktree_path, "-f" ], cwd=self.repo_path) return True

集成到任务系统：

def assign_task_to_worktree(task_id: str, agent_id: str): """ 为任务分配独立工作树 确保并行执行时不会相互干扰 """ wt_manager = WorktreeManager(repo_path=".") # 创建工作树 worktree_path = wt_manager.create_worktree(task_id) # 更新任务记录 task = task_db.get_task(task_id) task["worktree"] = worktree_path task["assigned_to"] = agent_id task_db.save_task(task) # 启动智能体（在独立工作树中执行） subprocess.Popen([ "python", "agents/autonomous_agent.py", "--agent-id", agent_id, "--task-id", task_id, "--worktree", worktree_path ]) return worktree_path

五、完整架构：所有机制的融合

完整实现展示了所有12个机制的融合，形成737行、22+工具的完整参考实现。

团队系统 知识系统 上下文管理 工具层（22+工具） 独立worktree 独立worktree 独立worktree 👤 用户 🔄 主智能体循环 🧠 Claude模型 🔧 工具分发器 bash执行 文件读写 TODO管理 技能加载 子智能体 后台任务 团队协作 工作树管理 消息历史 三层压缩 文件持久化 SKILL.md文件 TASKS.jsonl JSONL邮箱 开发者智能体 测试智能体 审查智能体 WT1 WT2 WT3

六、Harness Engineering的应用场景：超越编码

Harness Engineering的模式不仅适用于软件开发，它适用于任何复杂、多步骤、需要判断力的工作领域：

# 房地产管理智能体EstateAgent = Model + { "tools": ["property_sensors", "maintenance_api", "tenant_comms"], "knowledge": ["building_codes.md", "maintenance_procedures.md"], "permissions": ["spending_limits", "approval_workflows"]}# 农业智能体AgricultureAgent = Model + { "tools": ["soil_sensors", "irrigation_controls", "weather_api"], "knowledge": ["crop_guides.md", "pest_management.md"], "permissions": ["water_usage_limits", "chemical_application_rules"]}# 医疗研究智能体MedicalAgent = Model + { "tools": ["literature_search", "lab_instruments", "data_analysis"], "knowledge": ["research_protocols.md", "ethics_guidelines.md"], "permissions": ["data_privacy", "irb_approval_required"]}# 教育智能体EducationAgent = Model + { "tools": ["curriculum_db", "student_progress_api", "assessment_tools"], "knowledge": ["pedagogy_guides.md", "learning_objectives.md"], "permissions": ["grade_modification_limits", "parent_notification"]}

循环始终相同，工具、知识、权限随领域变化，模型本身具有通用性。

七、实战指南：如何开始构建你的Harness

7.1 快速开始（5分钟）

# 1. 克隆仓库git clone https://github.com/shareAI-lab/learn-claude-codecd learn-claude-code# 2. 安装依赖pip install -r requirements.txt# 3. 设置API密钥echo "ANTHROPIC_API_KEY=sk-ant-xxx" > .env# 4. 运行第一个智能体python agents/s01_agent_loop.py

7.2 学习路径建议

第一周：掌握核心循环

• • Day 1-2: s01 (Agent Loop) + s02 (Tool Use)
• • Day 3-4: s03 (TodoWrite) + s04 (Subagents)
• • Day 5-7: 实践：构建你的第一个多工具智能体

第二周：理解知识管理

• • Day 1-2: s05 (Skill Loading)
• • Day 3-4: s06 (Context Compact)
• • Day 5-7: 实践：为你的智能体添加领域知识

第三周：掌握持久化

• • Day 1-3: s07 (Task System) + s08 (Background Tasks)
• • Day 4-7: 实践：构建长期任务管理系统

第四周：团队协作

• • Day 1-4: s09-s12 (Teams, Protocols, Autonomous, Worktree)
• • Day 5-7: 实践：构建多智能体协作系统

7.3 关键原则

1. 永远不要修改核心循环：每个新机制都是循环之外的添加
2. 工具描述至关重要：模糊的描述导致模型误用
3. 收集任务-过程数据：每次执行都是训练信号
4. 从简单开始：s01的一个工具、一个循环就足够强大

八、未来展望：Harness Engineering将重塑软件工程

行业报告显示：一个团队使用Harness Engineering方法，完全不手动编写代码，仅通过智能体完成任务。

这不是未来，这是现在。

技术领袖在其网站上专门收录了Harness Engineering的文章，将其视为软件工程的新范式。

我们正在见证一个新时代：

• •工程师的角色转变：从"编写代码"到"设计框架"
• •智能体的普及：每个领域都将拥有自己的智能体
• •训练数据的积累：你的框架收集的轨迹，将训练下一代模型
• •自主系统的崛起：从辅助工具到自主执行

行动号召

1. 立即开始：克隆shareAI-lab/learn-claude-code仓库，运行s01
2. 加入社区：分享你的Harness设计，学习他人的经验
3. 收集数据：记录智能体的每次决策，这是宝贵的训练信号
4. 跨领域应用：将Harness模式应用到你的专业领域

结语：构建智能体的世界，而非智能体本身

模型就是智能体。代码就是框架。构建伟大的框架，智能体将完成其余一切。

当你理解了Harness Engineering的本质，你会发现：

• • 你不再试图用if-else控制智能体
• • 你专注于为智能体构建清晰、强大、安全的环境
• • 你信任模型的决策能力，你提供它需要的工具和知识
• • 你收集执行数据，帮助进化下一代模型

这不是编程，这是世界构建（World Building）。

你正在为智能体创造一个可以感知、思考、行动的世界。这个世界越清晰、越丰富、越安全，智能体就越能发挥其潜力。

现在，开始构建你的世界吧。

学AI大模型的正确顺序，千万不要搞错了

🤔2026年AI风口已来！各行各业的AI渗透肉眼可见，超多公司要么转型做AI相关产品，要么高薪挖AI技术人才，机遇直接摆在眼前！

有往AI方向发展，或者本身有后端编程基础的朋友，直接冲AI大模型应用开发转岗超合适！

就算暂时不打算转岗，了解大模型、RAG、Prompt、Agent这些热门概念，能上手做简单项目，也绝对是求职加分王🔋

📝给大家整理了超全最新的AI大模型应用开发学习清单和资料，手把手帮你快速入门！👇👇

学习路线:

✅大模型基础认知—大模型核心原理、发展历程、主流模型（GPT、文心一言等）特点解析
✅核心技术模块—RAG检索增强生成、Prompt工程实战、Agent智能体开发逻辑
✅开发基础能力—Python进阶、API接口调用、大模型开发框架（LangChain等）实操
✅应用场景开发—智能问答系统、企业知识库、AIGC内容生成工具、行业定制化大模型应用
✅项目落地流程—需求拆解、技术选型、模型调优、测试上线、运维迭代
✅面试求职冲刺—岗位JD解析、简历AI项目包装、高频面试题汇总、模拟面经

以上6大模块，看似清晰好上手，实则每个部分都有扎实的核心内容需要吃透！

我把大模型的学习全流程已经整理📚好了！抓住AI时代风口，轻松解锁职业新可能，希望大家都能把握机遇，实现薪资/职业跃迁～

这份完整版的大模型 AI 学习资料已经上传CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】