# My Claude Code OS Runs my $3M/yr Business. Steal This.
**作者**: Nate Herk
**日期**: 2026-05-01T07:34:46.000Z
**来源**: [https://x.com/nateherk/status/2050116705322512766](https://x.com/nateherk/status/2050116705322512766)
---
Frameworks. Repo anatomy. Connections. Skills. Routines. Wikis. Mindset shifts. Every gotcha I hit along the way.
By the end of this article, you'll know exactly how to build your own AI Operating System inside Claude Code, even if you've never opened it before.
## Why an AI OS in the First Place
An OS is the layer between you and your computer. macOS. Windows. iOS.
An AI OS is the same idea with intelligence on top.
It sees all your files. It touches your tools. It remembers better than you do. It can pull from the exact source faster than you can.
I'm not exaggerating when I say I could spend an entire workday with Claude Code open and still get more done than someone clicking through 30 different apps.
The reason this works is the four Cs sitting underneath it.
1. Context
2. Connections
3. Capabilities
4. Cadence
Once those four are in place, the OS runs in the background while your laptop is closed.
Tools change every six months. Models get deprecated. SDKs get retired. The Three Ms and the Four Cs don't. That's the durable layer this whole article is about.
## The Three Ms of AI™
Three habits to internalize before you touch the repo.
1️⃣ The Default Shift
→ Before any task, ask "how could AI do this, or at least 30 percent of it?"
→ I had to update 300+ YouTube descriptions last month. Old me would have clicked through every video. New me brainstormed with Claude Code, found an API path, done in minutes.
2️⃣ The Function Breakdown
→ Your role is a tree of tasks. A YouTube video isn't one job. It's ideation, scripting, packaging, descriptions, comment replies, and more.
→ You don't automate a YouTube video. You automate one chunk at a time. Each chunk is reusable across other workflows.
3️⃣ The Curiosity Rule
→ Never accept AI output without asking why.
→ Treat AI as a mentor, not a vending machine. Mentors push back, ask questions, sharpen you. Vending machines just take a coin.
Here's the part nobody warns you about. Productivity drops before it climbs.
When you make a real change, expect a 20 percent dip for the first few days. The question isn't "will this be hard." It's "is the dip worth the 50 percent gain on the other side."
Most people quit during the dip. Don't.
## The Four Cs of an AI OS™
This is the practical framework. The order matters.
→ Context: what AI knows about you, your team, your tools, your voice, your money
→ Connections: what data it can reach
→ Capabilities: what it can produce
→ Cadence: when it acts on its own while you sleep
You can't have cadence without connections. You can't have capability without context. Build them in order. One, two, three, four.
Easy test. Open a new Claude session. Ask it a real business question. Does it answer like a teammate or like a stranger who met you five seconds ago?
If it's the stranger, you have zero context. Start there.
## Map Your Tools Before You Touch the Repo
Before you open VS Code, sketch this on paper.
Seven tier-one domains:
→ Revenue
→ Customer
→ Calendar
→ Comms
→ Tasks
→ Meetings
→ Knowledge
For each one, write down where the data actually lives.
An example of what this could look like:
→ Revenue: Skool, Stripe, QuickBooks
→ Customer: Skool, YouTube
→ Calendar: Google Workspace
→ Comms: Google Workspace, ClickUp, Slack
→ Tasks: ClickUp, Notion
→ Meetings: Fireflies
→ Knowledge: YouTube transcripts, Google Workspace, local files
This sketch becomes your connections roadmap. Every tool here will eventually need an API key, an MCP, or a CLI bridge into Claude Code.
If you can't see all your business in one diagram, your AI OS won't either.
## Inside the Starter Repo
I built a Claude Code template that lives on GitHub. You clone it, open it in VS Code, and you're set up in five minutes.
https://github.com/nateherkai/AIS-OS
Here's what's in it and why each folder matters.
→ .claude/skills: where every reusable recipe lives. Ships with three skills out of the box: Audit, Level Up, and Onboard.
→ Archives: where Claude moves old documents you don't actively need. Don't delete, archive.
→ Contexts: where Claude builds out files like About Business, About Me, and Priorities. This is the Context C.
→ Decisions: an append-only log of meaningful decisions. When something matters, it gets a date, a reasoning, and a context entry.
→ References: external knowledge. The Three Ms doc lives here. Tool API references live here. SOPs live here.
→ claude.md: the master prompt for the entire project. It tells Claude who you are, how the folders work, when to invoke which skill, and where things live.
→ .env: your secret file. API keys go here, never in chat. Listed in .gitignore so it never gets pushed publicly.
The claude.md is the file that evolves the most. Mine gets updated two times a day. As you add new folders, new skills, new connections, this file gets the source-of-truth update so Claude actually knows your project.
## The Onboarding Skill (Day One)
You clone the repo, open it in VS Code, double-click Claude Code, and just say "I want to set up my AI operating system. Help me get onboarded."
It invokes the Onboard skill. Seven-question interview. By the end you have an About Me, About Business, Priorities, and a voice sample on disk.
Tip: don't type two-sentence answers. Use a voice tool like Glaido and dump three paragraphs into each answer. The richer the context, the better every future answer.
After onboarding, ask "what should I focus on this week?" and watch it pull from the three files it just wrote. That's your first proof the loop works.
## Connecting Tools the Right Way
Day two is connections. Here's the order I learned the hard way.
1️⃣ Make a separate account for your AI OS
→ Don't give Claude Code your personal API key with full permissions.
→ I made an account called Up at AI inside ClickUp and only gave that account's API key to Claude.
→ Same for Stripe, QuickBooks, anywhere it touches money.
→ Separate keys also let you see which automation is spending what.
2️⃣ Prefer API endpoints over MCP servers
→ MCPs load every endpoint and every function whether you need it or not. That eats tokens.
→ Tell Claude: "Use the API directly. Research the docs once, save them as a markdown reference, and pull from that file when you need an endpoint."
→ Markdown is cheap to read. API docs are expensive to crawl every time.
3️⃣ Store keys in .env, never in chat
→ Tell Claude to create the .env file with placeholders.
→ You paste the keys in the file and save. Never paste them into the chat history.
4️⃣ Default to bypass permissions only after you trust it
→ Plan mode is for brainstorming. Auto mode lets it do safe stuff and ask before risky stuff. Bypass lets it do everything.
→ I run on bypass. Has it deleted things? Yes. Only when I asked it to.
But here's the thing. The first time a connection fails, treat it as a gift.
Ask Claude to update the relevant API doc or skill so the same failure can never happen again. Every failure becomes permanent learning if you build the loop.
## Skills Are Where the Real Leverage Lives
Skills are reusable SOPs for your AI agents. Same way you'd train a human with an SOP, you train Claude with a skill.
A skill is just a folder. .claude/skills/skill-name/skill.md.
The skill.md has YAML front matter at the top with a name and description. Below it, the step-by-step instructions. That's it.
Anatomy of a skill:
→ Name and description: required, used by Claude to find the skill
→ Step-by-step rules: the actual SOP
→ Reference files: brand guidelines, tone, target avatars, anything heavy
→ Scripts: optional Python or JS that the skill can call
Reference files don't have to live nested under the skill folder. They can live in /references and the skill points to the path. Use whichever feels cleaner.
How Claude knows when to use a skill: progressive context loading.
→ Level 1: scan all skill front matter. Roughly 100 tokens per skill. Cheap.
→ Level 2: load the full skill.md if it picks one. Couple thousand tokens.
→ Level 3: only pull reference files when the task actually needs them.
That's why skill.md should stay under 500 lines and reference docs should be separate.
The six-step skill-building framework:
1️⃣ Name and trigger (slash command, natural language, or both)
2️⃣ Goal in one sentence (what's the output)
3️⃣ Step-by-step process (what you'd do manually, in order)
4️⃣ Reference files (what context does it need)
5️⃣ Rules and guardrails (what could go wrong)
6️⃣ The improvement loop (after you run it, update it)
Here's what stood out from my own skills.
The Pulse Check skill used to call the ClickUp MCP and search every list ID every time. Slow. Wasteful. So I hardcoded the list IDs into the skill.md itself. Now it knows them instantly.
It also delegates to a sub-agent called clickup-searcher so the heavy ClickUp data never blows the main context window.
That's the difference between a skill that runs and a skill that runs well. You watch it work the first few times. You patch the obvious waste. You move on.
The feedback cycle is the real unlock. Run it, watch it, give feedback, fix it, run it again. By the tenth run, the skill is sharp. By the thirtieth, it's part of how your business runs.
## Skills Live Two Places
Project-level: .claude/skills inside a specific repo. Only that project sees them.
Global: ~/.claude/skills in your home directory. Every Claude Code session can reach them.
I install front-end design as a global skill so it's there in any project. I keep business-specific skills in the Herk 2 repo so they only fire where they matter.
## Audit and Level Up: The Built-in Improvement Loop
The starter repo ships with three skills. Onboard you already met. The other two are how the OS keeps getting sharper without you having to think about what to build next.
1️⃣ Audit
→ Run /audit any time you feel stuck or want a checkup.
→ It scores your AI OS out of 100 across the four Cs: context, connections, capabilities, cadence.
→ Returns your top three gaps, ranked by leverage, not alphabetically.
→ Saves every audit so you can track your score climbing over time.
The first time I ran it, I got 54.5 out of 100. One day in. That's the right kind of honest.
2️⃣ Level Up
→ Run /level-up after the audit when you want capability gaps, not structural ones.
→ It pulls from your priorities, your connections, and what's reachable right now, then asks five questions:
→ Walk me through this past week. What did you do three or more times?
→ Drudgery. Anything manual, boring, or copy-paste?
→ Smart intern test. Anything a smart intern could absolutely handle that you did yourself because explaining it would take longer?
→ Constraint. If 500 new community members showed up Monday, what would break first?
→ Growth lever. What would give you 500 more clients tomorrow if it ran on autopilot?
Answer those five and there's no way you're stuck. Every answer surfaces a skill to build, an automation to run, or a connection to add.
The pair is the engine. Audit finds where the foundation is thin. Level Up finds where the next leverage point is hiding. Run them weekly and the OS improves on its own cadence.
## Cadence: Where It Becomes a 24/7 Employee
Capabilities make Claude useful when you ask. Cadence makes it useful when you don't.
Three options that matter.
1️⃣ Cloud Routines
→ Anthropic infrastructure. Your laptop can be off.
→ Triggered by schedule, API call, or GitHub event.
→ Pro plan: 5 runs a day. Max plan: 15. Team and Enterprise: 25.
2️⃣ Local Scheduled Tasks
→ Run on your machine, in the desktop app.
→ Catch up if you missed a run.
→ Need the app open and the computer awake.
3️⃣ Loop
→ One-off recurring runs inside a single session.
→ Three-day expiry, then auto-deletes.
→ Great for "every five minutes check if my deploy is done." Wrong for weekly recurring jobs.
Here's where Cloud Routines bite people. The gotcha list:
→ Routines run from a cloned GitHub repo. No local file access. If your skill needs a local file, the routine can't see it.
→ Your .env never gets pushed to GitHub (it's gitignored). So routines can't read your API keys from .env. You have to put them in the routine's cloud environment variables instead.
→ You also have to tell the prompt explicitly: "use the API key from the environment variable, don't look for a .env." Otherwise it'll try to read .env, fail, and stop.
→ Network access defaults to "trusted." That only allows known Anthropic-vetted domains. If you need ClickUp or anything else, switch the cloud environment to "full" access. There's a small risk if your inputs are untrusted, but for private repos with controlled inputs, it's fine.
→ Each run is stateless. The cloned repo gets destroyed after the run finishes. Anything that depends on cookies or local session state won't work.
→ Minimum interval is one hour. Loop and local tasks can go faster.
→ Don't push a massive 200MB repo into the cloud just to run a small routine. Spin up a smaller dedicated repo per routine if context is heavy.
Routines basically inject a prompt into a real Claude Code session. The same prompt you'd type yourself. So write specific, one-shot prompts. The routine isn't going to stop and ask clarifying questions for you.
## The LLM Wiki Layer (Karpathy's Idea)
This is the unlock most people miss.
Andrej Karpathy posted about using LLMs to maintain personal knowledge bases. No fancy RAG. No embeddings. No vector DB.
Just a folder with markdown files, an index file, and a log file.
The structure:
→ /raw: the source documents (transcripts, articles, meeting notes)
→ /wiki: the organized output (concepts, entities, sources, analysis)
→ /wiki/_index.md: the master index
→ /wiki/_log.md: append-only operation history
→ /wiki/_hot.md: a 500-token cache of what was most recently active
You drop a file into /raw and tell Claude "ingest this." It reads the source, creates wiki pages, builds backlinks between concepts, updates the index, logs the operation. Done.
I have two of these vaults running right now.
→ One is my YouTube transcripts vault. 36+ video transcripts ingested. I can ask any question about my own content and it answers from the wiki, not from a vector search.
→ One is my Herk Brain vault. My personal second brain. Meeting notes, business decisions, priorities, the works.
Why this matters: one X user moved 383 scattered files and 100+ meeting transcripts into a wiki and dropped token usage by 95 percent on queries.
It also kills the "I forgot which Slack thread that was in" problem. The wiki has the source link, the date, the entity references, all in one place.
Pair it with Obsidian if you want a visual graph view. Obsidian is just a markdown viewer, it changes nothing about how Claude reads the files. But the visual layer helps you spot relationship clusters you didn't know were there.
The hot cache is the move I'd missed. A small 500-token file at the top of the wiki that captures the active state of your week. Claude reads it first, before crawling the bigger wiki. Saves a ton of tokens on repeat queries.
## Mindset Shifts You'll Need
Building the OS is half technical, half psychological. The technical part is easy. The mindset part is where most people stall.
→ Default Shift: assume AI does it first. Manually do it only as a last resort.
→ Function Breakdown: every job is a tree of tasks. Automate the leaves first, not the trunk.
→ Treat AI as a mentor: don't ask "do this for me." Ask "should I do this, what would you do differently."
→ Never binary: the question is never "can AI do this?" It's "to what percentage."
→ Productivity drops before it climbs: take the 20 percent dip seriously. The 50 percent gain is on the other side.
→ Failure is data: every broken run becomes a skill update or a reference doc update. Nothing breaks twice.
→ POC mindset: Proof of Concept first. Build the cheapest version. If it proves out, then dedicate real resources. I built dashboards as Claude Artifacts before ever investing time into a custom dashboard.
→ Per-account permissions: separate API keys per agent or per service. Restrict scope. Read-only where possible. Audit which automation is spending what.
→ Boring is beautiful: deterministic workflows beat AI agents nine times out of ten. Most business processes don't need autonomy. They need a Python script that runs on a cron.
## Daily and Weekly Loops
Daily:
→ Morning: ask Claude to plan your day. If the plan is bad, write down what context it was missing. Patch tomorrow.
→ End of day: which skills did you use, which prompts did you have to repeat, what did you have to correct.
Weekly:
→ Friday: run /audit, then /level-up. Pick one gap from each, build it next week.
→ Repeat.
That's the whole rhythm. The OS doesn't need a manager. It needs a loop.
## Success Criteria for an AI OS
Not KPIs. Subjective signals that it's working.
1️⃣ Your team would rather message your AI OS than message you (because it has better memory and never sleeps)
2️⃣ You stop opening browser tabs (because most of your work happens inside Claude Code)
3️⃣ Knowledge leaves your head (because it lives in the wiki, the contexts folder, and the skills)
If even two of three are true within a month, the system has taken.
## Wrap
The whole thing is just folders, markdown files, and a few API keys.
The frameworks make it durable. The repo gives you a starting point. The skills make it leverageable. The cadence makes it autonomous. The wiki makes it permanent.
Tools change. Models change. The Three Ms™ and the Four Cs™ don't.
I walk through every step of this build live in the full video. Link in the first reply.
## 相关链接
- [Nate Herk](https://x.com/nateherk)
- [@nateherk](https://x.com/nateherk)
- [https://github.com/nateherkai/AIS-OS](https://github.com/nateherkai/AIS-OS)
- [3:34 PM · May 1, 2026](https://x.com/nateherk/status/2050116705322512766)
- [9,070 Views](https://x.com/nateherk/status/2050116705322512766/analytics)
- [View quotes](https://x.com/nateherk/status/2050116705322512766/quotes)
---
*导出时间: 2026/5/1 18:52:29*
---
## 中文翻译
# 我的 Claude Code 操作系统经营着我那价值 300 万美元/年的业务。拿去用吧。
**作者**: Nate Herk
**日期**: 2026-05-01T07:34:46.000Z
**来源**: [https://x.com/nateherk/status/2050116705322512766](https://x.com/nateherk/status/2050116705322512766)
---
框架。仓库结构。连接。技能。常规。Wiki。思维转变。这一路走来的每一个坑。
读完这篇文章，你将确切知道如何在 Claude Code 中构建你自己的 AI 操作系统，即使你之前从未打开过它。
## 为什么一开始要做一个 AI OS
操作系统是你和电脑之间的那一层。macOS。Windows。iOS。
AI OS 也是同样的概念，只是上面多了一层智能。
它能看到你所有的文件。它能触碰你的工具。它比你记得更牢。它能比更快地从源头提取信息。
我说我不夸张，我可以花一整天时间开着 Claude Code，完成的工作仍然比一个在 30 个不同应用间点击的人要多。
这之所以有效，是因为底层的四个 C。
1. Context（上下文）
2. Connections（连接）
3. Capabilities（能力）
4. Cadence（节奏）
一旦这四个到位，即使你合上笔记本电脑，操作系统也会在后台运行。
工具每六个月变一次。模型会被弃用。SDK 会退休。但“三个 M”和“四个 C”不会。这就是整篇文章所关注的持久层。
## AI 的三个 M™
在接触仓库之前，需要内化的三个习惯。
1️⃣ 默认转向
→ 在任何任务之前，问自己“AI 怎么做这个，或者至少做其中的 30%？”
→ 上个月我不得不更新 300 多个 YouTube 描述。以前的我会逐个点击视频处理。现在的我和 Claude Code 头脑风暴，找到了一条 API 路径，几分钟搞定。
2️⃣ 功能拆解
→ 你的角色是一棵任务树。一个 YouTube 视频不是一份工作。它是构思、脚本、包装、描述、评论回复等等。
→ 你不能自动化一个 YouTube 视频。你一次自动化一个块。每个块在其他工作流中是可复用的。
3️⃣ 好奇心规则
→ 永远不要在没有问为什么的情况下接受 AI 的输出。
→ 把 AI 当作导师，而不是自动售货机。导师会反驳，会提问，会磨炼你。自动售货机只是吞硬币。
这里有个没人警告你的部分。生产力在提升之前会先下降。
当你做出真正的改变时，前几天预期会有 20% 的下降。问题不在于“这会不会很难”。而在于“这种暂时的低谷是否值得换来另一边 50% 的提升”。
大多数人在低谷期放弃。别这样。
## AI OS 的四个 C™
这是实操框架。顺序很重要。
→ Context（上下文）：AI 关于你、你的团队、你的工具、你的语调、你的资金知道些什么
→ Connections（连接）：它能触及哪些数据
→ Capabilities（能力）：它能生产什么
→ Cadence（节奏）：当你睡觉时它何时自行行动
没有连接就没有节奏。没有上下文就没有能力。按顺序构建它们。一、二、三、四。
简单的测试。打开一个新的 Claude 会话。问它一个真正的业务问题。它回答得像一个队友，还是像一个五秒钟前才遇到你的陌生人？
如果是陌生人，你的上下文就是零。从这里开始。
## 在接触仓库之前先映射你的工具
在打开 VS Code 之前，在纸上画一下这个。
七个一级领域：
→ Revenue（营收）
→ Customer（客户）
→ Calendar（日历）
→ Comms（通讯）
→ Tasks（任务）
→ Meetings（会议）
→ Knowledge（知识）
对于每一个，写下数据实际存放的位置。
这大概是什么样子的一个例子：
→ Revenue（营收）：Skool, Stripe, QuickBooks
→ Customer（客户）：Skool, YouTube
→ Calendar（日历）：Google Workspace
→ Comms（通讯）：Google Workspace, ClickUp, Slack
→ Tasks（任务）：ClickUp, Notion
→ Meetings（会议）：Fireflies
→ Knowledge（知识）：YouTube 文字记录, Google Workspace, 本地文件
这个草图将成为你的连接路线图。这里的每个工具最终都需要一个 API 密钥、一个 MCP 或一个通往 Claude Code 的 CLI 桥接。
如果你不能在一个图表中看到你的整个业务，你的 AI OS 也做不到。
## 初始仓库内部
我在 GitHub 上建立了一个 Claude Code 模板。你克隆它，在 VS Code 中打开，五分钟即可设置完成。
https://github.com/nateherkai/AIS-OS
下面是里面的内容以及为什么每个文件夹很重要。
→ .claude/skills：每个可复用配方所在的地方。默认自带三个技能：Audit（审计）、Level Up（升级）和 Onboard（入职）。
→ Archives：Claude 移动你不需要的旧文档的地方。不要删除，而是归档。
→ Contexts：Claude 构建诸如 About Business（关于业务）、About Me（关于我）和 Priorities（优先事项）等文件的地方。这是 Context C。
→ Decisions：有意义决策的仅追加日志。当事情重要时，它会获得一个日期、一个理由和一个上下文条目。
→ References：外部知识。三个 M 的文档住在这里。工具 API 参考住在这里。SOP（标准作业程序）住在这里。
→ claude.md：整个项目的主提示词。它告诉 Claude 你是谁，文件夹如何工作，何时调用哪个技能，以及东西在哪里。
→ .env：你的秘密文件。API 密钥放在这里，绝不要放在聊天中。列在 .gitignore 中，这样它永远不会被公开推送。
claude.md 是演变最多的文件。我的一天更新两次。当你添加新文件夹、新技能、新连接时，这个文件会得到“真实来源”的更新，以便 Claude 真正了解你的项目。
## 入职技能（第一天）
你克隆仓库，在 VS Code 中打开它，双击 Claude Code，然后直接说“我想设置我的 AI 操作系统。帮我完成入职。”
它调用 Onboard 技能。七个问题的面试。最后，你在磁盘上有了 About Me、About Business、Priorities 和一个语音样本。
提示：不要输入两句话的答案。使用像 Glaido 这样的语音工具，并在每个答案中倾倒三段话。上下文越丰富，未来的每个答案就越好。
入职后，问“我这周应该关注什么？”并看着它从它刚刚编写的三个文件中提取信息。这是循环有效的第一个证明。
## 以正确的方式连接工具
第二天是连接。这是我艰难学到的顺序。
1️⃣ 为你的 AI OS 创建一个单独的账户
→ 不要把具有完全权限的个人 API 密钥给 Claude Code。
→ 我在 ClickUp 中创建了一个名为 Up at AI 的账户，只把那个账户的 API 密钥给 Claude。
→ Stripe、QuickBooks、任何涉及金钱的地方也是一样。
→ 单独的密钥还让你能看到哪个自动化花了什么钱。
2️⃣ 优先使用 API 端点而不是 MCP 服务器
→ MCP 会加载每一个端点和每一个函数，不管你需不需要。这会吃掉 token。
→ 告诉 Claude：“直接使用 API。研究一次文档，将其保存为 markdown 参考，当你需要一个端点时从该文件中提取。”
→ Markdown 读取便宜。每次爬取 API 文档昂贵。
3️⃣ 将密钥存储在 .env 中，绝不要在聊天中
→ 告诉 Claude 创建一个带有占位符的 .env 文件。
→ 你将密钥粘贴到文件中并保存。永远不要将它们粘贴到聊天记录中。
4️⃣ 只有在你信任它之后才默认绕过权限
→ Plan 模式用于头脑风暴。Auto 模式让它做安全的事情，在冒险的事情之前询问。Bypass 让它做所有事情。
→ 我在 Bypass 模式下运行。它有没有删过东西？有的。只有在我要求它的时候。
但事情是这样的。第一次连接失败时，把它视为一种礼物。
让 Claude 更新相关的 API 文档或技能，以便同样的失败永远不会再次发生。如果你建立循环，每一次失败都会成为永久的学习。
## 技能是真正的杠杆所在
技能是你的 AI 智能体的可复用 SOP。就像你用 SOP 训练人类一样，你用技能训练 Claude。
技能只是一个文件夹。.claude/skills/skill-name/skill.md。
skill.md 的顶部有 YAML front matter，包含名称和描述。下面是分步说明。就是这样。
技能的剖析：
→ 名称和描述：必需，Claude 用它来查找技能
→ 分步规则：实际的 SOP
→ 参考文件：品牌指南、语调、目标画像，任何繁重的东西
→ 脚本：技能可以调用的可选 Python 或 JS
参考文件不必嵌套在技能文件夹下。它们可以住在 /references 中，技能指向路径。使用哪个感觉更干净就用哪个。
Claude 如何知道何时使用技能：渐进式上下文加载。
→ Level 1：扫描所有技能 front matter。每个技能大约 100 token。便宜。
→ Level 2：如果选择了一个，加载完整的 skill.md。几千个 token。
→ Level 3：只有当任务真正需要时才提取参考文件。
这就是为什么 skill.md 应保持在 500 行以下，参考文档应该分开。
六步技能构建框架：
1️⃣ 名称和触发器（斜杠命令、自然语言或两者皆有）
2️⃣ 一句话目标（输出是什么）
3️⃣ 分步过程（你会手动做的事情，按顺序）
4️⃣ 参考文件（它需要什么上下文）
5️⃣ 规则和护栏（什么可能出错）
6️⃣ 改进循环（你运行它后，更新它）
以下是我自己的技能中突出的地方。
Pulse Check 技能过去每次都调用 ClickUp MCP 并搜索每个列表 ID。慢。浪费。所以我将列表 ID 硬编码到了 skill.md 本身中。现在它立即知道它们。
它还委托给一个名为 clickup-searcher 的子智能体，这样繁重的 ClickUp 数据永远不会撑爆主上下文窗口。
这就是一个能运行的技能和一个运行良好的技能之间的区别。你看着它工作前几次。你修补明显的浪费。然后继续前进。
反馈周期是真正的解锁。运行它，观察它，给出反馈，修复它，再次运行。到第十次运行时，技能就很敏锐了。到第三十次时，它就成了你业务运行方式的一部分。
## 技能存在于两个地方
项目级：.claude/skills 在特定的仓库内。只有那个项目能看到它们。
全局：~/.claude/skills 在你的主目录中。每个 Claude Code 会话都可以访问它们。
我将前端设计安装为全局技能，这样它在任何项目中都在。我将业务特定的技能保留在 Herk 2 仓库中，这样它们只在相关的地方触发。
## 审计和升级：内置的改进循环
初始仓库自带三个技能。Onboard 你已经见过了。另外两个是操作系统如何在不让你思考下一步构建什么的情况下保持更敏锐。
1️⃣ Audit（审计）
→ 当你感到卡住或想要检查时随时运行 /audit。
→ 它在四个 C 上给你的 AI OS 打分（满分 100）：上下文、连接、能力、节奏。
→ 返回你的前三个差距，按杠杆排序，而不是按字母顺序。
→ 保存每次审计，以便你可以跟踪分数随时间的攀升。
我第一次运行时，得到了 100 分里的 54.5 分。一天时间。这是那种正确的诚实。
2️⃣ Level Up（升级）
→ 在审计后运行 /level-up，当你想要能力差距而不是结构性差距时。
→ 它从你的优先事项、你的连接以及目前可接触的东西中提取，然后问五个问题：
→ 带我回顾一下过去的一周。你做了三次或更多次的事情是什么？
→ 苦差事。任何手动的、无聊的或复制粘贴的事情？
→ 聪明实习生测试。有什么事情是一个聪明的实习生绝对能处理的，但你因为解释起来需要花更长时间而自己做了？
→ 约束。如果周一来了 500 个新社区成员，什么会最先崩溃？
→ 增长杠杆。如果它在自动 pilot 上运行，什么会明天给你带来 500 个更多的客户？
回答这五个问题，你就不会卡住了。每个答案都会揭示一个要构建的技能，一个要运行的自动化，或一个要添加的连接。
这一对是引擎。Audit 找出哪里基础薄弱。Level Up 找出下一个杠杆点隐藏在哪里。每周运行它们，操作系统会按照自己的节奏改进。
## 节奏：它变成 24/7 员工的地方
能力让你在询问时 Claude 有用。节奏让你在不询问时它也有用。
三个重要的选项。
1️⃣ Cloud Routines（云例行程序）
→ Anthropic 基础设施。你的笔记本电脑可以关机。
→ 由时间表、API 调用或 GitHub 事件触发。
→ Pro 计划：每天 5 次运行。Max 计划：15 次。Team 和 Enterprise：25 次。
2️⃣ Local Scheduled Tasks（本地计划任务）
→ 在你的机器上运行，在桌面应用中。
→ 如果你错过了一次运行，它会补上。
→ 需要应用打开且电脑唤醒。
3️⃣ Loop（循环）
→ 单个会话内的一次性重复运行。
→ 三天有效期，然后自动删除。
→ 适合“每五分钟检查一次我的部署是否完成”。不适合每周重复的工作。
这就是 Cloud Routines 咬人的地方。坑人清单：
→ 例行程序从克隆的 GitHub 仓库运行。没有本地文件访问。如果你的技能需要本地文件，例行程序看不到它。
→ 你的 .env 永远不会被推送到 GitHub（它被 gitignore 了）。所以例行程序不能从 .env 读取你的 API 密钥。你必须将它们放在例行程序的云环境变量中。
→ 你还必须明确告诉提示词：“使用来自环境变量的 API 密钥，不要寻找 .env。”否则它会尝试读取 .env，失败，然后停止。
→ 网络访问默认为“受信任”。这只允许已知的 Anthropic 审核过的域。如果你需要 ClickUp 或其他任何东西，将云环境切换到“完全”访问。如果你的输入不受信任，会有很小的风险，但对于具有受控输入的私人仓库，这没问题。
→ 每次运行是无状态的。克隆的仓库在运行完成后被销毁。任何依赖 cookies 或本地会话状态的东西都不会工作。
→ 最小间隔是一小时。Loop 和本地任务可以更快。
→ 不要为了运行一个小小的例行程序就把一个巨大的 200MB 仓库推送到云端。如果上下文很重，可以为每个例行程序启动一个更小的专用仓库。
例行程序基本上是将一个提示词注入到一个真正的 Claude Code 会话中。就像你自己输入的提示词一样。所以要写具体的、一次性的提示词。例行程序不会停下来为你澄清问题。
## LLM Wiki 层（Karpathy 的想法）
这是大多数人错过的解锁。
Andrej Karpathy 发帖关于使用 LLM 维护个人知识库。没有花哨的 RAG。没有嵌入。没有向量数据库。
只是一个带有 markdown 文件、索引文件和日志文件的文件夹。
结构：
→ /raw：源文档（文字记录、文章、会议笔记）
→ /wiki：有组织的输出（概念、实体、来源、分析）
→ /wiki/_index.md：主索引
→ /wiki/_log.md：仅追加操作历史
→ /wiki/_hot.md：最近活动内容的 500 token 缓存
你将一个文件丢进 /raw 并告诉 Claude“摄取这个”。它读取源文件，创建 wiki 页面，在概念之间建立反向链接，更新索引，记录操作。完成。
我现在运行着两个这样的库。
→ 一个是我的 YouTube 文字记录库。摄取了 36 个以上的视频文字记录。我可以问任何关于我自己内容的问题，它从 wiki 回答，而不是从向量搜索。
→ 一个是我的 Herk Brain 库。我的个人第二大脑。会议笔记、业务决策、优先事项，所有东西。
为什么这很重要：一个 X 用户将 383 个分散的文件和 100 多个会议文字记录转移到一个 wiki 中，查询的 token 使用量减少了 95%。
它还解决了“我忘记那是哪个 Slack 线程”的问题。Wiki 有源链接、日期、实体引用，都在一个地方。
如果你想要可视化的图形视图，可以将它与 Obsidian 配对。Obsidian 只是一个 markdown 查看器，它不改变 Claude 读取文件的方式。但可视化层帮助你发现你不知道存在的关集群。
热缓存是我错过的招数。位于 wiki 顶部的一个小型 500 token 文件，捕捉你的一周的活动状态。Claude 在爬取更大的 wiki 之前先读取它。在重复查询上节省大量 token。
## 你需要的思维转变
构建 OS 一半是技术，一半是心理。技术部分很容易。思维