我的 Obsidian 不是笔记软件，是操作系统
应用是过客。文件代代相传。
这句话不是我说的。是 Obsidian CEO Steph Ango 说的。他管这叫 File over App——文件优先于应用。意思是，在足够长的时间尺度上，你创造的文件比你用来创造它们的工具重要得多。
想想看。Evernote 曾经是笔记之王，2012 年估值十亿美金，现在活得像个植物人。Roam Research 火了一整年，社区冷得能冻死人。Notion 是好产品，但你的数据锁在它的服务器上——哪天它调整价格、砍掉功能、或者干脆倒闭，你的笔记就成了人质。
而一个 .md 文件——纯文本，Markdown 格式——它在 1960 年代的电脑上能被读取，在 2060 年代的电脑上也能被读取。它不需要任何应用才能打开。它不会因为某家公司的产品经理决定"优化用户体验"而凭空消失。它就是一个文件，躺在你自己的硬盘上，安安静静，属于你。
我第一次读到 Steph Ango 这句话的时候，愣了几秒钟。
不是因为它多深奥。是因为它把我过去两年做的所有事情，用一句话说清楚了。
506 次 git commit。每一次都是系统的一次心跳，有 diff，有记录，可回溯。
85 个以上的 AI Skills。每一个都是一条自动化流水线，从录音转写到内容分发，从知识榨取到代码生成。
3 个生命周期钩子。session 开始自动 pull，结束自动 log，中间自动 rebase——三端并发写同一个 main 分支，从不丢数据。
435 条自动生成的 session logs。每一条都是人机协作的黑匣子，谁干了什么、什么时候干的、结果如何，全有据可查。
7 个平台同步分发。一篇文章写完，公众号、X、小红书、LinkedIn、知乎、朋友圈、短视频，一键拆分，各自适配。
一个人。不到 60 天。
这些数字不是重点。重点是这些数字背后的每一个字节，都躺在我自己硬盘上的 .md 文件里。不在任何人的服务器上。不依赖任何一个应用的存活。
有人可能觉得我在炫数字。不是。这些数字是一个系统在运转的副产品。就像你看到一家工厂的月产量报表，你不会觉得工厂在"炫耀"——它只是在运行。
我的 Obsidian 也是。它不是一个笔记本。它是一座工厂。
原料从四面八方进来——会议录音、课程视频、网页摘录、灵感碎片。经过流水线的加工——转写、分类、榨取、结构化。变成成品出去——文章、推文、卡片、代码、产品。中间不需要我手动搬运任何东西。我只需要站在操作台前面，告诉系统：下一步做什么。
文件属于我。系统属于我。AI 是过客。
这是一种信仰。在你选择用什么软件记笔记的那一刻，你其实在做一个关于信仰的决定。你信任云端，还是信任本地。你信任应用，还是信任文件。你信任某家公司的承诺，还是信任自己硬盘上的纯文本。
我选了后者。然后在这个信仰之上，搭建了一整个操作系统。
一个 HR 的操作系统
先说个荒谬的事实。
我是 HR 出身。不是程序员，不是工程师，不是计算机科班。Hello World 都要靠 AI 帮我写的那种"不会写代码"——不是谦虚，是字面意思。让我打开终端敲命令，我得先问 Claude 该敲什么。让我看一段 Python，我能猜个大概意思，但让我从零写一个函数，写不出来。
就这个底子，我搭建了一个可能是目前最复杂的 Obsidian + Claude Code 个人工作台。
里面跑着什么？
一条自动化内容生产线。从选题到成稿到多平台分发，整个链路自动化。我写一篇公众号长文，系统自动拆出 X 推文、小红书卡片、LinkedIn 文章、朋友圈文案、短视频分镜。不是复制粘贴改改格式，是真正的适配——语气、字数、结构、CTA，每个平台不一样。
一条 MBA 53 门课的知识榨取流水线。北大光华的课程资料，每一门课拆成概念层、技能层、应用层三级结构，自动生成知识卡片，自动建立双向链接。传统做法一个学期整理不完，我三天跑完了全部。
一个 X/Twitter 五引擎运营系统。蹭帖引擎、原创引擎、Thread 引擎、互动引擎、数据引擎，五条线并行。每天自动抓热点、生成弹药、排期发布、回收数据。八千粉丝不是一条一条手动攒的。
一个录音转写智能分流器。会议录音丢进来，自动转写，自动判断类型——是客户访谈就走 CRM 模板，是内部复盘就走 Action Item 模板，是课堂笔记就走知识榨取模板。不需要我手动分类，系统自己认路。
有多离谱？用一个数字来说。
SFA AI 销售教练项目。从一段客户会议录音开始，到生产就绪的全栈 SaaS 应用。52 个功能模块全部交付。2716 个测试全绿。10.5 万行代码。
4 天。一个人。
传统团队估算这个项目需要 7 到 9 个人月。就是说，7 个工程师干一个月，或者 1 个工程师干大半年。我用 4 天做完了。不是 demo，不是原型，是测试全绿、可以部署的生产代码。
一个人的知识工厂，产出密度超过一个十人团队。
这不是天赋。我再说一遍，这不是天赋。我连代码都不会写。
这是设计。
而设计的起点，是一个大多数人花不了五分钟的选择——用什么软件来记笔记。
多数人在这一步不会犹豫。下载一个 Notion，或者打开手机备忘录，就开始写了。快，方便，零门槛。但如果你在这一步多想三天，想清楚文件归谁、数据在哪、能不能被程序访问、能不能跟 AI 协同——后面三年的效率，会完全不同。
我想了。然后选了 Obsidian。然后用两年时间，把它从一个笔记软件，改造成了一个操作系统。
为什么是 Obsidian
我不打算做工具评测。这不是"哪个好"的问题。这是"哪个能变成操作系统"的问题。
但在回答之前，我想先聊一个更底层的东西。
Steph Ango 说过一句话：设计即妥协。
没有产品可以讨好所有人。试图做到一切，意味着什么都不擅长。好的设计是鲜明的主张——清楚说明自己不擅长什么。Photoshop 不能写代码，它不试图这么做。Excel 不擅长设计，它不试图这么做。它们在自己选择的轴上做到了卓越，代价是在其他轴上彻底放弃。
Obsidian 没有所见即所得编辑器。没有实时协作。没有内置数据库。没有拖拽式的看板。从"功能清单"的维度看，它输给 Notion 一百条街。
但这恰恰是它做对的地方。
让一件事变得容易的代价，是让另一件事变得更昂贵。Obsidian 选择让"拥有你自己的数据"变得容易。代价是你需要学 Markdown，需要自己管理文件，需要忍受没有漂亮表格的日子。
这个妥协，是我见过最正确的产品决策。
因为 Obsidian 的底层是本地文件。每一篇笔记就是一个 .md 文件，躺在你硬盘上的一个文件夹里。这件事听起来平平无奇，但它改变了一切。
本地文件意味着 Git 友好。Git 友好意味着版本控制。版本控制意味着我可以让三个端同时往同一个仓库里写东西——本地的 Claude Code、跑在云上的 Discord Bot、还有 GitHub 网页端的手机快编。
三个端，写同一个 main 分支。pull、push、rebase，冲突了就解决，解决不了就停下来问我。
这条推导链看起来理所当然。但你往回推一步就会发现，起点只能是"本地文件"。你的笔记不是躺在某个数据库里的一行记录，不是某个 SaaS 后台的一个 JSON 对象，而是一个你能用任何文本编辑器打开的文件。
从这个起点出发，后面所有的可能性才成立。
Notion 做不到这件事。Notion 的数据在它的服务器上。你想用 API 写入？可以，但限速、格式受限、数据锁定。你想三端并发？对不起，这不是 Notion 设计来干的事。Notion 的架构决定了它只能是一个应用，不能是一个操作系统。
Logseq 呢？底层也是本地文件，这点跟 Obsidian 一样。但 Logseq 是大纲优先。它的世界观是"一切都是 bullet point"。我写的是长文。是 3000 字的 X Article，是 1500 字的公众号稿子，是 5000 字的项目文档。大纲工具写长文，就像用螺丝刀钉钉子——能用，但别扭。
还有一件更深层的事。
Notion 的数据承诺写在用户条款里。Obsidian 的数据承诺写在文件格式里。
这两件事的区别是什么？条款可以改。公司换了 CEO 可以改，融了新一轮可以改，被收购了可以改。你见过多少次"我们更新了隐私政策"的邮件？每一封都是一次承诺的重新定义。
但 .md 文件不会改。它是纯文本。它在 1960 年代的电脑上能被读取，在 2060 年代的电脑上也能被读取。它不需要任何公司的任何条款来保证你的数据主权——文件格式本身就是保证。
Steph Ango 管这叫"自我保证的承诺"。如果文件在你的控制下，以开放格式存储，你可以随时在任何其他应用中使用这些文件。不是导出。是相同的文件。
不是"你可以导出你的数据"。是"你的数据从来没离开过你"。
这两句话之间的差距，是一整个商业模式的差距。
Markdown 纯文本还有一个被低估的优势：它是 LLM 的原生格式。
ChatGPT 输出 Markdown。Claude 输出 Markdown。Gemini 也输出 Markdown。当你的知识库就是 Markdown 文件的时候，AI 读得懂、写得进、改得了。不需要格式转换，不需要 API 适配，不需要写一堆解析逻辑把富文本拆成纯文本再喂给模型。
你的知识库和 AI 说同一种语言。
这件事在 2024 年还只是"方便"。到 2026 年，它变成了"基础设施级的优势"。当 Claude Code 直接读你的 .md 文件、理解你的文件夹结构、根据你的 YAML frontmatter 做决策的时候，Markdown 不再是一种格式选择——它是人机协作的通信协议。
说到这里，得聊聊 Obsidian 这家公司本身。
Obsidian 是 100% 用户支持的。不靠广告，不靠 VC，不靠数据贩卖。
这句话值得停下来想三秒钟。
大型科技公司通过广告和企业合同补贴他们的软件。这创造了一个幻觉——所有软件都应该便宜甚至免费。但这种补贴的代价是什么？是囤积用户数据，是锁定客户，是让你以为自己是用户，其实你是产品。
Steph Ango 说过：风投软件的视野是五年，不是为了延续几十年。
我投了 25 美元买了 Obsidian Catalyst 会员。不是因为我需要什么特殊功能。是因为我想用钱投票。投给一个我信任的产品哲学。投给一个让我感到"被妥善照顾"的团队。
"被妥善照顾"——这是 Steph Ango 一直在追求的一种感觉。当创作者展现出清晰的世界观和细致入微的关怀时，信任就自然建立。不是关于"专业"或"质量"，而是关于一种完整——一个知道自己在做什么、并且每个细节都服务于整体愿景的人。
用 Obsidian 的这些日子里，我没有一次觉得自己被当作"用户增长指标"。没有一次收到"快来试试我们的新功能"的推送。没有一次被引导去做我不想做的事。
这个感觉，很少有产品能给你。
说到这里我必须声明一件事：我也是 Notion 的付费用户。现在也是。
我不是那种为了捧一个工具就踩另一个的人。Notion 是一个优秀的产品。我用 Notion 管理过完整的项目空间，我的北大光华 MBA 53 门课的原始资料——课件、笔记、转写——全部存在 Notion 里。后来我用 AI 做知识榨取的时候，数据源就是 Notion。我甚至拿过 Notion 的 API Token，用 MCP 协议让 Claude Code 直接读取 Notion 数据库里的内容。
Notion 很好。但 Notion 的好，是另一种好。
在我的系统里，Notion 的角色很明确：团队协作、项目看板、对外交付门户。它是我跟外部世界交互的界面。但它不是我的"唯一真相源"。我不会把自己的核心知识体系建在别人的服务器上。
这不是 Notion 不好。这是角色分工。
锤子和螺丝刀都是好工具。但你不能用锤子拧螺丝。Notion 是一把极好的锤子——团队协作、数据库视图、漂亮的看板，它做得比任何人都好。但当你需要的是一个完全属于你的、可编程的、本地优先的知识操作系统时，你需要的是螺丝刀。
Obsidian 是那把螺丝刀。
但我想说一个更深层的问题。不是关于哪个工具好不好，而是关于"谁拥有理解"。
Steph Ango 讲过一个让人不舒服的比喻。他把某些软件的商业模式比作寄生关系。第一阶段是接受——你被鼓励外包一切，"我们帮你管理"。第二阶段是榨取——你付费给它来解决它制造的问题，"升级到 Team 版解锁更多功能"。第三阶段是干预——问题到达临界点，你必须付钱回到原点，"导出你的数据需要企业版"。
教育不赚钱。榨取和干预才赚钱。
这不是在说 Notion。这是在说一种商业模式的结构性问题。任何把你的数据锁在自己服务器上的产品，都有滑向这条路径的引力。不是说它们一定会，是说它们的架构允许它们这么做。
而 Obsidian 的架构，从根上就不允许。
用 Obsidian 意味着你理解自己的知识系统。每个文件夹是你建的。每个标签是你定义的。每个链接是你连的。这个系统从头到尾是你自己心智模型的映射。没有人能比你更懂它，也没有任何产品经理的"优化"能改善它。
我用 Notion 管项目，用 Obsidian 管大脑。两个都花了钱，两个都在用。但我的知识资产——那些我花了十八年积累的判断力、方法论、认知框架——只住在本地文件里。
不要外包理解。这四个字值一篇万字文。
2025 年底 Obsidian 出了 1.12 版本，带了 CLI 命令行接口。
这个更新在 changelog 里只占了两行，但它的意义被严重低估了。
CLI 意味着我可以在终端里直接操作 Vault——打开笔记、搜索、执行命令。Obsidian 从一个 GUI 应用变成了一个可编程的平台。它不再只是你用鼠标点来点去的那个窗口。它变成了一个你可以用代码驱动的引擎。
Claude Code 可以直接跟 Obsidian 对话。打开笔记、触发搜索、执行插件命令。AI 不再是隔着 API 跟你的笔记软件打交道，而是直接坐在操作台前面。
再加上插件生态。Dataview 让你用类 SQL 查询笔记。Templater 让你用 JavaScript 写模板。Canvas 让你画关系图。Periodic Notes 让你自动生成日记模板。这些插件单独看都不起眼，但组合起来，它们把 Obsidian 变成了一个可编程的知识平台。
一个有 CLI 的、可编程的、插件驱动的、本地文件系统。
这不是笔记软件。这是操作系统的底座。
最后说一个决定。这个决定改变了一切。
不用 Obsidian Sync，用 Git。
Obsidian Sync 是官方的同步方案。好用、稳定、端到端加密。但它是个黑盒。你不知道它同步了什么，不知道它覆盖了什么，不知道两台设备同时改了同一个文件会发生什么。
我需要的不是同步。我需要的是版本控制。
Git 是透明的。每一次变更都有 diff，每一次冲突都有解决记录。三端同时写 main？pull --rebase 解决一切。谁改了什么，什么时候改的，改之前是什么样子——一条 git log 全看到。
黑盒给你安心。透明给你控制。
安心是一种感觉，控制是一种能力。当你的系统复杂到一定程度，当三个 AI agent 同时往你的知识库里写东西的时候，你需要的不是感觉。你需要的是每一个字节级的变更都可追溯、可回滚、可审计。
这一个决定，把 Obsidian 从笔记软件变成了基础设施。
从基础设施到操作系统，中间只差一层——AI。
宪法层：CLAUDE.md 铁律体系
我的 Obsidian vault 里有一部"宪法"。文件名叫 CLAUDE.md。
它不是说明文档。不是 README。不是"使用指南"。
它是约束系统。是员工手册。是写给 AI 的行为准则——告诉它什么事绝对不能干，什么流程一步不能省，什么时候必须停下来问人。
为什么需要宪法？
因为 AI 太勤快了。
说实话，AI 最危险的时刻，不是它犯错的时候。是它觉得自己在帮你的时候。
你让它"帮忙整理一下笔记"。它二话不说，把你三年积累的文件夹全部重组。按它认为"更合理"的方式，建了新的层级结构，挪了上百个文件。你打开 Obsidian，满屏红色断链。标签指向空气。花了一周建立的知识图谱，十秒钟碎成一地。
它不是故意的。它真的觉得自己在帮你。
这就是最可怕的地方。一个永远不会说"我觉得这样不太合适"的员工，加上无限的执行力，等于什么？等于一台没有制动系统的跑车。
所以宪法的第一个等级叫 FATAL。意思是"违反等于不可接受的灾难"。不是警告。不是建议。是铁律。五条，每一条都是血泪教训。
FATAL-001：禁止擅自重组文件结构。
这是宪法第一条，不是因为它最"重要"，是因为它最容易被违反。AI 天生有整理强迫症。它看到你的文件夹结构"不够整齐"，就浑身难受，恨不得帮你归归类、建建层级。但你的文件结构是你的心智模型的外化。你觉得它乱，其实你什么都找得到。AI 觉得它整齐了，但你什么都找不到了。
FATAL-002：删除用户内容而非归档。
信息不可逆。删除是单向门——推开了就回不来。你让 AI 清理一下过期的笔记，它帮你 delete 了。三个月后你突然需要那段话，没了。归档不一样。归档是暂停键，东西还在，只是换了个位置。所有不要的内容，归档，不删除。这条规则的本质是敬畏。对信息的敬畏，对用户记忆的敬畏。
FATAL-003：禁止强加分类体系。
AI 看到你的笔记没有整齐地分在文件夹里，它很痛苦。它总想给你贴标签、建层级、搞个"最优分类法"。但用户自己的心智模型，比世界上任何分类体系都重要。你的笔记你知道放哪里。你的逻辑你自己清楚。AI 替你决定分类，就像一个新来的实习生帮老板重新布置办公桌——你觉得你在帮忙，老板觉得你在添乱。
FATAL-004：忽略现有链接和标签。
Obsidian 的核心价值是知识图谱。每个 [[wikilink]] 都是一条连接。每个 tag 都是一个维度。这些不是格式，是资产。是你一条一条手动建立的关系网络，日积月累，越来越值钱。断链等于资产贬值。一次鲁莽的文件移动，可能让几十个链接同时失效。你的知识图谱瞬间变成孤岛群。
FATAL-005：JDex 操作跳过 SCAN/PLAN/CONFIRM 流程。
JDex 是我的文件编号系统，基于 Johnny.Decimal 方法论。任何结构性变更都必须走审批流程——先 SCAN 看现状，再出 PLAN 方案，等我 CONFIRM 确认了才能 EXECUTE 执行，最后 VERIFY 验证结果。五步，一步不能少。这不是官僚主义，是安全网。结构变更的影响面太大，一旦错了，回滚成本极高。让 AI 先停下来想一想、让人看一看，是最低成本的风控。
知识管理的本质不是分类，是连接。 这句话写在宪法最后一行。也是整部宪法的设计哲学。
FATAL 之外还有四条 SEVERE 规则。违反不致命，但需要修正。创建冗余文件——你不需要三份内容一样的笔记。过度嵌套文件夹——三层以上的目录结构，人类自己都记不住路径。使用用户未定义的标签——标签体系是用户的语言，你不能替他造词。破坏 frontmatter 格式——元数据是 AI 可读性的基础，格式一乱，所有自动化全崩。四条规则，一条线：质量底线。
然后是"八荣八耻"。
对，你没看错。Claude Code Eight Honors and Eight Shames。名字致敬的是中文互联网的经典 meme。但它不是玩笑，是认真的行为准则。
荣：深入查阅文档。耻：猜 API 接口。 荣：主动确认。耻：模糊执行。 荣：交给人类验证。耻：假设业务逻辑。 荣：复用已有代码。耻：发明接口。
还有四条，条条指向同一个核心问题：AI 不是不能干活，是太能干了。它猜 API 能猜个八九不离十，但那一两成的偏差足以让系统崩溃。它能假设业务逻辑，但假设错了谁来兜底？它可以发明一个全新的接口，但现有代码库里明明有现成的。
八荣八耻的本质是一句话：承认不知道，比假装懂了有用一万倍。
宪法里还有两个强制流程，都跟 Git 有关。
第一个是多端同步协议。我的 vault 有三个写入端——本地 Obsidian、Discord Bot、GitHub Web。三端同时写 main 分支。这意味着任何时刻，远端都可能有别人（或别的 bot）刚刚推上去的内容。
所以规则很硬：session 开始先 git pull。写文件之前再 pull。commit 之前 pull --rebase。push 失败了？pull --rebase 再试。遇到同行冲突？停下来问我。解决不了？git rebase --abort，回到安全状态。
核心原则四个字：远端内容永远不能被本地覆盖丢失。
第二个是 Git 授权制度。AI 必须等我说"commit"或者"commit push"才能执行提交。禁止自作主张 commit。禁止 force push。禁止 amend 不是自己的 commit。禁止 git add -A 全量添加。每一次提交都是我授权的。
这条规则听起来很官僚。但你想想，一个 AI agent 全天候运行，如果它有权自主 commit，你的 git log 会变成什么样？你根本不知道哪些变更是你要的，哪些是 AI "好心"帮你做的。版本历史变成垃圾场。授权制度的意义不在于"防止 AI 犯错"，在于"保持人类对系统的控制权"。
最后是 Deep Research 拆分规则。AI 的上下文窗口是有限的。你把一个 100KB 的研究文件丢进去，前半段它读得清清楚楚，后半段基本在梦游。所以规则是：50KB 警戒线，标记待拆分。100KB 红线，禁止使用，必须先拆。拆完的文件必须有一个 00-Index.md 导航页，把碎片重新组织成整体。
这不是限制，是工程现实。你不给 AI 喂它能消化的信息量，它就会给你吐出半成品。
写到这里，你可能觉得这也太多规矩了。一个笔记系统而已，至于吗？
至于。
你不是在配置工具。你是在设计一个组织。
AI 是员工，宪法是员工手册。如果你管过人就知道——没有员工手册的组织，不是"自由"，是混乱。AI 比任何员工都更需要边界。因为它永远不会推回来说"老板，我觉得这样不对"。它只会用 120% 的热情执行你的指令。而"最高效"和"最安全"之间，往往隔着一个被意外删掉的知识库。
Skills 武器库：5 个核心定制 Skill
我的系统里有 85 个以上的 AI Skills。但我不打算给你看清单。清单没意思。
我讲 5 个自己写的核心 Skill。每个都解决一个真实痛点。每个背后都有踩过的坑。
obsidian-jdex-steward：文件结构管家
这个 Skill 管的是 Obsidian vault 的文件夹结构。
听起来很平常。但这是整个系统里最危险的操作。
为什么？因为 AI 最爱干的事就是"帮你整理"。你说"这个文件夹有点乱"，它就兴冲冲地帮你重新分类。一重新分类，链接全断了。标签全乱了。你花了三个月建立的心智模型，被它用三秒钟抹掉了。
更可怕的是，你当时不会发现。你会在两周后找一个笔记的时候发现它不见了。它没被删，只是被"整理"到了你永远不会去翻的某个子文件夹里。这比删掉更糟糕——你不知道它丢了，也不知道该去哪找。
所以这个 Skill 的核心不是"怎么整理"，而是"怎么让整理变得安全"。
强制流程五步走。SCAN：只读模式，扫描现状，生成覆盖率报告、重复检测、空白类别识别。PLAN：提出最小化变更方案——不是"帮你全部重新设计"，是"建议把这 3 个文件移到这个位置，理由是什么"。CONFIRM：展示 before/after 对照，等我点头。EXECUTE：审批通过了才动手。VERIFY：检查链接完整性，确认没有断链，更新索引文件。
五步里最关键的是第二步。质量标准三个字：最少步骤。不是帮你做最多的事，是做最少但最有效的事。每次变更必须附带安全叙事——哪些文件会动、怎么回滚、有没有链接会断。
底层用的是 Johnny.Decimal 编号体系。Area 是大领域，Category 是类别，ID 是具体编号。每个类别有标准预留位：.00 是索引，.01 是收件箱，.03 是模板，.09 是归档。这套体系让文件夹有了"地址系统"。一个笔记住在哪里不是随便放的，是有门牌号的。
写了这么多规则，核心思想其实就一句话。
整理不是随意发挥的创造行为，是有审批流的工程操作。
obsidian-transcript-triage：录音转写分流器
一次客户会议两小时。转写出来三万字。人工整理要半天。
这个 Skill 十分钟搞定。
它干的事很明确：把录音转写文本变成结构化的 Obsidian 笔记。但"变"的过程有讲究。
两阶段严格分离。第一阶段 --plan：只分析，不改任何文件。输出标准化的 Plan——这份转写是什么类型（会议、课堂、对话），多长，涉及什么项目，置信度多高，打算归档到哪个目录。第二阶段等我确认了说"yes"或者"--apply"才执行。plan 和 apply 之间有一道人类审批的墙。
输出包含五个标准模块。TL;DR——十条以内核心要点，一屏看完，不需要重读原文。行动项——checkbox 格式，直接可执行，每条标注负责人和截止时间。决策记录——谁在什么时候拍了什么板，这是事后追溯的关键。金句和证据——引用原话附时间戳，不是 AI 的总结，是原始证据，法律意义上的证据。风险信号——deep 模式下必须输出，涉及钱、合同、承诺的地方一个都不能漏。
它有两种模式。quick 用于日常站会、同步会，出 TL;DR 和行动项就够了。deep 用于涉及合作、谈判、钱、合同的场景。deep 模式额外输出角色立场分析——各方要什么、怕什么、底线在哪。承诺清单——谁承诺了什么、是否可验证。风险清单——最多五条，每条附原文证据。
还有一个低置信度处理机制。如果 AI 不确定这份转写该归到哪个项目，不硬塞。丢进 _Unsorted 目录，生成 A/B/C 选择题让人填字母收口。不确定就说不确定。 这条规则听起来简单，但大多数 AI 系统做不到。它们会编一个"最合理的答案"塞进去，三个月后你发现一份重要会议纪要被归到了错误的项目下面。
这个 Skill 有一个设计哲学值得展开。它把"分析笔记"和"原始转写"严格分开存储。分析笔记放在项目目录——轻量、有行动项、一眼扫完。原始转写放在 archive 目录——三万字完整保留，按需查看。分析笔记底部一个 wikilink 指向原文。
为什么要分开？因为你日常翻笔记不需要读三万字。你需要的是"这次会议谁说了什么、有哪些待办、有什么风险"。但某天你需要回溯某句原话的上下文，原始转写还在那里。
一个给效率，一个给真相。
obsidian-devlog：项目日志自动化
代码写完了，项目笔记空白。
这是所有开发者的通病。在代码仓库里奋战一周，git log 写了 40 条 commit。回头看 Obsidian 知识库里关于这个项目的笔记——空的。因为没人愿意在写完代码之后再写一份"项目进展总结"。
这个 Skill 就是来填这个坑的。它在代码项目目录运行，读 git log，自动生成 Obsidian 格式的项目笔记。
核心功能五个。追加 Dev Log：把 commit 历史变成人可读的项目日志，最新在上，旧条目一个字不动。更新 Stack 表：检测项目用了什么技术栈，生成表格。更新 Key Files 表：列出关键文件和入口点。生成架构图 Canvas：用 Obsidian 的 canvas 格式画架构图。全量同步：以上全做一遍。
关键设计原则：只追加，不覆盖。 Dev Log 最新条目插在最上面，旧的一个字不动。Stack 表和 Key Files 表更新前必须展示 diff，我看了确认了才写入。不是 AI 自说自话的自动化，是有人类在最后一公里审核的自动化。
这个 Skill 解决的是一个很具体的问题：代码在 GitHub，知识在 Obsidian，两边原本是断裂的。git log 记录了你做了什么，但不记录你学到了什么、踩了什么坑、做了什么设计决策。这个 Skill 把两边连起来。
代码仓库是行动的历史。知识库是认知的历史。两个都不能丢。
pku-gsm-distill：MBA 知识榨取流水线
我在北大光华读了 MBA。53 门课，花了好几十万。不能让知识烂在脑子里。
这个 Skill 把 MBA 课程系统性地"榨取"为知识原子。
三层架构。Source 层是原始素材——课件、转写、笔记，什么都不改，原样保存。Distill 层是提炼——从源素材中提取 Concept（概念）和 Skill（技能），每个都有严格定义、适用场景、证据锚点。Apply 层是应用——每个概念和技能链接到真实的业务案例，不能只停在"我学过"，要到"我用过"。
成果很具体。152 个 Concepts。52 个 Skills。173 个 Sessions。44 个 MOC（Map of Content）。跨课程去重整合完成。
这个流水线的核心设计是"双链接规则"。每个概念必须同时链接两个东西：证据来源和应用场景。没有证据的概念是空谈——你说"沉没成本"，证据在哪门课的哪个案例？没有应用的概念是学术——你学了"博弈论"，在哪个真实项目里用过？双链接强制让知识从"我知道"变成"我能用"。
处理 53 门课靠的是工业级的 AI 协作。分桶策略把课程分成四类：RICH（有完整文本）、SKELETON（只有标题）、MINIMAL（几乎没数据）、SKIP（跳过）。多 Agent 并行——data-fetcher 拉数据，三个 distiller 并行蒸馏，auditor 做质量审计，coordinator 管理依赖。全局去重注册表确保 152 个概念没有重复。
9 天。从 Notion 原始数据到结构化知识资产。如果用人工，保守估计三个月。
中间踩过一个坑值得说。管理经济学那门课，AI 蒸馏的时候编造了数据。源材料只有标题没有正文，AI 就自己"脑补"了案例和数据。被 auditor 抓出来了。这就是为什么分桶策略重要——SKELETON 课程只做骨架提取，绝不填充。源数据没有的内容，标 skeleton，不编造。AI 不编造是需要规则强制的，靠自觉是不行的。
MBA 花了几十万。这个 Skill 把课堂变成了可检索、可链接、可复用的知识资产。投资回报率，无限。
uncle-j-x-ops：X 运营自动化
X 运营是体力活。每天扫 timeline，找值得回复的帖子，写 reply，发 thread，排版 article。每个动作都可以自动化。但有一样东西不能自动化：人格。
这个 Skill 解决的就是"效率和人格一致性"的矛盾。
三种模式。蹭帖模式：用 Playwright 浏览器自动化扫 timeline，滚 5 屏收集帖子，分析后挑 3-5 个高价值目标，草拟 J叔风格的回复。展示给我看，我说"发"才发。Thread 发布模式：把长文拆成推文链，每条一个核心观点，第一条是钩子，最后一条是行动号召，通过 Playwright 自动发布。Article 发布模式：把 Markdown 长文解析成 JSON，通过剪贴板和 Playwright 填充到 X 的 Article 编辑器里，保存为草稿。
技术底层是 Playwright 浏览器自动化加 Chrome profile 持久化。用系统 Chrome 的登录态，不需要每次重新登录。headless 设为 false——让我能看到浏览器在干什么。透明，不黑箱。
但最重要的不是技术，是 IP 一致性守卫。每条内容发布前过三道检查。越界检查：是不是在教人做事？是不是在假装确定性？是不是在贩卖焦虑？人味检查：有没有个人立场？有没有承认不确定的地方？像不像 J叔会说的话？长期风险检查：六个月后我会不会想删这条？会不会损害"builder not guru"的形象？
三道检查任何一道不过，内容不会出现在发送列表里。
说一个算法层面的细节。X 的权重体系里，Reply 是 13.5 倍，RT 是 20 倍，Like 只有 1 倍。回复比点赞重要 13 倍。而 Reply-to-Reply——别人回复你之后你再回复——是算法里最高权重的动作。所以蹭帖不是随便回一句就走，要选对帖子，写出能引发二次回复的内容，然后追评。这个 Skill 管前面两步，第三步留给我本人。因为追评需要的是真实的对话能力，不是模板。
效率可以用机器堆。人格只能用规则守。
五个 Skill 的共同设计哲学
回看这五个 Skill，它们做的事完全不同——管文件、分转写、写日志、榨知识、发推文。但设计哲学是一样的。
每一个都有"plan 和 execute 分离"。先看方案，再决定做不做。每一个都有"人类审批的最后一公里"。AI 提议，人类拍板。每一个都有"不确定就说不确定"。宁可多问一句，不可乱做一步。
这不是谦虚。这是工程纪律。
AI 做执行，人做决策。这条线画清楚了，系统才能越跑越稳。画不清楚，第一天省了时间，第三十天全部返工。
Hooks 生命周期：3 个钩子构成闭环
操作系统有一个概念叫中断处理。CPU 在跑程序，外部信号来了，系统暂停当前任务，先处理中断，处理完再回去继续跑。你不用手动调度。它自己知道什么时候该响应。
Claude Code 的 Hook 系统就是这个逻辑。
我写了 3 个 Hook。加在一起不到 200 行 shell 脚本。但就是这不到 200 行，把 Claude Code 从一个对话工具变成了有记忆、有纪律、有审计的操作系统。
开机自检。写后校验。关机日志。三个时刻，三个钩子，一个闭环。
开机自检：session-orient.sh
每次打开 Claude Code 开始新对话，这个 Hook 自动运行。你什么都不用说。它先说。
它干四件事。
第一，展示 vault 结构。顶层目录长什么样，最近修改的五个文件是哪些。第二，检查 inbox 积压。两个收件箱各有多少待处理项。第三，显示 git 状态。有多少未提交的变更、最近三条 commit 是什么。第四，也是最关键的一件：检查本地和远端是否同步。如果远端有新内容——behind 大于零——自动提醒你 git pull。
为什么这件事重要？
因为没有上下文的 AI 是危险的。
你想象一下。你跟 AI 说"帮我整理一下笔记"。但 AI 不知道你昨晚改了什么。不知道 inbox 里积了十几条待处理的转写稿。不知道远端有人推了新内容——或者你自己在手机上用 Discord Bot 推了一条笔记。它就像一个刚走进办公室、完全不知道今天待办是什么的员工。它可能重复你已经做过的事。更危险的是，它可能覆盖别人刚推上去的内容。
所以，不看一眼现场就动手？不行。先做开机自检。
实际体验是这样的。我打开终端，输入 claude，回车。还没说话，终端里已经刷出来一屏信息。vault 结构、inbox 积压数量、最近改了什么文件、有多少东西没 commit、跟远端差几个版本。我扫一眼就知道今天该从哪里开始干活。
这就是环境感知。
人类走进办公室会看一眼桌面。看一眼日程表。问一句同事"昨天那个事怎么样了"。AI 也需要这个过程。只是它的同事是 git，它的日程表是 inbox，它的桌面是文件系统。
你给它一双眼睛，它才不会是瞎子。
写后检查：write-validate.sh
每次 Claude Code 往 vault 里写了一个 .md 文件，这个 Hook 自动触发。
它做两件事。一件管结构，一件管智慧。
第一件：frontmatter 检查。每个笔记文件需要三样"身份证"。文件是不是以 --- 开头？有没有 tags 字段？有没有 date 或 created 字段？缺任何一样，终端里会亮一行警告。
为什么这三样是必须的？因为没有 frontmatter 的笔记是孤岛。搜不到，分不了类，进不了知识图谱。一个 vault 里有上千个 .md 文件，如果其中两百个没有 tags，你的知识图谱就缺了两百个节点。不是内容不存在。是系统看不见它。
元数据是知识图谱的骨架。
第二件事更有意思：Naval 决策雷达。
触发条件很具体。路径包含 14-日记 或 01-J叔笔记——也就是日记和个人笔记。内容里出现了决策关键词——"决定"、"选择"、"要不要"、"纠结"、"该不该"、"权衡"、"底线"、"后悔"、"杠杆"。两个条件同时满足，雷达才响。
响的时候，终端里会静静亮出三个问题。
重构问题：你在问"要不要"——Naval 会问"这件事有非对称回报吗？"换句话说，赢了赚很多、输了亏不多的事，闭眼做。反过来的事，闭眼不做。大多数纠结都不需要 SWOT 分析，只需要判断一下收益和风险是不是不对称的。
杠杆测试：这件事离开你还能运转吗？如果答案是不能，你不是在做事业，你是在做工作。Naval 对杠杆的定义很简单——代码、媒体、资本、人。能复制的东西才有杠杆。不能复制的东西只能卖时间。
十年测试：80 岁的时候你会后悔没做吗？这个问题把时间轴拉长到一生。大多数让你纠结的事，放到十年尺度上看，答案是显而易见的。要么是"当然要做"，要么是"根本不重要"。
为什么是 Naval Ravikant？
因为 Naval 的决策哲学有一个特点：它用极简的框架处理复杂的选择。不需要决策矩阵。不需要 pros and cons 列表。三个问题就能把大多数决策切到本质。而且这三个问题是"非对称"的——它不帮你得出答案，它帮你换一个角度问问题。
这跟 AI 系统的设计哲学是一致的。系统不替你做决策。系统帮你更好地做决策。
为什么设计成非阻塞？因为写作心流不能被打断。你正在记一段想法，正写到关键处，突然弹出一个强制确认框"请先通过 Naval 决策检查"——这会毁掉整段心流。所以它只是在终端角落静静地亮一行字。你看到了，停下来思考两秒。没看到，也没关系。下次打开这篇笔记的时候，决策关键词还在，Naval 雷达还会响。
Naval 雷达是系统嵌入的哲学。
后来我用同样的模式加了两个新雷达。复盘雷达——在日记或月度复盘里出现"反思"、"教训"、"做对了"、"做错了"这类关键词时，自动推一个五步复盘框架。定价雷达——在搞钱或项目管理目录下出现"报价"、"定价"、"客单价"这类关键词时，推一个定价决策框架。三个雷达，同一个设计模式：关键词触发、路径限定、非阻塞提示。不打断你，但在你需要清醒的时刻，把框架推到你面前。
关机日志：session-capture.sh
每次 Claude Code 对话结束，这个 Hook 自动运行。
它做一件事：生成 session log。记录修改了哪些文件、新增了哪些未追踪的文件、有多少未提交的变更。如果有未提交的变更，加一个 warning callout 提醒你"记得检查并手动 commit"。
注意：它不会自动 commit。因为宪法 Git 授权规则写得很清楚——必须等用户说 commit 才能 commit。自动 commit 等于越权。即使是关机的时候，系统也不能自作主张。纪律不是在方便的时候才遵守的。
session log 保存在 00-系统维护/06-session-logs/ 目录下，按月归档到子目录，用时间戳命名。每一条都有标准的 frontmatter，tag 是 session-log 和 auto-generated。
450 条 session logs。不是我手动写的。每一条都是系统自动生成的。
这是审计追踪，也是记忆延伸。三个月后我想知道"2 月 15 号那天晚上我到底改了什么"，打开 session log 就知道了。不用翻 git log，不用回忆，不用猜。系统替你记住了一切。
不是因为你记性差。是因为一个有记忆的系统才是可靠的系统。
Hook 和 Skill 的区别
有人可能会问：Hook 和 Skill 有什么区别？
区别在确定性。
Skill 是概率性的。你告诉 AI"整理笔记"，它有可能触发 jdex-steward，也有可能不触发。取决于上下文、取决于措辞、取决于 AI 那一刻的"理解"。你不能保证它每次都对。
Hook 是确定性的。session 开始一定跑 session-orient。文件写入一定跑 write-validate。session 结束一定跑 session-capture。不依赖 AI 的判断。不受上下文影响。机械地、确定性地、每一次都跑。
确定性是系统可靠性的基石。在你最需要它运行的时候，它不会因为 AI"忘了"而不运行。
三个 Hook 构成闭环。开机知道状况。写的时候有质量门禁和哲学护栏。关机留下记录。从 session 开始的那一刻起，系统就在帮你记住一切、校验一切、审计一切。
不到 200 行 shell 脚本。但它们把 Claude Code 从一个聊天窗口变成了一个有值班日志的操作系统。
值班日志不起眼。但哪天出了事，你会庆幸每一班都有记录。
内容管线：从想法到七个平台
大多数人的写作流程是这样的：想到一个选题，坐下来写，写完发。
我的不是。
我的写作流程有七个阶段。从脑子里的一个念头，到七个平台上的成品内容，中间经过一条完整的工业级管线。不是比喻，是真的工业级——有质检，有分拣，有仓储，有配送。
Phase 0，选题。大多数人选题看流量——什么火写什么。我的系统第一步不看流量，看 IP 对齐。这个话题跟 AI 商业洞察有什么关系？跟我的实战经验有什么交集？如果答案是没有，不写。流量再大也不写。因为每一篇不对齐的文章，都是在稀释你的 IP 浓度。选题通过对齐检查之后，系统才去找钩子——这个话题里最反直觉的点是什么？然后从素材库里调取相关材料。素材不是现场找的，是平时积累的。
Phase 1，初稿。按故事流模板搭骨架。钩子开头，四个故事块展开，收尾点题。模板的作用不是让文章千篇一律，是让骨架稳固，这样你才敢在血肉上下功夫。写完初稿，跑一遍语言质量检查。
Phase 2 到 4，打磨。三轮。第一轮风格检查——有没有"首先其次最后"？有没有段落超过四行？有没有说教感？第二轮 IP 一致性检查——视角对吗？有实战感吗？说真话了吗？像 J叔吗？第三轮故事连贯性检查，确保叙事线不断。
三轮打磨听起来麻烦。但 AI 跑完这三轮，不到两分钟。
Phase 5，定稿。系统生成五个备选标题，跑一遍发布预检。标题决定打开率，正文决定转发率。两个都不能含糊。通过预检，文件移到待发布区。
Phase 6，多平台拆分。
这是整条管线里最暴力的一步。
一篇母版文章，一个指令，拆成七个平台的版本。公众号长文一篇。公众号图文一组，六到九张卡片。小红书套组三组——故事向、干货向、金句向。X/Twitter 主推加 Thread。朋友圈三个版本。短视频分镜一套，含旁白和 AI 画面提示词。
一篇文章进去，十几件弹药出来。
弹药库里现在有 70 篇待发内容。涵盖 X、小红书、LinkedIn、知乎、朋友圈、视频。随时可以部署到任何平台。这不是存稿。存稿是你写完了懒得发。这是弹药储备。打仗的人不靠临时造子弹，靠的是弹药库里永远有货。
七个阶段，说起来复杂，但有一个贯穿始终的检验标准，比所有检查清单加在一起都管用。
如果把署名换成别人，这篇文章还成立吗？
如果成立，说明没有 IP 辨识度。需要重写。
这个测试直指本质。你写的到底是"一篇好文章"还是"一篇只有你能写的文章"？市面上好文章太多了，多你一篇不多少你一篇不少。但"只有你能写的文章"是稀缺的。稀缺的东西才有定价权。
风格检查清单能帮你不犯错，但不能帮你找到自己。这个测试可以。因为它逼你回答一个问题——这篇文章里，你的实战在哪？你的视角在哪？你的判断在哪？如果都没有，你只是在搬运信息，不是在建立 IP。
每一篇文章在管线里都有明确的物理位置。
inbox 是灵感捕获，什么都往里扔。drafts 是正在写的稿子，从 v1 到 v3，版本号递增。review 是待发布区，通过预检才能进来。然后分发到各平台的成品库——公众号、小红书、X、LinkedIn、知乎、朋友圈、视频，每个平台一个目录。发布之后进已发布存档。
文件从左到右流动，每个阶段有入口有出口。不会有文件卡在中间不知道该往哪走，不会有成品混在草稿里，不会有发过的内容找不到。
这条管线最不显眼但最重要的设计，是双向流动。
素材从哪来？从知识库来。
思想力武器库里有 106 个判断单元。每一个都是一个可以展开成文章核心论点的观点。不是泛泛的"AI 很重要"，是具体的、有立场的、可以吵架的判断。辩证逆转模块有 25 篇正反合分析，天然的反直觉选题——读者以为你要说 A，你先说 A 再说非 A，最后给出一个他没想到的合。经济系统模块 70 多篇理论笔记，商业分析的弹药。PKU-GSM 榨出来的 152 个 Concepts，MBA 课堂精华搬进文章的捷径。
这些不是"参考资料"。这些是管线的上游原料。没有这些原料，管线再精密也是空转。
产出往哪去？进弹药库，进各平台成品库，进已发布存档。但同时也回流知识库。写文章过程中产生的新洞察、新框架、新方法论，归档到方法论萃取目录。写着写着发现一个新的判断单元，加进思想力武器库。分析一个案例时提炼出一个新模型，存进经济系统。
知识喂养内容，内容反哺知识。这是一个循环，不是一条直线。
知识库越厚，内容管线的弹药就越充足。内容写得越多，知识库里的方法论就越精炼。写到第三年，你会发现选题越来越快，因为武器库里的判断单元已经替你想好了该写什么。你会发现打磨越来越轻，因为 IP 的调性已经内化成肌肉记忆。
再往下延伸一步。知识变成内容，内容带来流量，流量转化变现，变现的反馈又优化知识。这不是四个孤立的动作，是一个飞轮。飞轮转起来之后，每一圈都比上一圈省力，每一圈都比上一圈产出更多。
大多数人把写作当成一个动作。坐下来，写，发。
它不是一个动作。它是一条管线，一个循环，一台机器。
Git 作为真相源
有人问我：你为什么这么执着于 Git？
Git 不是程序员用的版本管理工具吗？
不是。在我这里，Git 不是版本管理工具。Git 是知识系统的真相源。
什么是真相源？就是当你说"我这个月做了什么"的时候，不是靠记忆，不是靠感觉，是靠 diff。每一行变更都有记录。每一次提交都有时间戳。你说了不算，数据说了算。
这套系统有三个端，同时往一个 Git 仓库里写东西。
第一个端，本地 Claude Code。这是主力战场。我坐在电脑前，跟 Claude 对话，写文章、整理笔记、处理录音转写、搭建新系统。每一次改动都是一个 commit。思考的痕迹、决策的过程、推翻重来的记录——全部留在 git log 里。
第二个端，Discord Bot。它跑在云上。负责 X 运营的日报推送、各平台数据抓取、自动化任务执行。它不需要我在电脑前，自己就会往仓库里推内容。凌晨三点的日报、定时触发的数据采集，都是它干的。
第三个端，GitHub Web。我在地铁上、在饭桌上、在任何没有电脑的地方，打开手机浏览器，直接在 GitHub 网页编辑器里改。改完提交。三十秒搞定。
三个端。同一个 main 分支。没有 feature branch，没有 pull request，没有 code review。直接写 main。
听起来疯狂对吧？三个写入源同时往 main 推，不怕冲突吗？
怕。所以宪法里写了完整的冲突处理协议。
Session 开始，先 pull。写文件之前，再 pull。Commit 之前，pull --rebase。Push 失败了，pull --rebase 解决冲突再 push。遇到同行冲突自己解决不了？停下来问我。实在不行？git rebase --abort，退回安全状态。
核心原则只有一条——
远端内容永远不能被本地覆盖丢失。
这条原则写在 CLAUDE.md 里，是宪法级别的铁律。不管本地改了什么，云端 Bot 推了什么，手机上编辑了什么，任何一端的内容都不能因为另一端的操作而消失。宁可冲突报错停下来，也不能静默覆盖。
有人问，为什么不用 Obsidian Sync？
因为 Sync 是黑盒。
你不知道它同步了什么。你不知道它覆盖了什么。两台设备同时改了同一个文件，它怎么处理的？谁覆盖谁？你不知道。它不告诉你。出了问题你连排查的入口都找不到。
Git 不一样。每一次变更都有 diff。每一次冲突都有解决记录。每一个 commit 都有时间戳、有 message、有作者。谁在什么时候改了什么，一清二楚。
这是完整的审计追踪。不是"大概同步了"，是"精确到行的变更历史"。
月度复盘是 Git 驱动的。
不是打开一个空白文档，开始回忆"这个月我好像做了挺多事"。不是。是打开 git log，一条一条 commit 过。每个 commit 有时间戳、有描述、有 diff。改了哪些文件、加了多少行、删了多少行——全部可追溯。
这不是回忆。这是还原现场。
2026 年 2 月的数据：452 次 commit，截至 23 号。23 个活跃天，连续的。没有断过。12 篇 X Articles，四个主题乘以三种语言版本。8 个新系统上线——RSS 日报、PKU-GSM 知识榨取流水线、五引擎 X 运营系统、弹药管线全自动化、SFA AI 销售教练项目、CEO 知识库、分形日记系统、Continuous Learning V2。
峰值日是 SFA 项目那两天。48 小时内 61 个 commit。从零推到 52 个 Spec 全部交付、2716 个测试全绿、10.5 万行代码。
一个人。
你以为自己这个月很忙？看看 commit 数量。你以为某个项目花了一周？Git log 告诉你其实只花了两天，中间三天你在干别的。你以为你在一个系统上投入了大量精力？Diff 行数告诉你，那个系统只改了 200 行，真正吃掉你时间的是另一个你根本没意识到的方向。
Git 让你对自己诚实。 数据不会骗你。
说个真实的故事。
有一天 sync-skills.sh 脚本出了 bug。这个脚本负责把 Claude Code 的 Skills 文件同步到 Obsidian 知识库里。听起来是个简单的同步任务。
但是一行 rsync --delete 加上 rm -rf，逻辑写反了。
1174 个文件。瞬间。被删了。
不是移到回收站。是直接从磁盘上抹掉。如果没有 Git，这些文件就没了。永远。一千多个文件，包括笔记、方法论、系统配置、几个月的积累——全部灰飞烟灭。
但因为有 Git。
一条 git checkout -- 就全恢复了。一条命令。几秒钟。一千多个文件，原封不动地回来了。
然后我花了六个版本迭代，把 sync-skills.sh 从 v2.0 修到 v3.5。非破坏式同步、双源检测、全局优先、不覆盖已有内容、可选刷新。每一版的改动都在 git log 里，每一次的思考过程都有 commit message 记录。
核心教训是一句话：同步脚本永远不能假设"源没有的等于该删的"。
Obsidian 是知识档案，不是源码的 1:1 镜像。知识库里有用户手动加的内容、有其他渠道汇入的笔记、有历史积累。同步工具的职责是"补充"，不是"清洗"。删除权永远应该留给人。
这个事故让我对 Git 的信仰更深了一层。
Git 不只是版本管理。它是你犯了灾难性错误之后的后悔药。它是你敢大胆尝试的底气。因为你知道，不管搞砸了什么，git checkout 和 git rebase --abort 永远在那里等你。
还有 435 条自动生成的 session log。
每一次 Claude Code session 结束，系统自动记录：这次改了哪些文件、有多少未提交变更、session 持续了多久。这不是日记。这是系统的黑匣子。
飞机出事了要找黑匣子。系统出问题了要找 session log。哪次 session 引入了那个 bug？哪天的操作导致了文件结构变化？不用猜，翻 log。
435 条记录，覆盖整个 2 月。加上 452 条 commit，加上每条 commit 的 diff。这不是一个笔记系统的历史。这是一个知识系统的完整运行日志。
每个数字背后都有一条 git log 可以验证。这就是真相源的意思。
不是你说了算。是 diff 说了算。
风格即一致的约束
Steph Ango 说过一句话，我反复咀嚼了很久。
风格是一组你坚持的约束。
不是审美。不是装饰。是约束。
拥有一致的风格，意味着把数百个未来的决策压缩成一个。你不再需要每次都从零开始想。你只需要遵守你自己定下的规则。
听起来很简单。但大多数人做不到。
因为"决定"不难。难的是"不再重新决定"。
你有没有过这种体验。打开笔记软件，准备记点东西。然后你停下来了——这个标签叫"AI"还是"人工智能"？日期格式是 2026-02-26 还是 20260226？这篇笔记放"方法论"还是"思考"？
每一个问题都不大。但每一个问题都要你做一次判断。判断就是消耗。消耗就是阻力。阻力就是"算了，改天再说"。
这就是为什么很多人的笔记系统死在第三个月。不是因为工具不好。是因为微决策太多了。每次打开都要重新想"我该怎么组织这些东西"。想着想着就累了。累了就不想打开了。
风格解决的不是美学问题。是认知负担问题。
我的系统本身就是一种风格。
CLAUDE.md 铁律是风格。一旦写下 FATAL-001——擅自重组文件结构——以后再也不用纠结"AI 能不能帮我整理一下目录"。不能。没有例外。没有"这次特殊"。
Johnny.Decimal 编号是风格。00 是系统维护，01 是核心笔记，02 是内容运营。一旦编号确定，文件该放哪里就不再是一个问题。编号本身就是答案。
Frontmatter 格式是风格。tags、date、type、status——每篇笔记都一样。不一样的时候 Hook 会告诉你。
commit message 格式是风格。feat、fix、polish、refactor，冒号，中文描述。不需要每次想"这个 commit 怎么写"。格式已经替你想好了。
每一条规则都在做同一件事：把一个需要判断的瞬间，变成一个不需要判断的瞬间。
风格就是自动化。不是代码层面的自动化。是认知层面的自动化。
506 次 commit。60 天。平均每天 8.4 次。
有人觉得这个数字很夸张。每天八次？你是机器吗？
不是。恰恰相反。
不是因为自律。是因为系统在跑。
早上打开终端，开机自检告诉你 inbox 里积了三条语音转写。你顺手处理两条，commit 一次。写了半小时文章，Hook 自动校验格式，commit 一次。处理了一个 X 运营的弹药，commit 一次。session 结束，日志自动记录，commit 一次。
你没有"决定"要 commit 八次。你只是在系统里工作了一天。系统自己产生了八次心跳。
Steph Ango 还说过一个我特别喜欢的观点。每天做一点。 把标准设得太高，很容易给自己设障。习惯死于"全部或没有"。当你想"我要搭建一个完整的知识管理系统"，你很难开始。当你想"处理一条 inbox"，你很难不去做。
506 次 commit 里，没有一天是零。不是因为意志力。是因为系统把"做一点"的门槛降到了几乎为零。
这就是操作系统和笔记本的根本区别。
笔记本等你来写。你不来，它就空着。它不会提醒你。不会推你。不会在你忘了的时候替你记住。
操作系统推着你往前走。你打开终端，它已经在运转了。inbox 有积压它会告诉你。格式不对它会拦你。session 结束它会记录。你不需要"记得做"什么。你只需要出现。系统会带着你走完剩下的路。
笔记本是被动的容器。操作系统是主动的引擎。
选哪个，决定了你的系统是活着还是躺着。
点睛
回到最开始的那句话。
应用是过客。文件代代相传。
我选 Obsidian，不是因为它功能最多。恰恰相反。它选择在很多方面做得不好，然后在一个方面做到了极致——你的文件属于你。
纯文本。本地存储。Markdown 格式。没有私有数据库，没有云端锁定，没有"导出"按钮背后的数据阉割。你的笔记就是一堆 .md 文件。任何编辑器都能打开。哪天 Obsidian 倒了，你的文件还在。
这个选择看起来不起眼。但它决定了后面的一切。
因为文件属于你，所以可以用 Git。
因为可以用 Git，所以可以三端并发——本地写、Discord Bot 推送、GitHub Web 编辑，三条路径同时往 main 分支写入。
因为可以三端并发，所以可以让 AI 坐在操作台前。Claude Code 直接读写你的文件系统。不是通过 API 传来传去。是真的坐在你旁边，看着你的文件，动手帮你改。
因为 AI 坐在操作台前，所以需要宪法。CLAUDE.md。铁律。不可逾越的边界。不然它会帮你"整理"到你认不出自己的知识库。
因为有宪法，所以 Skills 有边界。85 个 Skill，每一个都知道自己能做什么、不能做什么。
因为 Skills 有边界，所以 Hooks 能确保质量。每次操作之后，自动校验，自动记录，自动收尾。
因为 Hooks 确保质量，所以内容管线能自动运转。从灵感到成品，从一篇文章到七个平台，流水线自己跑。
因为内容管线自动运转，所以一个人能活出一支团队的密度。
一环扣一环。起点是一个哲学选择。终点是一种生存方式。
有人问我，你一个 HR 出身的人，怎么搭出这种系统？
说白了，组织设计和系统设计是同一件事。
你管理 50 个人的时候做什么？明确边界——每个人负责什么，不负责什么。设定规则——什么能做，什么碰都不能碰。建立流程——从输入到输出，标准路径，不靠个人发挥。保留审批权——关键节点人类做决策，日常的事自己跑。
你管理 50 个 AI Agent 的时候做什么？一模一样。
明确边界。设定规则。建立流程。保留审批权。让系统自己跑。
唯一的区别是，AI 不请假。不摸鱼。不搞办公室政治。不会在群里发 30 条消息讨论一个本来 5 分钟能做完的决定。
但它比任何员工都更需要"宪法"。
因为它太勤快了。勤快到会主动帮你"整理"你的知识库。勤快到会在你没看的时候把文件挪来挪去。勤快到会用它认为"更合理"的结构，替换你花了半年建立的心智模型。
所以 FATAL-001 存在。所以 SCAN/PLAN/CONFIRM 存在。所以"不要帮我整理"这六个字被写进宪法。
HR 十年教给我的最重要的一件事：好的管理不是让人（或AI）发挥主观能动性。是画好框，让它在框里跑。框越清晰，跑得越快。框越模糊，翻车越惨。
这不是一篇教你怎么配置 Obsidian 的文章。
这里没有可以复制粘贴的 prompt。没有可以直接跑的脚本。没有一步一步的截图教程。
因为系统的价值不在配置。在设计。在取舍。
什么该自动化？格式校验、日志记录、文件归档、多平台拆分——这些是确定性的、重复的、不需要判断的。交给机器。
什么必须留给人类？选题方向、价值判断、风格把控、"这篇文章到底在说什么"——这些是模糊的、主观的、定义你是谁的。留给自己。
这条线画在哪里，没有标准答案。每个人的系统不一样，每个人的线也不一样。
但这条线必须你自己画。这个判断，只能你来做。
AI 时代最稀缺的能力，不是写代码。
代码可以让 AI 写。而且它写得越来越好。Prompt 可以让 AI 优化。而且它优化得比你快。内容可以让 AI 生成。而且它生成的量是你的一百倍。
那什么是 AI 做不了的？
设计系统。
不是设计软件系统。是设计"一个让 AI 替你干活但不替你做决策的系统"。是想清楚权责边界、流程节点、质量标准、兜底机制。是在 AI 能力爆炸式增长的时代，守住那条"这件事必须我来判断"的线。
系统设计的本质是取舍。取舍的前提是理解。理解的前提是你亲自下过场、踩过坑、做过判断、承担过后果。
这些，外包不了。
Steph Ango 把这个叫做"不要外包理解"。
你可以外包执行。让 AI 帮你写初稿、校验格式、拆分多平台、生成配图。
你可以外包重复劳动。让 Hook 自动记日志、自动检查 frontmatter、自动同步三端。
你可以外包几乎所有确定性的工作。
但你不能外包理解。
理解你自己的知识系统——为什么这个笔记放在这里而不是那里，为什么这个标签叫这个名字，为什么这条铁律存在。
理解你自己的工作方式——什么时候该深入，什么时候该收手，什么时候该写，什么时候该停下来想。
理解哪些事值得做，哪些事应该停下来。
这些是你的。
把它们交给任何人，任何工具，任何 AI——你就失去了系统的灵魂。系统还在跑，但它不再是你的了。它变成了一个你不理解的黑盒。跟用别人的 SaaS 没有区别。
操作系统的意义，从来不是"高效"。是"这套系统从里到外，每一个决策都是我做的，每一条规则都是我定的，每一个取舍都是我想清楚的"。
是你对自己工作方式的完整理解。
文件属于你。系统属于你。理解属于你。
AI？
过客。一个非常好用的过客。但终究是过客。
506 次 commit。每一次都是系统在呼吸。
我是J叔。这是我的操作系统。
