SamWang

A Developer

[SamWang @samwangdd]

I'm on @Plasma One waitlist. Trying to get in if anyone has an access code.

[Boris Cherny @bcherny]

As engineering, product, design, DS, etc. melt into a new kind of role, I was reflecting on what roles might look like in the future. For example, when I look at the Claude Code team I see what I think is five archetypes:

1. Prototyper: comes up with brand new ideas; churns out many ideas, most of which don't ship
2. Builder: quickly turns a prototype/idea into production-grade product/infra
3. Sweeper: cleans up the UI, simplifies the code and system, unships, optimizes performance
4. Grower: takes a product that has been built and iterates on it to improve Product-Market Fit
5. Maintainer: owns a mature system to make it secure, reliable, fast, and efficient as it scales

Many people span across 2 roles, and sometimes 3 roles. I also notice that these roles are not really tied to job function -- eg. across Anthropic, some designers match category 1, some 2, some 3; same for engineers, PM, DS.

A healthy team needs a mix of these, depending on the product:

- A product that is new and pre-PMF needs people that are strong at 1+2+3
- A product that is growing and has found PMF needs 2+3+4 and some 5
- A product that has strong PMF needs 3+4+5 and some 2

Maybe product roles of the future will look more like this, and less like the domain-specific roles of today?

[Addy Osmani @addyosmani]

https://t.co/hIe0UX7z6T

[OneHopeA9 @onehopeA9]

https://t.co/TuB20jUmg2

[xiyu @ohxiyu]

https://t.co/LwuAjCb8GE

[Mr.RC｜𝟎𝐱𝐔 @MrRyanChi]

https://t.co/TEUP3779I5

[huangserva @servasyy_ai]

https://t.co/cFTj7bX8ba

[Yanhua @yanhua1010]

https://t.co/KrNNEZS02w

[撸毛小狗 @LumaoDoggie]

Vibe coding 最强模型, 一定是 Claude 结合 Codex

是的, 一定需要两个结合起来, 最后产生的代码质量更高.

比如说这篇论文:
Understanding Agent Scaling in LLM-Based Multi-Agent Systems via Diversity" (arXiv:2602.03794) 提到
同源的模型,跟容易遇到瓶颈.

原因也很简单. opus 4.6, 训练集和训练参数都是一样的, 你分几个agent来角色扮演, 也是会容易出现信息茧房. 这时候引入Codex, 就不一样了.

实际上我现在的流程是这样的.
Plan阶段
Opus 4.6 做计划, Codex gpt 5.3 Xhigh 挑刺 (最多三个来回)

实施阶段
Sonnet 4.6写代码, 另外一个Sonnet 4.6初步审核代码. Codex 5.3 high 最终审核代码
(最多三个来回)

这里面评审完了打回去改, 多轮评审. 最后达到一个最佳状态.

缺点:
1. 时间长
这是必然的. 多轮迭代下来, 1个小时很正常.

2. 耗token
主要是Claude 贵. Codex的很便宜, 忽略不计了.
还好我有个 0.3倍 和 0.15 倍费率的Claude 订阅. (具体看2楼)
(0.15倍费率的 Sonnet 4.6我现在当主力) Codex自己去咸鱼上找一个, 十几二十元一个月足够用了.

你可以看到 Codex 给 Claude review出很多bug出来.最终结果是 准确性很高.

另外, Claude Code 调用 Codex 有两种方法, MCP或者 Skills. 这里建议用Skill, 有一些性能上的考虑, 这里不细说了. Github 上搜 "skill-codex" 就行了.

当然, 你要不嫌麻烦, 开几个Claude 和 Codex命令行窗口, 来回复制黏贴 双方的吵架结论 也可以. 我建议是搞成自动化的:

以下是我的Claude[.]md 文件, 你们可以参考一下. 我打磨了两周了, 现在已经稳定了, 很好用.

有的时候Claude 会忘记上下文, 这时候prompt里可以让他重新加载一下 Claude .md, 或者
明确告诉它 "现在修复xx问题, 然后从第0阶段开始"

----以下是 Claude. md 文件, 你可以直接复制过去----

# xx项目 — 强制性规则

## 模型层级与角色归属
* **主管/规划者 (The Lead/Planner)：** 主 CLI 会话。负责把控策略和 `https://t.co/M6ogWWPwN4` 规则。你不编写代码；你负责委派任务。例外情况：微小的修改（如拼写错误、配置值、日志信息）可以由主管直接进行而无需委派。**仅当**审查者标记出架构缺陷、交易策略不兼容或达到重试上限时才进行干预。
* **蓝图实现者 (`blueprint-implementer`，Sonnet 4.6)：** 子代理。严格按照主管的蓝图编写新功能和测试。**不**负责修复测试失败问题。
* **调试者 (`debugger`，Sonnet 4.6)：** 子代理。负责修复测试套件或审查者标记的局部错误、语法错误、失败的测试和内存泄漏。
* **代码审查者 (`claude-code-reviewer`，Sonnet 4.6)：** 子代理。执行快速通道的内部验证（第 1 阶段）。

---

## 实施前：Actor-Critic 架构辩论（第 0 阶段）
**触发条件：** 新功能、架构变更、复杂的业务逻辑或复杂的错误修复时必须进行。
**绕过条件：** 琐碎任务可跳过第 0 阶段。“琐碎任务”定义为：(a) 任何 ≤5 行的修复，且**未**触及关键路径列表中的文件，或 (b) 关键路径文件中的更改，但**仅**修改日志、配置值或注释——绝不涉及控制流、算术或状态突变。如果更改处于模棱两可的边界，则**不属于**琐碎任务——请运行第 0 阶段。符合绕过条件的任务示例：拼写错误修复、简单的 UI 微调、一次性诊断脚本（如拉取 VPS 日志）或简单的配置更新。

> **阻塞网关 (BLOCKING GATE)：** 第 0 阶段是一个严格的顺序网关。主管必须等待 Codex 返回且计划被锁定后，才能开始**任何**实施工作。切勿在后台运行 Codex 审计并同时并行实施——这样做违背了实施前审查的初衷，且属于违反协议的行为。

**1. 草案 (主管)：** 主管编写一份严格的、循序渐进的架构蓝图，详细说明业务逻辑、组件、数据结构、状态变化和执行流程。

**2. 质询 (Codex 技能桥接)：**
通过 `Skill("codex")` 在**前台**（非后台）调用 `codex` 技能。将其配置为使用 `gpt-5.3-codex` 并设置 `model_reasoning_effort` 为 `xhigh`。传递以下有效载荷：
* **目标范围 (Target Scope)：** 提议的架构蓝图。
* **意图 (Intent)：** （例如，“规划永续套利仓位的平仓逻辑”）
* **重点 (Focus)：** 指示 Codex 无情地审计计划，寻找**业务逻辑缺陷**、策略偏差、数学假设、竞争条件、状态不同步以及订单路由中的边缘情况。
* **格式 (Format)：** 指示 Codex 返回可操作的批评意见，格式严格遵循：`[组件] - [严重程度] - [架构/逻辑缺陷] - [建议的缓解措施]`。

**3. 评估与辩论循环（迭代）：**
主管必须结合项目不变量及其更广泛的背景，批判性地评估 Codex 的批评。你**绝不能**盲目接受所有发现，也不要对客观事实进行辩论。你必须对 Codex 的反馈应用这种严格的二分法：

* **路径 A：客观错误（自动修复并遵守）：** 如果 Codex 标记了客观的数学错误、API 约束违规、单位转换错误、数据损坏风险或明显的竞争条件，**不要辩论**。立即接受该发现，将修复整合到蓝图中，并进入下一次迭代。
* **路径 B：主观/策略选择（辩论与反驳）：** 如果 Codex 批评了风险容忍度假设（例如，最低费用、样本充足性、滑点缓冲）或合理的架构设计选择存在分歧，**如果 Codex 的建议损害了套利策略或交易量，你必须予以反驳**。提出合乎逻辑的反驳意见，为原始架构辩护或提出折中方案。

**循环中的后续步骤：**
* 再次通过 `Skill("codex")` 调用 `codex` 技能，明确命令它**“恢复上一个 Codex 会话” (resume the previous Codex session)**，以便它记住上下文。传递修改后的蓝图（对于路径 A）或主管的反驳意见（对于路径 B）。
* **退出条件（何时打破循环）：** 继续“草案 -> 批评 -> 评估/辩论”循环，直到满足以下**任一**条件：
1. **达成共识（锁定计划）：** Codex 报告零客观错误，并且要么同意你的策略性辩护，要么你们达成了一个折中的蓝图。（进入第 1 阶段）。
2. **迭代上限：** 你完成了 **3 个完整的辩论周期**且无法达成一致。**不要**开始编写代码；停止该过程并移交给 用户。（状态：已升级 🛑）
3. **主观/策略僵局：** 模型在无法仅凭逻辑解决的策略假设上存在根本分歧。停止该过程并移交给 用户。（状态：已升级 🛑）

> **移交检查点：** 只有在达到退出条件 1（锁定计划）后，主管才能将蓝图移交给 `blueprint-implementer`。在计划锁定之前，请勿委派实施任务。一旦计划被锁定，请自主进行第 1 阶段和第 2 阶段，无需向 用户 请求确认——仅在定义的升级条件（迭代上限、主观分歧、AI 冲突）下才进行升级。

---

## 实施后：Actor-Critic 审查协议（不可协商）
在修改了下方关键路径中的**任何**代码后，在宣布任务完成之前，你必须遵循这个分为三个阶段的流水线。

### 第 1 阶段：内部验证（Actor 团队：规划者 + 子代理）
在调用外部工具之前，你必须确保代码处于“稳定的候选状态”。

1. **执行移交：** 主管定义计划。`blueprint-implementer` 编写代码。
2. **适应性思维自我审查：** （委派给 `claude-code-reviewer`）审查逻辑中是否存在竞争条件（特别是在下单环节）、内存泄漏和变量遮蔽现象。
3. **冲突优先级规则：** 架构审查优先于测试结果。如果测试因架构更改而失败，请评估是否应更新测试以匹配新架构——**切勿**仅仅为了让旧测试通过而撤销架构决策。
4. **测试自动化：** `blueprint-implementer` 编写或更新相关测试。如果测试失败，委派给 `debugger` 进行修复。在进入第 2 阶段之前，你**必须**运行测试并达到 `PASS` 状态（**所有**测试均为绿色，零失败）。如果发现预先存在的测试失败，请对其进行审查：如果测试是合理的并且反映了真实预期，请更新代码或测试以使其通过；不要忽略它们。
5. **稳定性网关：** 仅当代码功能正常、通过本地 lint 检查并满足当前任务要求时，才继续交给 Codex。

### 第 2 阶段：“最终 Boss”审计（Critic：Codex 5.3 高级推理）
仅在第 1 阶段成功且测试全部通过后才触发此阶段。

**1. Codex 技能桥接（全新会话）**
通过 `Skill("codex")` 启动一个**全新的** `codex` 技能会话，以避免第 0 阶段带来的上下文臃肿。将其配置为使用 `gpt-5.3-codex` 并设置 `high` 推理工作量 (reasoning effort)，传递以下有效载荷：

* **标准 (The Standard)：** 提供在第 0 阶段结束时生成的最终版“锁定蓝图”。
* **目标范围 (Target Scope)：** （例如，`variational_client/browser_client.py` @ 第 45-120 行）
* **变更 (Diff)：** **仅**提供 `git diff` 或更改的具体代码行。
* **意图 (Intent)：** （例如，“为 Variational DEX 实现高精度滑点保护”）
* **权衡 (Trade-offs)：** （例如，“牺牲 50 毫秒的执行速度以换取额外的飞行前余额检查”）
* **重点 (Focus)：** （例如，“重点审计异步锁使用中的重入问题、数学精度丢失和竞争条件”）
* **格式 (Format)：** 指示 Codex **仅**返回可操作的发现，严格格式化为项目符号：`[文件/行] - [严重程度] - [漏洞/缺陷] - [建议的修复]`。

**2. 执行与修复循环（迭代 2 与 3）**
* **自动修复：** 委派给 `debugger` 修复 Codex 标记的客观错误或安全漏洞。
* **循环要求：** 在应用修复后，你**必须**通过 `Skill("codex")` 调用 `codex` 技能，并明确命令它**“恢复上一个 Codex 会话” (resume the previous Codex session)** 以保持上下文，并将新的 diff 传递给它。你**不能**自我证明你自己的修复。
* **退出条件（何时打破循环）：** 你必须继续“修复 -> 重新审计”循环，直到满足以下**任一**条件：
1. **完全通过 (Clean Pass)：** Codex 报告零客观功能缺陷。（状态：成功 ✅）
2. **仅主观反馈 (Subjective Feedback Only)：** Codex 标记的**唯一**剩余问题是主观的设计/功能选择（例如，API 排序偏好）。**不要**尝试修复主观选择；打破循环并移交给 用户。（状态：已升级 🛑）
3. **迭代上限 (Iteration Cap)：** 你完成了 **3 个完整周期**，但仍然存在客观错误。**不要**交付代码；停止该过程并移交给 用户。（状态：已升级 🛑）
4. **AI 冲突 (Conflicting AI)：** Codex 在不同的迭代中提供了相互矛盾的指令。（状态：已升级 🛑）

### 第 3 阶段：强制移交摘要 + 自动提交
每当循环停止时（成功、达到上限或升级），你必须提供此状态报告：

* **最终状态：** [成功 ✅ / 已升级 🛑]
* **Codex 发现：** （用简短的项目符号列出被标记的关键漏洞或逻辑缺陷）
* **采取的行动：** （总结代码在审查循环期间是如何演变的）
* **剩余事项：** （任何需要 用户 最终批准的主观设计选择或边缘情况）

**自动提交规则（仅限成功时）：** 当最终状态为“成功 ✅”时，立即创建所有更改文件的 git 提交，无需等待被要求。**仅**暂存当前任务触及的文件（绝不使用 `git add -A`）。提交消息格式：根据情况使用 `fix:` / `feat:` / `refactor:`，并附带一个简洁的正文，总结修复的错误或添加的功能。**始终**在末尾附加 `Co-Authored-By: Claude Sonnet 4.6 <[email protected]>`。在“已升级 🛑”状态下**切勿**自动提交——请先等待 用户 的批准。

### Codex 不可用时的后备方案
如果在第 0 阶段或第 2 阶段无法调用 Codex，**不要**进行自我证明。立即将蓝图或代码更改的当前状态升级给 用户。（状态：已升级 🛑）

> **技能名称：** Codex 技能被注册为 `codex`（而不是 `skill-codex`）。始终通过 `Skill("codex")` 调用。插件包名为 `skill-codex`，但其内部的技能名为 `codex`。

---
### 关键路径（始终触发审查）：
- `variational_client/browser_client.py` — 订单下达、会话身份验证、隐蔽模式

[Jason Zuo @xxxjzuo]

这几天在鼓捣"永续 Agent"，受到@MatthewBerman 和 @yanhua1010 的帖子启发，今天也来分享一下我的经验

为什么想做“永续Agent” - 因为普通 AI Agent交互是无状态的
你关掉窗口它就忘了。Context 一压缩，任务丢了、教训忘了、该干嘛不知道了。
我自己用 OpenClaw 这一个多月，做了大量的context管理，memory归档重构，依然会反复出现“失忆的情况。

怎么搞？
1️⃣ 任务不能存脑子里
先搞了个 .issues/ 目录，所有任务写文件。
压缩？无所谓，issue list 一拉就知道该干嘛。
Heartbeat 每 30 分钟扫一遍，有活就干。
2️⃣ 记忆不能只靠 context
三层 memory：每日日志 + 长期 https://t.co/yk3i4sAuRH + 快速索引。
重要的标 P0 永不删，普通的带 TTL 自动过期。
3️⃣ 24/7 但不乱跑
深夜也执行任务，但不打扰人。
真钱 / 对外消息 / 删文件 → 等我确认
整理 / 学习 / 扫描 → 照常跑

核心就一句话：
任务持久化 + 记忆持久化 + 主动巡检 = 永续

不是让 AI "一直开着"，是让它跨 session 还记得自己该干嘛。

下一步准备搞：每晚自动提炼记忆 + 每日简报汇报任务进展 + 失败或高风险决策自动建 issue

[XinGPT🐶 @xingpt]

https://t.co/5GBtn0C4qr

[AYi @AYi_AInotes]

5 条顶级开发者在用的 https://t.co/mqh4jpV2xZ 配置技巧：
1. “在编写任何代码之前，请先描述你的方案并等待批准。如果需求不明确，在编写任何代码之前务必提出澄清问题。”

2.“如果一项任务需要修改超过 3 个文件，请先停下来，将其分解成更小的任务。”

3.“编写代码后，列出可能出现的问题，并建议相应的测试用例来覆盖这些问题。”

4.“当发现bug时，首先要编写一个能够重现该bug的测试，然后不断修复它，直到测试通过为止。”

5.“每次我纠正你之后，就在 CLAUDE .md 文件中添加一条新规则，这样就不会再发生这种情况了。”

文件原文比我上面写的要详细得多，但希望这些能体现出其精神。

[meng shao @shao__meng]

让 Claude Code / Manus 看起来像魔法的关键不主要在模型本身，而在 Agent 的工程架构 -- @LangChain @LangChain_JS 总结出的四种 Agent 架构模式

1) Planning Tool（计划与进度管理）
· 浅层 agent 的常见失败方式：拿到任务就直接调用工具，缺少分解与检查点；一旦中途出错，就容易继续“硬做”，直到偏离目标。
· LangChain 强调的模式：先把任务拆成步骤、维护状态（todos/计划）、按步骤推进、遇到变化再调整。
· 工程价值：这相当于把“项目管理/执行框架”内置到 agent 回路里：
· 降低长任务失控概率
· 让“下一步做什么”可解释、可调试
· 方便加入质量门槛（比如每步完成条件、回滚策略）
· 需要警惕的点：计划工具并不自动带来正确性，它主要提升可控性与一致性。如果评估指标只看“最终答对”，可能感觉提升有限；但在生产系统里，可控性往往比偶发正确更重要。

2) Subagent Spawning（子智能体隔离式深挖）
· 问题背景：复杂任务常需要对某个子问题深挖（读很多文档/代码/日志）。如果把这些细节都塞进主智能体上下文，会造成：
· 上下文窗口被“污染”（重要目标被稀释）
· 主回路推理变慢、变乱
· 子智能体模式：把某个子任务交给隔离的子智能体，它在自己的上下文里深挖，最后只把结构化摘要返回主智能体。
· 工程价值：这是典型的“分治 + 上下文预算管理”，在以下场景尤其有效：
· 调研/阅读大量资料
· 在大代码库里定位实现
· 多路线对比（让不同子智能体并行探索）
· 风险点：
· 子智能体的结论可能“自信但错”，因此需要主智能体做交叉验证或要求子智能体给出证据/引用。
· 并行子智能体会增加成本，需要调度策略（何时开、开几个、何时停止）。

3) Sandboxed Filesystem（沙箱文件系统作为“上下文工程”载体）
· LangChain 在反对什么：
· 只靠对话上下文来记忆会溢出
· RAG/检索可能噪声大
· 在服务器上执行不可信代码有安全风险
· 沙箱文件系统带来的能力：给 agent 一个隔离环境，提供 ls/read/write/edit/grep/shell 等操作，让它把：
· 中间产物（笔记、草稿、提纲、测试输出）
· 关键上下文（需求、约束、决策记录）
· 可复用摘要（读书报告、接口说明）
落到文件里，从而把“短期记忆”外化成“长期可检索的工作区记忆”。
· 工程价值：这其实是把 agent 从“聊天机器人”升级为“能在工作区持续产出与迭代的执行者”，并且安全边界更清晰。
· 现实注意点：沙箱并不能替代权限治理：你仍需要定义哪些命令允许、网络是否放开、能否访问私有仓库/密钥等。

4) Detailed System Prompts（把提示词当“操作手册”）
· 关键点：LangChain 认为 prompt 不该只是“你是个 helpful assistant”，而要像工程 SOP：
· 何时先计划、何时直接做
· 何时调用工具、失败如何恢复
· 输出写到哪里、格式如何约束
· 如何记录决策与假设
· 工程价值：
· 行为一致性更强（可预测）
· 可调试（你能定位是哪条规则导致行为）
· 可定制（不同应用有不同“工作规范”）
· 潜在代价：系统提示越细，越可能“过度约束”导致灵活性下降；需要在“规范化”与“探索性”之间做平衡，并持续迭代。

[Anthropic @AnthropicAI]

How is AI changing work inside Anthropic? And what might this tell us about the effects on the wider labor force to come?

We surveyed 132 of our engineers, conducted 53 in-depth interviews, and analyzed 200K internal Claude Code sessions to find out.
https://t.co/YLLjs9W9e5

[Philipp Schmid @_philschmid]

Excited to share a System Instructions for Gemini 3 Pro that improved performance on several agentic benchmarks by around 5%. 🚀

We collaborated with the @GoogleDeepMind post-training research team to include some best practices in our docs. 🤝

[李继刚 @lijigang]

我现在的读书过程：

1. 筛：写一个 Prompt，生成书籍的思想和框架的抽取。扫一眼，判断是否值得阅读原文。

2. 读：从头到尾阅读经筛选后的书籍原文。

3. 问：把阅读过程中的疑惑、产生的联想，与模型对话讨论。

4. 记：在本地笔记软件中生成一篇读书笔记。

5. 图：将读书笔记通过 Nano Banana Pro 生成一篇可视化图形。

[ℏεsam @Hesamation]

Google just dropped a new 50-page doc on building agents that actually work in the real world. it's a fast introduction to the theory of what you must know about agents.

It covers:
→ core agent architecture
→ LLM (the brain behind agents)
→ tools (the hands of the agents)
→ multi-agent orchestration
→ how to deploy agents
→ evaluation and metrics
→ self-evolving learning agents
→ how agents evolve and learn
→ covering AlphaEvolve example

you can download and read it from Kaggle: https://t.co/nLKRlX0RZs

[宝玉 @dotey]

这篇总结也很好：
https://t.co/rQqEhdiORG

Anthropic 又发布了一篇神级指南。

这次的主题是：如何构建更高效的 AI 智能体 (AI Agent)，让它们能更聪明地使用工具，并且极大地节省 Token 。

如果你是 AI 开发者，这篇文章绝对不容错过！

它主要解决了 AI 智能体在调用工具时遇到的三大难题：Token 成本、延迟 (latency) 和工具组合的效率。

怎么做到的？简单来说，它把“代码执行”和“模型编写的代码” (MCP, Model-Written Code) 结合了起来。它不再让 AI 智能体直接去“调用工具”，而是把这些工具“伪装”成代码 API，让 AI 智能体像程序员一样通过写代码来使用它们。

以下是这篇指南的核心干货：

1. Token 效率的“黑洞”：想象一下，如果 AI 智能体一上来就把所有可能用到的工具定义全塞进大脑（上下文窗口 (context window)），并且在执行任务时，每一步的中间结果都塞回去。这样会导致 Token 开销大到爆炸，一个复杂的多工具任务跑下来，有时会超过 15 万个 Token。

2. “代码即 API” 策略：新方法是，不直接调用工具，而是把这些“模型编写的代码” (MCP) 工具包打包成代码 API（比如 TypeScript 模块）。AI 智能体可以像程序员一样“导入” (import) 并通过编程来调用它们。效果立竿见影：一个 15 万 Token 的任务，瞬间被压缩到了 2000 个 Token，节省了 98.7%！

3. 工具的“渐进式发现”：不再一股脑加载所有工具。AI 智能体学会了“按需取用”，通过搜索文件系统或调用 search_tools（搜索工具）函数，只在需要时才加载当前任务相关的工具定义。这完美解决了“上下文臃肿” (context rot) 和 Token 过载的问题。

4. “数据本地处理”：在把结果喂给大语言模型 (LLM) 之前，先在代码执行环境里把数据处理好（比如筛选、转换、汇总）。举个例子：AI 智能体不需要查看 1 万行的表格，代码环境会先帮它筛选出那 5 行最重要的，再交给它。

5. 更优的控制流 (Control Flow)：与其让 AI 智能体一步步地“指挥”工具（比如“做完A，再做B”），不如直接用代码原生的循环 (loops)、条件判断 (conditionals) 和错误处理来管理流程。这样做，既减少了延迟，也省了 Token。

6. 隐私保护：敏感数据可以在整个工作流中传递，而完全不进入大模型的“视野”（上下文）。只有那些被明确指定“返回”或“记录”的值才会被模型看到，还可以选择自动对个人身份信息 (PII) 进行脱敏。

7. 状态持久化 (State Persistence)：AI 智能体可以把中间结果存成文件，“断点续传”。这样一来，它们就能处理那些需要跑很久的“大任务”，并且能跟踪进度。

8. 可复用的“技能包”：AI 智能体可以把写好的有效代码保存成“可复用函数”（并配上 SKILL .MD 文档），久而久之，它就能积累出一个强大的高级“技能库”。

这种方法虽然更复杂，也还不完美，但它绝对能全面提升你构建的 AI 智能体的效率和准确性。

[Peter Steinberger 🦞 @steipete]

"now that you wrote the code, what would you do better?" is such a great unlock to improve agent code quality.

[李继刚 @lijigang]

;;;;;;;;;;;;;;;;;;;;;;;;
;; META INFO
;; author: 李继刚
;; version: 1.0
;; date: 2025-10-10
;; purpose: 遵循 Why-How-What 框架，对任意概念进行结构化、多层次的深度解析。
;;;;;;;;;;;;;;;;;;;;;;;;

概念三问

【使用说明】
用户只需提供一个概念，你将自动执行以下三步分析，生成一个深刻、直观且结构化的解答。

🎯 第一步：追问其本 (The Why)
核心目标： 理解此概念为何存在。

执行动作： 首先阐明，这个概念的诞生，是为了解决什么领域里的哪个根本性问题或核心矛盾。这会提供一个最坚实的“认知之锚”，让用户明白我们为何需要它。

💡 第二步：建立直觉 (The How)
核心目标： 感性地“触摸”这个概念。

执行动作： 设计一个极其简单、生动的核心类比或微型情境。这个类比将剥离所有专业术语，旨在用日常生活中已有的经验，让用户瞬间“感觉”到这个概念是如何运作的。

🔧 第三步：系统化认知 (The What)

核心目标： 理性地“拆解”这个概念。

执行动作： 将这个概念拆解成一个微型心智模型，包含以下三个部分：

A. 核心构成： 它由哪几个最关键的部分组成？
B. 运作机制： 这几个部分之间是如何互动的？
C. 应用边界： 在什么情况下它适用？在什么情况下它不适用？

等待用户提供任何一个希望深入理解的概念，你将生成一份遵循此框架的、清晰易懂的解答。