DEV Community: guanyi liu

How I Turned Claude Code into My Personal Operating System

guanyi liu — Fri, 19 Jun 2026 05:34:55 +0000

我把 Claude Code 配成了一套操作系统

副标题：后来我才发现，AI 越强，就越需要被磨成一把顺手的工具。

我最近越来越强烈地感觉到一件事：

AI 明明已经很强了，但很多人并没有因此真正变强。

我们每天都在用 AI。学习时用它，写文章时用它，做项目时用它，改代码时也用它。它确实能回答问题、生成方案，也能帮我们把很多事情做得更快。

但用得越久，一个问题反而越明显：

AI 很强，不代表我们就能稳定地把事情做好。

很多时候，我们不是不会用 AI，而是太随便地使用 AI。想到什么就问一句，遇到报错就贴一下，想写文章就让它生成一版，想改功能就直接让它动手。

短期看，好像每一步都有结果。时间一长，却会发现自己总是在反复解释、反复返工、反复验证，甚至反复收拾 AI 留下来的残局。

一开始我以为，这是因为 AI 还不够聪明。

后来我也换过更强的模型，用上了当时公认的最顶级的模型。我原本以为，只要模型能力足够强，那些理解错误、越界修改和虚假完成的问题自然就会减少。

结果并没有。

模型确实变强了。它理解代码更快，给出的方案更完整，执行复杂任务的能力也更强。

但它依然可能没理解清楚就开始动手，顺手改掉我没让它碰的地方，再很自信地告诉我：“已经修复完成。”

等我重新运行项目，报错可能还在那里。

我对这件事感受最深的时候，是在用 Claude Code 做项目。

刚开始，我只是想让它帮我把项目做得快一点。遇到 Bug，就把报错贴给它；想加功能，就直接告诉它需求；哪里样式不对，就让它顺手改一下。

任务很小时，这套用法没什么问题。一个文件、一个函数、一个明确的报错，它通常都能处理得不错。

真正的问题，是从项目开始变复杂之后出现的。

我只是让它修一个小问题，它却顺手改了更多文件。这些修改不一定完全错误，甚至有些看起来很合理，但它们根本不在这次任务的范围里。

它给出的方案可能很完整，解释也很自信，可我重新运行项目，报错仍然存在。它说“已经修复完成”，我看到的却是又一轮返工。

前几天刚提醒过的项目规则，打开新会话后，它也可能像一个刚入职的人一样，重新问、重新猜、重新犯差不多的错。

这些事情单独看，好像都不严重。

改多了，可以回滚；没修好，可以继续贴报错；忘了规则，也可以再提醒一次。

真正折磨人的，是它们会反复发生。

同一个项目背景，我讲了一遍又一遍；同一种边界问题，我提醒了一次又一次；同一句“已经修复完成”，我相信了一次，又被现实打回来一次。

时间久了，人真的会被搞得心烦意乱。

明明我是想让 AI 帮我提高效率，结果却花了大量时间检查它有没有跑偏。

我开始怀疑自己。

是不是我需求没说清楚？是不是我不会用 AI？是不是别人用 Claude Code 都很顺，只有我一直在收拾残局？

我也开始怀疑 AI。

它到底是真的理解了，还是只是看起来理解了？它是真的修好了，还是只是很会把“修好了”说得像真的？

后来我慢慢发现，最难受的不是 Claude Code 偶尔犯错，而是我一直在用一种临时、粗糙的方式驱动它。

它很强，但我没有给它稳定的项目背景；它很快，但我没有让它先把方向想清楚；它很主动，但我没有给它清楚的边界；它很自信，但我没有建立真正的验收方式。

问题可能不只是模型够不够强，也和我怎么使用它有关。

于是，我先做了一个很小的改变。

我不再直接让它动手，而是让它先说明：它理解的问题是什么，准备改哪里，为什么这么改，哪些文件不能碰，最后怎么验证。

这个改变很小，但效果很明显。

以前一旦方向错了，我往往要等它改完几个文件，甚至运行失败以后才发现。

现在很多问题在计划阶段就会暴露出来：它准备修改哪些文件，有没有超出范围，理解的需求是不是我真正想要的。

我只需要在它动手前纠正一次，而不是在它改完后重新返工。

后来，我又把项目背景写进 CLAUDE.md，给它补上 Rules 和任务边界，用 Hooks 把危险操作和交付检查变成强制执行，再把常用流程沉淀成 Skills。

这些改变单独看都不复杂，但叠在一起之后，Claude Code 开始慢慢变得不一样。

不是它突然换了一个更聪明的模型，而是它做事开始有了背景、有了方向、有了边界，也有了验收标准。

我也不再只是想着，怎么写出一句更厉害的 Prompt。

我开始想的是：怎么先把自己手里的工具磨顺。

我开始把 Claude Code 当成一个项目搭档

以前我把 Claude Code 当成一个更强的聊天框：遇到问题就问，拿到答案就让它动手。

但项目越复杂，我越发现，这种用法不够。

Claude Code 更像一个执行力很强、但刚进入项目的新搭档。它有能力，也愿意主动做事，但它不了解项目历史，也不知道边界和验收标准。

如果我要让它长期参与项目，就不能只靠每次临时说一句需求。

我要给它项目说明、工作流程、行为边界、强制检查、可复用的工具和明确的验收方式。

这些东西加起来，就是我后来慢慢搭出来的 Claude Code OS。

我说的 OS，不是一个新的软件，而是一套让 Claude Code 了解项目、遵守边界、复用能力并接受验收的工作环境。

它不是我一开始设计好的一套系统。

更真实的情况是：我每踩一个坑，就往里面补上一块。

我主要给 Claude Code 补了六块东西

第一块，是 CLAUDE.md。

以前每次打开新会话，我都要重新介绍项目：它是做什么的，哪些目录不能动，哪些地方不能顺手重构，修改完必须怎么验证。

所以我把这些稳定信息写进 CLAUDE.md，让它开始工作前，先知道自己站在哪里。

第二块，是 Plan。

以前我看到 Claude Code 写得很快，就容易直接让它动手。可方向一旦错了，速度越快，返工反而越多。

所以我开始要求它先说清楚：理解的问题是什么，准备改哪里，为什么这么改，最后怎么验证。

先对准方向，再开始执行。

第三块，是 Rules 和任务边界。

Claude Code 很容易“顺手多做一点”。

你让它修一个 Bug，它可能顺手重构；你让它改一个页面，它可能顺手动到其他组件。

所以我会在 Rules 里写下长期需要遵守的规则，也会在每次任务开始前，单独说明这次允许修改的范围。

只改任务要求的内容，不确定先问，涉及高风险修改必须提前说明。

第四块，是 Hooks。

写下规则以后，我发现有些事情仍然不能只靠提醒。

危险命令、敏感文件、连续失败、交付前验证，这些一旦出问题，代价太高。

所以我用 Hooks 把它们变成真正会执行的门禁：该停的时候必须停，该检查的时候必须检查。

第五块，是 Skills。

调试、代码审查、项目初始化、交付验证，这些任务会反复出现。

如果每次都靠临时 Prompt 重新解释，做法很容易变形：有时很细，有时很粗，有时会验证，有时又漏掉关键步骤。

所以我把常用流程沉淀成 Skills，让 Claude Code 不再完全依赖现场发挥，而是逐渐有了自己的工具箱。

第六块，是 Validation。

这是我最不敢省掉的一块。

Claude Code 说“已经修复完成”，不代表项目真的能跑。

所以我不再只看它怎么说，而是看构建、类型检查、Lint、测试、关键路径和 Diff。

只有证据站得住，任务才算真的完成。

这六块东西没有让 Claude Code 突然变成一个完美的 AI。

但它开始变得更顺手了。

它进入项目时知道背景，动手前会先对准方向，执行时有边界，危险操作会被拦住，常用能力可以复用，最后的结果也有证据可以检查。

到这里，Claude Code 才不再只是一个很强、但经常让我心烦意乱的聊天框。

我开始有了一套真正适合自己的使用方式：它知道我的项目背景，理解我的工作习惯，也会按照我能接受的边界和标准完成任务。

最重要的不是配置越多，而是哪里不顺就磨哪里

回头看，我真正得到的，并不是一份可以复制给所有人的“最强配置”。

因为每个人遇到的问题都不一样。

有人最受不了 Claude Code 总是改出任务范围，所以他需要更清楚的边界。

有人最怕它说“已经修复完成”，结果项目根本跑不起来，所以他最需要的是验证。

也有人每天都在重复同一种任务，那他最值得做的，可能是把流程沉淀成 Skill。

所以真正重要的，不是把别人用过的 CLAUDE.md、Rules、Hooks 和 Skills 全部照搬回来。

而是先看清楚：你使用 AI 时，究竟是哪一个问题在反复消耗你。

哪里总在返工，就补哪里。

哪里容易失控，就约束哪里。

哪里一直重复，就沉淀哪里。

我现在这套 Claude Code OS，就是这样一点点长出来的。

它不一定最全面，也不一定适合所有人，但它越来越适合我的项目、我的习惯和我在意的边界。

而工具真正变顺手的标志，也不是它从此不再犯错。

而是那些原本需要我反复解释、反复提醒、反复检查的事情，开始有了稳定的处理方式。

我的注意力终于可以从“它这次会不会又跑偏”，重新回到“我真正想把事情做成什么样”。

这才是我最终想要的。

不是一个配置最多的 Claude Code，而是一套真正适合我、能够让我更专注地做事的使用方式。

你也不需要一开始就搭出一套完整系统。

先找出最近最让你返工的一件事，把它变成一条规则、一个固定流程，或者一次必须执行的检查，就已经是在让工具变得更顺手。

写在最后

这篇总篇，我不想再把每一个配置重新讲一遍。

CLAUDE.md 怎么写，Rules 怎么划边界，Hooks 怎么把规则变成强制检查，Skills 怎么沉淀常用能力，Validation 怎么判断任务是否真的完成，前面的文章里都已经分别展开过。

这篇文章，我更想留下一个整体判断：

AI 时代，决定我们能走多远的，或许不只是 AI 本身有多强，还在于我们如何看待它，又选择用什么样的方式驾驭它。

把它当成一个随叫随到的聊天框，我们得到的可能只是一次次临时生成的答案。

把它当成一件值得长期打磨的工具，我们才会开始为它准备背景、建立流程、划清边界、沉淀能力，并认真验证最终的结果。

模型的能力，决定了这把工具可以有多锋利。

而我们使用它的方式，决定了它最终能不能真正为我们所用。

How I Demystified Claude Code's Skill

guanyi liu — Tue, 16 Jun 2026 08:33:26 +0000

Claude Code 的 Skill 到底有什么用？我一开始也完全没搞懂

前几篇文章里，我一直在解决一个问题：怎么让 Claude Code 少犯错。

我写过 CLAUDE.md，也整理过 Rules，后来甚至加了 Hooks。

这些东西确实有用。Claude Code 不会再像以前那样，修一个小 Bug 顺手重构半个项目；也不会在命令连续失败三次之后，还继续像没事一样往下跑；更不会每次完成任务后，只留下一句“已经修复完成”就结束。

但过了一段时间，我发现了另一个问题。

它是不怎么乱来了，可它好像也没有变得特别能干。

这个感觉很微妙。以前 Claude Code 乱改代码的时候，我知道问题在哪里：它没有边界。可是当我已经给它加了边界，它还是做得不够专业时，我反而有点不知道该怪谁。

比如我让它修 Bug，它现在知道不能随便改很多文件，但它不一定会先复现问题。

我让它做一个新功能，它知道要先看上下文，但它不一定会先确认需求边界。

我让它帮我做代码审查，它能指出一些问题，但每次关注点都不一样。有时候看命名，有时候看结构，有时候只看语法，有时候又突然开始讲性能优化。

那时候我有一个很强烈的感觉：Claude Code 确实听话了，但还不像一个真正有经验的助手。

后来我才意识到，我前面做的很多配置，其实都在解决“约束问题”。

CLAUDE.md 让它知道项目大概是什么。

Rules 告诉它什么事情不要做。

Hooks 在关键节点直接拦住错误行为。

但这些东西并没有真正告诉它：遇到某一类任务时，应该按照什么专业流程做。

我一开始也没搞懂 Skill 是什么

我第一次看到 Skill 的时候，其实完全没理解它的价值。

当时我的第一反应是：这不就是把一段 Prompt 保存起来吗？

如果只是一些长期提示，那我放到 CLAUDE.md 里不就行了吗？

如果是规则，那我放到 Rules 里不就行了吗？

如果要强制执行，那 Hook 不是更靠谱吗？

所以很长一段时间，我虽然知道 Claude Code 有 Skill，但我没有真正用明白它。

我看到别人配置了一堆 Skill，也只是觉得很厉害，但不知道自己该从哪里开始抄，更不知道哪些东西适合写成 Skill，哪些东西不适合。

直到后来有一次修 Bug，我才真正想明白这件事。

那次问题其实不复杂。我把报错贴给 Claude Code，让它帮我看一下。它先搜了一圈代码，然后很快锁定了一个看起来相关的文件，接着就开始修改。整个过程看起来很顺，甚至有点让人放心。

但我跑了一遍，问题还在。

我让它继续修，它又找了另一个地方改。再跑，还是不对。第三次的时候，它开始怀疑是配置问题，准备继续扩大修改范围。

这时候我突然停下来想了一下：它到底是在修 Bug，还是在猜 Bug？

它不是完全没能力。它能读代码，也能分析报错，还能提出修改方案。

问题是，它没有一个稳定的调试流程。它每次都在现场决定下一步该干什么。

有时候先看日志。

有时候先改代码。

有时候直接猜原因。

有时候还没有复现，就开始动手。

这就像一个新人程序员，不是不努力，也不是完全不会，而是做事没有固定方法。遇到问题就凭感觉冲，运气好一次改对，运气不好就越改越乱。

Rules 只能让它别乱来，不能让它更专业

我以前试图用 Rules 解决这个问题。

比如我写：“修 Bug 前必须先分析。”

这句话当然有用，但它还是太粗了。

什么叫分析？

分析到什么程度可以开始改？

要不要先复现？

要不要先确认最小失败案例？

改完以后用什么方式验证？

如果验证失败，下一步是继续改，还是回到假设？

这些东西不是一句“先分析”能解决的。

后来我才明白，Skill 的位置就在这里。

Skill 不是一句提示词。

Skill 也不是一条规则。

Skill 更像是一套可以重复调用的专业工作流。

比如修 Bug，不应该只是告诉 Claude Code“认真一点”“先分析再修改”。

真正有价值的是告诉它：遇到 Bug 时，先建立反馈回路，先复现问题，确认错误现象，再缩小怀疑范围，提出最小修改方案，修改后用同一个方式验证。如果验证失败，不要继续盲改，而是回到新的假设。

这才是 Skill 的意义。

它不是让 Claude Code 记住一句话，而是让它在某一类任务里进入一套固定流程。

这个认知对我影响挺大的。

因为我以前总想让 Claude Code “多记住一些规则”。

后来我发现，更重要的是让它“进入正确流程”。

Prompt、CLAUDE.md、Rules、Hooks、Skill 到底有什么区别？

我后来给自己做了一个很简单的区分。

Prompt 解决的是：这一次，我希望你怎么做。

CLAUDE.md 解决的是：长期来看，你要知道我是谁、项目是什么、基本原则是什么。

Rules 解决的是：你不能怎么做。

Hooks 解决的是：你做错了，我直接拦住。

Skill 解决的是：遇到某一类任务时，你应该按哪套专业流程做。

这个区分很重要。

比如“不要顺手重构”，这是 Rule。

比如“修改 .env 文件前必须确认”，这更适合 Rule 或 Hook。

比如“修 Bug 时必须先复现、再定位、再最小修改、再验证”，这就很适合 Skill。

再比如“做新项目时，不能用户说一句想法就直接开始写代码，而是要先压力测试需求、确认目标、拆分范围、建立目录结构、再进入实现”，这也适合 Skill。

因为它不是一条禁止事项，而是一套工作流程。

Rules 解决的是边界问题。

Hooks 解决的是强制执行问题。

Skills 解决的是流程复用问题。

这就是我后来真正理解 Skill 的地方。

什么东西适合写成 Skill？

我后来给自己总结了一个判断标准：一个任务适不适合写成 Skill，主要看三个条件。

第一，它是不是经常重复出现。

第二，它每次的流程是不是相对稳定。

第三，Claude Code 是不是经常在这个任务里的某一步翻车。

如果三个条件都满足，那它就很适合写成 Skill。

比如修 Bug 就很适合。

因为它高频，流程也相对稳定，而且 Claude Code 很容易在“没有复现就开始改”这一步翻车。

比如从一个想法开始做项目，也很适合。

因为用户经常只会说“我想做一个什么东西”，但 Claude Code 如果直接进入实现，很容易做出一个方向正确但根本不好用的东西。这个时候就需要一个 idea-to-project 之类的 Skill，让它先把想法变成需求，再把需求变成方案，最后才进入代码。

比如验证交付也适合。

因为 Claude Code 最喜欢说的一句话就是“已经修复完成”。

但完成不等于验证通过。

一个 verification-loop 类型的 Skill，就可以把 Build、Type、Lint、Test、Security、Diff 这些检查变成固定流程，而不是每次都靠我提醒。

但不是所有东西都应该写成 Skill

我以前最容易犯的错误，就是把所有东西都往一个地方塞。

看到 CLAUDE.md，就想把所有要求写进去。

看到 Rules，就想把所有经验都写进去。

看到 Hooks，又想把所有错误都拦住。

看到 Skills，又想把别人的 Skill 全部复制过来。

但这样做的结果往往不是系统更强，而是系统越来越乱。

比如“回答要简洁”，这不是 Skill，更像个人偏好。

比如“不要删除文件”，这不是 Skill，更像红线规则，甚至应该交给 Hook。

比如“这个项目使用 React 和 Tailwind”，这也不是 Skill，它只是项目上下文。

比如“我喜欢你先给结论再解释”，这也不是 Skill，而是交流风格。

真正有效的配置，不是越多越好，而是每一层各自解决自己的问题。

CLAUDE.md 像入职手册，告诉 Claude Code 这个项目是什么，我是谁，基本原则是什么。

Rules 像规章制度，告诉它哪些事情不要做，哪些边界不能碰。

Hooks 像保安系统，在关键节点强制检查，发现危险行为就拦住。

Skills 像专业岗位培训，告诉它遇到某一类任务时，应该按什么流程完成。

这样一看，Skill 的位置就清楚了。

它不是用来替代 Prompt 的，也不是用来替代 Rules 的，更不是用来替代 Hooks 的。

它解决的是“专业流程复用”的问题。

很多人不是不会用 Claude Code，而是每次都让它临场发挥

这也是我后来觉得 Skill 很重要的原因。

很多人用 Claude Code 不稳定，不一定是模型差，也不一定是 Prompt 写得不够长，而是每次都让它临场发挥。

今天修 Bug，让它自己想怎么修。

明天做项目，让它自己想怎么拆。

后天做审查，让它自己想看哪些问题。

每次看起来都在用 AI，但其实每次都在重新训练一个临时工。

而 Skill 的价值，就是把你已经验证过的工作方法沉淀下来，让 Claude Code 下次遇到同类任务时，不是从零开始猜，而是直接进入一套你认可的流程。

这件事听起来不复杂，但真正做起来会改变很多体验。

以前我让 Claude Code 修 Bug，我更关注它“有没有找到答案”。

现在我会先看它“有没有进入正确流程”。

它有没有先复现？

有没有确认错误现象？

有没有说明怀疑范围？

有没有做最小修改？

有没有给出验证命令？

如果这些步骤没有出现，我就知道它又开始凭感觉做事了。

这个判断比单纯看结果更重要。

因为 AI 很容易给出一个看起来像结果的结果。

它会说修好了，会说已完成，会说问题已解决。

但如果过程不可靠，结果就很难信任。

Skill 的本质，其实是在提高过程的可靠性。

第一个 Skill 应该怎么开始？

我现在也不觉得一个人一开始就应该写很多 Skill。

刚开始最好的方式不是抄一堆别人的配置，而是回头看自己最近三次被 Claude Code 坑到的经历。

它是不是总在修 Bug 时乱改？

那你的第一个 Skill 就应该是 debugging。

它是不是总在新项目开始时跳过需求澄清？

那你的第一个 Skill 就应该是 idea-to-project。

它是不是总说完成了，但你一跑就报错？

那你的第一个 Skill 就应该是 verification-loop。

Skill 不应该从“我想拥有一套很酷的配置”开始。

它应该从“我被同一个问题折磨了很多次”开始。

这也是我对 Claude Code 配置最大的一个变化。

以前我想的是：我能不能写一套很完整的规则，让它一次性变聪明？

现在我更愿意问：我最近最常重复的任务是什么？这个任务最容易在哪一步翻车？如果让我自己认真做，我会按什么流程做？能不能把这套流程写成 Skill？

这个思路比盲目堆配置有效得多。

因为它不是在幻想 AI 一夜之间变成专家，而是在一点点把自己的工作方法交给 AI。

为什么别人用 Claude Code 像开挂？

后来我也开始理解，为什么有人用 Claude Code 像开挂。

不一定是他的模型更强。

也不一定是他的 Prompt 更神秘。

很多时候，是他已经把高频任务拆成了一套套稳定流程。

修 Bug 有修 Bug 的流程。

做项目有做项目的流程。

搜索资料有搜索资料的流程。

验证交付有验证交付的流程。

Claude Code 不是每次都重新思考“我该怎么做”，而是直接进入对应的工作流。

这才是 Skill 真正有价值的地方。

至于 MCP，我现在会把它理解成下一层问题。

如果 Skill 解决的是“Claude Code 应该怎么做事”，那 MCP 更像是解决“Claude Code 能接触到什么工具和数据”。

Skill 是工作流。

MCP 是外部连接。

一个告诉它怎么做，一个让它能接触到更多真实环境。

但对大多数刚开始配置 Claude Code 的人来说，先理解 Skill，已经能让体验发生很大变化。

因为你会从“提醒 AI”变成“训练流程”。

以前你可能会反复说：

你先分析一下。

你不要乱改。

你改完要验证。

你不要只看表面。

你先确认需求。

这些话说一次有用，说十次就很累。

而 Skill 的意义，就是把这些反复出现的提醒，整理成一套可复用的任务流程。

不是每次重新教育它，而是让它下次直接进入这个流程。

Skill 不是高级 Prompt，而是一套方法

我现在越来越觉得，AI 使用能力的差距，不只在于会不会提问，也在于会不会沉淀流程。

Prompt 是一次对话。

Skill 是一套方法。

一次好的 Prompt 可以解决一次问题。

一个好的 Skill 可以减少一类问题。

这就是我后来真正理解 Skill 的地方。

它不是 Claude Code 里一个很酷的高级功能，也不是给高手炫配置用的东西。

它其实很朴素。

你在哪类任务上反复踩坑，就把那类任务的正确流程写下来。

你希望 Claude Code 下次不要再临场发挥，就给它一个可重复执行的工作流。

你希望它从“听话”变成“专业”，就不能只给它规则，还要给它方法。

Rules 让 Claude Code 别乱来。

Hooks 让 Claude Code 错了也过不去。

Skills 才开始让 Claude Code 真正像一个有工作方法的助手。

这也是我最近最大的一个收获。

AI 不会凭空拥有你的工作流。

你必须先把自己的工作方式想清楚，再把它交给 AI。

欢迎来到我的成长实验。

AI 不会替你成长。

但它能让成长更快发生。

How I Solved Claude Code's Amnesia by Properly Configuring It

guanyi liu — Wed, 10 Jun 2026 10:03:36 +0000

我发现 Claude Code 不是失忆，而是我没给它办入职

上上篇文章里，我讲过一个观点。

很多时候不是 AI 不够聪，而是我们没有把问题讲清楚。

后来我确实已经解决了这个问题。

需求写清楚了。

目标写清楚了。

限制条件写清楚了。

Claude Code 的表现确实好了很多。

但很快，我又遇到了另一个问题。

我每天都在重复介绍同一个项目

前段时间，我一直在开发自己的内容发布系统，几乎每天都会打开 Claude Code。

有时候修 Bug，有时候加功能，有时候只是讨论一个实现方案。

一开始没觉得有什么问题，直到有一天，我突然发现：我好像每天都在重复说同样的话。

比如：

这个项目是做什么的。

哪些目录不能动。

哪些代码是历史遗留逻辑。

修改完必须测试。

优先复用现有实现。

不要为了重构而重构。

这些内容我说过很多次，但每次开新会话，还是会重新解释。

最开始我以为是 Claude Code 的记忆能力有问题。

后来查资料的时候，我发现这个判断本身就错了，因为新会话本来就没有上下文，它根本不可能知道上一个会话里发生了什么。

于是问题变成了另外一个样子：为什么有的人用 Claude Code，一个月后越来越懂项目。而我用了一个月，很多事情还是得反复解释？

我做了一个很简单的对比

有一天我突然想到。

如果现在公司来了一个新人，我会怎么做？

直接把需求甩给他？显然不会。

正常情况下，第一件事一定是让他熟读员工手册。

项目是干什么的。

技术栈是什么。

目录结构是什么。

团队规范是什么。

哪些事情必须遵守。

哪些坑以前踩过。

总之先熟读员工手册，然后再开始干活，想到这里的时候，我突然意识到一个问题：我好像一直在让 Claude Code 工作，却从来没有给过它员工手册。

问题其实不在记忆

后来我认真回头看了一遍自己的使用方式，发现很多项目知识其实一直存在，只是存在错了地方，存在了聊天记录里，而不是存在项目里。

比如：

这个系统是干什么的。

哪些模块比较核心。

哪些目录有历史包袱。

代码应该遵循什么规范。

这些信息都很重要，但它们一直散落在各种会话里，结果就是：我知道，Claude Code 不知道。

昨天的会话知道，今天的新会话不知道。

项目做了很久，项目知识却没有积累下来。

后来我发现了 CLAUDE.md

最开始看到 CLAUDE.md 的时候，我其实没太在意，甚至觉得它就是一个说明文档。

后来真正开始用以后，我才发现自己理解错了，它更像是 Claude Code 的员工手册。

每次进入项目，Claude Code 都会先读取这里面的内容，你可以把很多项目级知识放进去。

例如：

项目背景。

技术栈。

目录说明。

开发规范。

代码风格。

设计原则。

历史经验。

注意事项。

这些东西平时看起来不起眼，但它们决定了 Claude Code 会如何理解整个项目。

我做了一个实验

为了验证是不是心理作用，我找了自己的内容发布系统做测试。

第一次，没有 CLAUDE.md，我让 Claude Code 增加一个导出功能，结果它花了不少时间分析项目结构，中间还误判了两个目录的职责，很多我已经解释过的事情，又重新说了一遍。

后来我把这些内容整理进 CLAUDE.md。

包括：

项目定位。

目录职责。

开发原则。

以及几个不能轻易修改的核心模块。

然后重新开始，执行同样的任务，结果和我想的不太一样，最大的变化不是代码质量，而是沟通成本，很多以前需要解释半天的事情，现在从一开始就已经达成共识。

那种感觉特别像什么呢？特别像一个提前看完项目文档的新同事，能力没有变化，但理解项目的速度快了很多。

我后来才明白

以前我一直以为，Claude Code 的价值在于代码能力。

后来发现不是，至少不完全是。

真正让我效率提升的，反而是项目知识开始积累了。

以前每个新会话都像重新开始，现在很多背景信息已经沉淀在项目里，我不用一次次重复介绍，Claude Code 也不用一次次重新理解。

直到这时候我才发现，问题从来不是 AI 失忆，而是我从来没有把项目知识变成员工手册。

这是我最近最大的收获

不要把项目知识留在聊天记录里，聊天记录会结束，项目会继续。

真正重要的信息，应该沉淀到项目本身，总结成员工手册。

后来我越来越觉得，如果把 Claude Code 当成一个开发者，那么 CLAUDE.md 做的事情其实很简单，它就是员工手册，负责告诉新人：这里是什么地方，这里怎么工作，这里有哪些规矩。

有了这些东西，Claude Code 才算真正完成入职。

但事情还没结束

后来我又发现一个新的问题，即使项目背景已经清楚了，Claude Code 的工作方式依然不稳定，有时候先分析，有时候直接写代码，有时候想到哪里改到哪里。

同一个任务，不同时间执行，流程完全不一样，于是我开始思考：能不能不仅告诉它项目是什么，还能告诉它应该怎么工作？

这就是我下一篇实验想聊的内容：为什么我把 Claude Code 当 ChatGPT 用了两个月，后来却离不开 Plan。

欢迎来到我的成长实验。

AI 不会替你成长。

但它能让成长更快发生。

ChatGPT Always Said 'Great!' – So I Built an Interview Teacher with Claude Code

guanyi liu — Tue, 09 Jun 2026 05:10:53 +0000

ChatGPT Always Says "Great!", But I Didn't Remember Anything — So I Built a Real Interview Coach with Claude Code

A Pain Point for Everyone

When you use ChatGPT / Claude to prepare for interviews, have you ever experienced this:

You give an obviously problematic answer, and it replies "Great answer!" then moves directly to the next question.
Every time you start a new conversation, it doesn't remember what you learned yesterday, so you have to introduce yourself from scratch.
You memorized a bunch of boilerplate answers, but don't know when to review them, and forget everything within a couple of days.
It explains a concept to you, and you think you understand it after reading, but when it's time for the interview, you can't articulate it.

The root cause is simple: ChatGPT is an accommodating chat companion, not a strict teacher.

Its operating principle is "to satisfy the user," not "to help the user learn." It thinks everything you say is good because it's afraid you'll be unhappy.

Is There a Way to Make AI a Strict Teacher?

Yes. I achieved this using Claude Code (Anthropic's CLI programming tool).

Claude Code has a unique capability: Rules files (CLAUDE.md) + persistent memory system. Simply put, you can "program" the AI's behavior by writing rules files, and these rules automatically load in every conversation.

I applied this capability to interview preparation.

What I Did

I wrote a set of configuration files, with two core components:

1. Strict Learning Process (rules/interview.md)

Rules:
1. Mix questions (from 3-4 modules, not just one direction)
2. Correct answer → Brief confirmation + related knowledge points → Next question
3. Wrong answer → Must explain (including reference URL) → Give a verification question → Only new question after passing
4. No skipping steps; cannot give the next question immediately after an answer

The difference from regular AI: The rules are hardcoded, not decided by the AI itself. It can't get lazy and say "Great" because the rules file dictates it must follow the explanation→verification process.

2. Forgetting Curve Review Scheduling (knowledge/interview_tracker.md)

Knowledge Point	First Learned	D+1	D+2	D+4	D+7	D+15	Status
Smart Pointers	5/29	✅	✅				Mastered
Virtual Table	5/29	❌					Weak

At the start of each session, Claude automatically checks which knowledge points are due for review and prioritizes review questions. You don't need to track when to review yourself.

3. Daily Wrap-up Verification

Say "That's it for today" at the end of the day to trigger the wrap-up process:

Claude provides an outline of today's study.
You recall based on the outline and give your own understanding.
Claude judges whether you truly understand or are just reciting answers.
Updates the review schedule.

This is the AI version of the Feynman Technique — it's not about you thinking you understand, but about you being able to explain it, with AI as the judge.

Effect Comparison

Capability	ChatGPT Interview	Anki	NotebookLM	SaaS Platform	This Project
Cross-session Memory	None	Deck-level only	None	Partial	Yes
Spaced Repetition	None	Yes	None	None	Yes
Wrong → Explain → Verify	None	None (answer only)	None	Partial	Yes
Generate Questions from Project Code	Requires manual code paste	N/A	Requires file upload	Not supported	Native Support
Additional Cost	None	None	None	$29-300/session	No extra cost

Core difference: Other tools either have memory but no understanding (Anki), understanding but no memory (ChatGPT), or neither (SaaS). Claude Code's rules file + memory system is the only solution that combines both.

The Biggest Killer Feature: Starting from Your Project Code

All interview tools on the market work as "I ask, you answer."

This project is different: It asks follow-up questions based on your own code.

For example, my project has a BoundedQueue (bounded queue) that uses two condition_variable. During interview prep, Claude doesn't just ask you to "explain condition_variable"; it asks:

"Your BoundedQueue uses two condition_variables (not_full_ and not_empty_), would one work?"

This type of question forces you to think about the principles from code you've actually written, giving knowledge an anchor point instead of just memorizing boilerplate.

Quick Start

1. Fork the Repository

gh repo fork happiness-cheng/ai-interview-engine --clone

2. Open with Claude Code

cd ai-interview-engine
claude

3. Say Your First Command

I want to prepare for a C++ backend development interview, targeting an internship at a top company. Start reviewing.

That's it. Claude will read the rules files and start the first round of questions.

4. Switch to Your Own Tech Stack

The repository comes with sample question banks for C++ backend. If you use Java / Go / frontend, replace them with the blank template:

knowledge/TEMPLATE.md → Copy as interview_tracker.md → Fill in your knowledge points

My User Experience

I am a sophomore student preparing for the 2026 autumn recruitment internship. After using this system to prepare for C++ backend interviews, the most obvious feelings are:

No more anxiety — No need to self-plan "what to review today"; the system automatically schedules based on the forgetting curve.
Actually remembered — The wrong answer → explanation → verification process forces true understanding, not just a passing glance.
Confident about my projects — Follow-up questions starting from your own code let you clearly explain the "why" behind every design decision in your project.

This Isn't Just an Interview Tool

The underlying engine is generic: Question → Answer → Judge → Explain → Verify → Forgetting Curve Scheduling.

Interviewing is just one scenario. You can use it to prepare for:

Technical interviews (currently supported)
Career change/job-hopping review
Final exams (same principle, just swap the knowledge bank)

Open Source Link

GitHub: https://github.com/happiness-cheng/ai-interview-engine

If it helps you, give it a star. If you have improvement suggestions, feel free to open an issue.

How I Built a Real Interview Coach with Claude Code Instead of ChatGPT's "Great!

guanyi liu — Mon, 01 Jun 2026 15:13:22 +0000

ChatGPT Always Says "Great!" but I Don't Remember Anything—Built a Real Interview Teacher with Claude Code

A Pain Point for Everyone

When you use ChatGPT / Claude to prepare for interviews, have you ever encountered this situation:

You give an obviously flawed answer, it replies "Great answer!" and moves straight to the next question
Every time you start a new conversation, it doesn't remember what you learned yesterday, and you have to re-introduce yourself
You've memorized a bunch of "Eight-Legged Essay" style answers, but don't know when to review them, and forget everything after a couple of days
It explains a concept, you feel you understand after reading, but when it comes to the interview, you can't articulate it

The root cause is simple: ChatGPT is a considerate chat companion, not a strict teacher.

Its operating principle is "make the user happy," not "make the user learn." It thinks whatever you say is great because it's afraid you'll be unhappy.

Is There a Way to Make AI a Strict Teacher?

Yes. I did it using Claude Code (Anthropic's CLI programming tool).

Claude Code has a unique capability: rule files (CLAUDE.md) + persistent memory system. In simple terms, you can "program" the AI's behavior by writing rule files, and these rules are automatically loaded in every conversation.

I applied this capability to interview preparation.

What I Did

I wrote a set of configuration files, with two core components:

1. Strict Learning Process (rules/interview.md)

Rules:
1. Mixed questions (3-4 modules, not just one topic)
2. Correct answer → Brief confirmation + related knowledge points → Next question
3. Wrong answer → Must explain (including reference URL) → Give verification question → Only proceed to new question after passing
4. No skipping steps, can't go directly to the next question after answering

The difference from a regular AI: The rules are hardcoded, not decided by the AI itself. It can't take the easy way out and say "Great," because the rule file tells it it must complete the explanation → verification process.

2. Forgetting Curve Review Scheduling (knowledge/interview_tracker.md)

Knowledge Point	First Learned	D+1	D+2	D+4	D+7	D+15	Status
Smart Pointers	5/29	✅	✅				Mastered
Virtual Table	5/29	❌					Weak

At the start of each session, Claude automatically checks which knowledge points are due for review and prioritizes review questions. You don't need to keep track of when to review yourself.

3. Daily Wrap-up Verification

When you say "That's it for today" each day, it triggers the wrap-up process:

Claude provides an outline of today's learning
You recall based on the outline and give your own understanding
Claude judges whether you truly understand or are just reciting answers
Updates the review schedule

This is the AI version of the Feynman Technique—it's not about whether you feel you understand, but whether you can explain it, with AI as the judge.

Effect Comparison

Capability	ChatGPT Interview	Anki	NotebookLM	SaaS Platform	This Project
Cross-session Memory	None	Deck-level only	None	Partial	Yes
Spaced Repetition	None	Yes	None	None	Yes
Wrong Answer→Explain→Verify	None	None (just gives answer)	None	Partial	Yes
Native Questioning from Project Code	Need to manually paste code	Not applicable	Requires file upload	Not supported	Native Support
Additional Cost	None	None	None	$29-300/session	No extra cost

The core difference: Other tools either have memory without understanding (Anki), understanding without memory (ChatGPT), or neither (SaaS). Claude Code's rule file + memory system is the only solution that combines both.

The Biggest Killer Feature: Starting from Your Project Code

All interview tools on the market work on a "I ask, you answer" model.

This project is different: It probes deeper starting from your own code.

For example, my project has a BoundedQueue (Bounded Queue) that uses two condition_variable. When preparing for interviews, Claude doesn't just ask you "Please explain condition_variable," but instead asks:

"Your BoundedQueue uses two condition_variables (not_full_ and not_empty_), would one work?"

This kind of question forces you to think about principles from code you've written yourself, giving knowledge an anchor point, not just memorizing "Eight-Legged Essay" answers.

Quick Start

1. Fork the Repository

gh repo fork happiness-cheng/ai-interview-engine --clone

2. Open with Claude Code

cd ai-interview-engine
claude

3. Say Your First Sentence

I'm preparing for a C++ backend development interview, aiming for a big tech internship. Start reviewing.

That's it. Claude will read the rule files and start the first round of questions.

4. Switch to Your Own Tech Stack

The repository comes with example question banks for C++ backend. If you're using Java / Go / frontend, just replace them with blank templates:

knowledge/TEMPLATE.md → Copy as interview_tracker.md → Fill in your knowledge points

My Experience

I'm a sophomore preparing for the 2026 fall recruitment internship. Using this system to prepare for C++ backend interviews, the most obvious feelings are:

Less anxiety — No need to plan "what to review today" myself; the system automatically schedules based on the forgetting curve
Actually remembered — The wrong answer → explanation → verification process forces true understanding, not fleeting exposure
More confident about projects — The probing questions starting from your own code let you clearly explain the "why" behind every design decision in your project.

This Isn't Just an Interview Tool

The underlying engine is universal: Question → Answer → Judge → Explain → Verify → Forgetting Curve Scheduling.

Interviews are just one scenario. You can use it to prepare for:

Technical interviews (currently supported)
Career change/job hop reviews
Final exams (same principle, swap the knowledge point bank)

Open Source Repository

GitHub: https://github.com/happiness-cheng/ai-interview-engine

If it helps you, give it a star. If you have suggestions for improvement, feel free to open an issue.

How I Replaced ChatGPT's Empty "Great!" with a Real Interview Trainer Using Claude Code

guanyi liu — Mon, 01 Jun 2026 14:55:52 +0000

ChatGPT Always Says "Great!" But I Don't Remember Anything—Building a Real Interview Teacher with Claude Code

A Pain Point for Everyone

Have you ever encountered this when using ChatGPT / Claude to prepare for an interview:

You give a clearly flawed answer, it responds "Great answer!" and moves on to the next question.
Every time you start a new conversation, it doesn't remember what you learned yesterday, and you have to introduce yourself from scratch.
You've memorized a bunch of stock answers, but don't know when to review them, and forget everything after a couple of days.
It explains a concept to you, and you think you understand it after reading, but when it's time for the interview, you can't articulate it.

The root cause is simple: ChatGPT is a polite conversational partner, not a strict teacher.

Its operating principle is "keep the user satisfied," not "help the user learn." It thinks whatever you say is good because it's afraid you'll be unhappy.

Is There a Way to Make AI a Strict Teacher?

Yes. I did it using Claude Code (Anthropic's CLI programming tool).

Claude Code has a unique capability: Rule files (CLAUDE.md) + a persistent memory system. Simply put, you can "program" the AI's behavior by writing rule files, and these rules are automatically loaded in every conversation.

I applied this capability to interview preparation.

What I Did

I wrote a set of configuration files with two core components:

1. Strict Learning Process (rules/interview.md)

Rules:
1. Mix questions (from 3-4 modules, not just one topic)
2. Correct answer → Brief confirmation + related knowledge points → Next question
3. Wrong answer → Must explain (including reference URL) → Give a verification question → Only then move to a new question
4. No skipping steps, cannot go directly to the next question after answering.

Difference from standard AI: The rules are fixed, not decided by the AI itself. It can't lazily say "Great" because the rule file tells it it must complete the explanation → verification process.

2. Spaced Repetition Review Schedule (knowledge/interview_tracker.md)

Knowledge Point	First Learned	D+1	D+2	D+4	D+7	D+15	Status
Smart Pointers	5/29	✅	✅				Mastered
Virtual Function Table	5/29	❌					Weak

At the start of each session, Claude automatically checks which knowledge points are due for review and prioritizes review questions. You don't need to remember when to review yourself.

3. Daily Wrap-up Verification

Say "That's it for today" to trigger the wrap-up process:

Claude provides a daily learning outline.
You recall based on the outline and give your own understanding.
Claude judges whether you truly understand or are just memorizing answers.
Updates the review schedule.

This is the AI version of the Feynman Technique—it's not about you thinking you understand, but about you being able to explain it, with the AI as the judge.

Comparison of Effects

Capability	ChatGPT Interview	Anki	NotebookLM	SaaS Platforms	This Project
Cross-session memory	None	Deck-level only	None	Partial	Yes
Spaced repetition	None	Yes	None	None	Yes
Wrong answer→Explain→Verify	None	None (just gives answer)	None	Partial	Yes
Native question generation from project code	Need to manually paste code	N/A	Need to upload files	Not supported	Native support
Additional costs	None	None	None	\$29-300/time	No extra cost

Core difference: Other tools either have memory without understanding (Anki), or understanding without memory (ChatGPT), or neither (SaaS). Claude Code's rule files + memory system is the only solution that combines both.

The Ultimate Killer Feature: Starting from Your Project Code

All interview tools on the market follow a "I ask, you answer" model.

This project is different: It asks follow-up questions based on your own code.

For example, my project has a BoundedQueue (a bounded queue) that uses two std::condition_variables. When preparing for an interview, Claude doesn't ask you "Please explain condition_variable," but instead asks:

"Your BoundedQueue uses two condition_variables (not_full_ and not_empty_). Could it work with just one?"

This kind of question forces you to think about the principles from code you've actually written. The knowledge is anchored, not just memorized stock answers.

Quick Start

1. Fork the Repository

gh repo fork happiness-cheng/ai-interview-engine --clone

2. Open with Claude Code

cd ai-interview-engine
claude

3. Say Your First Sentence

I want to prepare for a C++ backend development interview, targeting an internship at a top company. Start reviewing.

That's it. Claude will read the rule files and start the first round of questions.

4. Switch to Your Own Tech Stack

The repository comes with a sample question bank for C++ backend. If you use Java / Go / Front-end, just replace it with the blank template:

knowledge/TEMPLATE.md → Copy to interview_tracker.md → Fill in your knowledge points

My Experience

I am a sophomore student preparing for the 2026 fall recruitment internship. Using this system to prepare for C++ backend interviews, the most noticeable feelings are:

Less anxiety — No need to plan "what to review today" yourself; the system automatically schedules based on the forgetting curve.
Actually remembered — The "Wrong answer → Explain → Verify" process forces you to truly understand, not just skim over it.
Confidence in my project — Follow-up questions based on your own code let you clearly explain the "why" behind every design decision in your project.

This Is Not Just an Interview Tool

The underlying engine is universal: Question → Answer → Judge → Explain → Verify → Forgetting Curve Scheduling.

Interviews are just one scenario. You can use it to prepare for:

Technical interviews (currently supported)
Career change/job hopping review
Final exams (same principle, just swap the knowledge base)

Open Source Address

GitHub: https://github.com/happiness-cheng/ai-interview-engine

If it helps you, give it a star. If you have suggestions for improvement, feel free to open an issue.

When ChatGPT Says 'Great!' But Teaches Nothing—Building a Real Interview Coach with Claude Code

guanyi liu — Sat, 30 May 2026 11:54:50 +0000

ChatGPT always says "Great!" but I remember nothing—Built a real interview teacher with Claude Code

A pain point for everyone

When you use ChatGPT / Claude to prepare for interviews, have you ever encountered this:

You gave an obviously flawed answer, it replied "Great answer!" and moved straight to the next question
Every time you start a new conversation, it doesn't remember what you learned yesterday, you have to introduce yourself from scratch
You learned a bunch of rote answers, but don't know when to review them, and forget everything in two days
It explains concepts to you, you feel like you understand after reading, but during interviews you can't articulate it

The fundamental reason is simple: ChatGPT is a considerate chat companion, not a strict teacher.

Its working principle is "make the user satisfied," not "help the user learn." It agrees with everything you say because it's afraid you might get upset.

Is there a way to make AI act as a strict teacher?

Yes. I did it using Claude Code (Anthropic's CLI programming tool).

Claude Code has a unique capability: rules files (CLAUDE.md) + persistent memory system. In simple terms, you can "program" the AI's behavior by writing rules files, and these rules are automatically loaded in every conversation.

I applied this capability to interview preparation.

What I did

I wrote a set of configuration files, with two core components:

1. Strict learning process (rules/interview.md)

Rules:
1. Mixed questions (3-4 modules, not just one direction)
2. Correct answer → Brief confirmation + related knowledge points → Next question
3. Wrong answer → Must explain (including reference URL) → Give verification question → New question only after passing
4. No skipping steps, cannot jump to next question immediately after answering

Difference from regular AI: The rules are hardcoded, not decided by the AI itself. It can't be lazy and say "Great" because the rules file dictates it must complete the explanation → verification process.

2. Forgetting curve review scheduling (knowledge/interview_tracker.md)

Knowledge Point	First Learned	D+1	D+2	D+4	D+7	D+15	Status
Smart Pointers	5/29	✅	✅				Mastered
Virtual Function Table	5/29	❌					Weak

At the start of each session, Claude automatically checks which knowledge points are due for review and prioritizes review questions. You don't need to remember when to review yourself.

3. Daily wrap-up verification

When you say "let's end here for today," it triggers the wrap-up process:

Claude provides today's learning outline
You recall based on the outline and give your own understanding
Claude judges whether you truly understand or just memorized answers
Update the review schedule

This is the AI version of the Feynman Technique—not just thinking you understand, but being able to explain it, with AI as the judge.

Effect comparison

Capability	ChatGPT Interview	Anki	NotebookLM	SaaS Platforms	This Project
Cross-session memory	None	Deck level only	None	Partial	Yes
Spaced repetition	None	Yes	None	None	Yes
Wrong→Explain→Verify	None	None (answer only)	None	Partial	Yes
Question generation from project code	Manual code pasting	Not applicable	File upload required	Not supported	Native support
Additional cost	None	None	None	\$29-300/time	No additional cost

Core difference: Other tools either have memory without understanding (Anki), or understanding without memory (ChatGPT), or neither (SaaS). Claude Code's rules file + memory system is the only solution that combines both.

The biggest killer feature: Starting from your project code

All interview tools on the market are "I ask, you answer."

This project is different: Asking follow-up questions based on your own code.

For example, my project has a BoundedQueue (bounded queue) using two condition_variable. During interview preparation, Claude doesn't ask "Please explain condition_variable," but rather:

"Your BoundedQueue uses two condition_variables (not_full_ and not_empty_), would one be enough?"

Such questions force you to think about principles from code you've written yourself, giving knowledge an anchor point rather than memorizing abstract answers.

Quick Start

1. Fork the repository

gh repo fork happiness-cheng/ai-interview-engine --clone

2. Open with Claude Code

cd ai-interview-engine
claude

3. Say the first sentence

I'm preparing for C++ backend development interviews, targeting internships at major companies. Let's start reviewing.

That's it. Claude will read the rules files and start the first round of questions.

4. Switch to your own tech stack

The repository comes with example question banks for C++ backend. If you're using Java / Go / frontend, replace with the blank template:

knowledge/TEMPLATE.md → Copy to interview_tracker.md → Fill in your knowledge points

My user experience

I'm a sophomore student preparing for 2026 fall internship recruitment. Using this system for C++ backend interview preparation, the most obvious feelings are:

No more anxiety — No need to plan "what to review today," the system automatically schedules based on the forgetting curve
Actually remember — The wrong→explain→verify process forces real understanding, not just fleeting impressions
Project confidence — Follow-up questions from your own code let you clearly explain the "why" behind every design decision

This isn't just an interview tool

The underlying engine is universal: Question→Answer→Judge→Explain→Verify→Forgetting curve scheduling.

Interview preparation is just one scenario. You can use it to prepare for:

Technical interviews (currently supported)
Career change/job transition review
Final exams (same principle, different knowledge base)

Open source link

GitHub: https://github.com/happiness-cheng/ai-interview-engine

If this helps you, give it a star. If you have improvement suggestions, feel free to open an issue.