# Stop using AI. Start having AI systems running.
**作者**: Will Chen
**日期**: 2026-07-23T07:23:07.000Z
**来源**: [https://x.com/stablechen/status/2080191964247625824](https://x.com/stablechen/status/2080191964247625824)
---
I used to use AI the normal way. I’d open ChatGPT or Claude, ask for something, get an answer, and close the window. The next conversation started from scratch.
That’s no longer how I work. I have AI systems running.
When I open my coding agent, it already shows my goals, focus, and habits. One sentence about playing pickleball can update cardio and my social log. I can ask questions against fourteen years of journals, old AI conversations, work recordings, and transcripts from walks. At night I can send agents into separate Git branches and review what they built the next morning.
It looks very planned when I list it all out. It wasn’t.
Most of it came from complaining to a coding agent. I’d lose a good thought on a walk, forget to open a habit app, or find myself correcting the same agent behavior again. I’d say what was annoying me, let the agent change the repo, and keep using the new version. This happened almost every day for a few months.
Each change felt trivial. Together they became an environment that remembers what I’m doing, carries state from one day to the next, and keeps working after I leave.
I have one fairly stubborn rule: if using a system feels like extra work, I’m eventually going to stop using it. I don’t find that morally interesting. I’d rather change the interface, timing, or division of labor than keep rediscovering that I can’t force myself through the same bad setup forever.
AI makes it cheap to keep changing the setup. Language practice can happen during cardio. Thinking can happen while I walk. A habit tracker can live inside the coding agent I already have open. A correction I make once can become a rule that every later agent inherits.
This is the stack I ended up keeping.
## Pi: the harness that grows the stack
I have a hard time getting excited about most AI productivity apps. There are so many of them, and I’m usually thinking that somebody else’s hand-built workflow isn’t going to fit me as well as my own repo plus Claude. The tools I keep tend to add a new primitive or extend what a coding agent can already do.
Pi is the main harness for AI Organs. I didn’t feel the x-factor with OpenClaw, even when everybody was excited about it. I felt it with Pi, t
The reason is simple: Pi can modify the environment it’s running inside. If I want another command, a different view, or a rule that should survive the conversation, I tell the agent in normal language and it edits the harness. I don’t file myself a feature request and come back on the weekend.
This still feels like firing off Claude. The difference is that the answer sometimes becomes part of the place where I work. I asked for my habits to appear instantly, so Ctrl+H now opens them. I wanted one log entry to update several parts of my life, so the logging command learned how. If I have to give the same correction twice, I tell the agent to put it in an instruction, test, or example.
Everything lives in one repo. AGENTS.md is symlinked to CLAUDE.md, so I can drive the same system with Claude Code when I want Claude Fable 5, or through AI Organs when I want Pi. I care more about the repo than model continuity. The files, commands, history, tests, and permissions are still there when I switch models.
This is why the stack grew without feeling like a separate project. A problem appears while I’m already working. I complain in the same window, the agent changes the place where it happened, and I go back to what I was doing.
After months of that, the repo contains a strange amount of me: commands I reach for without thinking, policies I no longer want to reconsider, interfaces fitted to my attention, and records that let agents begin with context I’d never fit into a prompt. None of this felt ambitious while I was adding it one irritation at a time.
I started calling the stateful pieces organs because they don’t behave like ordinary apps. Each one owns a domain—habits, money, language learning, work history—and leaves behind enough state for an agent to pick up later. I can switch models without losing that accumulated body.
## Tools
Some of the most important pieces are ordinary products used in a slightly weird way.
## Plaud NotePin
The Plaud NotePin is a $180 recorder I wear on a lanyard when I walk through Golden Gate Park or along Ocean Beach. The price is honestly offensive because the hardware is basically a Bluetooth microphone with a button, and then they charge monthly for transcription. What the fuck are you paying $180 for?
I bought it anyway. A phone app can do the same thing for most people, but I wanted to record for hours and send the output into my own pipeline. The dedicated object removes the choice. I put it on, hold the button, feel it buzz, and start walking.
On a long day I can walk 40–50,000 steps because I’m busy talking. I don’t need a subject before I leave. I can spend the first ten minutes complaining that I have nothing to say, repeat myself, take the wrong branch, and eventually find the thing I actually care about. I keep walking because I haven’t finished the thought.
The recording quality doesn’t have to be great. Wind, traffic, and half-finished sentences used to make this kind of archive pointless. Modern transcription is spectacular. It can recover words that are barely audible and an LLM can reconstruct an argument that arrived out of order.
People also wildly overestimate how much text a human life produces. Hours of speech sound like an absurd data problem, but it isn’t that many tokens. It’s easily managed.
This is why I’m willing to ramble. Coherence can happen later. A model can recover the argument, keep the phrases that still sound like me, show me what I kept circling, and ask whether it got the reconstruction right. The only part I have to do live is capture the thought before it disappears.
Andrej Karpathy recently described the ten-minute desk version of this pattern: switch to voice, ramble without filtering, and let the model reconstruct the thought. He writes that “LLMs are somehow very good at reconstructing long incoherent rambles.”
https://x.com/karpathy/status/2079610838143623371?s=20
Plaud is the same move worn on a lanyard and allowed to run for an afternoon.
Since April 14, the NotePin has captured 61 transcripts and 586,192 words across 41 days. Those walks now feed essays, language lessons, decisions, prototypes, and searches I couldn’t have anticipated while I was talking.
You’d be surprised how much signal you emit in daily life. Most of it disappears because it doesn’t arrive in publishable order. Walking and commuting used to be dead time. Now they produce raw material while also making the day more enjoyable.
The pipeline still lags sometimes. I don’t care. A transcript can be summarized next week or reprocessed by a better model next year. The only permanent failure is not recording it.
## OBS + timer
One thing I’ve always struggled with is starting remote work. You can call it procrastination or ADHD, but I don’t find either label very helpful. They make it sound like a moral failure and don’t tell me what to change. The actual problem is usually the ten minutes before I begin. Once I’m working, I’m fine.
I open OBS, the free streaming app, and record my screen with a small box of my talking head in the corner. Then I set a physical timer, usually for 45 minutes. That is the backbone of my ability to work.
I’m basically pretending to livestream. I explain what I’m about to do, narrate while I do it, and talk through whatever is confusing me. The audience is my future self, plus whatever agents end up reading the transcript. I like to ramble, so this makes the work much more engaging than sitting silently at a computer trying to be disciplined.
I also make weird noises and occasionally sing to entertain or embarrass my future self. Once you get over how strange it is to have a tiny livestream with no viewers, I can’t imagine working without it.
The recording fixes another problem I didn’t have a good name for: work often feels like it won’t count. You can spend an hour trying something, get nowhere, close the laptop, and feel as if the hour disappeared. If I record it, the session exists. Even a bad block shows what I tried, where I got stuck, and what I was thinking at the time.
The files upload to Dropbox and a private, unlisted YouTube playlist. YouTube is free video storage. I have gigabit upload at home, storage is cheap, and my protocol is record, trim the ends, post. If I open Premiere, DaVinci, or CapCut, I’ve already fucked it up. Editing turns a work record into a content project.
The timer matters, but I use it differently depending on the work. For execution, I keep the countdown visible. For open-ended thinking, I hide it; watching the minutes drain makes generative work worse. Either way, the timer externalizes the boundary so I don’t have to keep asking myself whether I’ve worked long enough.
This is seriously a life hack for ADHDers. It’s useful for self-study, auditing where your time went, and holding onto a thread long enough to finish it. Speaking out loud gives the attention somewhere to go.
OBS is reality contact.
I got the idea from watching George Hotz do eight-hour livestreams and stay completely locked in. There are now more than 1,500 hours on my private playlist. A friend once doubted that I was actually working, so I sent him the link. He looked at it and invested $10,000 immediately. Fifteen hundred hours of footage is hard to bullshit.
I used to justify recording everything by saying that a future model might be able to use it. That future has already started. Cortex contains transcripts from 542 sessions, and agents retrieve what I said while I was working alongside my chats, walks, journals, and logs. I’m not saving video in the abstract hope that it becomes useful one day. Five hundred forty-two sessions are already memory.
## Raycast snippets
Raycast is basically a command line for normal people on a Mac. The first thing I tell people is to disable Spotlight and give Command+Space to Raycast instead.
The real difference is programmability. Spotlight searches for things Apple decided it should search for. Raycast can run extensions, scripts, snippets, window commands, and my own AI commands from the same box. I have an extension where I type money and see my bank balances. If I want a new behavior, I can write it once and summon it from anywhere on the computer. It feels closer to adding a command to myself than installing another app.
Snippets are the smallest part and maybe my favorite. I type a short trigger in any text box and Raycast expands it into a timestamp, a template, or a whole way of interacting with an LLM.
My most-used one is `!bear`, the clarity bear:
> First think deeply, reviewing and then interview me, one question at a time presenting me well-considered options and suggestions to advance your clarity until you reach 100% clarity. For each question try to indicate what the source of confusion might be, or how answering this will determine something you need (be concise). Try to opt for multiple-choice when it’s clear enough to do so.
I use it when I don’t know what to prompt because I don’t know what I think yet. The model starts interviewing me one question at a time. Multiple-choice is the trick. It gets the options right about 95% of the time, and picking or rejecting an option is much easier than inventing a clean prompt from a confused state. I use it for stuck projects, specs, braindumps, mental-state debugging, and other people’s dilemmas.
`!time` is even simpler. It expands into a timestamped Markdown line. I pair that with Raycast Notes and hold-to-dictate, which is faster and more reliable than building some elaborate Notion integration. Local and instant beats integrated and networked.
The clarity bear was once a product. I built a whole application around braindump → interview → clarity meter. The product died. The useful part survived as sixty words behind a keystroke. That exact passage has appeared in 69 files since, carrying the same fossilized typo every time. I never retype it.
## Morning mantra + goals.md
The morning mantra is a text file I read out loud before work. I’m on version eight. Calling it a mantra makes it sound spiritual, but I treat it like software: lines get added, reviewed, and deleted when they stop being useful. I recently removed a few because they were just anxiety pretending to be wisdom.
It exists because I can understand something perfectly at night and wake up the next morning without access to the feeling. If I know an insight is going to decay, I put the instruction somewhere tomorrow’s version of me will actually see it. The final line tells me to start the timer.
goals.md stays visible in the agent interface. It contains the two outcomes I’m currently trying to reach and the work that matters now. Agents can explore how to get there, but I don’t want the destination rewritten by whichever conversation happened most recently.
## GPT Live inside cardio
Fuck it: GPT Live is the best language-learning app I’ve used. After one good session my reaction was, why am I not scheduling thirty minutes of this every day while doing cardio?
Language apps optimize exercises. I want to know whether I can explain metacognition in French, argue about a business idea, role-play a weird situation, or flirt with a virtual waitress. This is the first tool that makes me want to talk about anything instead of completing the next lesson.
The obvious alternative is talking to people, but that requires scheduling, confidence, and enough energy to be publicly bad at a language. GPT Live has infinite patience. I can arrive tired, mix languages, change subjects halfway through, and ramble until the sentence appears. It still understands what I’m reaching for.
The important feature is interruption. The instant I don’t know a word, or can’t remember whether something is masculine or feminine, I ask and get the answer inside the conversation. The correction arrives at the exact point of uncertainty. A flashcard app can’t do that, and a class usually won’t.
I run the session during cardio so it has a fixed place in the day. The physical activity is already happening; the conversation makes it interesting enough that I stop watching the clock.
The sessions aren’t confined to one language. They run about 98% in French, with jumps into Cantonese or Korean. If I want to practice a Korean sentence, the model explains it in French, gives me the complete Korean, breaks it into fragments, and waits while I repeat each one. French is becoming the medium of cognition rather than the object being studied.
We rehearse conversations I’ll actually need to have. I can show up halfway through cardio, tired and mixing three languages, and work through something difficult I want to explain to a real person. GPT Live keeps track of the meaning while the languages change.
I was already doing a cruder version in 2024, reading native articles “sentence by sentence, word by word” with voice mode. It became consistent when I attached it to cardio. The sessions now read from and feed the Korean organ’s _state.md, so live practice and structured lessons share a record of what I know and where retrieval fails.
The model says the Korean sentence. Then the first fragment. I repeat it. It adds the next fragment. We keep going until I can say the whole thing without help.
## Organs: letting the state accumulate
The tools above still need me to press record or start the conversation. The organs are code and files that stay available inside the agent. They keep enough history that I don’t have to explain the domain again every time.
## `organs log`
I’ve kept journals for years, but journaling is still an activity you have to decide to do. Most ordinary events aren’t important enough to make me open a separate app and write a reflective entry.
I type `organs log` followed by one sentence in the terminal where I’m already working. The command adds a timestamp and appends the sentence to today’s Markdown file. One file per day, no form, no categories to remember. About 112 of the last 121 days are recorded.
If I write that I played pickleball and joined a pickup game, the agent checks cardio and records a social event. I don’t open the habit tracker, then the social tracker, then a journal. I describe what happened once.
The original sentence stays verbatim. Agents love turning specific thoughts into bland summaries, so the rule is to add interpretation without replacing the source. A weird phrase, repeated complaint, or exact order of thought might be the useful part later. Storage is cheap. Re-creating the sentence isn’t possible.
After a few months, I can ask what I was doing the last time I felt this way or whether a new idea is actually new. The answer comes back with dates and my own words.
## Habits
I’ve tried normal habit apps. The problem is that the habit tracker itself becomes another habit. If I have to remember to open a separate dashboard before it can remind me what to do, it has already failed.
My tracker is a SQLite database rendered directly inside the agent interface. Ctrl+H opens it underneath my goals and current focus. If I don’t know what to do next, I press the shortcut and look at what’s still open.
The agent sees the same list. If I log a pickleball game, it can check cardio automatically. If several habits are still open, it can suggest one from the interface I’m already using. The more I use the coding agent, the more often I see my habits. That’s why this tracker works when the others didn’t.
I’m not trying to perform a perfect streak for a screenshot. I want today to feel connected to a larger system I chose. If a habit becomes overwhelming, I can scale it down or skip it without losing the record.
## Chat archive and Cortex
AI conversations are weirdly disposable by default. I can spend three hours developing an idea with Claude and then open a new chat next week with none of that work available.
Now every conversation gets exported to Markdown and summarized. I have 3,520 summaries. In one run, agents processed 3,273 conversations in about two hours, pulled the 77 with the strongest writing material, and found 101 possible drafts.
A chat window is an interface. It shouldn’t determine how long the thought lives.
Cortex indexes 9,480 documents and 189,703 chunks in a 1.77 GB SQLite file: daily logs, fourteen years of journals, conversations, meetings, OBS sessions, and walks. It runs keyword and vector retrieval together, then reranks the results. grep is not very good when the corpus is your entire life and you don’t remember the words you used.
That was the original problem. I’d remember having a thought but not when, where, or how I phrased it. The first time I asked a question against years of my own writing and got an answer with dated evidence, it was honestly a little shocking. A vague intuition suddenly had a history.
Before a decision, I can ask for the last five times I made a similar one. For language practice, an agent can inspect what I actually talk about and generate vocabulary from my obsessions. I don’t have to sit there summoning an autobiographical word list from memory. The curriculum is already present in the record.
But search by itself isn’t that interesting. Everybody has search. What became useful was being able to run operations on my past.
Agents can move chronologically through every log, walk, chat, and journal and extract the ideas into a schema. Another fleet can build prototypes from those objects. Test agents can exercise them. My feedback can change the evaluation criteria, and a tournament can rank what survives.
I can also ask several agents to simulate possible futures using evidence about what I sustain, abandon, enjoy, and return to. It isn’t prophecy. It’s a better thought experiment because the agents can read more of my history than I can hold in working memory.
This is why I think “memory” is too small a name for it. The records can be filtered, compared, turned into schemas, split across agents, used to build prototypes, and scored against my later feedback. The computation I already spent thinking isn’t trapped in the moment when I did it.
I once called Cortex “not a second brain, but a thousand brains.” A second brain helps you find what you stored. Cortex lets many minds work over what you lived.
I trust the archive for evidence, not intent. It can tell me what I said and how often I returned to it. It doesn’t get to decide what I want now.
Anything new I build can start with that history instead of an empty prompt.
## A few other organs
The worklog keeps one Markdown file per day explaining why the code changed. Git preserves the diff; it doesn’t preserve what I was trying to do.
The email organ ran a written triage policy over 33,166 messages and produced 82 action items. The policy also contains a hard rule that nothing I sent can be deleted.
The finance organ talks directly to the Mercury API—@mercury Personal has a great API, shoutout—and traces transactions back to the events that produced them. I don’t use the MCP because it’s a wrapper around an API I can already call.
Tasks stay in Things 3. It has a good phone interface, its schema has barely changed in ten years, and things-cli can read the SQLite database. I’ll replace it when I have a phone interface worth replacing it with.
## Taskbox, Git, and Linear
One Claude Code session barely touches a Max subscription. If I drive it by hand, I’m leaving most of what I paid for unused. Taskbox is how I fan work out into separate agent runs without losing track of which prompt produced which result. It has handled 2,271 runs and more than 300 million tokens.
Git is almost absurdly well suited to agent work. Each agent gets an isolated branch or worktree, changes real files, and returns a diff. If three agents try three approaches, I can compare the code instead of comparing three confident paragraphs in chat.
The pull request is where the branches have to become one accepted version. Tests run, review agents inspect the diff, and I merge what survives. This is basically what Unix was made for.
Linear holds the unresolved question while the agents work. I have a strong opinion about this: Linear is for converging states, not checking shit off a vague task list. A good issue is the home where competing branches, evidence, and review eventually settle into one answer.
Once I select an approach, the reason can become a test, example, or instruction. That’s how one moment of taste changes hundreds of later runs.
/will gives Claude a model of my 58 skills and seven protocols I wrote for myself. Claude Code already knows how to call a shell or read a file; this command tells it what Will Chen can do.
I am using Claude while Claude is pretending to use Will Chen, as an agent.
It identifies the part that still needs human judgment, taste, conversation, or courage, then hands me the context and a procedure I wrote earlier. The agent can often retrieve my own capabilities more reliably than I can.
## Systems: when the day starts to feel different
At this point the stack stops feeling like a collection of tools. I can close the laptop without losing the state of the day. The files remain, the agents keep their assigned work, and the next session doesn’t begin with me trying to remember everything.
## The morning briefing
The morning briefing is the first thing I read. It pulls together my goals, current focus, open habits, tasks, calendar, body data, finances, and whatever the agents finished overnight.
I don’t open six apps and reconcile them in my head. The coding agent and I start with the same screen. If I ask what matters today, it can answer from the actual state instead of generating generic advice.
It isn’t a report I save for later. It tells me what to do next.
## One day through the stack
In the morning I read the briefing and mantra, then start the timer.
During the day, events go into one-line logs. A walk produces a transcript. Ctrl+H shows the next habit. An OBS recording becomes part of the archive. I use each thing normally and the records accumulate behind it.
In the evening I review what happened, update the worklog, and send out work that doesn’t need me. Agents process transcripts, try implementations, run tests, or prepare options. By the time I return the next morning, there is usually something concrete waiting for review.
## The loops
For me, an agent is a loop. It reads a state, does something, checks the result, and either continues or stops. Treating every subagent like a separate employee with a personality only makes the coordination harder to reason about.
A walk becomes a transcript. Cortex retrieves related material. Taskbox sends an operation across it. The result comes back as a file, branch, log entry, or update to another organ. If an agent gets something wrong, the correction becomes a test or instruction before the next run.
Every useful loop touches something outside the model. A completed workout updates the tracker. A bank transaction updates the financial state. A test says whether the code works. Without those answers, the agents would only become better at agreeing with themselves.
The model reads the files, calls the commands, and moves information between domains. I can replace the model because the repo, records, policies, tests, and permissions survive the session.
## From using AI to having AI systems running
I didn’t decide to build a second brain or a life operating system. I kept using a coding agent during my real day and changing whatever annoyed me. Because those changes lived in one repo, each new fix started from the last one.
This is the part I think people miss about personal AI. The architecture can emerge later. The first requirement is somewhere for a correction to remain. Put the tracker where you already work. Record the session if recording makes it easier to start. Move language practice into cardio if that’s where it becomes enjoyable. When the fix works, keep it.
Most AI demos make generation look like the breakthrough. We already generate too much stuff. The larger change for me is that connection became cheap: a walk can feed an essay, a log entry can update a habit, an old conversation can become a prototype, and one correction can reach every agent that comes after it.
In 2024, I wrote: “record as much data as possible—I believe compute will be cheaper in the future and allow us to go over all the notes that we took.” At the time, that was a bet. Now the record can be searched, transformed, distributed across agents, tested, and returned as action.
This essay came out of the same stack. I dictated parts while walking, retrieved the relevant logs and conversations, sent sections through separate agents, checked the claims against dated evidence, and kept revising the result in the same repo.
AI Organs is only a few months old and it has already stabilized a surprising amount of my life and mental energy. An insight has somewhere to go. It can become a command, a policy, a test, a lesson, a draft, or a task for another agent instead of remaining one more thing I’m supposed to remember.
That is the shift. I still use AI, obviously. But more and more often, I have AI systems running.
## 相关链接
- [Will Chen](https://x.com/stablechen)
- [@stablechen](https://x.com/stablechen)
- [5.7K](https://x.com/stablechen/status/2080191964247625824/analytics)
- [https://x.com/karpathy/status/2079610838143623371?s=20](https://x.com/karpathy/status/2079610838143623371?s=20)
- [@mercury](https://x.com/@mercury)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [3:23 PM · Jul 23, 2026](https://x.com/stablechen/status/2080191964247625824)
- [5,776 Views](https://x.com/stablechen/status/2080191964247625824/analytics)
---
*导出时间: 2026/7/23 21:29:24*
---
## 中文翻译
# 别再用 AI 了。让 AI 系统运转起来。
**作者**：Will Chen
**日期**：2026-07-23T07:23:07.000Z
**来源**：[https://x.com/stablechen/status/2080191964247625824](https://x.com/stablechen/status/2080191964247625824)
---
我过去是以“正常方式”使用 AI 的。打开 ChatGPT 或 Claude，提问，得到答案，然后关掉窗口。下一次对话又是从零开始。
现在我的工作方式已经不是这样了。我让 AI 系统持续运转。
当我打开我的编码智能体时，它已经显示了我的目标、专注点和习惯。一句关于打匹克球的话可以同时更新我的有氧记录和社交日志。我可以对着十四年的日记、旧的 AI 对话、工作录音以及散步时的转写文本提问。到了晚上，我可以把智能体派往不同的 Git 分支，第二天早上再审查它们构建了什么。
当我把这些都列出来时，看起来非常有规划。但其实不是。
其中大部分都源于向编码智能体抱怨。我会在散步时丢掉一个好想法，忘记打开习惯打卡应用，或者发现自己又在纠正智能体的同一个毛病。我会说出烦到我的地方，让智能体去修改仓库，然后继续使用新版本。这样的情况在几个月里几乎每天都在发生。
每一次改动都显得微不足道。但它们加在一起，就成了一个记得我在做什么、能把状态从一天带到下一天、并且在我离开后仍在持续运转的环境。
我有一条相当固执的规则：如果使用一个系统感觉像是额外的工作，我最终一定会停止使用它。我并不觉得这在道德上有什么值得探究的。与其不断重新发现自己无法永远强迫自己忍受同一套糟糕的设置，我更愿意去改变界面、时机或分工。
AI 让持续调整设置变得很便宜。语言练习可以在有氧运动时进行。思考可以在散步时进行。一个习惯追踪器可以驻留在本来就已经打开的编码智能体里。我做一次纠正，就能变成一条之后每个智能体都会继承的规则。
这就是我最终保留下来的技术栈。
## Pi：让技术栈生长的骨架
大多数 AI 效率类应用很难让我兴奋起来。这类东西太多了，而且我通常的想法是：别人手工搭建的工作流，不会比我自己的仓库加 Claude 更适合我。我保留下来的工具，往往是增加了某种新原语、或扩展了编码智能体已有能力的那种。
Pi 是 AI Organs 的主骨架。我对 OpenClaw 始终没有那种“x 因素”的感觉，哪怕所有人都为它兴奋。而 Pi 给了我那种感觉，t
原因很简单：Pi 可以修改它运行于其中的环境。如果我想要一个新命令、一个不同的视图，或一条应该在对话结束后仍然存在的规则，我用日常语言告诉智能体，它就去修改骨架本身。我不会给自己提个功能需求然后等周末再来处理。
这感觉起来仍然像是在跟 Claude 对话。区别在于，答案有时会变成我所工作的地方的一部分。我要求我的习惯能立刻显示出来，于是 Ctrl+H 现在就能打开它们。我想要一条日志同时更新我生活的几个方面，于是日志命令学会了这样做。如果我不得不把同一个纠正说两遍，我就让智能体把它写进指令、测试或示例里。
一切都存在于同一个仓库中。AGENTS.md 通过符号链接指向 CLAUDE.md，所以当我想要 Claude Fable 5 时可以用 Claude Code 驱动同一个系统，想要 Pi 时则通过 AI Organs。比起模型的一致性，我更在乎仓库本身。切换模型时，文件、命令、历史、测试和权限都还在那里。
这就是为什么这个技术栈在生长时并不像一个单独的项目。问题在我已经工作时出现。我在同一个窗口里抱怨，智能体修改了问题发生的地方，然后我继续做手头的事。
几个月下来，这个仓库里装进了一个惊人数量的“我”：我脱口而出的命令、我不再想重新考虑的规则、为我的注意力量身定制的界面，以及让智能体一上来就带着上下文的记录——这些上下文我永远塞不进一个提示词里。而在我一次一次为一个小烦恼打补丁的时候，这一切都不显得有什么雄心。
我开始把这些有状态的部分称为“器官”，因为它们的行为不像普通应用。每一个都掌管一个领域——习惯、金钱、语言学习、工作经历——并留下足够的状态，让智能体日后可以接续。我可以切换模型，而不丢失这个积累起来的身体。
## 工具
其中一些最重要的部分，其实是以稍微有点奇怪的方式使用的普通产品。
## Plaud NotePin
Plaud NotePin 是一个 180 美元的录音器，当我在金门公园或海滨散步时，我把它挂在挂绳上戴着。这个价格说实话很冒犯，因为硬件基本上就是一个带按钮的蓝牙麦克风，然后他们还对转写按月收费。你他妈到底是在为这 180 美元付什么钱？
我还是买了。对大多数人来说，一个手机应用可以做到同样的事，但我想连续录几个小时，并把输出送进我自己的流水线。这个专用物件消除了选择成本。我戴上它，按住按钮，感觉到它震动，然后开始走。
在精力充沛的一天，我可以走上 4 万到 5 万步，因为我忙着说话。出门前我不需要一个主题。我可以用前十分钟抱怨自己没什么可说的、重复自己、走错岔路，最终找到我真正在乎的那件事。我会继续走下去，因为我还没有把这个想法想完。
录音质量不需要太好。风声、车流和没说完的句子曾让这种档案毫无意义。现代转写技术非常出色。它能恢复几乎听不清的词语，而 LLM 可以重构一段顺序混乱的论证。
人们也严重高估了一个人的一生会产生多少文本。几个小时的讲话听起来像一个荒谬的数据难题，但其实没有那么多 token。完全可以管理。
这就是为什么我愿意信马由缰地讲。连贯性可以以后再说。模型可以恢复论证，保留那些听起来仍然像我风格的说法，向我展示我一直在围绕什么打转，并询问它重构得是否正确。我唯一必须当场做的，就是在想法消失之前把它捕捉下来。
Andrej Karpathy 最近描述了这种模式的十分钟桌面版本：切换到语音，不加过滤地随意说，让模型重构思路。他写道：“大语言模型在某种程度上非常擅长重构冗长而不连贯的漫谈。”
https://x.com/karpathy/status/2079610838143623371?s=20
Plaud 是同样的招数，只是挂在挂绳上，被允许运行一整个下午。
自 4 月 14 日以来，NotePin 在 41 天里捕捉了 61 份转录文本、586,192 个词。这些散步如今为文章、语言学习、决策、原型以及我在说话时无法预料的搜索提供素材。
你会惊讶于自己在日常生活中发出多少信号。大部分都消失了，因为它们没有以可发布的顺序到达。散步和通勤曾是死时间。现在它们既产生原材料，又让一天更愉快。
流水线有时仍然滞后。我不在乎。一份转录可以下周再总结，或明年由更好的模型重新处理。唯一永久的失败是没有记录下来。
## OBS + 计时器
我一直纠结的一件事是开始远程工作。你可以称之为拖延症或多动症，但我觉得这两个标签都不太有用。它们听起来像是道德上的失败，却不告诉我该改什么。实际问题通常是开始前的那十分钟。一旦开始工作，我就没事了。
我打开 OBS，这个免费的直播软件，录下我的屏幕，并在角落里放一个显示我说话脑袋的小窗口。然后我设一个实体计时器，通常是 45 分钟。这就是我工作能力的支柱。
我基本上是在假装直播。我解释我接下来要做什么，边做边解说，并把任何让我困惑的地方说出来。观众是未来的我，加上任何最终会阅读这份转录的智能体。我喜欢漫谈，所以这让工作比沉默地坐在电脑前努力自律有趣得多。
我还会发出奇怪的声音，偶尔唱歌，来取悦或让未来的我难为情。一旦你克服了对着一个没有观众的微型直播的奇怪感，我就无法想象没有它怎么工作。
录像还解决了另一个我一直没有好名字来描述的问题：工作常常感觉不算数。你可以花一小时尝试某件事，毫无进展，合上电脑，感觉那一小时消失了。如果我录了下来，这个工作时段就存在了。即使是一段糟糕的工作记录，也能显示我尝试了什么、在哪里卡住、以及当时在想什么。
文件上传到 Dropbox 和一个私密、不公开的 YouTube 播放列表。YouTube 是免费的视频存储。我家有千兆上传带宽，存储很便宜，我的流程是：录制，剪掉首尾，发布。如果我打开 Premiere、DaVinci 或 CapCut，那就已经搞砸了。剪辑会把工作记录变成内容项目。
计时器很重要，但我根据工作类型以不同方式使用它。对于执行类工作，我让倒计时保持可见。对于开放式思考，我把它藏起来；看着时间流逝会让生成性工作变糟。无论如何，计时器把边界外化出来，这样我就不必不断问自己是否工作得够久了。
这对多动症患者来说真的是一个生活技巧。它对自学、审计时间去向，以及把一个思路坚持到完成都很有用。大声说话让注意力有了去处。
OBS 是与现实的接触。
我这个想法来自看 George Hotz 做八小时的直播并保持完全的专注。我的私人播放列表现在已有超过 1,500 小时。一位朋友曾怀疑我是否真的在工作，于是我把链接发给他。他看了一下，立刻投了 10,000 美元。一千五百小时的录像是很难作假的。
我过去常常以未来的模型或许能利用这些内容为由，来证明记录一切是合理的。那个未来已经开始了。Cortex 中包含 542 个工作时段的转录文本，智能体可以检索我在工作时说过的话，与我的聊天记录、散步、日志一起。我并不是抱着抽象的希望保存视频，指望有一天它会变得有用。五百四十二个时段已经是记忆了。
## Raycast 片段
Raycast 基本上是 Mac 上普通人用的命令行。我告诉人们的第一件事就是禁用 Spotlight，把 Command+Space 让给 Raycast。
真正的区别在于可编程性。Spotlight 搜索的是苹果决定它应该搜索的东西。Raycast 可以在同一个输入框里运行扩展、脚本、片段、窗口命令以及我自己定义的 AI 命令。我有一个扩展，输入 money 就能看到我的银行余额。如果我想要一个新行为，我可以写一次，然后从电脑上的任何地方调用它。这感觉更像是给自己添加一条命令，而不是又安装一个应用。
片段是最小的部分，也可能是我最喜欢的部分。我在任何文本框中输入一个简短的触发词，Raycast 就会把它展开成一个时间戳、一个模板，或一种与 LLM 交互的完整方式。
我最常用的是 `!bear`，清晰熊：
> 首先深入思考，回顾然后采访我，一次一个问题，向我提供经过深思熟虑的选项和建议以提升你的清晰度，直到达到 100% 清晰。对于每个问题，尽量指出困惑的来源可能是什么，或回答这个问题将如何确定你需要的东西（要简洁）。在足够明确的情况下，尽量采用选择题的形式。
当我不知道该怎么写提示词时，因为我还不清楚自己的想法，我就用它。模型开始一次一个问题地“采访”我。选择题是关键。它猜对选项的概率约为 95%，而在思路混乱的状态下，选择或否决一个选项远比凭空编出一个清晰的提示词要容易得多。我用它来处理卡住的项目、规格说明、头脑倾倒、心理状态调试，以及别人的两难困境。
`!time` 更简单。它会展开成一行带时间戳的 Markdown。我把它和 Raycast Notes 以及长按语音输入搭配使用，这比构建某种复杂的 Notion 集成更快、更可靠。本地且即时胜过集成且联网。
清晰熊曾经是一款产品。我围绕“头脑倾倒 → 采访 → 清晰度量表”构建了一整个应用程序。产品死了，但有用的部分以一段六十个字、藏在快捷键后面的文本活了下来。从那以后，这段文字出现在了 69 个文件中，每次都带着同一个固化的拼写错误。我从不重新输入它。
## 晨间箴言 + goals.md
晨间箴言是我在开始工作前大声朗读的一个文本文件。现在已经是第八版了。称它为“箴言”听起来很玄乎，但我把它当软件来对待：条目会被添加、审查，一旦不再有用就会被删除。我最近删掉了几条，因为它们只是伪装成智慧的焦虑。
它存在的理由是：我可以在晚上完全理解某个道理，但第二天早上醒来时那种感觉就无法触及了。如果我知道某个洞见注定会衰减，我就把指令放到明天的自己真正会看到的地方。最后一行提醒我启动计时器。
goals.md 始终显示在智能体界面上。它包含我目前正在努力实现的两个目标以及当下重要的工作。智能体可以探索如何到达那里，但我不想让目的地被最近发生的某次对话改写。
## 有氧运动中的 GPT Live
管他呢：GPT Live 是我用过的最好的语言学习应用。一次畅快的使用之后，我的反应是：为什么我没有把每天三十分钟的这个安排到有氧运动中？
语言类应用优化的是练习题。而我想要知道的是我能否用法语解释元认知、争论一个商业创意、角色扮演一个奇怪的情境，或者和一个虚拟服务员调情。这是第一个让我想随便聊点什么而不是完成下一课的工具。
显而易见的替代方案是和人交谈，但这需要安排时间、自信，以及足够的精力去公开地出丑。GPT Live 有无限的耐心。我可以疲惫地开始，混合语言，中途换话题，喋喋不休直到那个句子浮现。它依然明白我想表达什么。
最重要的功能是打断。当我不认识某个词，或者记不清某个词是阴性还是阳性的那一刻，我当场提问，答案就在对话中出现。纠正恰好落在不确定的那个点上。抽认卡应用做不到这一点，而课堂通常也不会。
我把练习安排在有氧运动中，这样它就在一天中有了固定的位置。身体活动本来就在进行，而对话让它变得足够有趣，以至于我不再盯着时钟看。
练习并不局限于一种语言。大约 98% 的时间是法语，期间会跳到粤语或韩语。如果我想练习一个韩语句子，模型用法语解释它，给我完整的韩语，把它拆成片段，然后等我逐个复述。法语正在成为认知的媒介，而不是被研究的对象。
我们排练那些我真的需要进行的对话。我可以在有氧运动进行到一半时出现，疲惫不堪、混杂着三种语言，演练一些我想要向一个真实的人解释的难题。在语言来回切换的过程中，GPT Live 始终追踪着含义。
其实早在 2024 年，我就在做一个更粗糙的版本：用语音模式“逐句逐词”地阅读母语文章。当我把它绑定到有氧运动上后，它才变得稳定持续。现在，练习会读取并回写韩语器官的 _state.md，因此实时练习和结构化课程共享一份关于我知道什么、以及哪里提取失败的记录。
模型说出韩语句子，然后是第一个片段。我复述。它加上下一个片段。我们一直继续，直到我能在没有帮助的情况下说出完整的句子。
## 器官：让状态不断积累
上面的工具仍然需要我去按下录制或开始对话。器官则是常驻在智能体内部的代码和文件。它们保存了足够的历史，让我不必每次都重新解释一遍背景。
## `organs log`
我写日记已经很多年了，但写日记终究是一项需要你主动决定去做的活动。大多数日常琐事都不够重要，不足以让我专门打开一个应用写一篇反思性的记录。
我在自己本来就在用的终端里输入 `organs log`，后跟一句话。这个命令会加上时间戳，并把这句话追加到当天的 Markdown 文件中。每天一个文件，无需表单，也无需记住任何分类。最近 121 天里大约有 112 天都有记录。
如果我写下我去打了匹克球并参加了一场临时组局，智能体就会查看 cardio 并记录一个社交活动。我不需要先打开习惯追踪器，再打开社交追踪器，再打开一个日记应用。我只需把发生的事描述一遍。
原始的句子原封不动地保留。智能体热衷于把具体的想法变成平淡的总结，所以规则是：可以添加解读，但不能替换原文。一个奇怪的说法、一个反复出现的抱怨，或者思路的精确顺序，可能正是日后有用的部分。存储很便宜，而重新还原那句话是不可能的。
几个月之后，我可以问：上次我有这种感觉的时候在做什么？或者这个新想法是不是真的新？答案会带着日期和我自己的原话返回。
## 习惯
我试过普通的习惯打卡应用。问题在于，打卡工具本身会变成又一个需要坚持的习惯。如果我还得记得先打开一个单独的面板，它才能提醒我该做什么，那它已经失败了。
我的打卡器是一个直接渲染在代理界面里的 SQLite 数据库。按 Ctrl+H 会在我的目标和当前焦点下方打开它。当我不知道接下来该做什么时，就按下快捷键，看看还有什么没完成。
代理看到的也是同一份列表。如果我记录了一场匹克球比赛，它可以自动勾选有氧运动这一项。如果还有几个习惯没完成，它会在我正在使用的界面里建议我完成其中一个。我越是使用编码代理，就越频繁地看到我的习惯。这就是为什么这个打卡器在其他工具都失败的情况下能奏效。
我并不是想为了截图维持一个完美的连续打卡记录。我希望今天与我选择的一个更大系统相连。如果某个习惯变得让人不堪重负，我可以缩小规模或跳过它，而不会丢失记录。
## 聊天存档与 Cortex
AI 对话在默认情况下出奇地容易被丢弃。我可能花三个小时与 Claude 一起打磨一个想法，然后下周打开一个新对话，之前的工作成果却全都不可用。
现在，每次对话都会被导出为 Markdown 并生成摘要。我有 3,520 份摘要。在一次运行中，代理在大约两小时内处理了 3,273 段对话，挑出了 77 段最具写作素材价值的，并发现了 101 个可能的草稿方向。
聊天窗口只是一个界面。它不应该决定一个想法能存活多久。
Cortex 在一个 1.77 GB 的 SQLite 文件中索引了 9,480 份文档和 189,703 个数据块：每日日志、十四年的日记、对话、会议、OBS 录制会话和散步记录。它同时运行关键词检索和向量检索，然后对结果重新排序。当语料库是你的整个人生，而你又不记得自己当时用了哪些词时，grep 就不太管用了。
这正是最初的问题所在。我记得自己有过某个想法，却不记得是在什么时候、在哪里、用什么措辞表达的。当我第一次针对自己多年的文字提问，并得到一个附带带日期证据的回答时，说实话，那有点令人震撼。一种模糊的直觉突然有了历史。
在做决定之前，我可以询问过去五次我做类似决定时的情况。在语言练习方面，代理可以分析我实际谈论的内容，并根据我的执念生成词汇表。我不必坐在那里凭记忆召唤一份自传式的单词列表。课程内容已经存在于记录之中。
但搜索本身并不那么有趣。人人都有搜索。真正变得有用的，是能够对我的过去执行操作。
代理可以按时间顺序遍历每一条日志、每一次散步、每一段对话和每一篇日记，并将其中的想法提取成结构化的模式（schema）。另一组代理可以根据这些对象构建原型。测试代理可以对它们进行验证。我的反馈可以改变评估标准，然后一场“锦标赛”可以对存活下来的方案进行排名。
我还可以让多个代理利用关于我坚持什么、放弃什么、享受什么、重新拾起什么的证据，来模拟可能的未来。这不是预言。它是一个更好的思想实验，因为代理能读取的历史比我工作记忆所能容纳的要多得多。
这就是为什么我认为“记忆”这个名字对它来说太狭小了。这些记录可以被筛选、比较、转化为模式、分配给多个代理、用于构建原型，并根据我后续的反馈进行评分。我在思考时已经付出的计算，不再被困于我思考的那一刻。
我曾把 Cortex 称为“不是一个第二大脑，而是一千个大脑”。第二大脑帮你找到你存储的东西。Cortex 则让许多个头脑来加工你所经历的生活。
我信任这个存档作为证据，而非意图。它能告诉我我说过什么、多久重提一次。但它无权决定我现在想要什么。
我构建的任何新东西，都可以从这段历史出发，而不是从一个空白的提示开始。
## 另外几个“器官”
工作日志（worklog）每天保留一个 Markdown 文件，解释代码为什么变动。Git 保存的是差异（diff），但它不保存我当时想做什么。
邮件器官对 33,166 封邮件执行了一套书面分拣策略，产出了 82 条待办事项。该策略还包含一条硬性规则：我发出的任何邮件都不得删除。
财务器官直接与 Mercury API 对话——@mercury Personal 的 API 非常棒，必须表扬一下——并将交易追溯到产生它们的具体事件。我不使用 MCP，因为它只是一个我已经能直接调用的 API 的封装。
任务保留在 Things 3 中。它的手机界面很好用，其数据模式十年来几乎没有变化，而且 things-cli 可以读取它的 SQLite 数据库。等我有了值得替换它的手机界面，我才会换掉它。
## Taskbox、Git 与 Linear
一个 Claude Code 会话几乎用不完 Max 订阅的额度。如果我手动驱动它，就等于让我付费的大部分能力闲置。Taskbox 就是我在不丢失“哪个提示产生了哪个结果”这一对应关系的前提下，把工作分发到多个独立代理运行中的方式。它已经处理了 2,271 次运行和超过 3 亿个 token。
Git 几乎出奇地适合代理工作。每个代理获得一个隔离的分支或工作树（worktree），修改真实的文件，然后返回一个 diff。如果三个代理尝试三种方案，我可以比较代码，而不是比较聊天中三段自信满满的文字。
拉取请求（pull request）是各分支必须收敛为一个被接受版本的地方。测试运行、审查代理检查 diff，我合并存活下来的那部分。这基本上就是 Unix 被创造出来要做的事情。
当代理在工作时，Linear 保管着尚未解决的问题。对此我有一个坚定的观点：Linear 是用来让状态收敛的，不是用来在一个模糊的任务清单上划勾的。一个好的 issue，是相互竞争的分支、证据和审查最终沉淀为一个答案的归宿。
一旦我选定了一种方案，选择它的理由就可以变成一个测试、一个示例或一条指令。这就是一个瞬间的品味判断如何影响之后数百次运行的方式。
/will 命令让 Claude 获得一个关于我的 58 项技能和我为自己写下的七套协议的模型。Claude Code 本来就知道如何调用 shell 或读取文件；这个命令告诉它 Will Chen 能做什么。
我在使用 Claude，而 Claude 正在扮演使用 Will Chen 的角色，作为一个智能体。
它会识别出哪些部分仍然需要人类的判断、品味、对话或勇气，然后把上下文和我之前写好的流程交给我。这个智能体检索我自身能力的可靠性，往往比我自己还高。
## 系统：当一天开始变得不同时
到了这一步，这套技术栈不再像是一堆工具的集合。我可以合上笔记本电脑而不会丢失当天的状态。文件依然存在，智能体继续执行分配给它们的工作，下一次会话不需要我从头回忆所有事情。
## 晨间简报
晨间简报是我每天读的第一样东西。它汇集了我的目标、当前焦点、未完成的习惯、任务、日程、身体数据、财务状况，以及智能体在夜间完成的所有工作。
我不需要打开六个应用再在脑子里对齐它们。我和编码智能体从同一个屏幕开始。如果我问今天什么最重要，它能根据实际状态回答，而不是生成泛泛的建议。
它不是留到以后再看报告，它告诉我接下来该做什么。
## 通过这套技术栈的一天
早晨我读简报和箴言，然后启动计时器。
白天，事件进入单行日志。一次散步产生一份转录文本。Ctrl+H 显示下一个习惯。一次 OBS 录制成为档案的一部分。我照常使用每样东西，记录则在背后不断累积。
晚上我回顾当天发生的事，更新工作日志，把不需要我参与的工作发出去。智能体处理转录、尝试实现、运行测试，或者准备备选方案。等我第二天早上回来时，通常已经有具体的东西在等待审查。
## 循环
对我而言，智能体就是一个循环。它读取一个状态，做某件事，检查结果，然后要么继续，要么停止。把每个子智能体都当作一个有独立人格的员工来对待，只会让协调更难理清。
一次散步变成一份转录。Cortex 检索相关素材。Taskbox 对它执行一次操作。结果以文件、分支、日志条目或对另一个器官的更新形式返回。如果某个智能体出了错，纠正会在下一次运行前变成一条测试或指令。
每一个有用的循环都会触及模型之外的东西。一次完成的锻炼更新追踪器。一笔银行交易更新财务状态。一次测试说明代码是否可用。没有这些反馈，智能体只会越来越擅长自我认同。
模型读取文件、调用命令、在各个领域之间移动信息。我可以更换模型，因为仓库、记录、策略、测试和权限都能在会话结束后保留下来。
## 从使用 AI 到拥有在运行的 AI 系统
我并没有决定去构建一个第二大脑或人生操作系统。我只是在真实的一天里持续使用编码智能体，并改动任何让我烦心的地方。因为这些改动都存在于同一个仓库中，每一次新的修复都从上一次开始。
这就是我认为人们在个人 AI 上忽略的部分。架构可以之后再涌现。首要条件是有一个让纠正得以留存的地方。把追踪器放在你本来就在工作的地方。如果录制能让你更容易开始，就录下会话。如果语言练习在有氧运动中变得有趣，就把它挪到有氧运动里。当修复有效时，就保留它。
大多数 AI 演示把生成当作突破点。我们已经生成了太多东西。对我而言更大的变化是：连接变得廉价了——一次散步可以喂养一篇文章，一条日志可以更新一个习惯，一段旧对话可以变成原型，而一次纠正可以传递到之后的每一个智能体。
2024 年，我写道：“尽可能多地记录数据——我相信未来计算成本会更低，让我们能够回顾我们记下的所有笔记。”当时，那只是一个赌注。现在，这些记录可以被检索、转换、分发到各个智能体、进行测试，并作为行动返回。
这篇文章也出自同一套技术栈。我在散步时口述了部分内容，检索了相关的日志和对话，把各部分交给不同的智能体，用带日期的证据核查了其中的论断，并在同一个仓库中不断修订结果。
AI Organs 才诞生几个月，它已经稳定了我生活中相当惊人的一部分，以及我的心智能量。一个洞见有了去处。它可以变成一条命令、一项策略、一次测试、一堂课、一份草稿，或交给另一个智能体的任务，而不是继续成为我又一件“应该记住的事”。
这就是转变。我当然还在使用 AI。但越来越多的时刻，我拥有的是在运行的 AI 系统。
## 相关链接
- [Will Chen](https://x.com/stablechen)
- [@stablechen](https://x.com/stablechen)
- [5.7K](https://x.com/stablechen/status/2080191964247625824/analytics)
- [https://x.com/karpathy/status/2079610838143623371?s=20](https://x.com/karpathy/status/2079610838143623371?s=20)
- [@mercury](https://x.com/@mercury)
- [升级到 Premium](https://x.com/i/premium_sign_up)
- [2026年7月23日 下午3:23](https://x.com/stablechen/status/2080191964247625824)
- [5,776 次浏览](https://x.com/stablechen/status/2080191964247625824/analytics)
---
*导出时间: 2026/7/23 21:29:24*
