source/_drafts/AI+SaaS和传统SaaS，真正拉开差距的是数据设计和交付价值.md

@@ -0,0 +1,251 @@
+---
+title: AI+SaaS和传统SaaS，真正拉开差距的是这四个点
+author: Gamehu
+date: 2026-03-27 11:00:00
+tags:
+  - AI
+  - SaaS
+  - 数据设计
+  - 架构设计
+categories:
+  - AI
+---
+
+<div class="tag-container">
+  <span class="ai-tag">AI</span>
+  <span class="sub-tag">SaaS思考</span>
+</div>
+
+<div class="article-quote">
+这两天一直在想，AI 时代做 SaaS，和以前比到底变了什么。一开始很容易把注意力放在模型上，比如要不要自己训模型，要不要做自己的 Agent，要不要把产品搞得特别“AI”。但想来想去，我觉得如果团队本质上还是一家行业 SaaS 公司，而不是 AI 公司，那很多问题其实没必要绕远路。
+</div>
+
+我现在更愿意把 AI+SaaS 和传统 SaaS 的差别，收敛成四个点来看。
+
+不是十个八个概念一起讲，而是抓住真正影响产品落地的四件事：
+
+1. SaaS 基本功
+2. 数据设计
+3. 提升人效
+4. 交付价值
+
+## 第一，SaaS 基本功不能丢，而且比以前更重要
+
+我现在越来越认同一件事：
+
+**别一上来就聊 AI，先把 SaaS 基本功做好。**
+
+这话听着像废话，但真不是。
+
+因为很多团队一接上大模型，心态就容易飘。总觉得以前产品上没补完的坑、流程里没捋顺的地方、数据上不规范的问题，好像都能让 AI 顺手一起解决。
+
+现实通常正好相反。
+
+如果一个 SaaS 系统本身就存在这些问题：
+
+- 权限没理清
+- 流程不稳定
+- 数据结构乱
+- 系统边界模糊
+- 交付模式本来就不成熟
+
+那 AI 接进来以后，大概率不是更强，而是更乱。
+
+因为 AI 不会替你补基本功，它只会把原来系统里那些问题更快放大出来。
+
+所以我现在更愿意把 AI 理解成一层增强能力，而不是重开一局。
+
+地基没打好，楼层加得越快，越容易歪。
+
+这也是为什么我觉得，对大多数行业 SaaS 来说，太早把注意力全放到“要不要训模型”上，其实是顺序错了。
+
+先把系统做好，先把业务跑顺，先把产品基本盘稳住，这才是第一位的。
+
+## 第二，数据设计不一样了
+
+传统 SaaS 的数据设计，核心诉求其实很明确：
+
+- 能支撑业务流程
+- 能完成增删改查
+- 能做统计报表
+- 能满足权限和审计
+
+这套东西今天一样重要，没什么可怀疑的。
+
+但 AI+SaaS 多了一层要求：
+
+**你的数据，不只是给系统存和查的，还得给 AI 理解和使用。**
+
+这一下要求就变了。
+
+以前很多系统的数据设计，做到“能录进去、能查出来、能对账”就差不多了。现在不行了，你还得继续想：
+
+- 数据够不够结构化
+- 字段语义清不清楚
+- 上下文能不能串起来
+- 历史记录好不好检索
+- 对象之间的关系是不是完整
+
+这个差别，在垂直行业里会特别明显。
+
+比如宠物医疗场景里，传统 SaaS 更关心的往往是：
+
+- 病历能不能录
+- 用药记录能不能查
+- 收费能不能对上
+- 报表能不能导出
+
+但 AI+SaaS 还得再往前走一步：
+
+- 问诊内容能不能结构化
+- 症状、病种、用药之间能不能稳定关联
+- 历史病例能不能被 AI 检索出来参考
+- 这些字段能不能支撑后面的摘要、推荐、风险提示
+
+也就是说，传统 SaaS 的数据设计，更像是为了业务流转服务。
+
+AI+SaaS 的数据设计，则变成了：
+
+**既要支撑业务流转，也要支撑 AI 理解、检索和调用。**
+
+这就是我为什么一直觉得，很多团队问“要不要自己训模型”，其实问偏了。
+
+对大多数行业 SaaS 来说，真正值钱的不是参数量，而是：
+
+- 行业数据结构
+- 结构化能力
+- 流程理解
+
+这几个东西做扎实了，哪怕你接的是现成模型，它也能真正进入业务。
+
+反过来，数据设计如果本身就散、乱、缺语义，那你换再强的模型，效果也不会有质变。
+
+## 第三，AI+SaaS 更强调提升人效
+
+这一点我觉得很重要，而且很落地。
+
+很多时候，客户要的并不是什么特别炫的 AI 对话体验，他更在意的是：
+
+**能不能少用几个人，或者让同样的人把事情做得更多、更稳。**
+
+像这些事，在很多行业里都很常见：
+
+- 补全和整理客户档案
+- 整理问诊记录并生成病历
+- 回访客户、维护客户关系
+- 基于历史记录做提醒和推荐
+
+以前这些事情，大多还是靠人一点点录、一条条跟、一项项维护。
+
+传统 SaaS 能做的，更多是给你一个操作台，让这些动作在线上完成。
+
+但 AI+SaaS 更理想的方向，是往自动化再走一步：
+
+- 自动整理档案
+- 自动生成病历草稿
+- 自动总结沟通内容
+- 自动给出客户跟进建议
+- 自动触发提醒和维护动作
+
+说白了，它不是让人换个地方继续干活，而是开始让系统替人分担一部分原本很琐碎、很重复、但又不得不做的工作。
+
+这件事的价值其实特别直接：
+
+- 减少人力投入
+- 提升单人产出
+- 降低遗漏概率
+- 让服务质量更稳定
+
+所以我现在会觉得，AI+SaaS 比传统 SaaS 更进一步的地方，不只是管理效率提升了，而是执行效率也开始被拉起来了。
+
+
+## 第四，交付价值不一样了
+
+传统 SaaS 卖的东西，核心其实很朴素：
+
+**把业务流程搬进系统。**
+
+原来靠 Excel、靠微信群、靠纸张、靠人肉接力做的事情，变成线上化、标准化、可追踪、可协同。
+
+这个价值到今天依然成立。
+
+但 AI+SaaS 已经不只停在这里了。
+
+它开始往前多走一步：
+
+**不只是把流程放进系统，而是尽量把结果做出来。**
+
+比如同样是问诊场景。
+
+传统 SaaS 提供的通常是：
+
+- 病历录入页面
+- 患宠档案管理
+- 用药记录管理
+- 查询和报表功能
+
+AI+SaaS 提供的可能是：
+
+- 语音自动转文字
+- 自动整理病历草稿
+- 自动提取关键字段
+- 自动总结沟通内容
+- 基于历史病例给出辅助提示
+
+你会发现，这时候客户买的就不只是一个录入系统了。
+
+他买的是一个能少填很多表、少做很多重复动作、还能把事情推进得更快一点的系统。
+
+这其实就是交付价值的变化。
+
+以前更像是交付功能。
+现在开始更像是交付结果。
+
+## 再补一个经常被问到的问题：要不要一上来就训模型，或者先做微调
+
+我的判断还是比较明确：
+
+**大多数行业 SaaS 团队，一开始都不应该把重点放在训练大模型或者微调大模型上。**
+
+原因其实也不复杂。
+
+第一，你本来就不是 AI 公司，核心目标不是做一个模型产品，而是把行业里的业务问题解决掉。
+
+第二，在产品早期，真正更稀缺的通常不是模型能力，而是：
+
+- 数据结构设计
+- 流程设计
+- 系统能力封装
+- 成本控制
+- 产品交付能力
+
+第三，如果连业务流程、数据沉淀、真实场景都还没跑顺，就太早去做训练或者微调，很多时候只是在提前消耗资源。
+
+说得直接一点，现阶段更务实的做法通常还是：
+
+- 先用现成模型
+- 先把 RAG、Workflow、MCP / Skills 这些能力接起来
+- 先让 AI 真正进入业务闭环
+- 等数据量、样本质量和场景稳定性都起来以后，再决定要不要做轻量微调
+
+所以这件事我会把它当成一个顺序问题，而不是一个技术信仰问题。
+
+不是永远不做。
+而是**不要一上来就做。**
+
+## 最后
+
+如果一定要我把 AI+SaaS 和传统 SaaS 的差别压缩成一句话，那我会这么说：
+
+**传统 SaaS 主要解决“把流程搬进系统”，AI+SaaS 则是在 SaaS 基本功做扎实的前提下，靠更适合 AI 的数据设计、更结果导向的交付方式，以及更强的自动化能力，把原来需要很多人做的事，尽可能自动化掉。**
+
+所以说到底，问题根本不只是要不要上 AI，也不是要不要训模型。
+
+真正的问题是：
+
+- 你的 SaaS 基本盘稳不稳
+- 你的数据结构能不能支撑 AI 真正进入业务
+- 你的系统到底是在交付功能，还是在交付结果
+- 你能不能通过 AI 真正把人效提起来
+
+这四个点想清楚了，方向基本就不会太偏。

source/_drafts/AI时代，AI+SaaS和传统SaaS到底哪里一样，哪里不一样.md

@@ -0,0 +1,390 @@
+---
+title: AI时代，AI+SaaS和传统SaaS到底哪里一样，哪里不一样
+author: Gamehu
+date: 2026-03-27 23:30:00
+tags:
+  - AI
+  - SaaS
+  - 大模型
+  - 架构设计
+categories:
+  - AI
+---
+
+<div class="tag-container">
+  <span class="ai-tag">AI</span>
+  <span class="sub-tag">SaaS思考</span>
+</div>
+
+<div class="article-quote">
+这两年聊 SaaS，几乎绕不开 AI。很多团队一上来讨论的不是产品，不是客户，不是场景，而是另一个更容易让人兴奋的话题：要不要训一个自己的大模型？我最近也在反复想这件事，尤其是当业务本身就是垂直行业 SaaS 时，这个问题看起来像技术选型，实际上更像战略判断。
+</div>
+
+## 写在前面
+
+如果把问题问得再直白一点，其实就是一句话：
+
+**AI+SaaS，和传统 SaaS，到底是不是两种生意？**
+
+我现在的答案是：
+
+**本质上还是同一门生意，但产品形态、交互方式、系统架构和护城河位置，都已经开始变了。**
+
+也就是说，AI 时代不是把 SaaS 推翻重来，而是把 SaaS 从“功能交付”推向“结果交付”。
+
+很多人一听到 AI，就容易把注意力全部放到模型本身。但对大多数垂直行业公司来说，特别是不是做模型研发的公司，真正应该盯住的并不是“我要不要训练大模型”，而是：
+
+1. 我到底在卖什么
+2. 我的 AI 能不能进入真实业务流程
+3. 我的护城河到底是在模型，还是在数据、流程和组织能力
+
+这几个问题想明白，很多焦虑就会自动消失。
+
+## 先说结论：相同点比你想的更多
+
+虽然这两年大家都在说 AI 会重构软件行业，但如果把镜头拉远一点看，AI+SaaS 和传统 SaaS 其实有很多相同点。
+
+### 1. 都是在解决一个具体业务问题
+
+无论是传统 SaaS，还是 AI+SaaS，客户花钱都不是为了买技术名词。
+
+客户买的从来不是：
+
+- 微服务
+- 云原生
+- 大模型
+- Agent
+- MCP
+- RAG
+
+客户真正买的是：
+
+- 门店效率有没有提升
+- 人员成本有没有下降
+- 决策速度有没有变快
+- 服务质量有没有更稳定
+- 营收有没有更好看
+
+这一点非常关键。
+
+传统 SaaS 解决的是业务流程线上化、标准化、系统化的问题。
+AI+SaaS 解决的依然还是这些问题，只不过多了一层“理解、生成、归纳、调用”的能力。
+
+所以从商业本质上讲，**你卖的仍然是业务价值，不是模型参数。**
+
+### 2. 都逃不开行业理解
+
+很多人觉得有了大模型，就可以跨行业横着打。现实没有这么乐观。
+
+一个做宠物医院、口腔诊所、供应链、工业质检的系统，真正难的从来不是“能不能接一个模型 API”，而是：
+
+- 行业术语是否理解准确
+- 关键字段是否抽象合理
+- 业务流程是否贴近一线
+- 异常分支是否考虑完整
+- 输出结果是否可落库、可追踪、可复核
+
+这些东西，传统 SaaS 时代重要，AI 时代只会更重要。
+
+因为模型越强，越容易让团队产生一种错觉：前面懂一点就够了，后面交给 AI。
+但实际上，**行业理解不够，AI 只会把错误放大得更快。**
+
+### 3. 都必须算账
+
+不管有没有 AI，SaaS 最终都得回到经营层面。
+
+传统 SaaS 要算：
+
+- 客单价
+- 实施成本
+- 交付周期
+- 运维成本
+- 续费率
+
+AI+SaaS 只是多加了几笔账：
+
+- Token 成本
+- 模型调用延迟
+- 并发成本
+- 缓存命中率
+- 复杂任务失败重试成本
+
+所以 AI+SaaS 不是不讲成本，恰恰相反，它比传统 SaaS 更需要精细化成本控制。因为你每一次“看起来很聪明”的回答，背后都是实打实的钱。
+
+## 再说不同点：变化确实已经发生了
+
+如果说上面讲的是“同”，那下面才是这两年真正值得重视的“不同”。
+
+## 一、传统 SaaS 交付功能，AI+SaaS 开始交付结果
+
+传统 SaaS 的经典路径是这样的：
+
+> 录入数据 -> 点击按钮 -> 按固定规则处理 -> 生成结果
+
+它的优势是确定性高、边界清晰、容易审计。
+
+AI+SaaS 则开始变成：
+
+> 输入目标 -> AI 理解意图 -> 调用系统能力 -> 组织多步流程 -> 输出结果
+
+比如过去医生写病历，可能是：
+
+- 人工录音
+- 手动录入
+- 手动整理字段
+- 手动生成病历
+
+现在 AI+SaaS 可以变成：
+
+- 语音转文字
+- 自动抽取结构化字段
+- 自动生成病历草稿
+- 自动补充风险提示
+- 自动同步到系统
+
+表面看只是多了 AI，实际上产品交付方式已经从“给用户一套工具”慢慢转成“帮用户完成一件事”。
+
+这是我认为 AI+SaaS 和传统 SaaS 最大的差别。
+
+以前比的是功能全不全。
+现在开始比的是结果快不快、准不准、顺不顺。
+
+## 二、传统 SaaS 的核心是流程固化，AI+SaaS 的核心是流程编排
+
+传统 SaaS 很强调 SOP 固化，把高频流程做成固定页面、固定表单、固定按钮。
+
+这套逻辑没有错，现在依然有价值。
+但 AI 进来后，新的重点变成了另一件事：
+
+**不是把每一步都写死，而是把哪些步骤该由人做、哪些步骤该由模型做、哪些步骤该由系统做，重新编排一遍。**
+
+比如一个典型的 AI 工作流可能长这样：
+
+1. 用户发起一个自然语言请求
+2. 模型理解当前意图
+3. RAG 检索行业知识或历史记录
+4. Workflow 决定下一步动作
+5. Skills 或 MCP 调用业务系统能力
+6. 结果回写系统并通知相关角色
+
+这里的核心难点，已经不是前端页面怎么画，也不是数据库怎么建表，而是：
+
+- 流程能不能拆得对
+- 人机边界划得清不清楚
+- 工具调用稳不稳定
+- 中间状态能不能追踪
+- 失败以后能不能兜底
+
+所以 AI+SaaS 更像是在做“流程编排系统”，而不只是“信息管理系统”。
+
+## 三、传统 SaaS 的壁垒在功能和实施，AI+SaaS 的壁垒开始往数据和工作流迁移
+
+这是很多人最容易判断错的地方。
+
+不少团队看到 AI 很强，第一反应就是：
+
+> 那我的壁垒是不是也应该是一套自己的模型？
+
+但对于绝大多数垂直 SaaS 公司来说，这个方向并不成立。
+
+原因很简单。
+
+### 1. 基础模型会越来越便宜
+
+模型能力会持续被大厂往下打，调用门槛会越来越低。
+
+你今天花巨大代价做的事情，明年可能已经变成基础设施。
+
+### 2. 客户不会因为你“有模型”就续费
+
+客户最终愿意留下来，通常不是因为你自研了一个 70B 模型，而是因为：
+
+- 你的行业数据更全
+- 你的工作流更贴业务
+- 你的系统接入更深
+- 你的交付结果更稳定
+
+### 3. 训练模型不等于形成商业壁垒
+
+如果没有稀缺数据、没有持续训练能力、没有足够资金和团队，硬上自研模型，大概率不是壁垒，是包袱。
+
+真正更现实的壁垒，反而是这些：
+
+- 行业数据结构
+- 高质量样本沉淀
+- 业务规则抽象
+- AI 工作流设计
+- 系统调用能力封装
+- 成本控制能力
+
+换句话说，**传统 SaaS 的护城河偏“软件能力”，AI+SaaS 的护城河更偏“数据 + 工作流 + 系统协同能力”。**
+
+## 四、传统 SaaS 的 UI 是菜单和表单，AI+SaaS 的 UI 可能是一句话
+
+这一点很多人还没完全适应。
+
+过去的 SaaS 系统，入口通常是：
+
+- 菜单
+- 列表
+- 表单
+- 按钮
+- 筛选器
+
+AI+SaaS 时代，入口可能变成：
+
+> “帮我把今天所有异常订单总结一下，并按紧急程度排序。”
+
+或者：
+
+> “把这次问诊记录整理成规范病历，顺便给出风险提醒。”
+
+也就是说，用户交互层从“操作系统”变成了“表达意图”。
+
+这会带来两个变化：
+
+### 1. 产品门槛下降
+
+很多原本需要培训半天才能上手的系统，现在可能一句自然语言就能完成关键操作。
+
+### 2. 对后端系统要求更高
+
+前面越自然，后面越不能乱。
+
+因为用户虽然只说了一句话，但系统背后可能已经触发了：
+
+- 权限校验
+- 数据查询
+- 规则判断
+- 多工具调用
+- 多步写回
+- 风险拦截
+
+所以 AI 不是把系统变简单了，而是把复杂度从界面转移到了中台和编排层。
+
+## 五、传统 SaaS 强调确定性，AI+SaaS 必须学会管理不确定性
+
+传统 SaaS 的世界里，逻辑通常比较硬。
+
+输入 A，按规则处理，输出 B。
+
+但 AI 不是这样。
+
+AI 天生带概率性。
+这意味着 AI+SaaS 在工程上必须多处理一层事情：
+
+- 模型幻觉
+- 结果波动
+- Prompt 漂移
+- 工具调用失败
+- 上下文污染
+- 不同模型输出差异
+
+这也是为什么我越来越觉得，AI 应用的核心能力不只是“接模型”，而是“管模型”。
+
+包括但不限于：
+
+- 模型抽象层
+- Prompt 管理
+- RAG 质量控制
+- 输出校验
+- 人工兜底机制
+- 审计日志与回放
+
+传统 SaaS 更像是在管理业务规则。
+AI+SaaS 则是在管理“业务规则 + 概率系统”。
+
+这个复杂度，客观上更高。
+
+## 那么，AI+SaaS 公司要不要自己训练大模型？
+
+我的判断很明确：
+
+**绝大多数情况下，不需要。**
+
+更准确一点说，大部分垂直行业 SaaS 公司真正需要的，不是训练基础模型，而是下面这套能力：
+
+- 用现成模型获得通用理解和生成能力
+- 用 RAG 补齐行业知识
+- 用 Workflow 串起任务流程
+- 用 MCP / Skills 打通真实业务系统
+- 用数据沉淀逐步形成自己的行业优势
+
+如果未来数据量足够大，样本质量足够高，业务场景也足够稳定，当然可以考虑轻量微调。
+
+但那也是在“业务已经跑起来”之后的优化动作，不应该是创业早期或产品早期的主战场。
+
+因为你不是 AI 公司。
+你是用 AI 做增强的行业 SaaS 公司。
+
+这两者差别非常大。
+
+## 我更认可的一种架构姿势
+
+如果现在让我给 AI+SaaS 一个比较务实的架构建议，我会更偏向这一层：
+
+> 基础模型层（可替换）  
+> -> RAG 层  
+> -> Workflow 层  
+> -> 业务 Skills / MCP 层  
+> -> SaaS 系统
+
+这个架构有几个明显好处：
+
+### 1. 模型可以替换
+
+你可以接 GPT，可以接 Claude，也可以接国内模型，未来甚至可以接自己微调过的模型。
+
+模型变成能力来源，而不是系统中心。
+
+### 2. 业务能力不会绑死在某个模型上
+
+真正重要的资产，例如：
+
+- 行业知识库
+- 工作流设计
+- 权限模型
+- 业务工具封装
+- 数据沉淀
+
+都还在自己手里。
+
+### 3. 方便控制成本和风险
+
+不同场景用不同模型，不同任务设不同预算，不同风险等级配置不同的审核机制，这种架构才适合做长期生意。
+
+## 最后一段，写给正在做行业 SaaS 的团队
+
+如果你现在也在做 AI+SaaS，我觉得有个问题值得先问清楚：
+
+**你到底是 AI 公司，还是行业 SaaS 公司？**
+
+如果你是前者，那你当然可以围绕模型能力构建团队、组织和研发路线。
+
+但如果你是后者，那更现实的路线应该是：
+
+- 把 AI 当成基础设施能力
+- 把模型当成可替换组件
+- 把重点放在行业数据、工作流和系统整合上
+- 把产品目标定义成“交付结果”，而不是“接入 AI”
+
+说得再狠一点。
+
+未来淘汰传统 SaaS 的，未必是另一个更会做页面的 SaaS。
+更可能是一个更懂业务结果、又更会编排 AI 的 SaaS。
+
+但同样的，未来能活下来的 AI+SaaS，也不是最会喊 Agent 概念的那批，而是那些能把 AI 真正塞进业务闭环里的人。
+
+## 结语
+
+所以回到最开始的问题。
+
+**AI+SaaS 和传统 SaaS，有很多相同，也有很大的不同。**
+
+相同的是，商业本质没变，客户价值没变，行业理解没变，成本约束也没变。
+
+不同的是，交互入口变了，系统架构变了，产品交付方式变了，护城河的位置也变了。
+
+如果要我把这篇文章压缩成一句话，那就是：
+
+**传统 SaaS 主要卖软件能力，AI+SaaS 开始卖业务结果；但决定你能不能赢的，依然不是模型本身，而是你对行业、数据和流程的掌控力。**

source/_drafts/AI时代，AI+SaaS和传统SaaS，真正拉开差距的是数据设计和交付价值.md

@@ -0,0 +1,238 @@
+---
+title: AI时代，AI+SaaS和传统SaaS，真正拉开差距的是数据设计和交付价值
+author: Gamehu
+date: 2026-03-27 23:00:00
+tags:
+  - AI
+  - SaaS
+  - 数据设计
+  - 人效
+categories:
+  - AI
+---
+
+<div class="tag-container">
+  <span class="ai-tag">AI</span>
+  <span class="sub-tag">SaaS思考</span>
+</div>
+
+<div class="article-quote">
+这一篇也是很早在草稿箱的文章，今天才整理出来。
+
+因为我这几年都在 SaaS行业，然后现公司也是做xx行业AI产品(SAAS)，这段时间一直反复在想一个问题：AI+SaaS 和传统 SaaS，到底有什么不同？一开始很容易把注意力放到"要自己训一个大模型"这种问题上比如我们公司ceo或者外部投资人、，但我可能有些不成熟的观点，我是觉得这根本不是核心，最起码当你的体量没起来或者故事没被资本接收的时候我觉得更应该关注的是另外几件事。
+</div>
+
+先把结论放在前面。
+
+我认为 AI+SaaS 和传统 SaaS 最本质的差异或者说核心关注点应该集中在三个地方：**数据设计、人效提升方式、交付给客户的价值**。
+
+但这三件事有一个前提，先别急着聊 AI，SaaS 的基本功必须先做扎实。
+
+---
+
+## 前提：SaaS 基本功不扎实，AI 进来只会更乱
+
+这话我是越来越信。
+
+很多团队一引入大模型，心态就容易飘。总觉得以前没做好的地方，权限没理清、流程不稳定、数据结构乱，好像 AI 一进来能顺带解决。
+
+实际上恰恰相反。
+
+<span class="highlight-text">AI 不会替你补基本功，它只会把原来系统里的那些问题，放大得更快、更明显。</span>
+
+如果一个 SaaS 系统的业务流程本身就跑不顺，系统边界本身就模糊，那接上 AI 以后，输出的结果会更不可信，追溯问题会更难，整体更乱。
+
+所以这件事我的顺序是：先把系统做好，**深入了解以及解决客户基本的痛点问题**，先把业务跑顺，再来谈 AI 怎么加。
+
+别把顺序弄反了。
+
+---
+
+## 一、数据设计，不只是给人用了，还要给 AI 用
+
+这是 AI+SaaS 和传统 SaaS 差别最大的地方之一，而且是很多团队最容易忽视的。
+
+传统 SaaS 里，数据设计的诉求其实很清楚：
+
+- 能支撑业务流程
+- 能做增删改查
+- 能出统计报表
+- 能满足权限和审计
+
+这些要求到今天依然成立，没什么可怀疑的。
+
+但 AI+SaaS 多了另一层要求：
+
+**你设计出来的数据，不只是给系统存和查的，还要能被 AI 理解、检索、调用。**
+
+这一要求一进来，标准就变了。
+
+拿一个典型的线下服务型业务来说，传统 SaaS 更在意的通常是：
+
+- 客户档案能不能录进去
+- 服务记录能不能查出来
+- 收费能不能对上
+- 报表能不能导出
+
+但 AI+SaaS 还需要往前再走一步：
+
+- 服务过程的内容能不能结构化
+- 客户、服务类型、处理结果之间有没有稳定的关联
+- 这些字段能不能支撑后面的摘要、推荐、风险提示
+
+传统 SaaS 的数据更像是为业务流转服务的。
+
+AI+SaaS 的数据要做两件事：既要支撑业务流转，也要支撑 AI 理解、检索和调用。
+
+这就是为什么我说，很多团队问"要不要自己训模型"，问的方向其实偏了。
+
+对大多数行业 SaaS 来说，真正有价值的不是模型的参数量，而是：
+
+- 行业数据有没有结构化
+- 字段语义清不清楚
+- 对象之间的关系完不完整
+- 历史记录好不好检索
+
+这几个东西做扎实了，哪怕你接的是现成模型，AI 也能真正进入业务。
+
+反过来，数据设计如果本身就散、乱、缺语义，换再强的模型，效果也不会有质变。
+
+<span class="highlight-text">行业数据结构，才是垂直 SaaS 的护城河，不是模型参数。</span>
+
+---
+
+## 二、提升人效，这才是 AI+SaaS 最直接的商业价值
+
+很多人聊 AI+SaaS，喜欢聊技术能力、聊 Agent、聊多模态。
+
+但我接触下来，客户真正关心的，往往比这朴实得多：
+
+**能不能少用几个人，或者让同样的人，把事情做得更多、更稳。**
+
+这件事在很多行业里都很具体。
+
+拿一个高频服务场景举例，过去的流程大概是：
+
+- 服务过程中手动记录，或者靠记忆
+- 服务结束后手动录入系统
+- 手动整理各个字段
+- 手动生成跟进记录或报告
+
+每一步都是人在做，每一步都可能出错，每一步都在消耗时间。
+
+AI+SaaS 能做的，是把这个链条改成：
+
+- 语音或对话自动转文字
+- 自动抽取关键字段
+- 自动生成服务记录草稿
+- 自动同步到系统
+- ...
+
+这不是把人换掉，而是把那些高频、重复、容易出错的动作，尽量自动化掉，让人能把精力放在真正需要判断的地方。
+
+传统 SaaS 能做的，更多是给你一套在线的操作台，让这些动作在系统里完成，而不是纸上或者微信群里。
+
+AI+SaaS 往前多走了一步：让系统替人分担一部分原本不得不做的工作。
+
+这个价值很直接：
+
+- 减少重复劳动
+- 提升单人产出
+- 降低遗漏概率
+- 让服务质量更稳定
+
+<span class="highlight-text">AI+SaaS 比传统 SaaS 进一步的地方，不只是管理效率，而是执行效率也开始被提起来了。</span>
+
+当然这件事有个前提。
+
+AI 要能真正进入业务，必须有一层东西支撑：系统里的那些"技能"。
+
+比如 AI 说要查某条历史服务记录，系统得真的有这个查询能力让它调；AI 说要生成跟进报告，系统得真的能写入并存档。
+
+模型负责的是理解意图、生成内容。系统负责的是真正执行动作。
+
+只有这两件事都做到位了，人效提升才是真实的，而不是停在 demo 层面。
+
+---
+
+## 三、交付价值不一样了：从交付功能，到开始交付结果
+
+传统 SaaS 卖的东西，本质是：**把业务流程搬进系统**。
+
+原来靠 Excel、靠微信群、靠纸张做的事情，变成线上化、标准化、可追踪。
+
+这个价值到今天依然成立，依然有人在买单。
+
+但 AI+SaaS 开始往前多走一步：
+
+**不只是把流程放进系统，而是把一部分结果做出来。**
+
+同样是一个服务场景，传统 SaaS 交付的是：
+
+- 一套录入服务记录的表单
+- 一套查询历史档案的功能
+- 一套出报表的界面
+
+AI+SaaS 交付的是：
+
+- 服务结束，记录草稿已经生成好了
+- 关键字段已经自动提取出来了
+- ...
+
+客户买的，就不只是一套表单了。
+
+他买的是"少填一堆表、少做一堆重复动作、事情还能推进得更快"这件事。
+
+这就是交付价值的变化。
+
+以前更像是交付功能。现在开始更像是交付结果。
+
+当然这个结果交付，并不是一上来就能做到的。
+
+它建立在：数据设计对了、系统能力封装好了、AI 工作流搭稳了，这三件事都就位之后，才能真正发生。
+
+---
+
+## 那要不要自己训模型？
+
+顺带说一下这个经常被q到的问题。
+
+我的判断比较直接：**大多数行业 SaaS，一开始根本不需要训练自己的模型，甚至连微调都不用急。**
+
+理由很简单。
+
+基础模型会越来越便宜越来越好用甚至可能会未来小参数的都能赶上现在大参数的模型，今天需要很高成本做的事，明年可能已经是基础设施。
+
+你当前真正更稀缺的，不是模型参数，而是：
+
+- 数据结构设计
+- 行业 KnowHow
+- AI 工作流设计
+- 系统调用能力封装
+- 成本控制
+
+这几件事做扎实，接现成模型就已经够用了，而且可以替换，可以随时换更便宜、更强的模型进来。
+
+等到数据量足够大、样本质量足够高、业务场景足够稳定，那时候再考虑轻量微调，顺序才是对的。
+
+不是永远不做，而是不要一上来就做。
+
+<span class="gradient-text">你不是 AI 公司，你是用 AI 做增强的行业 SaaS 公司。这两件事，差别很大。</span>
+
+---
+
+## 最后
+
+如果要我把 AI+SaaS 和传统 SaaS 的差别压缩成一句话：
+
+传统 SaaS 帮客户把流程搬进了系统；AI+SaaS 要做到的，是在流程进了系统之后，还能把结果尽量做出来、把重复劳动尽量替掉。
+
+但要做到这一步，要走的顺序是：
+
+1. SaaS 基本盘先稳住
+2. 数据设计为 AI 理解和检索打好基础
+3. 系统能力封装好，让 AI 真正能做事
+4. 人效提升有了数据支撑，才是真实的
+5. 从交付功能，慢慢往交付结果走
+
+这条路没有捷径。但每一步踩实了，护城河会越来越深。

source/_drafts/软件研发行业到底要不要考核.md

@@ -0,0 +1,410 @@
+---
+title: 软件研发行业到底要不要考核？——从 KPI、OKR 到工程文化的一些思考
+author: Gamehu
+date: 2026-03-19 23:00:00
+tags:
+  - 技术管理
+  - 团队建设
+  - 绩效考核
+  - 工程文化
+categories:
+  - 技术管理
+---
+
+在软件研发行业中，绩效考核几乎是一个绕不开的话题。
+
+大多数公司都会有各种各样的考核体系：
+
+- KPI
+- OKR
+- 绩效评级
+- 末位淘汰
+- PIP（Performance Improvement Plan）
+
+但如果仔细观察技术行业，会发现一个很有意思的现象：
+
+**越优秀的技术团队，往往越不依赖复杂的绩效考核体系。**
+
+例如：
+
+- Google 早期工程团队
+- Netflix 工程文化
+- GitHub 早期团队
+- Basecamp（原 37signals）
+
+这些团队在快速成长阶段，并没有复杂的 KPI 体系。
+
+这就引出了一个值得思考的问题：
+
+> 在软件研发行业中，绩效考核究竟解决了什么问题？
+
+---
+
+# 一、管理学视角：绩效考核从哪里来
+
+绩效管理并不是现代互联网公司发明的概念。
+
+早在 1954 年，管理学家 [Peter Drucker](https://en.wikipedia.org/wiki/Peter_Drucker) 就在其著作《The Practice of Management》中提出了一个重要思想：
+
+**Management by Objectives（MBO，目标管理）**
+
+参考资料：https://en.wikipedia.org/wiki/Management_by_objectives
+
+MBO 的核心思想是：
+
+> 通过明确目标，使员工的工作与组织目标保持一致。
+
+后来，大量绩效管理方法都从 MBO 演化而来。
+
+## KPI
+
+KPI（Key Performance Indicator）强调：
+
+**通过指标量化组织目标。**
+
+参考资料：https://en.wikipedia.org/wiki/Performance_indicator
+
+KPI 在以下行业中非常有效：
+
+- 制造业
+- 销售团队
+- 呼叫中心
+- 金融服务
+
+这些行业有一个共同特点：
+
+**产出容易量化。**
+
+例如：
+
+- 销售额
+- 订单数量
+- 客户数量
+- 生产件数
+
+但软件研发工作却并不完全符合这种模式。
+
+---
+
+# 二、软件工程研究：研发绩效很难量化
+
+软件工程领域其实很早就意识到了这个问题。
+
+著名计算机科学家 [Fred Brooks](https://en.wikipedia.org/wiki/Fred_Brooks) 在经典著作《The Mythical Man-Month》中写过一句非常有名的话：
+
+> "Measuring programming progress by lines of code is like measuring aircraft building progress by weight."
+
+参考资料：https://en.wikipedia.org/wiki/The_Mythical_Man-Month
+
+翻译过来就是：
+
+**用代码行数衡量程序员的工作，就像用飞机重量衡量飞机制造进度。**
+
+这句话后来被软件工程领域反复引用，因为软件开发有几个明显特征。
+
+## 1、软件开发是一种创造性工作
+
+软件开发更像：
+
+- 工程设计
+- 系统建模
+- 创造性解决问题
+
+而不是重复劳动。
+
+两个工程师完成同一个任务，效率差异可能是数倍甚至十倍。但这种差异很难用简单指标衡量。
+
+## 2、软件系统的复杂度极高
+
+大型软件系统的复杂度通常呈指数增长。
+
+很多工程工作的价值在于：
+
+- 降低复杂度
+- 提高可维护性
+- 提高系统稳定性
+
+这些价值往往很难短期量化。
+
+## 3、很多技术价值具有延迟性
+
+例如：
+
+- 架构重构
+- 技术债治理
+- 自动化测试建设
+- 基础设施优化
+
+这些工作在短期 KPI 中往往看起来"没有产出"，但长期价值非常大。
+
+---
+
+# 三、Goodhart 定律：指标一旦成为目标就会失效
+
+在经济学中有一个非常著名的定律：
+
+**Goodhart's Law**
+
+参考资料：https://en.wikipedia.org/wiki/Goodhart%27s_law
+
+它的核心观点是：
+
+> When a measure becomes a target, it ceases to be a good measure.
+
+翻译成中文就是：
+
+**当一个指标变成目标时，它就不再是一个好的指标。**
+
+在软件团队中，这种现象非常常见。
+
+例如：
+
+如果 KPI 是 **Bug 数量**，研发可能会：
+
+- 减少 Bug 记录
+- 延迟 Bug 上报
+
+如果 KPI 是 **提交次数**，工程师可能会：
+
+- 刻意拆分 commit
+
+当指标成为考核目标时，行为就会随之改变。
+
+---
+
+# 四、OKR 的出现：试图解决 KPI 的问题
+
+OKR（Objectives and Key Results）最早由 [Andy Grove](https://en.wikipedia.org/wiki/Andrew_Grove) 在 Intel 推广。
+
+参考资料：https://en.wikipedia.org/wiki/OKR
+
+后来被 Google 大规模使用。
+
+Google 对 OKR 的解释可以参考：https://rework.withgoogle.com/guides/set-goals-with-okrs/
+
+OKR 的核心思想是：
+
+- **目标驱动，而不是指标驱动**
+- **鼓励挑战性目标**
+
+例如：
+
+**目标：** 提升系统稳定性
+
+**关键结果：**
+
+- 故障率降低 50%
+- 自动化测试覆盖率达到 80%
+
+OKR 的设计初衷其实是：
+
+**弱化绩效考核的控制属性。**
+
+但在很多公司中，OKR 最终变成了：
+
+**另一种 KPI。**
+
+---
+
+# 五、真实案例：当考核脱离管理目标
+
+理论上的绩效考核是为了提升组织效率。
+
+但在现实企业中，很多考核制度的出现，往往并不是出于管理设计，而是源于管理情绪。
+
+下面是我自己经历过的一些真实案例。
+
+## 案例一：一次"情绪驱动"的考核制度
+
+有一次，公司发生了一件小事，让老板对研发团队有些不满。
+
+第二天一早，公司突然推出了一套研发绩效考核方案。
+
+这套方案的问题在于：
+
+**你一眼就能看出来，它几乎和研发效率没有关系。**
+
+很多指标明显只是为了增加约束，而不是为了提升效率。
+
+在制度发布之前，公司的一些关键角色甚至提前给我打了"预防针"：
+
+> "这个事情你别发作，先配合一下，不然大家都不好看。"
+
+原因也很简单：
+
+- 这个方案不是我能改的
+- 如果我公开反对，只会让场面更尴尬
+
+于是我选择了沉默。
+
+但结果很快就出现了。
+
+<span class="highlight-text">制度发布后的第二天，接近一半研发成员找我谈离职。</span>
+
+大家的反馈几乎一致：
+
+> "这个考核明显不是为了做事。"
+
+很快，老板也意识到问题的严重性。
+
+这套考核制度上线没多久就**不了了之了**。
+
+## 案例二：代码行数考核
+
+有一次领导跟我讨论研发考核指标时，提到过一个想法：
+
+> "能不能把代码行数作为一个指标？"
+
+这个想法其实非常典型。
+
+因为从管理视角来看，代码似乎是最容易量化的东西。
+
+但如果真的用代码行数考核，优化方法非常多：
+
+- 重构代码
+- 拆分函数
+- 增加日志
+- 自动格式化代码
+
+甚至仅仅运行一次代码格式化工具，都可能增加大量代码行。
+
+如果真这么考核，那我很可能很快就会成为：
+
+> **全公司代码行数第一的"代码 king"。**
+
+但很显然，这并不意味着软件质量更好。
+
+## 案例三：Bug 数量考核
+
+还有一个朋友的公司曾经设计过这样一套考核制度：
+
+- **研发团队考核：** Bug 数量
+- **测试团队考核：** 提交 Bug 数量
+
+乍一看似乎很合理。
+
+但仔细想想就会发现一个问题：
+
+**双方的激励机制完全相反。**
+
+- 研发希望：Bug 越少越好
+- 测试希望：Bug 越多越好
+
+最终大家的目标就变成了一件事：
+
+> **谁也别想好过。**
+
+这其实正好印证了 Goodhart 定律。
+
+---
+
+# 六、绩效考核什么时候才真正有用
+
+这并不意味着绩效考核完全没有价值。
+
+在某些情况下，绩效考核确实是必要的。
+
+## 1、团队规模扩大
+
+当团队规模达到几十人甚至上百人时：
+
+管理者很难了解每个人的具体工作。
+
+这时候考核体系可以作为一种管理工具。
+
+## 2、团队效率明显下降
+
+如果团队出现：
+
+- 需求延期严重
+- Bug 大量增加
+- 工作推诿
+
+考核体系可以帮助重新建立秩序。
+
+## 3、组织进入成熟阶段
+
+在成熟企业中，绩效考核往往用于：
+
+- 奖金分配
+- 人才梯队管理
+
+---
+
+# 七、优秀技术团队真正依赖的是什么
+
+很多优秀的软件公司在工程文化上有一个共同特点：
+
+**高信任 + 高责任。**
+
+例如：
+
+Netflix 工程文化强调：
+
+> Freedom and Responsibility
+
+参考资料：https://jobs.netflix.com/culture
+
+类似的工程文化也存在于：
+
+- GitHub Engineering：https://github.blog/engineering/
+- Basecamp：https://basecamp.com/books
+
+这些公司更强调：
+
+- 工程文化
+- 团队责任
+- 技术判断
+
+而不是复杂的绩效体系。
+
+---
+
+# 八、一个现实观察
+
+在很多公司中，当管理层开始：
+
+- 强化 KPI
+- 严格绩效排名
+- 大量使用 PIP
+
+往往意味着：
+
+**组织正在面对增长压力。**
+
+这并不一定意味着企业一定会失败。
+
+但通常说明：
+
+**管理层开始用制度替代文化。**
+
+---
+
+# 九、结论
+
+软件研发是一种高度创造性的工作。
+
+相比复杂的绩效制度，真正决定团队效率的往往是：
+
+- 清晰的目标
+- 优秀的人才
+- 健康的工程文化
+- 懂技术的管理者
+
+如果这些因素存在，考核体系往往可以非常简单。
+
+如果这些因素不存在，再复杂的 KPI 体系也很难解决问题。
+
+---
+
+# 参考资料
+
+1. [Management by Objectives - Wikipedia](https://en.wikipedia.org/wiki/Management_by_objectives)
+2. [Performance Indicator - Wikipedia](https://en.wikipedia.org/wiki/Performance_indicator)
+3. [The Mythical Man-Month - Wikipedia](https://en.wikipedia.org/wiki/The_Mythical_Man-Month)
+4. [Goodhart's Law - Wikipedia](https://en.wikipedia.org/wiki/Goodhart%27s_law)
+5. [OKR - Wikipedia](https://en.wikipedia.org/wiki/OKR)
+6. [Google OKR Guide](https://rework.withgoogle.com/guides/set-goals-with-okrs/)
+7. [Netflix Culture](https://jobs.netflix.com/culture)
+8. [GitHub Engineering](https://github.blog/engineering/)
+9. [Basecamp Books](https://basecamp.com/books)

source/_posts/AI Agent 架构深度解析：原理、模式与生产落地.md

@@ -0,0 +1,201 @@
+---
+title: AI Agent 架构深度解析：原理、模式与生产落地
+author: Gamehu
+date: 2026-03-31 10:39:52
+tags:
+  - AI
+  - Agent
+  - LLM
+  - 架构设计
+  - 软件工程
+categories:
+  - AI
+---
+
+<div class="tag-container">
+  <span class="ai-tag">AI</span>
+  <span class="sub-tag">Agent</span>
+  <span class="sub-tag">LLM OS</span>
+</div>
+
+> 这篇是我最近准备搭 Agent 时整理的学习笔记。它和上一篇 [《Agentic 入门：让 AI 不再一把梭，而是像人一样反复干活》](Agentic-入门：让-AI-不再一把梭，而是像人一样反复干活.md) 是一个系列：上一篇偏“怎么上手”，这一篇偏“底层怎么运转、上线怎么落地”。
+
+最近我想给自己的工作流做一套 Agent，结果第一周就被现实教育了：这事远不只是“写个提示词模板”那么简单。
+
+真动手之后你会发现，问题全在工程细节里。记忆怎么分层存储？任务队列怎么调度？循环什么时候该停？状态怎么恢复？这些都决定了系统是“能跑 Demo”，还是“能稳定跑在生产上”。
+
+最不适应的一点是，传统软件那套确定性思维在这里会失灵一大截。以前写业务代码，if-else 写完，流程基本可预期；现在很多控制流是 LLM 在运行时动态决定的，排错方式也完全变了。
+
+所以这篇我会把最近研究的几条主线串起来：Andrej Karpathy 的 LLM OS 视角、BabyAGI 的循环架构、以及 LangGraph 的状态机模式。目标很简单：把我自己踩坑后想明白的东西讲清楚，也给正在做 Agent 的你一个可复用的分析框架。
+
+## 一、核心概念深度辨析：Agent 与 Agentic
+
+先说我自己这次最大的认知纠偏：Agent 是"系统实体（名词）"，而 Agentic 是"设计模式与工作流（形容词）"。
+
+### 1. Agent（智能体）：基于大语言模型操作系统（LLM OS）的计算实体
+
+Agent 不仅仅是一个高级聊天机器人，而应该被视为一种具备拟人化特征的数字实体（People Spirits），或者说是基于大语言模型操作系统（LLM OS）运行的一台新型计算机<sup>4-6</sup>。在 LLM OS 的宏观架构中：
+
+* **CPU（中央处理器）：** 大语言模型（LLM）本身负责指令处理、推理与决策<sup>5, 7</sup>。
+* **RAM（内存/工作记忆）：** 模型的**上下文窗口（Context Window）**。这是一种短期的工作记忆，LLM 在此编排内存与计算以解决问题<sup>7, 8</sup>。
+* **外设与接口（Tools）：** Agent 可以通过工具调用与数字世界的外部基础设施交互，例如访问文件系统、运行代码沙箱或调用网络浏览器<sup>5, 9, 10</sup>。
+
+### 2. Agentic Workflow（智能体化工作流）：告别 Zero-shot 的迭代范式
+
+吴恩达（Andrew Ng）指出，传统上我们主要以"零样本（Zero-shot）"模式使用 LLM，即提示模型逐字生成最终输出而不进行任何修改。这很像要求一个人从头到尾敲击键盘写文章，全程不允许按退格键<sup>11</sup>。
+
+**Agentic 工作流是一种引入迭代循环（Loop）的系统方法论。** 它允许系统像人类工程师一样：规划大纲 -> 决定是否需要网络搜索 -> 撰写初稿 -> 审查初稿中的逻辑漏洞 -> 结合审查结果继续修改<sup>12</sup>。
+
+<div class="article-quote">
+<strong>惊人的工程收益：</strong>这种工作流带来了巨大的性能提升。在 HumanEval 代码编写基准测试中，GPT-3.5 的零样本正确率仅为 48.1%，GPT-4 为 67.0%；但是，如果将较弱的 GPT-3.5 放入 Agentic 迭代循环中，其正确率飙升至 95.1%<sup>13</sup>。
+</div>
+
+## 二、Agent 的底层架构与运行机制
+
+要理解 Agent 的底层架构，我们得先抛弃"它只是个聊天机器人"这个视角，把它当成一台<span class="highlight-text">基于自然语言指令运行的新型计算机</span>。
+
+### 2.1 宏观架构：大语言模型操作系统（LLM OS）
+
+前特斯拉 AI 总监 Andrej Karpathy 提出了理解 Agent 架构的最佳抽象模型：**LLM OS（大语言模型操作系统）**。在这个架构中：
+
+| 组件 | 对应关系 | 功能描述 |
+|------|----------|----------|
+| CPU（处理器） | 大语言模型（LLM） | 负责处理输入、执行逻辑推理、以及发出指令 |
+| RAM（内存 / 工作记忆） | 模型的**上下文窗口（Context Window）** 和 KV Cache | 短期工作记忆，任何在当前执行步骤中需要被 LLM 直接读取的信息，都必须被塞进这个窗口里 |
+| 外存（硬盘 / 长期记忆） | 外部的**向量数据库（Vector Database，如 Pinecone）** 甚至传统关系型数据库 | 由于 LLM 每次调用完成后会"失忆"（无状态），历史数据必须持久化在这里 |
+| 外设与执行器（Tools） | 代码沙箱（Code Sandbox）、文件系统读写权限、浏览器 API | 相当于计算机的网卡、显卡或机械臂 |
+
+{% asset_img llm-os-architecture.png LLM OS 架构示意图：展示 Agent 作为新型计算机的核心组件及其交互关系 %}
+
+### 2.2 核心模块拆解（以经典 Agent 为例）
+
+如果剥开代码看，一个标准的自主运行 Agent（例如早期 BabyAGI 或现代框架的核心模块）通常由以下几个核心组件（Components）构成：
+
+#### 1. 大语言模型控制器（LLM Controller）
+
+这是整个系统的大脑。它接收系统提示词（System Prompt），明确当前的角色设定、可用工具列表以及输出格式（通常为 JSON），以此将自然语言转化为结构化的机器动作。
+
+#### 2. 记忆管理系统（Memory System）
+
+* **短期记忆：** 通常由开发框架（如 LangChain/LangGraph）维护当前的对话历史或近期几步的操作日志。
+* **长期记忆：** 当任务周期极长时，框架会将之前的操作结果转化为"向量嵌入（Embeddings）"，存入向量数据库。当 Agent 执行新任务时，系统会通过"语义搜索（Semantic Search）"提取最相关的历史经验，拼接进当前的上下文中供 LLM 读取。
+
+#### 3. 工具与环境接口（Tool Integrations / Harness）
+
+LangChain 创始人 Harrison Chase 强调，现代 Agent 的强大来源于强大的<span class="highlight-text">"脚手架（Harness）"</span>。这包括预置的工具函数。<span class="highlight-text">最核心的工具是文件系统（File System）访问权限</span>，因为它可以让 Agent 把长篇的中间结果写入文件，而不是全部塞进上下文里导致内存溢出。
+
+### 2.3 运行机制：死循环与状态机（The Loop & State Machine）
+
+Agent 并不是"一口气"运行完的，它的底层是一个**事件驱动的循环结构（Loop）**。在工程实现里，主流运行机制大致有两种：
+
+#### 机制 A：经典的"三节点"死循环（如 BabyAGI）
+
+BabyAGI 证明了只要三个 Python 脚本节点相互配合，就能让 Agent 无限期自主运转：
+
+1. **任务执行节点（Task Execution）：** 读取当前任务队列的第一个任务，结合向量数据库中的历史上下文，调用 LLM 执行任务，并保存结果。
+2. **任务创建节点（Task Creation）：** 观察上一步的执行结果，调用 LLM 判断"为了实现总目标，接下来还需要新增什么任务？"，并将新任务丢进队列。
+3. **任务优先级排序节点（Task Prioritization）：** 调用 LLM 对现有的任务队列重新排序，清理冗余，决定下一步最该做什么。 *这个循环（While Loop）会不断运转，直到任务列表清空或达到预设的终止条件。*
+
+#### 机制 B：现代的图与状态机架构（如 LangGraph）
+
+面对更复杂的企业级业务，简单的死循环难以控制。现代框架（如 LangGraph）将运行机制升级为**有向图（Graph）和状态机（State Machine）**：
+
+* **节点（Nodes）：** 代表具体的处理单元（可以是一个调用 LLM 的函数，也可以是执行 Python 代码的工具）。
+* **边（Edges）：** 包含条件判断逻辑（如 IF-ELSE）。基于当前节点返回的结果，决定数据流向下一个哪个节点。
+* **状态管理（State Management）：** 整个图共享一个全局状态（State）。每次循环都在更新这个全局状态，并自带**持久化（Persistence）**功能。这意味着当 Agent 运行到一半崩溃，或者遇到高风险操作需要"人类审批"时，程序可以暂停保存状态，之后再无缝恢复。
+
+### 2.4 底层工程的终极挑战：上下文工程（Context Engineering）与执行轨迹（Traces）
+
+当我们把上面这些模块拼起来后，运行逻辑会发生根本变化，这也是研发人员最需要适应的地方：
+
+* **逻辑不再只存在于代码中：** 传统软件的控制流（If-Else）写在代码里；但 Agent 的控制流很大一部分由 LLM 在运行时动态决定（具有不确定性）。  
+* **上下文工程（Context Engineering）决定成败：** 决定 Agent 表现的，是每次循环调用 LLM 时，你在这个循环点（通过检索或状态机）给它组装了什么上下文。如果塞入的信息太多，LLM 会忘记关键指令；如果太少，它会产生幻觉。  
+* **排错（Debug）依赖执行轨迹（Traces）：** 在传统开发中，出 Bug 了我们看代码；但在 Agent 开发中，当系统在第 14 步失败时，看代码毫无用处，因为你需要知道前 13 步它往上下文（Context）里塞了什么。因此，记录每一步提示词、输入和输出的**执行轨迹（Traces）** 取代了源代码，成为了 Agent 开发中测试和调试的“唯一真相来源”。
+
+
+## 三、驱动系统运转的核心：四大 Agentic 设计模式
+
+在底层循环与状态机之上，真正让 Agent 表现出"智能感"的，是吴恩达总结的<span class="highlight-text">四种核心 Agentic 设计模式（Design Patterns）</span><sup>24</sup>：
+
+### 1. 工具使用（Tool Use）
+
+赋予 LLM 网络搜索、代码执行等外部函数调用能力，以收集信息或处理数据<sup>24</sup>。
+
+### 2. 规划（Planning）
+
+面对复杂目标时，LLM 能够自主提出并执行一个多步计划<sup>24</sup>。
+
+### 3. 反思（Reflection / Self-Correction）
+
+强迫 LLM 检查自身的输出，发现缺陷并提出改进方案<sup>24</sup>。例如，在缓解模型幻觉的研究中，Chain-of-Verification (CoVe) 强制模型生成验证问题并自我审查，而 Self-Refine 则采用"生成 -> 反馈 -> 改进"的迭代框架扮演自我批评者的角色<sup>25, 26</sup>。
+
+### 4. 多智能体协作（Multi-agent Collaboration）
+
+实例化多个不同的 AI 角色，通过分担任务和相互辩论，得出比单一 Agent 更优的解决方案<sup>24</sup>。
+
+
+## 四、研发视角的范式转换：开发 Agent 与传统软件的区别
+
+LangChain 创始人 Harrison Chase 指出，构建 Agent 会显著改变传统软件工程的一些基本常识<sup>27</sup>。
+
+### 1. 逻辑存在于模型中（非确定性系统）
+
+传统软件的逻辑被硬编码（Hard-coded）在代码中，开发者可以确切知道程序的流向；而在 Agent 中，程序的控制流是由大模型在运行时基于上下文动态涌现的，具有高度的黑盒性和不确定性<sup>27, 28</sup>。
+
+### 2. "执行轨迹（Traces）"取代代码，成为 Debug 的唯一事实依据
+
+由于 Agent 在循环中反复运行，当系统在第 14 步报错时，单看代码无法推断前 13 步 LLM 的上下文窗口里到底装载了什么<sup>29</sup>。因此，详细记录每一步输入、输出、工具调用和状态变化的**执行轨迹（Traces）**，取代了源代码，成为了开发者测试、排错（Debug）和团队协作的核心工具<sup>27, 30, 31</sup>。
+
+### 3. "脚手架（Harness）"与"上下文工程（Context Engineering）"决定成败
+
+长周期 Agent（Long-Horizon Agents）的成败往往不仅仅取决于底层模型有多强大，更取决于开发者构建的 <span class="highlight-text">Harness（深度定制的脚手架体系）</span><sup>32, 33</sup>。这包括内置的规划工具、处理超长文本的压缩（Compaction）策略，以及至关重要的文件系统访问权限（File System Access）<sup>9, 33, 34</sup>。这一切本质上都是 <span class="gradient-text">"上下文工程（Context Engineering）"</span>——即在 Agent 循环的每一个特定步骤，精准地为其上下文窗口注入最需要的记忆、工具结果和指引<sup>32, 35, 36</sup>。
+
+
+## 五、生产环境落地的终极指南
+
+对于准备把 Agent 投入生产环境的研发团队，行业里有一个高度一致的共识：<span class="highlight-text">不要一上来就追求 100% 全自动（Fully Autonomous）</span>。
+
+### 1. 做好迎接"Agent的十年"的准备，它是一个"九的游行"
+
+Andrej Karpathy 强调，目前行业处于"Agent的十年（Decade of Agents）"，而非所谓的一年<sup>37</sup>。构建可靠的 Agent 与研发自动驾驶汽车极度相似：展示一个能解决 90% 问题的 Demo 非常容易，但要达到生产级别，需要经历漫长的"九的游行（March of nines，即追求 99.9% 到 99.99% 的极端可靠性）"<sup>38, 39</sup>。
+
+### 2. 定位为"初稿生成器（First Drafts）"
+
+现阶段长周期 Agent 最杀手级的应用场景，不是直接交付最终结果，而是生成一份极具价值的"初稿"<sup>40</sup>。无论是代码的 Pull Request、SRE 的日志诊断分析报告，还是客户支持的复杂调研，Agent 的作用是承担粗重的初期工作，然后交由人类审核与编辑<sup>40, 41</sup>。
+
+### 3. 保留"自主性滑块（Autonomy Slider）"
+
+在产品设计（如 Cursor 或 Perplexity）中，必须赋予用户控制权<sup>42-44</sup>。开发者可以选择只补全一行代码（Tap completion）、修改单个文件，或是让 Agent 放开手脚重构整个代码仓库，用户可以根据任务复杂度动态调整这种"自主性滑块"<sup>44, 45</sup>。
+
+### 4. 终极形态：环境智能体（Ambient Agents）与 智能体收件箱（Agent Inbox）
+
+传统的基于聊天（Chat-based）的 Agent 受限于极高的延迟要求和一对一的交互瓶颈<sup>46-48</sup>。未来的生产级落地形态将走向<span class="highlight-text">环境智能体（Ambient Agents）</span><sup>46, 49</sup>。
+
+* **事件驱动与异步执行：** Ambient Agents 在后台静默运行，监听并响应事件流（如新收到的客户邮件、代码库提交、系统报警等）<sup>46</sup>。由于没有即时聊天的延迟压力，它们可以执行包含数十次工具调用和复杂规划的深层任务<sup>48, 50</sup>。
+* **人类在环（Human-in-the-loop）与 Agent Inbox：** 这种异步、高并发的运行模式绝不意味着失控。相反，系统必须设计一个类似"智能体收件箱（Agent Inbox）"的交互界面<sup>51</sup>。Agent 将执行到一半的高风险操作或半成品报告推送到收件箱中，人类在此进行<span class="highlight-text">审批（Approve）、编辑修改（Edit）、解答 Agent 的疑问（Answer），甚至进行"时间旅行（Time Travel，即回滚到之前某一步重新运行）"</span><sup>52, 53</sup>。这不仅保证了业务的安全性，人类的纠错反馈也将作为记忆（Memory），驱动 Agent 系统的自我迭代与进化<sup>51, 54</sup>。
+
+---
+
+<div class="article-quote">
+<strong>总结：</strong>我们正在经历软件工程范式的一次关键转折。从"软件 1.0"的确定性代码，到"软件 2.0"的神经网络权重，再到"软件 3.0"的 LLM 驱动 Agent，每一次跃迁都在重新定义"编程"这件事。对研发人员来说，理解 Agent 的底层架构——LLM OS 的计算模型、四大设计模式、以及上下文工程的核心地位——会是未来十年非常关键的技术投入。
+</div>
+
+---
+
+
+### 核心参考文章
+
+**1. 吴恩达 (Andrew Ng) —— Agentic 核心概念与设计模式**
+* [AI Agents that Work - The Batch](https://www.deeplearning.ai/the-batch/how-agents-can-improve-llm-performance/)
+* [Opportunities in AI (2024年演讲)](https://www.youtube.com/watch?v=q1XFm21I-VQ)
+
+**2. Lilian Weng (OpenAI) —— LLM Agent 架构百科全书**
+* [LLM Powered Autonomous Agents](https://lilianweng.github.io/posts/2023-06-23-agent/)
+
+**3. Andrej Karpathy —— LLM OS 系统愿景**
+* [Intro to Large Language Models (视频)](https://www.youtube.com/watch?v=zjkBMFhNj_g)
+* [The "Loopy" Era of AI (Twitter/X)](https://twitter.com/karpathy/status/1723140519217836416)
+
+**4. BabyAGI —— 自主智能体先驱**
+* [Birth of BabyAGI](https://yoheinakajima.com/task-driven-autonomous-agent-utilizing-gpt-4-pinecone-and-langchain-for-ultimate-efficiency/)
+* [Better Ways to Build Self-Improving AI Agents](https://yoheinakajima.com/blog/)

source/_posts/AI时代，AI+SaaS和传统SaaS，真正拉开差距的是数据设计和交付价值.md

@@ -0,0 +1,238 @@
+---
+title: AI时代，AI+SaaS和传统SaaS，真正拉开差距的是数据设计和交付价值
+author: Gamehu
+date: 2026-03-27 23:00:00
+tags:
+  - AI
+  - SaaS
+  - 数据设计
+  - 人效
+categories:
+  - AI
+---
+
+<div class="tag-container">
+  <span class="ai-tag">AI</span>
+  <span class="sub-tag">SaaS思考</span>
+</div>
+
+<div class="article-quote">
+这一篇也是很早在草稿箱的文章，今天才整理出来。
+
+因为我这几年都在 SaaS行业，然后现公司也是做xx行业AI产品(SAAS)，这段时间一直反复在想一个问题：AI+SaaS 和传统 SaaS，到底有什么不同？一开始很容易把注意力放到"要自己训一个大模型"这种问题上比如我们公司ceo或者外部投资人、，但我可能有些不成熟的观点，我是觉得这根本不是核心，最起码当你的体量没起来没被客户接受或者故事没被资本接收的时候我觉得更应该关注的是另外几件事。当然肯定只能写能说的，跟公司商业无关的哈。
+</div>
+
+先把结论放在前面。
+
+我认为 AI+SaaS 和传统 SaaS 最本质的差异或者说核心关注点应该集中在三个地方：**数据设计、人效提升方式、交付给客户的价值**。
+
+但这三件事有一个前提，先别急着聊 AI，SaaS 的基本功必须先做扎实。
+
+---
+
+## 前提：SaaS 基本功不扎实，AI 进来只会更乱
+
+这话我是越来越信。
+
+很多团队一引入大模型，心态就容易飘。总觉得以前没做好的地方，权限没理清、流程不稳定、数据结构乱，好像 AI 一进来能顺带解决。
+
+实际上恰恰相反。
+
+<span class="highlight-text">AI 不会替你补基本功，它只会把原来系统里的那些问题，放大得更快、更明显。</span>
+
+如果一个 SaaS 系统的业务流程本身就跑不顺，系统边界本身就模糊，那接上 AI 以后，输出的结果会更不可信，追溯问题会更难，整体更乱。
+
+所以这件事我的顺序是：先把系统做好，**深入了解以及解决客户基本的痛点问题**，先把业务跑顺，再来谈 AI 怎么加。
+
+别把顺序弄反了。
+
+---
+
+## 一、数据设计，不只是给人用了，还要给 AI 用
+
+这是 AI+SaaS 和传统 SaaS 差别最大的地方之一，而且是很多团队最容易忽视的。
+
+传统 SaaS 里，数据设计的诉求其实很清楚：
+
+- 能支撑业务流程
+- 能做增删改查
+- 能出统计报表
+- 能满足权限和审计
+
+这些要求到今天依然成立，没什么可怀疑的。
+
+但 AI+SaaS 多了另一层要求：
+
+**你设计出来的数据，不只是给系统存和查的，还要能被 AI 理解、检索、调用。**
+
+这一要求一进来，标准就变了。
+
+拿一个典型的线下服务型业务来说，传统 SaaS 更在意的通常是：
+
+- 客户档案能不能录进去
+- 服务记录能不能查出来
+- 收费能不能对上
+- 报表能不能导出
+
+但 AI+SaaS 还需要往前再走一步：
+
+- 服务过程的内容能不能结构化
+- 客户、服务类型、处理结果之间有没有稳定的关联
+- 这些字段能不能支撑后面的摘要、推荐、风险提示
+
+传统 SaaS 的数据更像是为业务流转服务的。
+
+AI+SaaS 的数据要做两件事：既要支撑业务流转，也要支撑 AI 理解、检索和调用。
+
+这就是为什么我说，很多团队问"要不要自己训模型"，问的方向其实偏了。
+
+对大多数行业 SaaS 来说，真正有价值的不是模型的参数量，而是：
+
+- 行业数据有没有结构化
+- 字段语义清不清楚
+- 对象之间的关系完不完整
+- 历史记录好不好检索
+
+这几个东西做扎实了，哪怕你接的是现成模型，AI 也能真正进入业务。
+
+反过来，数据设计如果本身就散、乱、缺语义，换再强的模型，效果也不会有质变。
+
+<span class="highlight-text">行业数据结构，才是垂直 SaaS 的护城河，不是模型参数。</span>
+
+---
+
+## 二、提升人效，这才是 AI+SaaS 最直接的商业价值
+
+很多人聊 AI+SaaS，喜欢聊技术能力、聊 Agent、聊多模态。
+
+但我接触下来，客户真正关心的，往往比这朴实得多：
+
+**能不能少用几个人，或者让同样的人，把事情做得更多、更稳。**
+
+这件事在很多行业里都很具体。
+
+拿一个高频服务场景举例，过去的流程大概是：
+
+- 服务过程中手动记录，或者靠记忆
+- 服务结束后手动录入系统
+- 手动整理各个字段
+- 手动生成跟进记录或报告
+
+每一步都是人在做，每一步都可能出错，每一步都在消耗时间。
+
+AI+SaaS 能做的，是把这个链条改成：
+
+- 语音或对话自动转文字
+- 自动抽取关键字段
+- 自动生成服务记录草稿
+- 自动同步到系统
+- ...
+
+这不是把人换掉，而是把那些高频、重复、容易出错的动作，尽量自动化掉，让人能把精力放在真正需要判断的地方。
+
+传统 SaaS 能做的，更多是给你一套在线的操作台，让这些动作在系统里完成，而不是纸上或者微信群里。
+
+AI+SaaS 往前多走了一步：让系统替人分担一部分原本不得不做的工作。
+
+这个价值很直接：
+
+- 减少重复劳动
+- 提升单人产出
+- 降低遗漏概率
+- 让服务质量更稳定
+
+<span class="highlight-text">AI+SaaS 比传统 SaaS 进一步的地方，不只是管理效率，而是执行效率也开始被提起来了。</span>
+
+当然这件事有个前提。
+
+AI 要能真正进入业务，必须有一层东西支撑：系统里的那些"技能"。
+
+比如 AI 说要查某条历史服务记录，系统得真的有这个查询能力让它调；AI 说要生成跟进报告，系统得真的能写入并存档。
+
+模型负责的是理解意图、生成内容。系统负责的是真正执行动作。
+
+只有这两件事都做到位了，人效提升才是真实的，而不是停在 demo 层面。
+
+---
+
+## 三、交付价值不一样了：从交付功能，到开始交付结果
+
+传统 SaaS 卖的东西，本质是：**把业务流程搬进系统**。
+
+原来靠 Excel、靠微信群、靠纸张做的事情，变成线上化、标准化、可追踪。
+
+这个价值到今天依然成立，依然有人在买单。
+
+但 AI+SaaS 开始往前多走一步：
+
+**不只是把流程放进系统，而是把一部分结果做出来。**
+
+同样是一个服务场景，传统 SaaS 交付的是：
+
+- 一套录入服务记录的表单
+- 一套查询历史档案的功能
+- 一套出报表的界面
+
+AI+SaaS 交付的是：
+
+- 服务结束，记录草稿已经生成好了
+- 关键字段已经自动提取出来了
+- ...
+
+客户买的，就不只是一套表单了。
+
+他买的是"少填一堆表、少做一堆重复动作、事情还能推进得更快"这件事。
+
+这就是交付价值的变化。
+
+以前更像是交付功能。现在开始更像是交付结果。
+
+当然这个结果交付，并不是一上来就能做到的。
+
+它建立在：数据设计对了、系统能力封装好了、AI 工作流搭稳了，这三件事都就位之后，才能真正发生。
+
+---
+
+## 那要不要自己训模型？
+
+顺带说一下这个经常被q到的问题。
+
+我的判断比较直接：**大多数行业 SaaS，一开始根本不需要训练自己的模型，甚至连微调都不用急。**
+
+理由很简单。
+
+基础模型会越来越便宜越来越好用甚至可能会未来小参数的都能赶上现在大参数的模型，今天需要很高成本做的事，明年可能已经是基础设施。
+
+你当前真正更稀缺的，不是模型参数，而是：
+
+- 数据结构设计
+- 行业 KnowHow
+- AI 工作流设计
+- 系统调用能力封装
+- 成本控制
+
+这几件事做扎实，接现成模型就已经够用了，而且可以替换，可以随时换更便宜、更强的模型进来。
+
+等到数据量足够大、样本质量足够高、业务场景足够稳定，那时候再考虑轻量微调，顺序才是对的。
+
+不是永远不做，而是不要一上来就做。
+
+<span class="gradient-text">你不是 AI 公司，你是用 AI 做增强的行业 SaaS 公司。这两件事，差别很大。</span>
+
+---
+
+## 最后
+
+如果要我把 AI+SaaS 和传统 SaaS 的差别压缩成一句话：
+
+传统 SaaS 帮客户把流程搬进了系统；AI+SaaS 要做到的，是在流程进了系统之后，还能把结果尽量做出来、把重复劳动尽量替掉。
+
+但要做到这一步，要走的顺序是：
+
+1. SaaS 基本盘先稳住
+2. 数据设计为 AI 理解和检索打好基础
+3. 系统能力封装好，让 AI 真正能做事
+4. 人效提升有了数据支撑，才是真实的
+5. 从交付功能，慢慢往交付结果走
+
+这条路没有捷径。但每一步踩实了，护城河会越来越深。

source/_posts/Context-Engineering-上下文工程.md

@@ -18,32 +18,35 @@ categories:
   <span class="sub-tag">大模型</span>
 </div>
 
-> 📎 **说明**：这篇文章是我在学习 [《Agentic 入门：让 AI 不再一把梭，而是像人一样反复干活》](Agentic-入门：让-AI-不再一把梭，而是像人一样反复干活.md) 时一起整理的。其实这篇关于 Context Engineering 的内容应该先发，但当时没整理好，所以后发了。这篇文章是我自己的学习整理。
+> 📎 **说明**：这篇文章是我在准备搭agent时学习过程的整理跟 [《Agentic 入门：让 AI 不再一把梭，而是像人一样反复干活》](Agentic-入门：让-AI-不再一把梭，而是像人一样反复干活.md) 一起整理的。按理说这篇应该更早发，但当时一直没整理顺，所以拖到了后面。内容还是以我自己的学习理解为主。
 
-**Context Engineering**（上下文工程）最早接触是去年Prompt Engineering 概念活了一段时间之后。
-在这之前好像AI应用开发的核心焦点一直是“提示词工程（Prompt Engineering）”。然而，随着大语言模型（LLM）从单次问答向能够自主运行的智能体（Agent）演进，一个全新的概念正逐渐占据主导地位：上下文工程（Context Engineering）。
-构建大语言模型应用，正在从“如何遣词造句写出完美的提示词”，转变为“如何配置上下文才能最大概率地生成模型所需的行为”。
+我最早注意到 **Context Engineering**（上下文工程），大概是在 Prompt Engineering 被聊得很热之后。
+
+**Context Engineering**（上下文工程）最早接触是Prompt Engineering 概念火了一段时间之后。
+在这之前好像AI应用开发的核心焦点一直是“提示词工程（Prompt Engineering）”。然而，随着大语言模型（LLM）从单次问答向能够自主运行的智能体（Agent）演进，上下文工程（Context Engineering）变得更加重要。
 
+很多时候，真正决定模型表现的，不是你那句话写得漂不漂亮，而是它在那一刻到底看到了什么，没看到什么。
+构建大语言模型应用，正在从“如何遣词造句写出完美的提示词”，转变为“如何配置上下文才能最大概率地生成模型所需的行为”。
 ---
 
 ## 一、先说问题：Prompt Engineering 到底卡在哪儿？
 
-用过 AI 的人应该都有这种体验：
+只要你认真用过一段时间 AI，大概率都会碰到这种情况：
 
-你认认真真写了一个很长的 Prompt，结果模型要么没懂你的意思，要么给出来的答案"飘"得很。你换了个角度再提问，它又忽然变得很靠谱。
+你写了一个很长的 Prompt，感觉已经把话说明白了，结果模型要么没懂，要么回答得很飘。可你换个问法，它又突然正常了。
 
 你开始怀疑：是我 Prompt 写得不好，还是模型本身忽强忽弱？
 
-这个问题背后藏着一个更根本的事情：<span class="highlight-text">模型能不能干好活，很大程度上取决于它"当下能看到什么"。</span>
+这个现象背后，其实是个更底层的问题：<span class="highlight-text">模型能不能干好活，很大程度上取决于它当下到底能看到什么。</span>
 
-Prompt Engineering 做的事，说白了是"怎么把这个问题问清楚"。这是必要的，但它管不了一件事——当你需要处理的信息量超出单次对话能装下的量时，怎么办？
+Prompt Engineering 解决的是“怎么把问题问清楚”。这当然重要，但它管不了另一件更麻烦的事: 当你要处理的信息，已经不是一轮对话能装下的时候，该怎么办？
 
 比如：
 - 你有一本 500 页的技术文档，想让 AI 帮你答用户问题
 - 你的系统里有十几个上下文来源（用户历史、实时数据、业务规则、代码片段……）
 - 你的 Agent 要跑十几步任务，中间状态要一直传下去
 
-这些场景里，"怎么问"已经不是最核心的问题了，**"怎么喂"才是**。
+到了这些场景里，“怎么问”就不是最核心的问题了，**“怎么喂”才是**。
 
 这就是 Context Engineering 要解决的事。
 
@@ -51,19 +54,19 @@ Prompt Engineering 做的事，说白了是"怎么把这个问题问清楚"。
 
 ## 二、那 Context Engineering 到底是什么？
 
-Anthropic 官方的说法是，它是**从 Prompt Engineering 演进来的**[《Effective context engineering for AI agents》](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents)，但两者的关注点不同：
+Anthropic 的说法是，它可以看成是**从 Prompt Engineering 往前走了一步**[《Effective context engineering for AI agents》](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents)，但两者盯的东西并不一样：
 
 - Prompt Engineering：**怎么写好这一句话**
 - Context Engineering：**怎么组织整个信息环境**
 
-后者更像是在做"信息架构"，你要决定：
+如果用我自己的话讲，后者更像是在做“信息架构”，你要决定：
 
 1. 哪些信息该放进上下文
 2. 这些信息按什么结构组织
 3. 什么时机、以什么方式把它们喂给模型
 4. 超出上下文窗口时，怎么选择性地保留和丢弃
 
-这件事听起来像工程，因为它**就是工程**。它不是让你背几个提示词公式，而是要你把整个信息流设计清楚。
+这件事听起来像工程，不是因为这个词高级，而是它真的就是工程问题。它不是让你背几个提示词套路，而是要把整个信息流理清楚。
 
 有一个比方我觉得很贴：
 
@@ -73,17 +76,17 @@ Anthropic 官方的说法是，它是**从 Prompt Engineering 演进来的**[《
 
 ## 三、它真正卡住的，不只是窗口大小，而是“注意力预算”
 
-很多人第一次接触上下文工程，会把重点放在“上下文窗口够不够大”上。
+很多人第一次接触上下文工程，都会先盯着“上下文窗口够不够大”。
 
 这个视角没错，但还不够。
 
-更准确的说法是：**模型真正稀缺的，不只是 token 容量，而是注意力预算。**
+但我现在越来越觉得，更准确的说法应该是：**模型真正稀缺的，不只是 token 容量，而是注意力预算。**
 
-你可以把上下文窗口理解成模型工作的“临时内存”。窗口越大，理论上能放进去的信息越多；但信息一多，不代表模型就能同样稳定地理解、提取、关联这些内容。
+你可以把上下文窗口理解成模型工作的“临时内存”。窗口大，确实代表理论上能塞进去更多东西；但塞得进，不等于它就能稳定地理解、提取、关联这些内容。
 
 这时候会出现一个很现实的问题：**上下文腐烂（Context rot）**。
 
-也就是上下文越长，信息越杂，模型越容易出现下面几种情况：
+说白了就是，上下文越长、信息越杂，模型越容易出现下面这些毛病：
 
 - 前面明明给过规则，后面还是忘
 - 中间插入很多工具输出后，开始抓不住重点
@@ -92,7 +95,7 @@ Anthropic 官方的说法是，它是**从 Prompt Engineering 演进来的**[《
 
 所以 Context Engineering 的核心不是“拼命往里塞”，而是：<span class="highlight-text">用尽量少、但信号强的信息，占住模型最宝贵的注意力。</span>
 
-这也是为什么很多 AI 系统上线后，问题并不出在模型不够聪明，而是出在上下文里混进了太多低信号内容。
+所以很多 AI 系统上线以后表现不稳，问题不一定出在模型不够聪明，很多时候就是上下文里混进了太多低信号内容。
 
 ---
 
@@ -102,13 +105,13 @@ Anthropic 官方的说法是，它是**从 Prompt Engineering 演进来的**[《
 
 它里面最核心的东西是 **Self-Attention（自注意力机制）**。
 
-用一句话说：模型在生成每一个词的时候，会同时"扫一眼"上下文窗口里所有其他的词，计算"哪些词跟当前词最相关"，然后根据这个相关性来决定输出。
+粗暴一点讲，模型在生成每一个词的时候，都会去“扫一眼”上下文里别的词，算一遍“谁跟我现在最相关”，再决定往下吐什么。
 
 这意味着：**模型的能力，很大程度上取决于窗口里装了什么**。
 
 你给它看的内容越准确、越有结构、越聚焦，它的注意力就越能集中在真正重要的部分。你塞一堆无关信息进去，它不会自动过滤掉，它只会"稀释"它的注意力。
 
-所以"上下文工程"这件事，在模型层面的物理底层，就是在跟 Self-Attention 机制博弈。
+所以“上下文工程”这件事，如果往底层追，本质上就是在跟 Self-Attention 的工作方式打交道。
 
 ---
 
@@ -116,7 +119,7 @@ Anthropic 官方的说法是，它是**从 Prompt Engineering 演进来的**[《
 
 很多人一提上下文工程，第一反应还是去改 System Prompt。
 
-这当然要改，但问题通常不是“写得不够长”，而是**写得不在正确高度**。
+这当然要改，但我现在觉得，问题通常不是“写得不够长”，而是**写得那个劲儿不对**。
 
 我现在更认同一个判断：好的系统提示词，应该在“规则足够清楚”和“保留模型推理空间”之间找到平衡。
 
@@ -125,7 +128,7 @@ Anthropic 官方的说法是，它是**从 Prompt Engineering 演进来的**[《
 - 写成 if-else 说明书，模型像被绑住手脚，遇到复杂情况反而不会变通
 - 写得过于抽象，只说“请你专业、严谨、友好”，基本等于没说
 
-更靠谱的做法是把系统提示词拆成几个清晰区块，比如：
+我现在更倾向于把系统提示词拆成几个清楚的区块，比如：
 
 - 背景信息：这个 Agent 是干什么的
 - 目标：这次任务最终要达成什么结果
@@ -133,7 +136,7 @@ Anthropic 官方的说法是，它是**从 Prompt Engineering 演进来的**[《
 - 工具说明：什么时候该调用什么工具
 - 输出要求：最后结果要长什么样
 
-你会发现，这其实已经不是“写一句提示词”，而是在设计一个小型运行环境。
+你会发现，这时候你做的已经不只是“写一句提示词”了，而是在给模型搭一个小型运行环境。
 
 ---
 
@@ -141,7 +144,7 @@ Anthropic 官方的说法是，它是**从 Prompt Engineering 演进来的**[《
 
 现在很多 AI 应用都在做 RAG（检索增强生成）——就是把一堆文档切片，存进向量数据库，等用户提问时捞出相关片段塞给模型。
 
-这条路方向没错，但有一个很隐蔽的问题：**文档切片会丢掉背景信息**。
+这条路当然没错，但里头有个很容易被忽略的问题：**文档一切片，背景信息很容易丢。**
 
 举个例子：你有一份技术文档，里面有一段话：
 
@@ -149,11 +152,11 @@ Anthropic 官方的说法是，它是**从 Prompt Engineering 演进来的**[《
 
 这句话单独拿出来是完整的，但如果你不知道这是在说"内网服务调用"而不是"公网 HTTP 请求"，这条建议可能直接坑掉你。
 
-Anthropic 在 2024 年提出了 **Contextual Retrieval**[《Contextual Retrieval》](https://www.anthropic.com/news/contextual-retrieval) 来解这个问题。方案的核心是：
+Anthropic 在 2024 年提出了 **Contextual Retrieval**[《Contextual Retrieval》](https://www.anthropic.com/news/contextual-retrieval) 来解这个问题。核心思路其实不复杂：
 
 在切片存储之前，先让模型给每个片段加一段 **"上下文注释"**，说明它来自哪个文档、属于哪个章节、要解决什么问题。然后把这个带注释的片段再做向量化。
 
-这样检索出来的内容，就不只是一句话，而是"一句话 + 它所在的语义背景"，命中质量会好很多。
+这样检索出来的内容，就不只是一句话，而是“一句话 + 它原本待着的语义背景”，命中质量会明显好一些。
 
 配合 **BM25 关键字检索**（而不是单纯依赖语义向量），精确度进一步提升。
 
@@ -163,7 +166,7 @@ Anthropic 在 2024 年提出了 **Contextual Retrieval**[《Contextual Retrieval
 
 ## 七、真正有用的方式，不是预加载全部，而是按需取用
 
-很多系统早期都会走一条很自然的路：既然上下文重要，那我就尽量多塞一点。
+很多系统在早期都会很自然地走一条路：既然上下文重要，那就多塞一点。
 
 比如：
 
@@ -172,12 +175,12 @@ Anthropic 在 2024 年提出了 **Contextual Retrieval**[《Contextual Retrieval
 - 检索结果 top 10 全塞进去
 - 工具执行日志原样全塞进去
 
-这样做一开始看着“信息很全”，但很快就会遇到两个问题：
+一开始看起来确实会有一种“信息很全”的安全感，但很快就会遇到两个问题：
 
 1. 模型越来越贵  
 2. 模型越来越乱
 
-更成熟的做法其实是 **Just-in-time context**，也就是“即时上下文”策略。
+更像样一点的做法，其实是 **Just-in-time context**，也就是“即时上下文”。
 
 它的思路是：**默认只保留索引、摘要、标识符，真正需要的时候再去取原文。**
 
@@ -190,7 +193,7 @@ Anthropic 在 2024 年提出了 **Contextual Retrieval**[《Contextual Retrieval
 
 然后让它在任务执行过程中，通过检索、搜索、读取工具，一步步把真正需要的信息拿进来。
 
-这种方式本质上是在做“渐进式披露”。模型不是一上来就看到整个图书馆，而是先拿到目录，再决定翻哪几页。
+这种方式本质上是在做“渐进式披露”。不是一上来把整个图书馆砸给模型，而是先把目录递给它，再让它决定该翻哪几页。
 
 这比一次性预加载所有材料，更接近人类真正工作的方式。
 
@@ -198,9 +201,9 @@ Anthropic 在 2024 年提出了 **Contextual Retrieval**[《Contextual Retrieval
 
 ## 八、长任务为什么特别容易翻车？因为上下文会被历史污染
 
-上面说的 Contextual Retrieval 解决的是"单次检索"的质量问题。但如果放到更复杂的 Agent 场景里，还有另一个维度：**上下文不是一开始就完整的，它是在任务执行过程中逐渐积累的**。
+上面说的 Contextual Retrieval，主要解决的是“单次检索”的质量问题。但到了更复杂的 Agent 场景里，还会多出另一个麻烦：**上下文不是一开始就完整的，它是任务跑着跑着一点点堆起来的**。
 
-多步 Agent 工作流最麻烦的地方，不是某一步做错，而是前面做过的所有事，都会变成后面的上下文负担。
+多步 Agent 工作流最烦人的地方，不一定是某一步直接做错，而是前面做过的所有事，最后都会变成后面的上下文负担。
 
 比如一个任务跑了二十几步之后，上下文里可能已经混着：
 
@@ -211,7 +214,7 @@ Anthropic 在 2024 年提出了 **Contextual Retrieval**[《Contextual Retrieval
 
 这时候问题就不是“窗口够不够”，而是**历史信息正在污染当前决策**。
 
-所以长周期任务里，上下文工程通常会用到三类策略：
+所以长周期任务里，通常就得想办法处理这件事。常见做法大概有三类：
 
 **① 压缩（Compaction）**
 
@@ -225,13 +228,13 @@ Anthropic 在 2024 年提出了 **Contextual Retrieval**[《Contextual Retrieval
 
 把特别耗 token 的探索任务丢给独立子智能体去做，让它在自己的“干净窗口”里完成搜索、归纳，再把浓缩后的结论返回主智能体。
 
-这三件事本质上都在解决同一个问题：**别让历史细节持续污染当前判断。**
+这三件事，本质上都在解决一个问题：**别让历史细节一直赖在窗口里，持续污染当前判断。**
 
 ---
 
 ## 九、Anthropic 的工程实践：XML 标签、工具边界和 Prompt Caching
 
-具体到怎么组织上下文，Anthropic 在他们的工程实践里[《Effective context engineering for AI agents》](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents) 给了几个很实用的抓手：
+具体到工程实践，Anthropic 在这篇文章里[《Effective context engineering for AI agents》](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents) 给了几个我觉得挺接地气的抓手：
 
 **① XML 标签**
 
@@ -253,7 +256,7 @@ Anthropic 在 2024 年提出了 **Contextual Retrieval**[《Contextual Retrieval
 </user_query>
 ```
 
-这不是魔法，就是**把结构显式化**，让模型不用猜。
+这玩意儿不是什么魔法，说白了就是**把结构摆明白**，别让模型自己猜。
 
 **② 工具边界要清楚**
 
@@ -268,7 +271,7 @@ Anthropic 在 2024 年提出了 **Contextual Retrieval**[《Contextual Retrieval
 
 那别说模型，人都得先愣一下。
 
-工具其实是模型和外部世界的契约。契约越清楚，模型越稳定；契约越暧昧，决策就越容易发散。
+我现在越来越觉得，工具其实就是模型和外部世界的契约。契约越清楚，模型越稳；契约越含糊，它越容易瞎试。
 
 **③ Prompt Caching（提示词缓存）**
 
@@ -276,7 +279,7 @@ Anthropic 在 2024 年提出了 **Contextual Retrieval**[《Contextual Retrieval
 
 Prompt Caching 允许你把这段内容缓存在 API 层，后续调用直接复用，不重复计算。
 
-这是一个纯工程优化，但它非常关键——**它让"维持一个丰富的长期上下文"在成本上变得可行**。
+这事看起来像纯工程优化，但很关键。因为它会直接决定：**“长期带着一大坨稳定上下文工作”这件事，在成本上到底能不能成立。**
 
 ---
 
@@ -284,7 +287,7 @@ Prompt Caching 允许你把这段内容缓存在 API 层，后续调用直接复
 
 在 OpenAI 前首席科学家 Andrej Karpathy 的一个演讲里[《Software Is Changing (Again)》演讲](https://www.youtube.com/watch?v=yIPgptGZmDY)，他把上下文窗口比作大模型的"有限内存"。
 
-这个比方很直接：
+这个比方我觉得挺好懂：
 
 模型本体里存的是"知识"，但它在干活时看到的，只有上下文窗口里的内容。超出窗口的东西，它看不见，也不存在。
 
@@ -296,7 +299,7 @@ Prompt Caching 允许你把这段内容缓存在 API 层，后续调用直接复
 
 根本原因都一样：**窗口装不下了，或者装的东西不对**。
 
-上下文工程要做的，就是在这个有限的空间里，把最该出现的东西，用最合适的方式装进去。
+上下文工程要做的，说到底就是在这个有限空间里，把最该放进去的东西，用合适的方式放进去。
 
 ---
 
@@ -309,28 +312,28 @@ Prompt Caching 允许你把这段内容缓存在 API 层，后续调用直接复
 | **Agentic Workflow** | 动态上下文 / 外部记忆 / 多步传递 | 如何在多轮任务里持续维护有效上下文 |
 | **Karpathy** | Context Window / Working Memory | 上下文为什么像“临时内存”，以及为什么会忘事 |
 
-这四个角度拼起来，你会发现 Context Engineering 其实横跨了四层：
+把这四个角度放在一起看，我自己现在的理解是，Context Engineering 其实横跨了四层：
 
 - 模型层：注意力到底怎么分配
 - 检索层：拿进来的资料到底准不准
 - 工作流层：多步任务怎么传递状态
 - 工程层：成本、延迟、缓存、工具契约怎么控制
 
-也正因为它跨层，所以它不是一个“写提示词的小技巧”，而是 AI 系统设计本身。
+也正因为它跨层，所以它不是一个“提示词小技巧”，而是 AI 系统设计里绕不过去的一部分。
 
 ---
 
 ## 十二、我目前的几个实际感受
 
-老实说，我学这块内容之前，犯过不少低级错误：
+老实说，我自己学这块之前，踩过的坑还真不少：
 
-1. **把所有背景信息一股脑塞进 System Prompt**，然后发现模型越来越"飘"。后来才明白：不是信息越多越好，是**相关信息越精准越好**。
+1. **把所有背景信息一股脑塞进 System Prompt**。当时总觉得“多给一点总没错”，结果就是模型越来越飘。后来才明白，不是信息越多越好，是**相关信息越准越好**。
 
-2. **以为 RAG 只是检索 + 拼接**，直接切片存向量就完事了。后来真碰到上下文断裂的 bug 才明白：检索出来的片段需要"知道自己是谁"。
+2. **以为 RAG 就是检索 + 拼接**。直接切片、存向量、捞出来就完事。后来真碰到上下文断裂的问题，才意识到：片段不能只被捞出来，它还得“知道自己是谁、从哪来”。
 
-3. **把 Prompt Engineering 等同于 Context Engineering**，以为把问题问好了就够了。后来才意识到在 Agent 场景里，问题怎么问已经排在"信息怎么组织"后面了。
+3. **把 Prompt Engineering 和 Context Engineering 混在一起**。一开始总觉得问题问对了就行，后来才发现，一到 Agent 场景里，“信息怎么组织”很多时候比“问题怎么问”更靠前。
 
-4. **误以为长上下文天然更强**。后来越做越发现，长上下文只是给了你“有机会放更多东西进去”，但如果没有筛选、压缩、分层和按需取用，它反而更容易把模型带偏。
+4. **误以为长上下文天然更强**。后来越做越发现，长上下文只是给了你“可以多放点东西进去”的机会，但如果没有筛选、压缩、分层和按需取用，它反而更容易把模型带偏。
 
 <span class="highlight-text">说白了，上下文工程是软件工程在 AI 时代的一个延伸——你不只是在写 Prompt，你在设计信息流。</span>
 
@@ -338,13 +341,13 @@ Prompt Caching 允许你把这段内容缓存在 API 层，后续调用直接复
 
 ## 结尾
 
-这篇是我的学习整理，没有深入展开代码实现，主要是先把概念层面的骨架搭清楚。
+这篇还是偏学习整理，没有往代码实现那层展开太多，主要先把我自己脑子里这套概念骨架搭起来。
 
-如果你也在做 AI 应用，或者在带团队搭 AI 系统，我现在会更建议你把注意力放在这几个问题上：
+如果你也在做 AI 应用，或者已经开始搭 Agent / AI 系统，我现在会更建议先盯住这几个问题：
 
 1. 你给模型的，到底是不是“最小但高信号”的信息？
 2. 你的检索结果，是不是保留了足够的背景语义？
 3. 你的多步任务里，有没有一套压缩、记忆、续跑机制？
 4. 你的工具和提示词结构，是否清晰到让模型不用猜？
 
-如果这几个问题都没想明白，模型即使再聪明，系统也很容易忽好忽坏。
+这些问题如果没想清楚，模型就算再聪明，系统表现也还是会一阵一阵的。

source/_posts/从零到-RAG-系统：成功与失败.md

@@ -1,83 +0,0 @@
----
-title: 从零到 RAG 系统：成功与失败
-author: Gamehu
-date: 2026-03-28 15:59:29
-categories:
-  - 技术
-tags:
-  - RAG
-  - LLM
-  - 向量数据库
-  - 工程实践
----
-
-A few months ago I was tasked with creating an internal tool for the company's engineers: a Chat that used a local LLM. Nothing extraordinary so far. Then the requirements came in: it had to have a fast response, I insist... fast!, and... it also had to provide answers about every project the company has done throughout its entire history (almost a decade). They didn't want a traditional search engine, but a tool where you could ask questions in natural language and get answers with references to the original documents. With emphasis on providing information from OrcaFlex files (a simulation software for floating body dynamics, cables, etc., widely used in the offshore industry). It already seemed complex, but it was confirmed when I was given access to 1 TB of projects, mixed with technical documentation, reports, analyses, regulations, CSVs, etc. The emotional roller coaster had begun.
-
-I'll tell you upfront that it was neither a quick nor easy process, and that's why I'd like to share it. From the first attempts, mistakes, to the final architecture that ended up in production. I also want to highlight that I had never done anything similar before and didn't know how a RAG worked either.
-
-We'll go problem by problem, and the solution I applied to each one.
-
-## Problem 1: selecting the right technology
-
-The first step was to define the stack.
-
-I needed a local language model, without relying on external APIs, for confidentiality reasons. Ollama emerged as the most mature and easy-to-use option for running LLaMA models locally. I tried several embeddings, and nomic-embed-text offered good performance and quality for technical documents.
-
-Next was a RAG engine to orchestrate the document indexing process, embedding generation, vector database storage, and queries. Without it, no matter how fast the language model is, we couldn't retrieve relevant information from the documents. Think of it like a book's index: without it, you'd have to read the entire book to find the information you need. And with a good index, you can go straight to the right page. I'll call this process indexing for simplicity, although it's really a vectorization and indexing process.
-
-After some research, I found a mature open source framework called LlamaIndex.
-
-The language I'd use would be Python, I could list many reasons, but the most important one is that I feel comfortable and productive with it. Additionally, both Ollama and LlamaIndex have excellent Python SDKs.
-
-I was ready to start building the software. I wrote my first scripts to run vector tests on the RAG system and do some query experiments. It worked really well with very little code. I thought it would be a project of a few weeks. I couldn't have been more wrong.
-
-The next step was working with the actual documents. Hold on tight, it's going to be a bumpy ride!
-
-## Problem 2: the document chaos
-
-My file source was a folder on Azure with a massive amount of technical documents: hundreds of gigabytes, thousands of files, various formats, with no organization or structure beyond the folder hierarchy. Every data engineer's dream (note the irony).
-
-I cracked my knuckles, set the RAG output to save to disk, and launched my first script. LlamaIndex ended up overflowing my laptop's RAM within minutes, choking my OS until everything froze. I tried many configurations, caching systems, and other strategies, but at some point my machine always died.
-
-After debugging, I discovered it was processing huge files that contributed nothing: videos, simulations, backup files... Documents that added nothing to a RAG system, but that LlamaIndex tried to process as if they were text. If a file weighed several gigabytes, the system tried to load it entirely into memory for processing, which was suicide.
-
-I added a filtering system to the pipeline that excluded files by extension and by name patterns (simulation files, numerical results, etc.).
-
-| Category | Excluded extensions |
-|----------|---------------------|
-| Video | mp4, avi, mov, mkv, wmv, flv, webm, m4v, mpg, mpeg, 3gp, mts... |
-| Images | jpg, jpeg, png, gif, bmp, tiff, svg, ico, webp, heic, psd... |
-| Executables | exe, dll, msi, bat, sh, app, dmg, so, jar... |
-| Compressed | zip, rar, 7z, tar, gz, bz2, xz |
-| Simulation | sim, dat |
-| Temporary | tmp, temp, cache, log, swp, pyc, crdownload, partial... |
-| Backups | bak, 3dmbak, dwgbak, dxfbak, pdfbak, stlbak, old, bkp, original... |
-| Email | msg, pst, eml, oft |
-
-I also removed files that were expensive to process and didn't add value either, like CSVs, JSONs, among others. On the other hand, I converted PDF, DOCX, XLSX, PPTX, etc. files to plain text so LlamaIndex could process them without issues.
-
-The result was a 54% reduction in the number of files to index. And of course, my RAM stopped exploding.
-
-I could finally start indexing without fear.
-
-## Problem 3: indexing 451GB of documents without dying in the attempt
-
-A RAG involves creating a vector index file containing document embeddings. Vectors are numerical representations of documents that allow measuring their similarity. LlamaIndex has a simple system you can configure with a couple of lines. You just point it to the directory and it takes care of storing all the information inside in JSON format. It's really convenient, works well, unless you're dealing with hundreds of gigabytes of documents. The system became unmanageable: every time the service restarted, it had to reprocess all documents from scratch, which could take days. Also, the default format is not optimal for large searches (JSON).
-
-I added a checkpoint system to save indexing progress. Every time a problem occurred, I wouldn't lose all progress, but could resume from the last processed file. However, data got corrupted, it was error-prone, and very slow. I was facing a bottleneck I couldn't overcome.
-
-After many trials and errors, and reading more about it, I decided to make the leap to a dedicated vector database: ChromaDB. An open-source database (Apache-2.0 license) for storing and querying vectors. Not to be confused with the Chrome/Chromium browser. ChromaDB is an abstraction layer that stores on top of a traditional database, I configured SQLite, and offers specific functionalities like similarity searches, clustering, etc.
-
-The change was radical and instant. Indexing went from being a monolithic process that loaded everything into memory to a batch pipeline that processed 150 files at a time, generated their embeddings, and stored them directly in ChromaDB. This allowed indexing the 451GB of documents across multiple sessions, with checkpoints, without losing progress on interruptions, without corrupted data. Additionally, it was really easy to back up and restore the index in case of failures (just copy the SQLite file).
-
-The system was ready. With a quick benchmark, I discovered I would need several months to index all the content with my laptop. Now the bottleneck was neither the RAM, nor the indexing system, nor the files, but the GPU.
-
-## Problem 4: my graphics card is not a rocket
-
-My laptop has an integrated graphics card. Processing 500 MB of documents by CPU takes 4-5 hours, not good numbers. I absolutely needed a powerful GPU. In a follow-up meeting, it was decided to rent me a virtual machine with an NVIDIA RTX 4000 SFF Ada, which has 20GB of VRAM. These kinds of rentals are not exactly cheap. Now I was working under more pressure.
-
-I modified my containers and the system was optimized to take advantage of the GPU. I launched my script. After several weeks, between 2 and 3, the indexing process finished without failures. 738,470 vectors, 54GB of index in ChromaDB, and a RAG system ready to answer questions. I copied the ChromaDB database, a SQLite file, to my local machine and that was it. To the relief of my Sysadmin and Project Manager, we could finally shut down the virtual machine. The cost was 184 euros on Hetzner, not cheap.
-
-It was time to build the backend and frontend.
-
-##

source/_posts/工作.md

@@ -25,7 +25,6 @@ tags: 求职
 Gamehu
 
 联系方式：
-电话：18515068121
 邮箱：gamehu@yeah.net
 Wechat：GamehuDB
 Twitter：https://x.com/Gamehu520
@@ -55,7 +54,6 @@ Code regards,
 Gamehu
 
 Contact:
-Phone: 18515068121
 Email: gamehu@yeah.net
 WeChat: GamehuDB
 Twitter: https://x.com/Gamehu520

source/_posts/慢下来：关于-AI-Agent-编程的反思.md

@@ -1,112 +0,0 @@
----
-title: 慢下来：关于 AI Agent 编程的反思
-author: Gamehu
-date: 2026-03-27 04:06:34
-categories:
-  - 思考
-tags:
-  - AI
-  - Agent
-  - 编程哲学
-  - 软件工程
----
-
-Mario Zechner（libGDX 作者）最新文章《Thoughts on slowing the fuck down》对当前 AI Agent 编程热潮提出了尖锐反思。文章指出：**我们正用 Agent 以惊人的速度给自己挖坑**。
-
-## 现状：一切都在崩坏
-
-作者观察到，软件质量正在加速下滑：
-- 98% 正常运行时间成为常态（而非例外）
-- 用户界面出现最奇怪的 bug
-- AWS 被曝 AI 导致故障，随后发布 90 天整改令
-- Windows 质量下滑，微软官方承认并承诺改进
-
-**核心问题**：声称 100% 代码由 AI 生成的公司，持续产出质量最差的产品。
-
----
-
-## 错误的工作方式
-
-### 1. 复合错误（Compounding Booboos）
-
-**人类 vs Agent 的关键差异：**
-
-| 人类 | Agent |
-|------|-------|
-| 犯错几次后学会不再犯 | 持续重复相同错误 |
-| 是瓶颈，每天只能引入有限错误 | 无瓶颈，几小时生成 2 万行代码 |
-| 痛苦到达阈值会修复 | 无痛感，直到为时已晚 |
-
-**结果**：无害的小错误以不可持续的速度复合，形成代码库怪物。
-
-### 2. 习得性复杂性的商人
-
-Agent 是"复杂性商人"：
-- 训练数据中见过大量糟糕的架构决策
-- 被委托架构应用，结果就是 immense complexity
-- 决策永远是局部的，导致代码重复、抽象过度
-
-**惊人对比**：人类企业代码库需要数年才能达到的复杂度，2 人团队 + Agent 几周内就能达成。
-
-### 3. Agentic 搜索召回率低
-
-当代码库膨胀后，Agent 无法找到所有需要修改的代码：
-- 无论是 ripgrep、LSP 还是向量数据库
-- 代码库越大，召回率越低
-- 导致重复代码、不一致性，最终绽放为"美丽的屎花"
-
----
-
-## 正确的工作方式（作者建议）
-
-### 适合 Agent 的任务
-
-好的 Agent 任务具备以下特征：
-- ✅ 范围可限定，无需理解完整系统
-- ✅ 可闭环评估（有明确的评估函数）
-- ✅ 非关键任务（内部工具、原型）
-- ✅ 人类是最终质量关卡
-
-**反例**：Karpathy 的 auto-research 用于优化启动时间？很好！但产出的代码绝非生产就绪——评估函数只捕获狭窄指标，忽略代码质量、复杂度、正确性。
-
-### 核心建议：慢下来
-
-> "Slowing the fuck down is the way to go."
-
-**具体做法：**
-
-1. **给自己时间思考** —— 真正在构建什么、为什么
-2. **设定代码生成上限** —— 与代码审查能力匹配
-3. **手写架构定义** —— API、系统整体结构亲手写
-4. **与 Agent 结对编程** —— 而非完全委托
-5. **保持在场** —— 看到代码逐步构建，理解系统"感觉"
-
-**为什么**：
-- 摩擦让你更好理解想构建什么
-- 经验和品味在此发挥作用（当前 SOTA 模型无法替代）
-- 慢下来才能学习和成长
-
-### 最终收益
-
-- 系统和代码库保持可维护性
-- 产品带来愉悦而非 slop
-- 构建更少但正确的功能
-- 学会说"不"本身就是功能
-- 理解系统，保持 agency
-- 能修复问题，能重构优化
-
----
-
-## 关键金句
-
-> "Coding agents are sirens, luring you in with their speed of code generation and jagged intelligence."
-
-> "Your agents never see each other's runs, never get to see all of your codebase... an agent's decisions are always local."
-
-> "All of this requires discipline and agency. All of this requires humans."
-
----
-
-**原文**：https://mariozechner.at/posts/2026-03-25-thoughts-on-slowing-the-fuck-down/
-
-**作者**：Mario Zechner（libGDX 创始人）

source/resume/en.md

@@ -1,5 +1,5 @@
 ---
-title: Huantao Hu - Resume
+title: Gamehu - Resume
 date: 2025-02-22 19:31:46
 type: resume
 comments: false
@@ -9,10 +9,9 @@ comments: false
 
 | | |
 |---|---|
-| **Name** | Huantao Hu |
+| **Name** | Gamehu |
 | **Experience** | 13 years |
-| **Email** | gamehu@yeah.net |
-| **Phone** | +86 18515068121 |
+| **Email** | <gamehu@yeah.net> |
 | **Blog / WeChat Official Account** | [gamehu.run](https://gamehu.run) / Gamehu |
 | **Education** | B.S. Computer Science, Chongqing University of Science and Technology |
 

source/resume/index.md

@@ -1,5 +1,5 @@
 ---
-title: 扈焕涛 - 简历
+title: 简历
 date: 2025-02-22 19:31:46
 type: resume
 comments: false
@@ -9,10 +9,9 @@ comments: false
 
 | | |
 |---|---|
-| **姓名** | 扈焕涛 |
+| **姓名** | Gamehu |
 | **工作年限** | 13年 |
-| **邮箱** | gamehu@yeah.net |
-| **电话** | 18515068121 |
+| **邮箱** | <gamehu@yeah.net> |
 | **博客/公众号** | [gamehu.run](https://gamehu.run) / Gamehu |
 | **学历** | 本科 · 重庆科技大学 · 计算机科学与技术 |