Appearance
2.6 Agent 时代进阶能力
2.6.4 Context Engineering：现代 AI 编程的核心技能
2025 年 6 月，Context Engineering 这个术语开始流行 [1]，由 Shopify CEO Tobi Lütke 和 Andrej Karpathy 在 X 上推广。
Prompt Engineering vs Context Engineering：
text
┌─────────────────────────────────────────────────────────────────────┐
│ Prompt Engineering vs Context Engineering │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ 【Prompt Engineering】—— 关于「你问什么」 │
│ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ "Write a professional email to decline a meeting" │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌──────────┐ │ │
│ │ │ LLM │ │ │
│ │ └──────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ [回复] │ │
│ │ │ │
│ │ · 单次交互 │ │
│ │ · 优化问题的措辞 │ │
│ │ · 静态字符串 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ 【Context Engineering】—— 关于「如何准备模型来回答」 │
│ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ System │ │ 对话历史 │ │ 检索到的 │ │ │
│ │ │ Prompt │ │ (Memory) │ │ 文档 (RAG) │ │ │
│ │ └──────┬──────┘ └──────┬──────┘ └──────┬──────┘ │ │
│ │ │ │ │ │ │
│ │ └────────────────┼────────────────┘ │ │
│ │ ▼ │ │
│ │ ┌─────────────┐ ┌──────────────┐ ┌─────────────┐ │ │
│ │ │ 可用工具 │ │ LLM │ │ 用户输入 │ │ │
│ │ │ 定义 │──│ │──│ │ │ │
│ │ └─────────────┘ └──────────────┘ └─────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ [回复/动作] │ │
│ │ │ │
│ │ · 系统设计 │ │
│ │ · 动态信息组装 │ │
│ │ · 确保模型始终获得相关信息 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘Tobi Lütke 的定义：
「Context Engineering 是为任务提供所有必要上下文的艺术，使 LLM 有可能解决它。」
Anthropic 的观点 [2]：
「大多数 Agent 失败不再是模型失败，而是 Context 失败。」
Context 的组成部分：
| 组件 | 英文 | 作用 | Claude Code 中的体现 |
|---|---|---|---|
| 系统提示 | System Prompt | 定义 AI 的行为规则 | CLAUDE.md 文件 |
| 短期记忆 | Short-term Memory | 当前对话历史 | 对话 context |
| 长期记忆 | Long-term Memory | 持久化的知识 | 项目文档、代码库 |
| 检索信息 | Retrieved Info (RAG) | 动态获取的相关内容 | 搜索到的代码片段 |
| 可用工具 | Available Tools | AI 能调用的功能 | 读文件、写文件、运行命令 |
为什么 Context Engineering 比 Prompt Engineering 更重要？
核心比喻：行业顾问
AI 就像一个只能来你公司上班一天、对你公司情况一无所知的行业顾问。
这个比喻比技术术语更容易理解：
| 顾问特点 | 对应 AI 特性 | 你需要做什么 |
|---|---|---|
| 只能待一天 | Context Window 容量有限（如 200K tokens） | 精选最重要的资料给 TA |
| 不知道公司情况 | 每次对话是无状态的 | 每次都要重新给背景信息 |
| 是行业专家 | 模型训练知识丰富 | 给对资料，TA 就能发挥专业能力 |
| 会被错误信息误导 | Context Poisoning | 确保给的资料准确 |
| 信息太多会分心 | Context Distraction | 只给相关的，不要堆砌 |
Andrej Karpathy 有另一个技术比喻：「LLM 就像 CPU，Context Window 就像 RAM」——CPU 再强，RAM 不够或者装错东西，程序也跑不好。
Context Engineering 四大策略
根据 LangChain 的总结 [3]，管理 Context 有四大策略。用顾问比喻来解释：
text
┌─────────────────────────────────────────────────────────────────────┐
│ Context Engineering 四大策略 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ 📝 Write (持久化) 🔍 Select (检索) │
│ ─────────────── ─────────────── │
│ 给顾问一个笔记本，让 TA 记下 只拿最相关的文档给 TA 看， │
│ 重要发现，明天来的人能接着用 不要把整个档案室搬过去 │
│ │
│ · Scratchpads（临时笔记） · CLAUDE.md（项目说明） │
│ · 长期记忆（跨会话） · RAG 检索（按需获取） │
│ │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ 🗜️ Compress (压缩) 🔀 Isolate (隔离) │
│ ─────────────── ─────────────── │
│ 把 100 页年报压缩成 3 页摘要， 让 TA 带几个助手分头调研， │
│ 保留关键信息，节省阅读时间 各自汇报结论，互不干扰 │
│ │
│ · Auto-compact（自动压缩） · Subagent（子任务代理） │
│ · 对话摘要 · 沙箱环境 │
│ │
└─────────────────────────────────────────────────────────────────────┘Context Rot 问题：
研究发现，Context 越长，准确率下降越明显（可达 24.2%）[4]。回到顾问比喻：
- 不是给的资料越多越好，给错了反而害 TA
- 堆砌无关信息 → 顾问分心，找不到重点
- 过时/矛盾信息 → 顾问被误导，给出错误建议
这就是 Anthropic 说的：「大多数 Agent 失败不再是模型失败，而是 Context 失败」
| 概念 | 英文 | 解释 | 为什么重要 |
|---|---|---|---|
| Context Engineering | Context Engineering [1:1] | 为 AI 准备最优上下文的艺术 | 现代 AI 编程的核心技能 |
| Context Rot | Context Rot | Context 越长准确率越低 | 理解为什么不是「越多越好」 |
| CLAUDE.md | — | Claude Code 的项目配置文件 | 团队共享 AI 使用规范 |
2.6.5 MCP：AI 连接外部世界的标准协议
2024 年 11 月，Anthropic 发布了 MCP（Model Context Protocol）[5]——一个让 AI 连接外部工具和数据源的开放标准。
MCP 解决什么问题？
在 MCP 之前，每个 AI 应用要连接外部服务，都需要写专门的连接器。假设你有 N 个 AI 应用和 M 个数据源，就需要 N × M 个连接器。
text
┌─────────────────────────────────────────────────────────────────────┐
│ 没有 MCP：N × M 集成问题 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ AI 应用 数据源/工具 │
│ ┌──────────┐ ┌──────────┐ │
│ │ Claude │────专用连接器 1────────│ GitHub │ │
│ │ Code │────专用连接器 2────────│ Slack │ │
│ │ │────专用连接器 3────────│ Database │ │
│ └──────────┘ └──────────┘ │
│ │
│ ┌──────────┐ ┌──────────┐ │
│ │ Cursor │────专用连接器 4────────│ GitHub │ │
│ │ │────专用连接器 5────────│ Slack │ │
│ │ │────专用连接器 6────────│ Database │ │
│ └──────────┘ └──────────┘ │
│ │
│ ⚠️ 每个 AI 应用 × 每个数据源 = 大量重复工作 │
│ │
└─────────────────────────────────────────────────────────────────────┘有了 MCP：
text
┌─────────────────────────────────────────────────────────────────────┐
│ 有 MCP：标准化协议 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ MCP Client MCP Protocol MCP Server │
│ (AI 应用) (标准协议) (数据源/工具) │
│ │
│ ┌──────────┐ ┌──────────┐ │
│ │ Claude │ │ GitHub │ │
│ │ Code │─┐ ┌───│ Server │ │
│ └──────────┘ │ │ └──────────┘ │
│ │ ┌──────────────┐ │ │
│ ┌──────────┐ │ │ │ │ ┌──────────┐ │
│ │ Cursor │─┼──────│ MCP 协议 │────────┼───│ Slack │ │
│ │ │ │ │ (JSON-RPC) │ │ │ Server │ │
│ └──────────┘ │ │ │ │ └──────────┘ │
│ │ └──────────────┘ │ │
│ ┌──────────┐ │ │ ┌──────────┐ │
│ │ ChatGPT │─┘ └───│ Database │ │
│ │ │ │ Server │ │
│ └──────────┘ └──────────┘ │
│ │
│ ✅ 写一次 MCP Server，所有 MCP Client 都能用 │
│ ✅ 用一个 MCP Client，能连接所有 MCP Server │
│ │
└─────────────────────────────────────────────────────────────────────┘MCP 的比喻：MCP 就像 USB-C 接口——不管是什么设备，只要支持 USB-C，就能互相连接。
MCP 架构详解：
text
┌─────────────────────────────────────────────────────────────────────┐
│ MCP 架构 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ MCP Host │ │
│ │ (如 Claude Code, Cursor) │ │
│ │ ┌─────────────────────────────────────────────────────┐ │ │
│ │ │ MCP Client │ │ │
│ │ │ (管理与 Server 的连接) │ │ │
│ │ └─────────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │ │
│ │ JSON-RPC 2.0 │
│ │ (stdio / HTTP+SSE) │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ MCP Server │ │
│ │ (轻量级程序，提供特定功能) │ │
│ │ │ │
│ │ 提供三种「原语」(Primitives): │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ Prompts │ │ Resources │ │ Tools │ │ │
│ │ │ 预定义提示 │ │ 数据资源 │ │ 可调用功能 │ │ │
│ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 外部服务/数据 │ │
│ │ GitHub / Slack / PostgreSQL / 文件系统 / ... │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘行业采用情况：
- 2025 年 3 月，OpenAI 正式采用 MCP，集成到 ChatGPT 桌面应用
- Block、Apollo 等公司已在生产环境使用
- Zed、Replit、Codeium、Sourcegraph 等开发工具都在集成 MCP
注意事项：
MCP 不能装太多！每个 MCP Server 的工具定义都会占用 Context，装太多会：
- 消耗大量 Token
- 可能触发 Context Rot
- 让 AI 在选择工具时更容易出错
| 概念 | 英文 | 解释 | 为什么重要 |
|---|---|---|---|
| MCP | Model Context Protocol [5:1] | AI 连接外部工具的标准协议 | 扩展 AI 能力边界 |
| MCP Server | MCP Server | 提供特定功能的轻量程序 | 写一次，所有 Client 可用 |
| MCP Client | MCP Client | AI 应用中管理连接的组件 | 用一个 Client 连所有 Server |
2.6.6 Subagent：Agent 调用 Agent
当任务变得复杂时，单个 Agent 的 Context Window 可能不够用。这时候就需要 Subagent——主 Agent 可以调用专门的子 Agent 来处理特定任务 [6]。
text
┌─────────────────────────────────────────────────────────────────────┐
│ Subagent 架构 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ 用户: 「帮我重构这个项目，优化性能，并添加测试」 │
│ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 主 Agent (Orchestrator) │ │
│ │ │ │
│ │ Thought: 这个任务很复杂，我需要分解成多个子任务 │ │
│ │ │ │
│ │ ┌─────────────────────────────────────────────────────┐ │ │
│ │ │ 1. 分析代码结构 → 调用 Explore Subagent │ │ │
│ │ │ 2. 设计重构方案 → 调用 Plan Subagent │ │ │
│ │ │ 3. 执行重构 → 自己处理或调用 Code Subagent │ │ │
│ │ │ 4. 性能优化 → 调用 Performance Subagent │ │ │
│ │ │ 5. 编写测试 → 调用 Test Subagent │ │ │
│ │ └─────────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │ │ │ │ │
│ ▼ ▼ ▼ ▼ │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ Explore │ │ Plan │ │Performance│ │ Test │ │
│ │ Subagent │ │ Subagent │ │ Subagent │ │ Subagent │ │
│ │ │ │ │ │ │ │ │ │
│ │ 专注于 │ │ 专注于 │ │ 专注于 │ │ 专注于 │ │
│ │ 代码探索 │ │ 方案设计 │ │ 性能分析 │ │ 测试编写 │ │
│ │ │ │ │ │ │ │ │ │
│ │ 独立 │ │ 独立 │ │ 独立 │ │ 独立 │ │
│ │ Context │ │ Context │ │ Context │ │ Context │ │
│ └────┬─────┘ └────┬─────┘ └────┬─────┘ └────┬─────┘ │
│ │ │ │ │ │
│ ▼ ▼ ▼ ▼ │
│ [探索结果] [设计方案] [优化建议] [测试代码] │
│ │ │ │ │ │
│ └──────────────┴──────────────┴──────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 主 Agent 整合结果 │ │
│ │ 返回给用户 │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘Subagent 的好处：
| 好处 | 说明 |
|---|---|
| Context 隔离 | 每个 Subagent 有独立的 Context Window，不会互相干扰 |
| 专业化 | 每个 Subagent 可以专注于特定领域 |
| 并行处理 | 多个 Subagent 可以同时工作 |
| 防止 Context 溢出 | 只把相关结果返回主 Agent，而不是全部细节 |
Claude Code 内置的 Subagent：
| Subagent | 功能 | 特点 |
|---|---|---|
| Explore Subagent | 代码库搜索和探索 | 使用 Haiku（更快更便宜） |
| Plan Subagent | 任务规划和方案设计 | 支持计划恢复 |
并行处理能力：
Claude Code 支持最多 10 个并行任务。社区实现甚至可以通过智能队列系统管理 100+ Agent。
| 概念 | 英文 | 解释 | 为什么重要 |
|---|---|---|---|
| Subagent | Subagent [6:1] | 被主 Agent 调用的专门化 Agent | 复杂任务分解，Context 管理 |
| Orchestrator | Orchestrator | 协调多个 Subagent 的主 Agent | 理解多 Agent 架构 |
2.6.7 Skills：可复用的专业能力包
Skills 是 Claude 的一个重要概念——它是「包含说明、脚本和资源的文件夹，Claude 在任务相关时动态发现和加载」[7]。
简单说：Skills 就像专业培训手册，为 AI 赋予特定领域的专业知识。
text
┌─────────────────────────────────────────────────────────────────────┐
│ Skills vs 其他概念的对比 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ 【Prompts】—— 即时指令 │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ "帮我写一封拒绝会议的邮件" │ │
│ │ │ │
│ │ · 单次对话有效 │ │
│ │ · 每次都要重新输入 │ │
│ │ · 告诉 AI「现在做什么」 │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 【Projects】—— 背景知识 │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 项目文档、API 规范、代码库结构... │ │
│ │ │ │
│ │ · 项目内始终可用 │ │
│ │ · 提供上下文信息 │ │
│ │ · 告诉 AI「你需要知道什么」 │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 【Skills】—— 程序化知识 │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ 代码审查流程、品牌指南应用、数据分析方法... │ │
│ │ │ │
│ │ · 跨对话持久有效 │ │
│ │ · 动态按需加载 │ │
│ │ · 告诉 AI「如何完成任务」 │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 【MCP】—— 工具连接 │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ GitHub、Slack、数据库、文件系统... │ │
│ │ │ │
│ │ · 持续连接外部服务 │ │
│ │ · 提供执行能力 │ │
│ │ · 让 AI「能够操作什么」 │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ 【Subagents】—— 任务委派 │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ Explore Agent、Plan Agent、专门化 Agent... │ │
│ │ │ │
│ │ · 调用时启动 │ │
│ │ · 独立 Context │ │
│ │ · 让 AI「委派给谁」 │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘Skills 的独特之处：渐进式加载
Skills 采用「渐进式信息披露」架构，这是它与其他概念最大的区别：
text
┌─────────────────────────────────────────────────────────────────────┐
│ Skills 的渐进式加载机制 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ 用户: 「帮我审查这段代码」 │
│ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 第 1 步：加载元数据 (~100 tokens) │ │
│ │ │ │
│ │ 发现可用 Skills: │ │
│ │ · code-review-skill (相关性: 高) │ │
│ │ · writing-assistant (相关性: 低) │ │
│ │ · git-workflow (相关性: 中) │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 第 2 步：按需加载完整指令 (最多 ~5000 tokens) │ │
│ │ │ │
│ │ 加载 code-review-skill 的完整内容: │ │
│ │ · 审查流程 │ │
│ │ · 检查清单 │ │
│ │ · 常见问题模式 │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 第 3 步：必要时加载相关文件和脚本 │ │
│ │ │ │
│ │ 如果需要，加载: │ │
│ │ · 团队编码规范文档 │ │
│ │ · 自动化检查脚本 │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
│ ✅ 只加载需要的内容，节省 Context │
│ ✅ 动态判断相关性，避免信息过载 │
│ │
└─────────────────────────────────────────────────────────────────────┘什么时候用 Skill？
「如果发现自己在多个对话中重复输入相同的提示词，就应该把它转换成 Skill。」
| 场景 | 示例 | 为什么适合用 Skill |
|---|---|---|
| 重复工作流 | 代码审查、PR 提交、发布流程 | 避免每次重复解释流程 |
| 组织规范 | 品牌指南、合规程序、编码规范 | 确保执行一致性 |
| 领域专业技能 | 数据分析方法、安全审计清单 | 封装专业知识 |
Skills 与其他概念的协作：
text
┌─────────────────────────────────────────────────────────────────────┐
│ 一个完整的 Claude Code 工作流 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ 用户: 「帮我审查这个 PR 并提交」 │
│ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ Claude Code Agent │ │
│ │ │ │
│ │ 1. 加载 Skill: code-review-skill │ │
│ │ → 知道「如何审查代码」 │ │
│ │ │ │
│ │ 2. 读取 Project Context: CLAUDE.md + 项目文档 │ │
│ │ → 知道「这个项目的规范」 │ │
│ │ │ │
│ │ 3. 调用 MCP: GitHub Server │ │
│ │ → 能够「读取 PR、提交评论」 │ │
│ │ │ │
│ │ 4. 委派 Subagent: Explore Agent │ │
│ │ → 让专门的 Agent「搜索相关代码」 │ │
│ │ │ │
│ │ 5. 加载 Skill: git-workflow-skill │ │
│ │ → 知道「如何提交 commit」 │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
│ Projects = 「你需要知道什么」(背景知识) │
│ Skills = 「如何完成任务」(程序化知识) │
│ MCP = 「能够操作什么」(工具连接) │
│ Subagent = 「委派给谁」(任务分解) │
│ │
└─────────────────────────────────────────────────────────────────────┘我正在用的 Skill 示例：
说起来，我昨天刚好弄了一个写作辅助的 Skill。这篇分享稿就是用 /writing-assistant 命令启动，然后边聊边写出来的。
后面计划把性能优化、代码审查、安全性检查这些也做成 Skill，团队一起用 Claude Code 的时候就能共享了。
| 概念 | 英文 | 解释 | 为什么重要 |
|---|---|---|---|
| Skills | Skills [7:1] | 可复用的专业能力包，动态按需加载 | 避免重复 prompt，确保一致性 |
| 渐进式加载 | Progressive Disclosure | 先加载元数据，按需加载完整内容 | 节省 Context，提高效率 |
2.6.8 我的亲历视角：从 Cursor 到 Claude Code
作者观点
以下是我个人的 AI 编程工具使用历程和感受。
我从 Copilot 用到 Cursor，再用到 Claude Code，每次切换都是因为「之前的工具不够用了」。
Cursor 阶段（2024）：
Cursor 的 Composer 让我第一次体验到「多文件编辑」的威力。以前用 Copilot，每次只能补全几行；用 Cursor，可以一次性改几个文件。但 Cursor 的问题是：
- 它是 GUI，有时候我更想在终端里工作
- 它的 Agent 能力有限，复杂任务还是需要手动介入很多
Claude Code 阶段（2025）：
切换到 Claude Code 后，最大的感受是自主性。我可以说「帮我把这个功能实现了」，然后去泡杯茶，回来代码就写好了（当然，还是要审查的）。
但 Claude Code 也有问题：
- Token 消耗很快，需要经常
/clear - MCP 装多了会出问题
- 有时候它会「过度自信」，做一些不必要的修改
一个教训：
刚开始用 Claude Code 的时候，我确实有段时间在「Vibe Coding」——Accept All，不看 Diff，出错就让它再改。结果就是 Part 3 会讲的那些踩坑经历。现在我的原则是：可以让 AI 写代码，但必须理解它写了什么。
[!TODO] 素材准备
- [ ] Context Engineering 概念图（Anthropic 博客）
- [ ] MCP 架构图（官方文档）
- [ ] Claude Code 工作流程演示 GIF
- [ ] Subagent 并行处理示意图
参考资料
📝 L3 | The New Skill in AI is Not Prompting, It's Context Engineering | Phil Schmid - Context Engineering 概念详解，由 Tobi Lütke 和 Andrej Karpathy 于 2025 年 6 月推广。 ↩︎ ↩︎
🔬 L1 | Effective context engineering for AI agents | Anthropic - Anthropic 官方文章：「大多数 Agent 失败不再是模型失败，而是 Context 失败」。 ↩︎
📝 L3 | Context Engineering for Agents | LangChain Blog - 四大策略框架：Write/Select/Compress/Isolate，详解每种策略的应用场景。 ↩︎
🔬 L1 | A Survey of Context Engineering for LLMs | arXiv - 2025 年学术综述，将 Context Engineering 定义为正式学科，涵盖 Context Rot 等问题的研究数据。 ↩︎
🔬 L1 | Introducing the Model Context Protocol | Anthropic - Anthropic 于 2024 年 11 月发布 MCP，AI 连接外部工具的开放标准，2025 年 3 月 OpenAI 正式采用。 ↩︎ ↩︎
💬 L4 | Claude Code Subagents | ClaudeLog - Claude Code Subagent 机制详解，支持 Explore、Plan 等专门化子 Agent。 ↩︎ ↩︎
🔬 L1 | Skills explained | Claude Blog - Skills 是包含说明、脚本和资源的文件夹，Claude 在任务相关时动态发现和加载，采用渐进式信息披露架构。 ↩︎ ↩︎