Posted in未分类

50行代码造一个Mini Claude Code｜从零拆解AI编程智能体核心原理

No Comments

目录

  1. 引言：为什么要造一个 Mini Claude Code
  2. 核心原理：一个循环就是全部
  3. AI 智能体强大的深层原因
  4. 用户最头疼的痛点分析
  5. V0 版本：Bash 就是一切
  6. V1 版本：模型即代理
  7. V2 版本：结构化规划与 Todo
  8. V3 版本：子代理机制
  9. V4 版本：Skills 机制
  10. 总结：Agent 的四层架构与核心公式
  11. AI 总结

1. 引言：为什么要造一个 Mini Claude Code Content-[00:00]

最近在高强度使用 Claude Code，对其底层原理产生好奇。在 GitHub 上发现了一个开源项目 shareAI-Lab/learn-claude-code，该项目实现了 5 个版本（V0 到 V4），渐进式地揭露了 Claude Code 的底层原理，相当于一个开源版本的 Claude Code。

核心疑问：

  • 当你在终端输入一句话，AI 如何知道修改哪个文件？
  • 为什么它能连续操作（读文件、改代码、跑命令），而普通聊天机器人只能回复文字？
  • 它真的理解代码了吗？还是某种模式匹配？
  • 为什么有时候很蠢（忘记刚才修改的文件）？
  • 为什么这么烧钱（Token 消耗巨大）？
  • 能不能从零构建一个类似的？需要多少代码？

2. 核心原理：一个循环就是全部 Content-[01:49]

抛开界面、权限系统、进度条等，核心原理非常简单：一个死循环。

核心流程：

  1. 用户指令：输入任务。
  2. 模型思考：决定调用什么工具。
  3. 调用工具：代码执行工具。
  4. 获取结果：工具返回结果。
  5. 继续思考：将结果反馈给模型，模型判断任务是否完成。
  6. 循环：直到模型认为任务完成，循环结束。

代码本质： 就是一个 while True 循环。

  • 调用模型 response = model(messages, tools)
  • 判断是否返回工具调用 if response.stop_reason != "tool_use"
  • 执行工具 result = execute(tool_call)
  • 结果反馈给模型 messages.append(result)
  • 回到第一步

模型是决策者，决定调用什么工具、以什么顺序、何时停止。代码只是提供工具的运行环境。

3. AI 智能体强大的深层原因 Content-[03:12]

AI 变成智能体（Agent）强大，不是来自单一技术突破，而是几个概念的奇妙组合：

  1. 工具赋予行动力：
    • 普通 LLM 只能输出文字。
    • 配备 bash, read_file, write_file, edit_file 四个工具后，它能探索代码库、理解代码、修改文件、运行命令。
    • 工具把“会说”变成了“会做”。
  2. 循环赋予自主性：
    • 传统助手：用户问 -> 模型答 -> 结束。
    • 智能体：用户问 -> 模型思考 -> 调用工具 -> 看结果 -> 再思考 -> 再调用工具 -> 直到任务完成。
    • 循环让模型从“一问一答”变成了“自主完成任务”。
  3. 上下文赋予记忆：
    • 每次工具调用的结果都会追加到消息历史中。
    • 模型能看到之前所有的操作和结果，就像程序员记得刚才读了什么代码、改了什么代码。
    • 消息历史就是模型的工作记忆。
  4. 提示词赋予方向：
    • 系统提示词告诉模型“你是谁”、“该怎么做”。
    • 工具描述告诉模型“你有什么能力”。
    • 好的提示词就是好的岗位说明书。

4. 用户最头疼的痛点分析 Content-[04:31]

理解原理后，就能明白为什么会出现以下痛点：

  1. 上下文遗忘：
    • 聊了 20 轮之后，模型开始忘记之前的文件。
    • 原因：上下文窗口有限，早期内容会被截断或压缩。这不是 Bug，是限制。
  2. AI 幻觉：
    • 模型自信地编造不存在的 API、虚构文件路径、生成看似正确但逻辑有问题的代码。
    • 原因：它在做概率匹配，匹配到的不一定正确。
  3. 任务跑偏：
    • 让它改个 Bug，它可能顺手重构了整个模块。
    • 原因：没有明确的任务追踪地址，模型在超长对话中迷失方向。
  4. Token 消耗惊人：
    • 每次循环都把完整的消息历史发给模型。
    • 读一个 500 行的文件，这 500 行就永远留在上下文里。
    • 实施几次工具调用，Token 轻松破万。这是记忆的代价。
  5. 复杂任务变慢：
    • 每一次工具调用都是一次完整的 API 请求。
    • 一个任务如果需要三四十次工具调用，就是三四十次的网络来回访问。
  6. 信任安全：
    • 让 AI 执行命令、修改文件，本质是把键盘交给了一个概率模型。
    • 路径安全检查、危险命令拦截、权限控制都在工程细节里。

网上流传的“最热门的编程语言”梗图（请用中文回答、请帮我修复代码、请不要添加注释等），本质上是因为上述原因导致模型表现不稳定。

5. V0 版本：Bash 就是一切 Content-[07:27]

核心理念： Bash is All You Need。 代码量： ~50 行。 工具： 仅 1 个工具 bash。

实现逻辑：

  • Unix 哲学：一切皆文件，一切皆可管道。Bash 是 Unix 世界的入口，拥有 Bash 就拥有一切能力（读文件、写文件、探索、执行、甚至实现子代理）。
  • 递归调用：通过 Bash 调用自身来实现子代理（python v0_bash_agent.py "task description"）。
  • 进程隔离：子代理在隔离环境中运行，仅返回最终摘要，避免污染主代理上下文。

代码核心：

  • 定义一个空的历史列表 history = []。
  • while True 循环调用模型。
  • 工具列表里只有一个工具名字叫 bash，参数类型是 object，必须要求参数是 command (string)。
  • 如果是工具调用，提取 command，通过 subprocess 执行命令，将结果加到历史列表，进入新一轮循环。

演示：

  • 输入“创建一个 hello.txt 文件”，模型返回工具调用 echo "Hello World" > hello.txt。
  • 执行命令，返回空结果。
  • 模型再次判断，返回最终结果“已创建”。
  • 输入“总结整个项目”，模型调用 Bash 运行自身脚本，实现递归子代理。

结论： 复杂能力从简单规则中涌现。一个工具就够了，Bash 就是通往一切的入口。

6. V1 版本：模型即代理 Content-[15:05]

核心理念： Model is Agent。 代码量： ~200 行。 工具： 4 个核心工具（覆盖 90% 场景）。

从聊天机器人到自主代理的转变：

  • 传统：用户 模型 文本回复。
  • Agent：用户 模型 [工具 结果] 回复。
  • 关键：模型反复调用工具，直到决定任务完成。模型是决策者。

四个核心工具：

  1. bash：执行命令。
  2. read_file：读取文件内容（可限制行数）。
  3. write_file：写文件内容。
  4. edit_file：编辑文件（替换特定内容）。

代码实现：

  • 在一个函数中开启 while True 循环。
  • 系统提示词规定工作流程：简单思考 -> 使用工具 -> 汇报结果。
  • 规则：优先使用工具，少说多做，不要凭空捏造路径，改动尽量精简。
  • 工具执行部分增加了危险命令拦截（如 rm -rf, sudo 等）。

结论： 确认了代理、确认了子代理、确认了权限系统的基础。本质还是在一个死循环里不断调用工具、返回结果。

7. V2 版本：结构化规划与 Todo Content-[21:02]

核心理念： Structured Planning & Todo。 代码量： ~300 行。 新增工具： todo_write。

解决的核心问题：

  • 计划在“脑中”（上下文中），10 次调用后就忘了。
  • 随着对话变长，早期意图被稀释，模型失去方向。

Todo 的好处：

  • 计划写入结构化列表，每次调用都能看到。
  • 确保每一次只干一件事。
  • 进度一目了然。

带规矩的清单（TodoManager）： 不是随手记的便签，给了三条硬规则：

  1. 最多 20 条待办：防止过度规划。
  2. 只能每次完成一个任务：避免分心，强制串行执行。
  3. 必须填写当前计划状态：标记为 pending, in_progress, completed。

代码实现：

  • 新增 TodoWrite 工具，接收代办内容、状态、当前正在干的事情，返回完整列表。
  • 系统提示词增加软约束：如果超过 10 轮没有更新 Todo，强制提醒模型更新。
  • 形成自我强化的反馈：模型调用 Todo 工具 -> 工具反馈完整列表 -> 模型执行当前任务 -> 完成后更新状态。

结论： 规矩立得好，活才干得好。约束不是限制，而是引导。

8. V3 版本：子代理机制 Content-[28:29]

核心理念： Sub-agent Mechanism。 代码量： ~450 行。 新增工具： task。 代理类型： 3 种专门化代理。

解决单一 Agent 的上下文困境：

  • 单一 Agent 处理复杂任务时，探索过的 20 个文件会一直留在历史列表中，导致后续任务失去焦点且消耗 Token。
  • V3 实现子弹隔离（上下文隔离），让每个任务拥有独立的上下文。

三种专门化代理：

  1. Explore (探索)：只读代理。用于搜索和分析。只能用 bash 和 read_file。不修改代码。
  2. Code (编码)：全能代理。用于实现功能和修复 Bug。可以使用所有工具。
  3. Plan (规划)：分析型代理。用于设计工作。只用于读取文件和规划，不直接修改代码。

Task 工具实现：

  • 接收描述、提示词、代理类型。
  • 生成一个新的子代理进程。
  • 子代理运行在隔离上下文中，看不到父代理的历史记录。
  • 子代理只返回最终的文本摘要，主 Agent 只看到结论，看不到细节。

流程： Explore -> Plan -> Code -> 总结。 结论： 分而治之是管理复杂性的终极武器。主 Agent 作为协调者，不再亲自干每一步，而是委派任务、汇总结果。

9. V4 版本：Skills 机制 Content-[37:24]

核心理念： Skills Mechanism。 代码量： ~550 行。 新增工具： skills。 范式转变： 从“训练 AI”到“教育 AI”。

知识外化：

  • 传统方式：知识锁在模型参数中，需要昂贵训练、GPU 集群、微调。
  • 新范式：知识外化到可编辑的文档（Skills.md）中。任何人可参与、即时生效、零成本、可版本控制。

四层架构（从深层到表层）：

  1. Model Parameters：预训练知识（通用能力基座）。
  2. Context Window：系统提示词（会话级别生效）。
  3. File System：配置文件（如 CLAUDE.md，持久化但局部）。
  4. Skill Library：技能包（可共享、组合、版本控制）。

工具 vs 技能：

  • Tool (工具)：模型能做什么（手和脚）。由代码实现，数量有限，需开发者维护。
  • Skill (技能)：模型知道应该怎么做（经验和知识）。由 Markdown 描述，无限扩展，社区共享。

Skills 三层结构（按需加载）：

  1. 元数据 (Metadata)：名称、描述、触发条件。始终加载（节省 Token）。
  2. SKILL.md 主体：完整的操作指南、步骤、规则。匹配对应 Skill 后才加载。
  3. 资源文件 (Resources)：参考代码、配置。按需加载，不占用初始上下文。

代码实现：

  • 定义 SkillsLoader，解析目录下 SKILL.md 文件。
  • 初始提示词只注入技能名称和描述。
  • 新增 skills 工具，当用户匹配到对应任务时，立即使用该工具加载技能内容注入对话。

结论： 知识作为一等公民。经验可以复用，从训练 AI 转变为教育 AI。

10. 总结：Agent 的四层架构与核心公式 Content-[44:35]

Agent 的四层架构：

  1. 工具系统：定义能力边界（V0 Bash -> V1 多工具 -> V3 工具过滤）。
  2. Todo 系统：把隐式计划转换为显式列表，通过硬约束引导模型保持聚焦（V2）。
  3. 子代理系统：通过 Task 工具创建独立进程，上下文隔离 + stdout 通信，实现分而治之（V3）。
  4. Skills 系统：知识从参数中解放，存储为 SKILL.md 文件，三层渐进披露节省 Token（V4）。

这门课教会我们的 6 件事：

  1. Agent = While 循环：核心永远是调用模型、执行工具、返回结果、不断重复。
  2. 工具定义能力边界：给模型什么样的工具，它就会有什么样的能力。
  3. 约束产生智能：给模型增加限制（如 Todo 规则），它反而能把活干得更好。
  4. 分而治之管理复杂性：一个 Agent 搞不定，就派出专家（子代理），通过隔离获得独立上下文。
  5. 知识 ≠ 参数：知识可以外化为文档（Skills），经验可以复用。
  6. 渐进式构建：不要一步到位，每次只增加一点点，验证有效再继续。

Agent 的构成公式： $$ \text{Agent} = \begin{cases} \text{While Loop} + \text{Bash} & (\text{V0: 本质}) \ + \text{Multi-Tools} & (\text{V1: 能力}) \ + \text{Todo} + \text{Constraints} & (\text{V2: 规划}) \ + \text{SubAgents} + \text{Roles} & (\text{V3: 协作}) \ + \text{Skills} + \text{Knowledge} & (\text{V4: 智慧}) \end{cases} $$

AI 总结

本视频通过从零构建一个 Mini Claude Code 的过程，深入浅出地拆解了 AI 编程智能体的核心原理。视频指出，无论多么复杂的 Agent 框架，其本质都是一个 While True 循环：模型思考、调用工具、获取结果、反馈思考。

作者通过五个版本的迭代（V0-V4），展示了如何通过简单的规则叠加涌现出复杂的能力：

  • V0 证明了 Bash 结合递归调用即可实现基础 Agent 能力。
  • V1 引入多工具（读写编辑），确立了模型作为决策者的地位。
  • V2 引入结构化 Todo 列表和硬约束，解决了长任务中的遗忘和跑偏问题。
  • V3 引入子代理机制和角色分工，通过上下文隔离解决了复杂任务的焦点分散和 Token 消耗问题。
  • V4 引入 Skills 机制，将知识外化为文档，实现了从“训练 AI”到“教育 AI”的范式转变，支持知识的按需加载和共享。

最终结论是：复杂的能力源于简单规则的巧妙组合。理解了这个核心循环和四层架构（工具、规划、子代理、技能），就掌握了构建 AI Agent 的钥匙。

Comments

No comments yet. Why don’t you start the discussion?

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注