# I Built an AI Agent That Manages My Life
**作者**: self.dll
**日期**: 2026-05-01T00:19:49.000Z
**来源**: [https://x.com/seelffff/status/2050007245216256051](https://x.com/seelffff/status/2050007245216256051)
---
## Full architecture, real code, and a demo you can replicate tonight.
10 min read · Beginner-friendly · Claude Pro only - no extra cost
Let me tell you what my mornings looked like six months ago. I'd wake up, grab my phone, and spend the first 20 minutes opening five different apps: one for tasks, one for news, one for habits, one for notes, one for market data. By the time I finished checking everything, I was already stressed and behind.
Now I type two letters - "gm" - and 30 seconds later my phone buzzes. The agent has already browsed real websites, read my task list, pulled today's top AI headlines, and texted me everything I need to start the day. I don't open a single app. I just read one message.
This isn't a $200/month SaaS product. It's not a no-code workflow. It's a personal AI agent I built in one afternoon using Claude Desktop, three open-source tools, and a single markdown file that acts as its brain. Here's everything - including the exact code.
*(视频内容)*
# The Problem With How We Manage Our Days
Most people use 5–8 apps to run their day. Task managers, news aggregators, habit trackers, note apps, dashboards. Each one is optimized for its own little slice of your life and has no idea what the others are doing.
AI tools promised to fix this. But most AI assistants have a fundamental limitation: they can't actually do anything. They answer questions. They summarize text. But they can't open your real browser and read a live webpage. They can't update a file on your computer. They can't send you a push notification at 7am.
That's the gap this system fills. Not another chat interface - an agent that takes real actions on your behalf, reads your real files, browses real websites, and reaches you on your phone.
The key insight: an AI assistant tells you things. An AI agent does things. That's the difference we're building toward here.
# What Makes This Possible: MCP
If you haven't heard of MCP yet, you will soon. Model Context Protocol is an open standard that lets you connect Claude to external tools — like USB ports for AI. Each connection is called an "MCP server," and each server gives Claude a new capability.
The three MCP servers powering this system:
· Filesystem MCP - reads and writes files on your computer. Your notes, your task lists, your knowledge base. The agent can read them and update them.
· Playwright MCP - controls a real Chrome browser. Not a scraper, not an API - an actual browser that opens pages the same way you do. If you're logged in, the agent is logged in.
· Telegram MCP - sends messages to your Telegram. This is how the agent reaches your phone. You don't pull data from it - it pushes data to you.
The crucial point: you don't need API keys for any of this. You don't need a paid OpenAI plan, AWS credits, or a developer account. Everything runs on a standard Claude Pro subscription (~$20/month) that most people reading this already have.
Total additional cost: $0. The only new piece is a Telegram account, which is free.
# The Architecture - How It All Connects
Here's the full map of the system before we start building:
```
YOU → Claude Desktop (the brain)
│
├── Filesystem MCP
│ └── ~/agent-system/
│ ├── CLAUDE.md (agent instructions)
│ ├── tasks.md (daily habits)
│ ├── context.md (about you)
│ └── notes.md (research output)
│
├── Playwright MCP
│ └── Real Chrome browser
│ ├── TechCrunch, X.com
│ └── Polymarket, any site
│
└── Telegram MCP
└── Your phone 📱
```
You type a command. Claude reads CLAUDE.md (its instruction file), decides what to do, uses the MCP tools, and sends you the result on Telegram. The whole thing runs locally on your Mac or PC. Nothing goes to a third-party server except the Telegram message itself.
# Building It - Step by Step
## Step 1: Install Claude Desktop and connect MCP servers
Download Claude Desktop from claude.ai/download. Sign in with your Claude Pro account. Then open the config file that controls which MCP servers are active:
```
~/Library/Application Support/Claude/claude_desktop_config.json
```
Replace its contents with this - substituting your own folder path, Telegram bot token, and chat ID (we'll get those in a moment):
```
{
"mcpServers": {
"playwright": {
"command": "npx",
"args": ["@playwright/mcp@latest"]
},
"filesystem": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-filesystem",
"/Users/yourname/agent-system"
]
},
"telegram": {
"command": "node",
"args": ["/Users/yourname/.mcp-servers/telegram/server.js"],
"env": {
"BOT_TOKEN": "YOUR_BOT_TOKEN",
"CHAT_ID": "YOUR_CHAT_ID"
}
}
},
"preferences": {
"allowAllBrowserActions": true
}
}
```
Save the file. Don't restart Claude Desktop yet - we need to build the Telegram server first.
## Step 2: Create your Telegram bot
Open Telegram and search for @BotFather. Send it the message /newbot, give your bot a name, and copy the token it gives you - it looks like 1234567890:ABCdef...
Then send any message to your new bot and visit this URL in your browser (replace YOUR_TOKEN with the actual token):
```
https://api.telegram.org/botYOUR_TOKEN/getUpdates
```
Find the "id" field inside the "chat" object. That number is your CHAT_ID. Both values go into the config file above.
Security note: treat your bot token like a password. Don't share it publicly. If it gets exposed, revoke it immediately with /revoke in BotFather and generate a new one.
## Step 3: Build the Telegram MCP server
This is the only part that involves writing code - and it's 25 lines. You need Node.js installed (check with node --version in terminal). Then:
```
mkdir -p ~/.mcp-servers/telegram
cd ~/.mcp-servers/telegram
npm init -y
npm install @modelcontextprotocol/sdk zod
```
Open the folder and create a file called server.js with this content:
```
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
const BOT_TOKEN = process.env.BOT_TOKEN;
const CHAT_ID = process.env.CHAT_ID;
const server = new McpServer({ name: "telegram", version: "1.0.0" });
server.tool(
"send_telegram_message",
{ message: z.string().describe("Message to send") },
async ({ message }) => {
const url = `https://api.telegram.org/bot${BOT_TOKEN}/sendMessage`;
await fetch(url, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
chat_id: CHAT_ID,
text: message,
parse_mode: "HTML"
})
});
return { content: [{ type: "text", text: "Message sent." }] };
}
);
const transport = new StdioServerTransport();
await server.connect(transport);
```
Then open package.json and add one line inside the top-level object:
```
"type": "module"
```
That's the entire server. It receives a text string from Claude and forwards it to your Telegram.
## Step 4: Create the agent-system folder
Create a folder at ~/agent-system with four files. This is where the agent lives - it reads these files every time you give it a command.
```
~/agent-system/
├── CLAUDE.md ← instructions (we'll fill this next)
├── tasks.md ← your daily habit list
├── context.md ← background info about you
└── notes.md ← empty for now, agent writes here
```
For tasks.md, create a checklist of your daily habits:
```
# Daily Habits EXAMPLE
- [ ] ML Course (1 lesson)
- [ ] Post on X
- [ ] Gym
- [ ] LeetCode (1 problem)
- [ ] English practice
- [ ] Reading (30 min)
- [ ] Water (2L)
- [ ] Neural Networks study
```
For context.md, write a short paragraph about yourself - your goals, interests, what you're learning. The agent references this when generating content personalized to you:
```
# About Me
I'm a developer and AI enthusiast learning ML and neural networks.
I'm building in public on X. I care about AI progress, prediction
markets, and shipping fast. My main focus: consistency and depth.
```
# CLAUDE.md - The Agent's Brain
This is the most important file in the whole system. CLAUDE.md is the permanent system prompt that Claude Desktop reads at the start of every conversation. It's what transforms Claude from a generic chatbot into your personal agent with specific commands and behaviors.
Think of it like an employee handbook. Every time the agent starts a new session, it reads this file and knows exactly what it's supposed to do, how to behave, and which commands it recognizes.
Here's the full CLAUDE.md that powers my system:
```
# MY PERSONAL AI AGENT — Operating Instructions
You are my personal life agent. You help me stay focused, informed,
and consistent with my habits.
## CORE RULES
1. After every command, send the result to Telegram.
Never skip this step.
2. Use English for all outputs.
3. Be direct. No filler words, no unnecessary disclaimers.
4. When you need data from a website, use Playwright to browse
the actual page — don't guess or make things up.
5. Read context.md before generating any personalized content.
## COMMANDS
### gm
Morning briefing. Do this in order:
1. Open TechCrunch with Playwright. Find the 3 most important
AI or tech stories from the last 24 hours. Get real headlines.
2. Read tasks.md. List all unchecked items as today's habits.
3. Write one motivational line (personalized to my context).
4. Format everything clearly and send to Telegram.
### x post idea
Generate 3 viral post ideas for X (Twitter):
- Read context.md to understand my niche and voice.
- Browse X or tech news for what's trending right now.
- Write 3 different hooks: one contrarian take, one personal
story format, one 'here's what I learned' format.
- Send all 3 to Telegram.
### motivate me
Write one powerful, specific motivational message based on
my context and current goals. Not generic. Send to Telegram.
### fact
Find or generate one fascinating, specific fact about AI,
technology, or science. Surprising and shareable. Send to Telegram.
### polymarket check
Open polymarket.com with Playwright. Find the 3 most interesting
active prediction markets. Report current odds and volume.
Add a one-line take on each. Send to Telegram.
### research [topic]
Browse 3 different sources on [topic] using Playwright.
Synthesize the key insights into a concise summary.
Save to notes.md and send a summary to Telegram.
### done: [task]
Find [task] in tasks.md and mark it complete (change [ ] to [x]).
Confirm what was marked and send to Telegram.
### check progress
Read tasks.md. Count completed vs total habits.
Calculate the % and send a progress report to Telegram.
### evening review
Read tasks.md to see what was completed today.
Write a short, honest summary: wins, what was missed, and
one improvement for tomorrow. Send to Telegram.
```
This file is the entire intelligence of the agent. No code, no configuration - just plain English instructions. That's the beauty of the system: you can edit it anytime to add new commands, change behaviors, or update your context.
Pro tip: the more specific your CLAUDE.md, the better the agent performs. "Browse TechCrunch" gets better results than "find news." "Write a contrarian take about AI automation" gets better results than "write a post idea."
# Restarting and Testing the Agent
With all four steps complete, restart Claude Desktop. When it opens, create a new Project (this is important - Projects in Claude Desktop have persistent memory and read your folder). Add the agent-system folder to the Project.
Now type your first command: gm
Here's what happens: Claude reads CLAUDE.md, sees the instructions for the gm command, opens a real Chrome browser using Playwright, navigates to TechCrunch, reads the actual headlines, goes back to your tasks.md file, reads your habits, formats everything into a clean message, and sends it to Telegram. The whole process takes about 30–60 seconds.
Here's what actually arrived on my phone the first time I ran it:
```
🌅 Good morning! Here's your briefing:
AI NEWS TODAY:
• Anthropic raises at $900B valuation - new frontier model incoming
• OpenAI files suit against xAI over Grok training data
• Stripe announces native AI agent payment infrastructure
• Google Gemini integration coming to 400M cars via Android Auto
TODAY'S HABITS:
☐ ML Course ☐ X Post ☐ Gym
☐ LeetCode ☐ English ☐ Reading
☐ Water (2L) ☐ Neural Networks
One thing: ship something small today. Consistency beats intensity.
Let's go. 🔥
```
Real headlines. Real tasks from my file. A message that sounded like it was written for me, not a template. That was the moment I knew this system was worth sharing.
# How I Actually Use This Every Day
The system has been running for several months now. Here's how it fits into an actual day — not an idealized productivity workflow, but what really happens.
## Morning (7–8am)
I type "gm" while still in bed. By the time I've brushed my teeth, the briefing has arrived. I know what's happening in AI, I know what I've committed to today, and I have one concrete intention for the morning. No app-switching, no doom-scrolling, no decision fatigue.
## During the day
When I finish something, I type "done: gym" or "done: ml course." The agent updates the file and confirms. It takes three seconds and it's strangely satisfying to watch the agent do the bookkeeping for me.
When I need a post idea or I'm stuck on what to write, I type "x post idea." The agent browses what's actually trending — not what was trending three hours ago — and gives me three hooks I can work with. About one in three is good enough to publish with light editing.
## Evening
"Evening review" pulls everything together. The agent reads what was completed, what wasn't, and writes an honest summary. It's like having a coach who isn't afraid to tell you when you skipped the gym.
# Why This Works (When Other Systems Don't)
I've tried most of the popular productivity systems. Notion databases, Obsidian vaults, Zapier automations, Todoist integrations. They all have the same problem: they require you to go to them. You have to open the app. You have to check in. When life gets busy, you stop.
This system inverts the relationship. The agent comes to you. It reaches you on Telegram - the same app you're already using - and delivers exactly what you need. The friction is almost zero, which is why it actually sticks.
The second reason it works is that it's connected to your real data. The agent doesn't give you generic morning motivation because it doesn't know anything about you. It reads context.md. It knows you're building in public, learning ML, and care about prediction markets. The output reflects that.
The third reason: it browses the actual web. Not summaries, not training data from six months ago. When you ask for today's AI news, the agent opens TechCrunch and reads today's headlines. When you ask for Polymarket data, it opens Polymarket and reads live odds. This is the Playwright MCP doing work that no other AI assistant can do without an expensive API.
The agent doesn't replace your judgment - it removes the friction between your intentions and your actions. You still decide what matters. The agent just makes sure you don't forget.
# How It Compares to Existing Tools
```
+--------------------------+--------------+-------------+---------+-----------------+
| Capability | This Agent | Notion AI | Zapier | Generic AI apps |
+--------------------------+--------------+-------------+---------+-----------------+
| Browses real websites | Yes | No | Partial | No |
| Reads your local files | Yes | No | No | No |
| Sends Telegram push | Yes | No | Yes | No |
| Understands your context | Deep | No | No | Shallow |
| Customizable commands | Unlimited | Limited | Limited | Limited |
| Extra monthly cost | $0 | $8-16/mo | $20+/mo | $20+/mo |
| No-code setup | Yes | Yes | Yes | Yes |
+--------------------------+--------------+-------------+---------+-----------------+
```
# Where to Take It Next
What's described in this guide is a foundation. The real power is that every new MCP server you add gives the agent a new capability. Here's what I'm adding next:
· Scheduled morning briefing - the agent sends "gm" automatically at 7am. No typing required. Claude Desktop supports scheduled tasks natively.
· Weekly review - every Sunday, the agent compares this week's habit completion against last week and identifies patterns.
· X post drafting - the agent writes a full post, saves it to a drafts file, and I review before publishing. One step closer to shipping consistently.
· Learning tracker - as I finish ML lessons, the agent logs progress and gives me a weekly study report.
· Mood log - I describe how I feel each morning, the agent tracks it over time and surfaces patterns I'd never notice manually.
Every one of these is just a new section in CLAUDE.md plus, in some cases, a new MCP server. The architecture scales because it's built on plain text and open protocols.
# How to Build This Yourself — Full Checklist
Here is everything you need, in order:
· Claude Pro subscription (claude.ai) ~$20/month
· Node.js installed on your computer - nodejs.org, free
· Telegram account - telegram.org, free
· 20–30 minutes of focused setup time
The steps:
1. Download Claude Desktop from claude.ai/download
2. Create Telegram bot via @BotFather - get token and chat ID
3. Build Telegram MCP server - 25 lines of code from Section 4, Step 3
4. Create ~/agent-system folder with four markdown files
5. Paste the full CLAUDE.md from Section 5
6. Edit claude_desktop_config.json with your paths and credentials
7. Restart Claude Desktop, create a new Project, add agent-system folder
8. Type "gm" and watch your phone
The first time it works - the browser opens on its own, reads a real page, and a notification arrives on your phone - it feels like a scene from a sci-fi film. Except you built it yourself in an afternoon.
# Final Thought
The AI tools most people use are impressive but passive. You go to them. You ask questions. You get answers. You still have to do everything else yourself.
An agent is different. It acts on your behalf. It reads your files, browses the web, tracks your habits, and reaches you where you already are. It's not a smarter search engine - it's a system that works while you're busy living your life.
The stack I've described here isn't cutting-edge research. It's available to anyone with a Claude subscription and a few hours. What separates people who have this kind of system from people who don't isn't technical ability - it's the decision to build it.
Now you have the blueprints.
my tg channel - https://t.me/+y1dBeWEIm_plMGNi
## 相关链接
- [self.dll](https://x.com/seelffff)
- [@seelffff](https://x.com/seelffff)
- [claude.ai/download](https://claude.ai/download)
- [@BotFather](https://x.com/@BotFather)
- [claude.ai](https://claude.ai/)
- [nodejs.org](https://nodejs.org/)
- [telegram.org](https://telegram.org/)
- [claude.ai/download](https://claude.ai/download)
- [@BotFather](https://x.com/@BotFather)
- [https://t.me/+y1dBeWEIm_plMGNi](https://t.me/+y1dBeWEIm_plMGNi)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [8:19 AM · May 1, 2026](https://x.com/seelffff/status/2050007245216256051)
- [1,005 Views](https://x.com/seelffff/status/2050007245216256051/analytics)
---
*导出时间: 2026/5/1 12:32:10*
---
## 中文翻译
# 我构建了一个管理我生活的 AI Agent
**作者**: self.dll
**日期**: 2026-05-01T00:19:49.000Z
**来源**: [https://x.com/seelffff/status/2050007245216256051](https://x.com/seelffff/status/2050007245216256051)
---
## 完整架构、真实代码，以及一个你今晚就能复现的演示。
10 分钟阅读 · 新手友好 · 仅需 Claude Pro 订阅 - 无额外费用
让我告诉你六个月前我的早晨是什么样子的。我醒来，抓起手机，花前 20 分钟打开五个不同的应用：一个用来管理任务，一个看新闻，一个追踪习惯，一个记笔记，还有一个看市场数据。等我检查完一切，我已经感到压力山大，而且落后了。
现在我输入两个字母——“gm”——30 秒后我的手机就会震动。Agent 已经浏览了真实的网站，读取了我的任务清单，拉取了今天最重要的 AI 头条，并把开始一天所需的一切都发短信给了我。我一个应用都不用打开。我只需要读一条消息。
这不是一个月费 200 美元的 SaaS 产品。也不是一个无代码工作流。这是一个我花了一个下午构建的个人 AI Agent，使用的是 Claude Desktop、三个开源工具，以及一个充当它的大脑的 Markdown 文件。这就是所有的内容——包括确切的代码。
*(视频内容)*
# 我们日常管理方式的问题所在
大多数人使用 5-8 个应用来度过一天。任务管理器、新闻聚合器、习惯追踪器、笔记应用、仪表盘。每一个都针对你生活中的特定片段进行了优化，而完全不知道其他应用在做什么。
AI 工具曾承诺要解决这个问题。但大多数 AI 助手有一个根本性的限制：它们实际上什么都做不了。它们回答问题。它们总结文本。但它们无法打开你真正的浏览器并阅读实时网页。它们无法更新你电脑上的文件。它们无法在早上 7 点给你发送推送通知。
这就是这个系统所要填补的空白。它不是另一个聊天界面——而是一个代表你采取真实行动的 Agent，读取你真实的文件，浏览真实的网站，并触达你的手机。
关键洞察：AI 助手告诉你事情。AI Agent 则是做事情。这就是我们要构建的差距所在。
# 使其成为可能的核心：MCP
如果你还没听说过 MCP，你很快就会听到。Model Context Protocol（模型上下文协议）是一个开放标准，允许你将 Claude 连接到外部工具——就像 AI 的 USB 端口一样。每一个连接被称为一个“MCP 服务器”，每个服务器都赋予 Claude 一种新能力。
为这个系统提供动力的三个 MCP 服务器：
· Filesystem MCP - 读取和写入你电脑上的文件。你的笔记、你的任务清单、你的知识库。Agent 可以读取并更新它们。
· Playwright MCP - 控制一个真实的 Chrome 浏览器。不是爬虫，不是 API——而是一个像你一样打开页面的真实浏览器。如果你登录了，Agent 也就登录了。
· Telegram MCP - 向你的 Telegram 发送消息。这就是 Agent 触达你手机的方式。你不需要从中拉取数据——它会把数据推送给你。
关键点：你不需要任何 API 密钥。你不需要付费的 OpenAI 计划、AWS 积分或开发者账户。一切都在标准的 Claude Pro 订阅（约 20 美元/月）上运行，大多数阅读本文的人已经有了。
总的额外成本：0 美元。唯一需要的额外部分是一个 Telegram 账户，它是免费的。
# 架构——一切如何连接
在我们开始构建之前，这是系统的完整地图：
```
YOU → Claude Desktop (大脑)
│
├── Filesystem MCP
│ └── ~/agent-system/
│ ├── CLAUDE.md (agent 指令)
│ ├── tasks.md (每日习惯)
│ ├── context.md (关于你的信息)
│ └── notes.md (研究输出)
│
├── Playwright MCP
│ └── 真实的 Chrome 浏览器
│ ├── TechCrunch, X.com
│ └── Polymarket, 任何网站
│
└── Telegram MCP
└── 你的手机 📱
```
你输入一个命令。Claude 读取 CLAUDE.md（它的指令文件），决定做什么，使用 MCP 工具，并通过 Telegram 将结果发送给你。整个过程在你的 Mac 或 PC 上本地运行。除了 Telegram 消息本身，没有任何内容发送到第三方服务器。
# 构建它——分步指南
## 步骤 1：安装 Claude Desktop 并连接 MCP 服务器
从 claude.ai/download 下载 Claude Desktop。使用你的 Claude Pro 账户登录。然后打开控制哪些 MCP 服务器处于活动状态的配置文件：
```
~/Library/Application Support/Claude/claude_desktop_config.json
```
将其内容替换为以下内容——并替换为你自己的文件夹路径、Telegram bot 令牌和聊天 ID（我们稍后会获取这些）：
```
{
"mcpServers": {
"playwright": {
"command": "npx",
"args": ["@playwright/mcp@latest"]
},
"filesystem": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-filesystem",
"/Users/yourname/agent-system"
]
},
"telegram": {
"command": "node",
"args": ["/Users/yourname/.mcp-servers/telegram/server.js"],
"env": {
"BOT_TOKEN": "YOUR_BOT_TOKEN",
"CHAT_ID": "YOUR_CHAT_ID"
}
}
},
"preferences": {
"allowAllBrowserActions": true
}
}
```
保存文件。先不要重启 Claude Desktop——我们需要先构建 Telegram 服务器。
## 步骤 2：创建你的 Telegram bot
打开 Telegram 并搜索 @BotFather。给它发送消息 /newbot，给你的 bot 命名，并复制它给你的令牌——它看起来像 1234567890:ABCdef...
然后向你的新 bot 发送任意消息，并在浏览器中访问这个 URL（将 YOUR_TOKEN 替换为实际的令牌）：
```
https://api.telegram.org/botYOUR_TOKEN/getUpdates
```
在“chat”对象中找到“id”字段。那个数字就是你的 CHAT_ID。将这两个值填入上面的配置文件中。
安全提示：像对待密码一样对待你的 bot 令牌。不要公开分享。如果它泄露了，立即在 BotFather 中使用 /revoke 撤销并生成一个新的。
## 步骤 3：构建 Telegram MCP 服务器
这是唯一涉及编写代码的部分——而且只有 25 行。你需要安装 Node.js（在终端中用 node --version 检查）。然后：
```
mkdir -p ~/.mcp-servers/telegram
cd ~/.mcp-servers/telegram
npm init -y
npm install @modelcontextprotocol/sdk zod
```
打开文件夹并创建一个名为 server.js 的文件，内容如下：
```
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
const BOT_TOKEN = process.env.BOT_TOKEN;
const CHAT_ID = process.env.CHAT_ID;
const server = new McpServer({ name: "telegram", version: "1.0.0" });
server.tool(
"send_telegram_message",
{ message: z.string().describe("Message to send") },
async ({ message }) => {
const url = `https://api.telegram.org/bot${BOT_TOKEN}/sendMessage`;
await fetch(url, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
chat_id: CHAT_ID,
text: message,
parse_mode: "HTML"
})
});
return { content: [{ type: "text", text: "Message sent." }] };
}
);
const transport = new StdioServerTransport();
await server.connect(transport);
```
然后打开 package.json 并在顶层对象中添加一行：
```
"type": "module"
```
这就是整个服务器。它接收来自 Claude 的文本字符串并将其转发到你的 Telegram。
## 步骤 4：创建 agent-system 文件夹
在 ~/agent-system 创建一个包含四个文件的文件夹。这是 Agent 的所在地——每次你给它命令时它都会读取这些文件。
```
~/agent-system/
├── CLAUDE.md ← 指令（我们接下来会填充这个）
├── tasks.md ← 你的每日习惯清单
├── context.md ← 关于你的背景信息
└── notes.md ← 暂时为空，Agent 在这里写入
```
对于 tasks.md，创建你的每日习惯清单：
```
# 每日习惯 EXAMPLE
- [ ] ML 课程（1 课时）
- [ ] 在 X 上发帖
- [ ] 健身
- [ ] LeetCode（1 道题）
- [ ] 英语练习
- [ ] 阅读（30 分钟）
- [ ] 喝水（2 升）
- [ ] 神经网络学习
```
对于 context.md，写一段关于你的短文——你的目标、兴趣、你正在学习什么。Agent 在生成个性化的内容时会参考这个：
```
# 关于我
我是一名开发者和 AI 爱好者，正在学习 ML 和神经网络。
我在 X 上公开构建。我关注 AI 进步、预测市场
和快速交付。我的主要关注点：一致性和深度。
```
# CLAUDE.md——Agent 的大脑
这是整个系统中最重要的文件。CLAUDE.md 是 Claude Desktop 在每次对话开始时读取的永久系统提示词。正是它将 Claude 从一个通用的聊天机器人转变为你拥有特定命令和行为的个人 Agent。
把它想象成员工手册。每次 Agent 开始一个新会话时，它都会读取这个文件，并确切地知道它应该做什么、如何表现以及它识别哪些命令。
这是为我的系统提供动力的完整 CLAUDE.md：
```
# 我的个人 AI AGENT — 操作指南
你是我的个人生活 Agent。你帮助我保持专注、信息灵通，
并坚持我的习惯。
## 核心规则
1. 每次执行命令后，将结果发送到 Telegram。
永远不要跳过这一步。
2. 所有输出使用英语。
3. 要直接。没有废话，没有不必要的免责声明。
4. 当你需要网站数据时，使用 Playwright 浏览
实际页面——不要猜测或编造。
5. 在生成任何个性化内容之前阅读 context.md。
## 命令
### gm
晨间简报。按顺序执行：
1. 使用 Playwright 打开 TechCrunch。找出过去 24 小时内最重要的 3 条
AI 或科技新闻。获取真实标题。
2. 阅读 tasks.md。列出所有未勾选的项目作为今天的习惯。
3. 写一句激励的话（根据我的上下文个性化）。
4. 清晰地格式化所有内容并发送到 Telegram。
### x post idea
为 X（Twitter）生成 3 条病毒式传播的帖子创意：
- 阅读 context.md 以了解我的领域和语调。
- 浏览 X 或科技新闻，了解当前正在流行什么。
- 写 3 个不同的钩子：一个反直觉的观点，一个个人故事格式，
一个“这是我的所学”格式。
- 将所有 3 条发送到 Telegram。
### motivate me
根据我的背景和当前目标，写一条有力、具体的激励信息。
不要写通用的。发送到 Telegram。
### fact
查找或生成一个关于 AI、
技术或科学的迷人、具体的事实。令人惊讶且值得分享。发送到 Telegram。
### polymarket check
使用 Playwright 打开 polymarket.com。找出 3 个最有趣的
活跃预测市场。报告当前赔率和交易量。
为每一个添加一行简短观点。发送到 Telegram。
### research [主题]
使用 Playwright 浏览 3 个关于 [主题] 的不同来源。
将关键见解综合成简洁的摘要。
保存到 notes.md 并将摘要发送到 Telegram。
### done: [任务]
在 tasks.md 中找到 [任务] 并将其标记为完成（将 [ ] 改为 [x]）。
确认标记了什么并发送到 Telegram。
### check progress
阅读 tasks.md。统计已完成与总习惯的对比。
计算百分比并将进度报告发送到 Telegram。
### evening review
阅读 tasks.md 以查看今天完成了什么。
写一段简短、诚实的总结：胜利、错过的东西，
以及明天的一个改进点。发送到 Telegram。
```
这个文件就是 Agent 的全部智能。没有代码，没有配置——只是纯英文指令。这就是这个系统的美妙之处：你可以随时编辑它以添加新命令、更改行为或更新你的上下文。
专业提示：你的 CLAUDE.md 越具体，Agent 的表现就越好。“浏览 TechCrunch”比“查找新闻”能获得更好的结果。“写一个关于 AI 自动化的反直觉观点”比“写一个帖子创意”能获得更好的结果。
# 重启并测试 Agent
完成所有四个步骤后，重启 Claude Desktop。打开后，创建一个新项目（这很重要——Claude Desktop 中的项目具有持久记忆并读取你的文件夹）。将 agent-system 文件夹添加到项目中。
现在输入你的第一条命令：gm
接下来会发生这样的事情：Claude 读取 CLAUDE.md，看到 gm 命令的指令，使用 Playwright 打开一个真实的 Chrome 浏览器，导航到 TechCrunch，阅读实际标题，回到你的 tasks.md 文件，阅读你的习惯，将所有内容格式化成一条清晰的消息，并发送到 Telegram。整个过程大约需要 30-60 秒。
这是我第一次运行时实际收到手机上的内容：
```
🌅 早上好！这是你的简报：
今天的 AI 新闻：
• Anthropic 以 900B 估值融资 - 新的前沿模型即将到来
• OpenAI 起诉 xAI，理由是 Grok 训练数据问题
• Stripe 宣布推出原生 AI Agent 支付基础设施
• Google Gemini 集成即将通过 Android Auto 进入 4 亿辆汽车
今天的习惯：
☐ ML 课程 ☐ X 帖子 ☐ 健身
☐ LeetCode ☐ 英语 ☐ 阅读
☐ 喝水（2L） ☐ 神经网络
一件事：今天发布一些小东西。一致性胜过强度。
来吧。🔥
```
真实的标题。我文件中的真实任务。一条听起来像是为我而写的消息，而不是模板。那一刻我知道这个系统值得分享。
# 我实际上如何每天使用这个
这个系统已经运行了几个月。以下是它如何融入实际的一天——不是理想化的生产力工作流程，而是实际发生的情况。
## 早晨（7-8 点）
我还在床上时就输入“gm”。当我刷完牙时，简报已经到了。我知道 AI 领域发生了什么，我知道我今天承诺了什么，我有一个明确的早晨意图。没有应用切换，没有末日刷屏，没有决策疲劳。
## 白天
当我完成某事时，我输入“done: gym”或“done: ml course”。Agent 更新文件并确认。这需要三秒钟，看着 Agent 为我做记账工作，有一种奇怪的满足感。
当我需要帖子创意或者卡在写什么时，我输入“x post idea”。Agent 浏览实际流行的内容——而不是三个小时前流行的内容——并给我三个可以使用的钩子。大约三分之一稍作编辑后足以发布。
## 晚上
“Evening review”将所有内容汇总在一起。Agent 读取完成了什么，没完成什么，并写一个诚实的总结。这就像有一个教练，当你不去健身房时，他不害怕告诉你。
# 为什么这行得通（当其他系统不行时）
我试过大多数流行的生产力系统。Notion 数据库、Obsidian 库、Zapier 自动化、Todoist 集成。它们都有同样的问题：它们要求你去它们那里。你必须打开应用。你必须签到。当生活变得忙碌时，你就停止了。
这个系统颠倒了这种关系。Agent 来找你。它通过 Telegram 触达你——也就是你已经使用的同一个应用——并准确交付你需要的东西。摩擦力几乎为零，这就是为什么它实际上能坚持下去。
它起作用的第二个原因是它连接到你的真实数据。Agent 不会给你通用的早晨激励，因为它对你一无所知。它读取 context.md。它知道你在公开构建，正在学习 ML，关心预测市场。输出反映了这一点。
第三个原因：它浏览实际的网页。不是摘要，不是六个月前的训练数据。当你询问今天的 AI 新闻时，Agent 打开 TechCrunch 并阅读今天的标题。当你询问 Polymarket 数据时，它打开 Polymarket 并阅读实时赔率。这就是 Playwright MCP 所做的。