Solo Entrepreneur Cases

Topic Selection (30 minutes)
  ↓
Writing (1-2 hours)
  ↓
Formatting + Image Selection (30 minutes)
  ↓
Manual Publishing to Each Platform (30 minutes)

Agent pushes 5 topics daily at 9 AM → Select one (1 minute)
  ↓
Agent generates first draft in 5 minutes → Manual review and modification (5 minutes)
  ↓
Automatically pushes to Lark → Format already set
  ↓
Ziliu one-click publishing → 14 platforms (4 minutes)

# Automatically executes every day at 9 AM
0 9 * * * /path/to/openclaw run daily-topic-push

1. Use search tools to find AI hot topics on social media from the past 24 hours
   ↓
2. Use Brave Search to find the latest news on Google
   ↓
3. Filter 5 topics based on positioning (AI programming + going global + entrepreneurship)
   ↓
4. For each topic, generate:
   - Alternative titles
   - Popularity rating
   - Angle of approach
   - Key points
   ↓
5. Push to Telegram

You: [Receive push notification at 9 AM]

Agent: Today's topic recommendations:

1. 【Popularity⭐⭐⭐⭐⭐】Claude Opus 4.6 Released
   Title: A single Claude plugin makes global software stocks evaporate $285 billion
   Angle: From technological breakthrough to market impact
   Key points: Performance improvement, application scenarios, industry impact

2. 【Popularity⭐⭐⭐⭐】OpenAI Codex Standalone App Launched
   Title: OpenAI's Big Move: Run 10 AI Agents at once to help you write code
   Angle: Product experience + practical testing
   Key points: Feature highlights, user experience, comparative analysis

3. 【Popularity⭐⭐⭐】AI Programming Tool Security Vulnerability
   Title: 280+ Leaky Skills: OpenClaw exposes API Keys
   Angle: Security alert + preventive measures
   Key points: Vulnerability analysis, scope of impact, solutions

4. 【Popularity⭐⭐⭐】Vibe Coding is Dead
   Title: Karpathy says the future is Agentic Engineering
   Angle: Programming paradigm shift
   Key points: Concept interpretation, practical cases, future trends

5. 【Popularity⭐⭐】OpenClaw 2.6 Tuning Record
   Title: From 4671 Crashes to 50% Token Savings
   Angle: Practical experience sharing
   Key points: Pitfalls encountered, optimization methods, effect comparison

Reply with a number to select, e.g.: write 1

You: write 1

Agent: Received! Starting to create 'A single Claude plugin makes global software stocks evaporate $285 billion'

# Agent automatically executes
def collect_materials(topic):
    # 1. Search for relevant news (serial search to avoid triggering limits)
    news = search_news(topic, source=['google', 'social_media', 'reddit'])
    
    # 2. Find relevant experiences from memory bank
    memories = search_memory(keywords=['copilot', '逆向', '出海'])
    
    # 3. Pull technical documents
    docs = fetch_tech_docs(topic)
    
    return {
        'news': news,
        'memories': memories,
        'docs': docs
    }

Writing style requirements:

Opening pattern:
- First sentence: "Hello everyone, I'm Meng Jian."
- Second sentence: Must be "explosive" (data, contrast, conflict)

Structure requirements:
- Modular paragraphs, clear numbering
- One quotable golden sentence every 500 words
- Use before vs after comparison for all scenarios
- Control length to 2000-3000 words

Title formula:
- Number + Result + Contrast
- Example: "Complete cross-platform publishing in 10 minutes, 94% efficiency improvement"

Ending requirements:
- "Eject" rather than "land"
- Conclude with a powerful statement
- Example: "Delegate repetitive tasks to the system, reserve judgment for yourself."

# Agent automatically executes
def push_to_feishu(article):
    # 1. Call Lark API to create a document
    doc = feishu.create_doc(
        title=article['title'],
        content=article['content']
    )
    
    # 2. Convert Markdown to Lark format
    formatted_content = convert_md_to_feishu(article['content'])
    
    # 3. Images automatically uploaded
    for img in article['images']:
        feishu.upload_image(doc.id, img)
    
    # 4. Generate link and send
    link = feishu.get_doc_link(doc.id)
    telegram.send_message(f"文章已生成：{link}")
    
    return link

1. Copy Markdown from Lark to Ziliu editor
   ↓
2. Ziliu automatically adapts to each platform's format:
   - Zhihu: Image centering, code block optimization
   - Juejin: Technical tags, code highlighting
   - Bilibili: Video cover, multi-part titles
   - Xiaohongshu: Emoji optimization, topic tags
   - Official Accounts: Layout beautification, read original text
   - ... 14 platforms in total
   ↓
3. Click "One-Click Publish"
   ↓
4. Chrome extension automatically fills in editors for each platform
   ↓
5. All published in 10 minutes

# Agent directly calls Ziliu API
def publish_to_all_platforms(article):
    # 1. Push to Ziliu
    draft = ziliu_api.create_draft(
        title=article['title'],
        content=article['content'],
        images=article['images']
    )
    
    # 2. Automatically publish
    result = ziliu_api.publish(
        draft_id=draft.id,
        platforms=['zhihu', 'juejin', 'bilibili', 'xiaohongshu', ...]
    )
    
    # 3. Return publishing result
    return result

Original process:
Agent finishes writing → Push to Lark → Open Lark → Copy content → Open Ziliu → Paste → Publish

Optimized:
Agent finishes writing → Directly call Ziliu API → Automatically publish

Eliminates 3 manual steps!

# Writing Style Guide.md

## Opening Pattern
- First sentence fixed: "Hello everyone, I'm Meng Jian."
- Second sentence must be "explosive":
  ✅ "I'm writing an article now, from topic selection to cross-platform publishing, it only takes 10 minutes."
  ✅ "A single Claude plugin makes global software stocks evaporate $285 billion."
  ❌ "Today we're discussing AI programming." (Too bland)

## Title Formula
Pattern 1: Number + Result + Contrast
- "Complete cross-platform publishing in 10 minutes, 94% efficiency improvement"
- "From 4671 crashes to 50% token savings"

Pattern 2: Conflict + Result
- "A single Claude plugin makes global software stocks evaporate $285 billion"
- "Vibe Coding is Dead, Karpathy says the future is Agentic Engineering"

Pattern 3: Question + Answer
- "Why do I no longer write articles manually? Because the Agent starts working before I do"

## Structure Requirements
- Modular paragraphs, numbered (01, 02, 03...)
- Each module 500-800 words
- Every 500 words must have a quotable golden sentence
- Use before vs after comparison for all scenarios

## Golden Sentence Requirements
- Short (10-20 characters)
- Powerful (impactful)
- Screenshot-friendly (good visual effect)

Example:
✅ "Delegate repetitive tasks to the system, reserve judgment for yourself."
✅ "Topics find me, I don't find topics."
✅ "The Agent starts working before I do."
❌ "I think AI is very useful." (Too bland)

## Ending Requirements
- "Eject" rather than "land"
- Conclude with a powerful statement
- Leave food for thought or a call to action

Example:
✅ "If you're also building a personal brand, and still manually writing, manually publishing, manually selecting topics—think about it, is your true value in 'typing on a keyboard' or in 'deciding what's worth saying'?"
❌ "That's all for today's sharing, thank you." (Too bland)

## Word Usage Habits
- Use more short sentences, fewer long sentences
- Use more verbs, fewer adjectives
- Use more data, fewer feelings
- Use more comparisons, fewer descriptions

## Forbidden Words
❌ "very", "quite", "especially" (Too vague)
❌ "possibly", "perhaps", "probably" (Uncertain)
❌ "I think", "I believe" (Too subjective)
✅ Replace feelings with data: "94% efficiency improvement" instead of "much efficiency improvement"

# memory/2026-02-11.md

## Today's Work
- Topic: Claude Opus 4.6 Released
- Article: 'A single Claude plugin makes global software stocks evaporate $285 billion'
- Publishing platforms: 14
- Readership data:
  - Zhihu: 5,230 reads
  - Juejin: 3,120 reads
  - Official Accounts: 2,890 reads

## Usage Data
- Search count: 15 times
- Words generated: 2,850 words
- Modification count: 3 times
- Time spent: 8 minutes

## Experience Log
- The "$285 billion" data in the title is very eye-catching
- The "explosive" opening works well, high sharing rate
- The "eject" ending sparked a lot of discussion

## Next Improvements
- Can add more practical case studies
- Technical details can be explored further

Iron Rule: All content must be manually confirmed before publishing

Reasons:
- AI may make factual errors
- Wording may be inappropriate
- Judgment may be biased

Process:
Agent finishes writing → Push to me → I review and modify → Publish after confirmation

AI is responsible for efficiency, humans for the quality baseline.

# crontab -e

# Push topics every day at 9 AM
0 9 * * * /usr/local/bin/openclaw run daily-topic-push

# Generate work log every day at 11 PM
0 23 * * * /usr/local/bin/openclaw run daily-summary

# Generate weekly report every Monday at 8 AM
0 8 * * 1 /usr/local/bin/openclaw run weekly-report

Without scheduled tasks:
- Only use when remembered
- Easy to forget
- Not systematic

With scheduled tasks:
- Topics are pushed every day at 9 AM
- You have to face it
- Driven forward, 10x more efficient

Before:
- Writing an article was a "heavy decision"
- Should I write? What to write? When to write?
- Often procrastinated, anxious

Now:
- Writing an article is a "light decision"
- The topics are already there
- Just daily updates, it's so easy!

# Agent Role Definition

## Identity
You are "Mobie", a professional content creation assistant.

## Core Responsibilities
1. Push 5 topics daily at 9 AM
2. Generate a first draft based on the selected topic
3. Automatically push to Lark
4. Record work log

## Writing Style
- Opening: "Hello everyone, I'm [Author Name]."
- Second sentence must be "explosive" (data, contrast, conflict)
- Structure: Modular paragraphs, clear numbering
- One quotable golden sentence every 500 words
- Ending: "Eject" rather than "land"

## Tool Permissions
- Can call: Search API, Lark API, Ziliu API
- Cannot: Auto-publish (manual confirmation required)

## Workflow
1. Search hot topics → Generate topics → Push to Telegram
2. Receive instruction → Collect materials → Generate first draft
3. Push to Lark → Wait for confirmation → Record log

## Boundaries
- Only responsible for content creation, nothing else
- All publishing must be manually confirmed
- Mark [To be verified] for uncertain facts

#!/bin/bash
# daily-topic-push.sh

# 1. Search hot topics
openclaw ask "搜索过去24小时AI编程领域的热点，生成5个选题"

# 2. Push to Telegram
openclaw telegram send "今日选题推荐：\n\n[选题内容]"

# 3. Record log
echo "$(date): 选题推送完成" >> /var/log/openclaw/daily-push.log

# ziliu_integration.py

import requests

class ZiliuAPI:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://api.ziliu.example/v1"  # Example API address
    
    def create_draft(self, title, content, images=None):
        """创建草稿"""
        response = requests.post(
            f"{self.base_url}/drafts",
            headers={"Authorization": f"Bearer {self.api_key}"},
            json={
                "title": title,
                "content": content,
                "images": images or []
            }
        )
        return response.json()
    
    def publish(self, draft_id, platforms):
        """发布到多个平台"""
        response = requests.post(
            f"{self.base_url}/publish",
            headers={"Authorization": f"Bearer {self.api_key}"},
            json={
                "draft_id": draft_id,
                "platforms": platforms
            }
        )
        return response.json()

# Usage example
ziliu = ZiliuAPI("your-api-key")

# Create draft
draft = ziliu.create_draft(
    title="10分钟完成全平台发布",
    content="# 文章内容...",
    images=["image1.jpg", "image2.jpg"]
)

# Publish to all platforms
result = ziliu.publish(
    draft_id=draft['id'],
    platforms=['zhihu', 'juejin', 'bilibili', 'xiaohongshu']
)

┌─────────────────────────────────────────────────────────┐
│                      Lark (Feishu)                       │
├─────────────────────────────────────────────────────────┤
│  Robot 1: Main Assistant  Robot 2: Content Creation Assistant  │
│  Robot 3: Technical Development Assistant Robot 4: AI News Assistant            │
└─────────────────────────────────────────────────────────┘
                          ↓ WebSocket
┌─────────────────────────────────────────────────────────┐
│                   OpenClaw Gateway Layer                    │
├──────────────┬──────────────┬──────────────┬────────────┤
│ Gateway 1    │ Gateway 2    │ Gateway 3    │ Gateway 4  │
│ Port: 18789  │ Port: 18790  │ Port: 18791  │ Port: 18792│
│ Profile:     │ Profile:     │ Profile:     │ Profile:   │
│ main-        │ content-     │ tech-dev     │ ai-news    │
│ assistant    │ creator      │              │            │
└──────────────┴──────────────┴──────────────┴────────────┘
                          ↓
┌─────────────────────────────────────────────────────────┐
│                      Agent Layer                            │
├──────────────┬──────────────┬──────────────┬────────────┤
│ main-agent   │ content-agent│ tech-agent   │ainews-agent│
│ Claude Opus  │ Claude Sonnet│ Claude Sonnet│ Gemini 2.5 │
│ 4.6 Thinking │ 4.5          │ 4.5 Thinking │ Flash      │
└──────────────┴──────────────┴──────────────┴────────────┘

# Start all Gateways
./start-all-gateways.sh

# Check status
./check-gateways.sh

Tool (API Service Platform)
  ↓
Content (Tutorials/Sharing)
  ↓
Community (Discussion Group)
  ↓
More people use the tool
  ↓
(Loop)

Problem:
- Users leave after use
- No stickiness
- Difficult to repurchase

Solution:
- Gather users together
- Help each other navigate pitfalls
- Share usage methods
- And use API services incidentally

Result:
- User retention improved
- Word-of-mouth spread
- Natural repurchase

¥49 = Filter + Hook

Filter:
- Don't want to be a customer service group
- Don't want to be overwhelmed by "how to configure this" questions
- People willing to pay ¥49 are at least serious about playing

Hook:
- Give $50 API credit
- User pays ¥49 (approx. $7), gets $50 credit
- Mathematically, they profit
- Psychologically, there's no feeling of "paying for a group"

Traffic Diversion:
- The $50 credit will drive traffic to the API service platform
- Users register, try it out, and naturally renew after getting used to it
- Red packets are customer acquisition cost
- Credit is the hook
- API consumption is LTV

Considered options:
- First 50 people free
- 50-100 people ¥29
- After 100 people ¥49

Reasons for abandonment:
- Too complex
- Free entrants have low participation
- Better to go straight to ¥49, simple and direct

# OpenClaw + AI Go Code Getting Started Tutorial

## 5 Steps to Get Started from Scratch

### Step 1: Get API Key
1. Visit your API service platform
2. Register an account
3. Enter the console
4. Copy API Key

### Step 2: Install OpenClaw
```bash
# macOS/Linux
curl -fsSL https://openclaw.example/install.sh | bash

# Windows
iwr https://openclaw.example/install.ps1 | iex

# Configure API Key
openclaw config set api.key "your-api-key"

# Test connection
openclaw ask "你好"

# Create Bot
openclaw telegram create-bot

# Bind Bot
openclaw telegram bind

# View available models
openclaw models list

# Switch to Claude
openclaw config set model "claude-opus-4"

# Switch to Codex
openclaw config set model "codex-5.3"

**2. Group Announcement (2 versions)**

```markdown
# Group Announcement v1 (Social Media Version)

Welcome to the OpenClaw Discussion Group!

This is not:
❌ Customer service group
❌ Course group
❌ Q&A group

This is:
✅ Player discussion group
✅ Experience sharing group
✅ Pitfall mutual aid group

Joining the group = agreeing to the above

---

# Group Announcement v2 (WeChat Version)

【OpenClaw Discussion Group】

Group Rules:
1. No teachers, no teaching assistants, no obligation to answer questions
2. If you have questions, read the tutorial first, then ask group members
3. Share your methods, help others grow
4. No advertising, no recruiting, no spamming

Credit Claim:
1. After joining the group, send: My WeChat ID
2. Wait for administrator to issue $50 credit
3. Log in to the API service platform to check

Tutorial Address:
[Notion Tutorial Document]

# payment_automation.py

from flask import Flask, request
import qrcode
import requests

app = Flask(__app__)

@app.route('/pay', methods=['POST'])
def handle_payment():
    # 1. Receive payment notification
    payment_data = request.json
    
    # 2. Verify payment
    if verify_payment(payment_data):
        # 3. Generate group QR code
        qr_code = generate_group_qrcode()
        
        # 4. Send to user
        send_qrcode_to_user(
            user_id=payment_data['user_id'],
            qr_code=qr_code
        )
        
        # 5. Record to database
        save_to_database(payment_data)
        
        return {"status": "success"}
    
    return {"status": "failed"}

def verify_payment(data):
    """Verify payment"""
    # Call WeChat Pay API to verify
    pass

def generate_group_qrcode():
    """Generate group QR code"""
    qr = qrcode.QRCode()
    qr.add_data("https://t.me/your_group")  # Replace with your group link
    qr.make()
    return qr.make_image()

def send_qrcode_to_user(user_id, qr_code):
    """Send QR code to user"""
    # Send via WeChat/Telegram
    pass

Process Optimization:
See poster → Scan code to pay → Group QR code automatically pops up → Join group

The shorter, the smoother, the higher the conversion rate

# credit_distribution.py

import pandas as pd
from datetime import datetime

class CreditManager:
    def __init__(self):
        self.db = pd.DataFrame(columns=[
            'user_id', 'wechat', 'amount', 'status', 'created_at'
        ])
    
    def add_user(self, user_id, wechat):
        """Add user"""
        self.db = self.db.append({
            'user_id': user_id,
            'wechat': wechat,
            'amount': 50,
            'status': 'pending',
            'created_at': datetime.now()
        }, ignore_index=True)
    
    def distribute_credit(self, user_id):
        """Distribute credit"""
        # 1. Check if already distributed
        if self.is_distributed(user_id):
            return {"error": "已发放"}
        
        # 2. Call API to distribute
        result = api_distribute_credit(user_id, amount=50)
        
        # 3. Update status
        self.db.loc[self.db['user_id'] == user_id, 'status'] = 'distributed'
        
        return result
    
    def is_distributed(self, user_id):
        """Check if already distributed"""
        row = self.db[self.db['user_id'] == user_id]
        return len(row) > 0 and row.iloc[0]['status'] == 'distributed'
    
    def export_report(self):
        """Export report"""
        return self.db.to_csv('credit_report.csv')

# Usage example
manager = CreditManager()

# Add user
manager.add_user('user123', 'wechat_abc')

# Distribute credit
manager.distribute_credit('user123')

# Export report
manager.export_report()

Managing credits for 100 people manually will eventually lead to errors:
- Duplicate distribution
- Missed distribution
- Disorganized records

Automated system:
- Prevents duplication
- Automatic recording
- One-click export

Social media:
- Posted several tweets with posters
- Main battleground, concentrated tech audience

Official Accounts:
- Published a text-image article
- Detailed introduction of group value

No paid traffic, no cross-promotion, purely organic traffic

First version of poster:
- Sent out with little response
- Low conversion rate

Second version of poster (adjusted by Claude Max):
- More visually appealing
- Clearer copy
- Added WeChat Pay automation
- Conversion immediately picked up

Lesson learned:
Don't underestimate the "last mile" experience

1. Xiao O (Personal Assistant)
   - Manages configuration
   - Manages memory
   - Manages reminders

2. Content Bot
   - Searches hot topics daily
   - Writes tweet drafts
   - Generates long-form article outlines
   - Automatically writes to Notion

3. Going Global Bot
   - Focuses on AI programming going global direction
   - In-depth research
   - Competitor analysis

4. Learning Bot
   - Teaches me how to use OpenClaw
   - Teaches group members usage tips
   - Organizes FAQ

5. Team Bot
   - Manages employee records
   - Manages KPIs
   - Manages payroll
   - Manages weekly reports

Single Bot issues:
- Context confusion
- Unclear roles
- Prone to errors

Multi-Bot advantages:
- Each manages its own area
- Independent operation
- Independent context
- No mutual interference

Equivalent to hiring 5 AI employees, 24/7 online

# Content Bot Configuration

## Role
You are the Content Bot, specifically responsible for content creation related tasks.

## Responsibilities
1. Search for AI programming hot topics daily at 9 AM
2. Generate 5 topics and push them to me
3. Generate tweet drafts based on the selected topic
4. Generate long-form article outlines
5. Automatically write to Notion

## Tool Permissions
- Can call: Search API, Notion API, Social Media API
- Cannot: Publish content (manual confirmation required)

## Workflow
1. Scheduled hot topic search
2. Generate topics
3. Push to Telegram
4. Wait for instructions
5. Generate content
6. Write to Notion

## Output Format
Topic format:
【Popularity⭐⭐⭐⭐⭐】Title
Angle: Angle of approach
Key points: Core points

Tweet format:
- First sentence: Eye-catching
- Middle: Core content
- End: Call to action
- Word count: Within 280 characters
### 15.3.7 Model Auto-Switching

**Watchdog Script**:

```python
# model_watchdog.py

import time
import requests
from datetime import datetime

class ModelWatchdog:
    def __init__(self):
        self.models = {
            'claude-opus-4': {
                'url': 'https://api.example.com/v1/claude',  # 替换为你的API地址
                'backup': 'claude-sonnet-4'
            },
            'codex-5.3': {
                'url': 'https://api.example.com/v1/codex',  # 替换为你的API地址
                'backup': 'codex-5.2'
            }
        }
        self.current_model = 'claude-opus-4'
    
    def check_health(self, model):
        """检查模型健康状态"""
        try:
            response = requests.get(
                self.models[model]['url'] + '/health',
                timeout=5
            )
            return response.status_code == 200
        except:
            return False
    
    def switch_model(self, from_model, to_model):
        """切换模型"""
        # 1. 更新配置
        update_config('model', to_model)
        
        # 2. 通知Telegram
        send_telegram_message(
            f"⚠️ 模型切换\n"
            f"从：{from_model}\n"
            f"到：{to_model}\n"
            f"时间：{datetime.now()}"
        )
        
        # 3. 记录日志
        log(f"Model switched: {from_model} -> {to_model}")
    
    def run(self):
        """运行看门狗"""
        while True:
            # 检查当前模型
            if not self.check_health(self.current_model):
                # 切换到备用模型
                backup = self.models[self.current_model]['backup']
                self.switch_model(self.current_model, backup)
                self.current_model = backup
            
            # 检查备用模型是否恢复
            for model in self.models:
                if model != self.current_model:
                    if self.check_health(model):
                        # 切回主模型
                        self.switch_model(self.current_model, model)
                        self.current_model = model
            
            # 等待5分钟
            time.sleep(300)

# 启动看门狗
watchdog = ModelWatchdog()
watchdog.run()

Model issues in the middle of the night:
- Automatic detection
- Automatic switching
- Telegram notification
- Wake up in the morning, already resolved

No manual intervention required!

1. Daily Work Log
   - What was done
   - What tools were used
   - What problems were encountered
   - Solutions

2. Content Drafts
   - Topic selection
   - Outline
   - Draft
   - Publication records

3. Topic Library
   - Hot topic tracking
   - Topic scoring
   - Usage status

4. Group Member Credit Management
   - User ID
   - WeChat ID
   - Credit status
   - Distribution time

5. Social Media KOL Monitoring
   - KOL list
   - MRR tracking
   - User count tracking
   - Product iteration records

# notion_automation.py

from notion_client import Client

class NotionAutomation:
    def __init__(self, token):
        self.client = Client(auth=token)
    
    def create_daily_log(self, content):
        """创建每日日志"""
        self.client.pages.create(
            parent={"database_id": "daily-log-db-id"},
            properties={
                "Date": {"date": {"start": datetime.now().isoformat()}},
                "Title": {"title": [{"text": {"content": f"日志 {datetime.now().date()}"}}]}
            },
            children=[
                {
                    "object": "block",
                    "type": "paragraph",
                    "paragraph": {"rich_text": [{"text": {"content": content}}]}
                }
            ]
        )
    
    def add_topic(self, topic, score, status="pending"):
        """添加选题"""
        self.client.pages.create(
            parent={"database_id": "topics-db-id"},
            properties={
                "Topic": {"title": [{"text": {"content": topic}}]},
                "Score": {"number": score},
                "Status": {"select": {"name": status}}
            }
        )
    
    def update_credit_status(self, user_id, status):
        """更新额度状态"""
        # 查找用户记录
        results = self.client.databases.query(
            database_id="credits-db-id",
            filter={"property": "UserID", "rich_text": {"equals": user_id}}
        )
        
        if results['results']:
            page_id = results['results'][0]['id']
            # 更新状态
            self.client.pages.update(
                page_id=page_id,
                properties={"Status": {"select": {"name": status}}}
            )

# 使用示例
notion = NotionAutomation("your-notion-token")

# 创建日志
notion.create_daily_log("今天完成了群冷启动，100人入群")

# 添加选题
notion.add_topic("Claude Opus 4.6发布", score=5)

# 更新额度状态
notion.update_credit_status("user123", "distributed")

Saw poster: approx. 500 people
  ↓ 20%
Clicked link: approx. 100 people
  ↓ 100%
Completed payment: 100 people
  ↓ 100%
Joined group: 100 people

Paid conversion rate: 20% (100/500)
Refund rate: 0%
Credit claim rate: 95% (95/100)
API activation rate: 60% (60/100)

First version of poster:
- Sent out with little response
- Conversion rate <5%

Second version of poster (Claude Max adjusted):
- More visually appealing
- Clearer copy
- Added WeChat Pay automation
- Conversion rate >20%

Lesson:
Don't underestimate the "last mile" experience

Considered:
- First 50 people join the group for free as seed users

Reason for abandonment:
- People who join for free vs. people who pay
- Engagement is completely different
- ¥49 isn't much, but the act itself is a filter

First version:
- Too long
- Nobody read it

Second version:
- Condensed into a few key points
- Added credit claim process
- Much better effect

Before AI:
- Write an article: 3 hours
- Weekly output: 2-3 articles
- Platform coverage: 3-4
- Feeling: Tired, anxious, procrastinating

After AI:
- Write an article: 10 minutes
- Weekly output: 7 articles
- Platform coverage: 14
- Feeling: Relaxed, efficient, sustained

The biggest change isn't speed, it's mindset

Before AI:
- Poster design: Find a designer, wait 3 days
- Credit system: Find a developer, wait 1 week
- Copy optimization: Edit myself, half a day
- Registration form: Use third-party tools, limited functionality

After AI:
- Poster: Claude Max adjusted, 10 minutes
- Credit system: Claude Max wrote, 30 minutes
- Copy: Claude Max optimized, 5 minutes
- Registration form: Claude Max developed, 20 minutes

The entire system was up and running in one day

Self-media is about to be disrupted

It's not that content itself is replaced by AI
But rather that the efficiency of content production is elevated by an order of magnitude by AI

Work that used to require a team
Can now be done by one person with AI

AI handles execution, humans handle judgment

Judge what?
- Whether a topic is worth pursuing
- Whether content quality meets standards
- Whether the strategic direction is correct
- How to respond to user feedback

AI can:
- Generate 100 topics
- Write 10 articles
- Design 20 posters

But only humans can judge:
- Which topic is most valuable
- Which article best fits the positioning
- Which poster converts best

It's not "doing things with AI"
But "building AI systems"

Difference:
Doing things with AI:
- Only used when remembered
- Requires re-instruction every time
- Limited efficiency improvement

Building AI systems:
- Runs automatically on schedule
- Has memory, has style
- 10x+ efficiency improvement

Case 1:
- Scheduled tasks push topics
- Style files ensure quality
- Memory system avoids repetition

Case 2:
- 5 Bots each manage a specific area
- Automated payment for group entry
- Watchdog automatically switches models

Don't strive for perfection, first get the minimum viable loop running

Case 1:
- First version of style file: 500 words
- Second version: 1000 words
- Third version: 3000 words
- Continuous optimization, getting better and better

Case 2:
- First version of poster: 5% conversion rate
- Second version of poster: 20% conversion rate
- Rapid iteration, immediate results

Core:
- Do first, then optimize
- Data-driven iteration
- Don't overthink

Core:
- Scheduled tasks push topics
- Agent generates first draft
- Manual review and modification
- Automatic multi-platform publishing

Key files:
- SOUL.md: Defines Agent role
- Style file: Ensures content quality
- Memory system: Avoids repetition

Effect:
- 3 hours → 10 minutes
- 94% efficiency improvement

Core:
- Automated payment for group entry
- Automated credit distribution
- Multi-Bot matrix management
- Notion records everything

Key components:
- Payment system: Reduces operational costs
- Credit system: Prevents duplicate or missed distributions
- Bot matrix: Each manages a specific area
- Notion: Central database

Effect:
- 100 people cold-started in 1 day
- 0 refunds

Core:
- Multi-model configuration
- Automatic health checks
- Automatic fallback switching
- Real-time notifications

Key scripts:
- Watchdog script
- Model configuration file
- Notification system

Effect:
- Automatically handles issues in the middle of the night
- No manual intervention required

Core:
- All operations automatically logged
- Automatically written to Notion
- Generates reports periodically
- Data-driven decision making

Content to log:
- Daily work log
- Content publication records
- User credit status
- KOL monitoring data

Effect:
- No manual logging required
- Data viewable anytime
- Data-driven optimization

Reason:
- AI may produce factual errors
- Wording may be inappropriate
- Judgment may be biased

Process:
Agent generates → Manual review → Publish after confirmation

AI handles efficiency, humans handle the quality baseline

Why?
- Lets the system "push you forward"
- Doesn't rely on "only used when remembered"
- Forms a stable work rhythm

Examples:
- Push topics at 9 AM daily
- Generate logs at 11 PM daily
- Generate weekly reports on Monday mornings

Why?
- Data-driven decision making
- Avoids repetitive work
- Continuously optimizes the system

What to log?
- What was done daily
- What tools were used
- What problems were encountered
- What the results were

Tools:
- Notion (structured data)
- Log files (raw data)
- Screenshots (visual records)

Don't strive for perfection:
- First get the minimum viable loop running
- Quickly launch for testing
- Iterate based on feedback

Case 1:
- First version of style file: 500 words
- Continuously optimized to 3000 words

Case 2:
- First version of poster: 5% conversion rate
- Second version of poster: 20% conversion rate

What is core value?
- Judgment (topic selection, quality, direction)
- Not execution (writing, design, publishing)

Delegate repetitive tasks to the system
Keep judgment for yourself

Case 1:
- Agent responsible for: searching, writing, publishing
- Human responsible for: topic selection, review, optimization

Case 2:
- AI responsible for: posters, systems, copy
- Human responsible for: pricing, strategy, operations

- Time saved: 20 hours per week
- Calculated at ¥200/hour: ¥16,000 saved per month
- ROI: 50x+

- Red packet income: ¥4,900
- Subsequent API consumption: Recurring income
- User LTV: ¥200-500/person
- ROI: 5-10x

Content Creation
  ↓
Multi-platform Publishing
  ↓
Fan Growth
  ↓
Influence Enhancement
  ↓
More Opportunities
  ↓
More Content Material
  ↓
(Loop)

Tool Product
  ↓
Content Tutorials
  ↓
Paid Community
  ↓
Users Use Tools
  ↓
Word-of-Mouth Spread
  ↓
More Users
  ↓
(Loop)

1. Find your core capability
   - Case 1: Content creation
   - Case 2: Technical products

2. Use AI to amplify this capability
   - Case 1: 10x content output
   - Case 2: Build a system in 1 day

3. Establish a growth flywheel
   - Case 1: Content → Fans → Influence
   - Case 2: Tools → Content → Community

4. Continuously optimize the system
   - Data-driven
   - Rapid iteration
   - Continuous improvement

~/.openclaw/
├── workspace/
│   ├── SOUL.md              # Agent角色定义
│   ├── writing-style.md     # 写作风格规范
│   └── memory/              # 记忆系统
│       ├── 2026-02-11.md
│       ├── 2026-02-12.md
│       └── ...
├── scripts/
│   ├── daily-topic-push.sh  # 每日选题推送
│   ├── generate-article.sh  # 生成文章
│   └── publish-all.sh       # 发布到所有平台
└── config/
    ├── feishu.json          # 飞书配置
    ├── ziliu.json           # 字流配置
    └── platforms.json       # 平台配置

# Agent Role Definition

## Identity
You are "[Agent Name]", a professional [role] assistant.

## Core Responsibilities
1. [Responsibility 1]
2. [Responsibility 2]
3. [Responsibility 3]

## Work Style
- [Style Requirement 1]
- [Style Requirement 2]
- [Style Requirement 3]

## Tool Permissions
- Can call: [List of tools]
- Cannot: [List of restrictions]

## Workflow
1. [Step 1]
2. [Step 2]
3. [Step 3]

## Boundaries
- [Boundary 1]
- [Boundary 2]
- [Boundary 3]

# crontab -e

# Daily topic push (9 AM)
0 9 * * * /path/to/openclaw run daily-topic-push

# Daily work log (11 PM)
0 23 * * * /path/to/openclaw run daily-summary

# Weekly report (Monday 8 AM)
0 8 * * 1 /path/to/openclaw run weekly-report

# Monthly report (1st of every month 9 AM)
0 9 1 * * /path/to/openclaw run monthly-report

#!/bin/bash
# publish-all.sh

# 1. Get article from Lark
article=$(openclaw feishu get-article "$1")

# 2. Push to Ziliu
draft_id=$(openclaw ziliu create-draft "$article")

# 3. Publish to all platforms
openclaw ziliu publish "$draft_id" \
  --platforms "zhihu,juejin,bilibili,xiaohongshu,wechat,csdn,segmentfault,jianshu,toutiao,baidu,sohu,163,sina,qq"

# 4. Log publication
echo "$(date): Published article $1" >> /var/log/openclaw/publish.log

~/.openclaw/
├── bots/
│   ├── personal-assistant/  # 私人助理Bot
│   ├── content-bot/         # 内容Bot
│   ├── learning-bot/        # 学习Bot
│   ├── team-bot/            # 团队Bot
│   └── outreach-bot/        # 出海Bot
├── automation/
│   ├── payment.py           # 支付自动化
│   ├── credit.py            # 额度管理
│   └── watchdog.py          # 模型看门狗
└── data/
    ├── users.csv            # 用户数据
    ├── credits.csv          # 额度记录
    └── logs/                # 日志文件

# Bot Configuration

## Role
You are [Bot Name], specifically responsible for [responsibilities].

## Responsibilities
1. [Responsibility 1]
2. [Responsibility 2]
3. [Responsibility 3]

## Tool Permissions
- Can call: [List of tools]
- Cannot: [List of restrictions]

## Workflow
1. [Step 1]
2. [Step 2]
3. [Step 3]

## Output Format
[Format description]

# payment_automation.py

from flask import Flask, request
import qrcode

app = Flask(__name__)

@app.route('/pay', methods=['POST'])
def handle_payment():
    # 1. Receive payment notification
    payment_data = request.json
    
    # 2. Verify payment
    if verify_payment(payment_data):
        # 3. Generate group QR code
        qr_code = generate_group_qrcode()
        
        # 4. Send to user
        send_qrcode_to_user(
            user_id=payment_data['user_id'],
            qr_code=qr_code
        )
        
        # 5. Log to database
        save_to_database(payment_data)
        
        return {"status": "success"}
    
    return {"status": "failed"}

if __name__ == '__main__':
    app.run(port=5000)

# credit_management.py

import pandas as pd
from datetime import datetime

class CreditManager:
    def __init__(self, db_path='data/credits.csv'):
        self.db_path = db_path
        self.load_database()
    
    def load_database(self):
        """Load database"""
        try:
            self.db = pd.read_csv(self.db_path)
        except:
            self.db = pd.DataFrame(columns=[
                'user_id', 'wechat', 'amount', 'status', 'created_at'
            ])
    
    def add_user(self, user_id, wechat, amount=50):
        """Add user"""
        self.db = self.db.append({
            'user_id': user_id,
            'wechat': wechat,
            'amount': amount,
            'status': 'pending',
            'created_at': datetime.now()
        }, ignore_index=True)
        self.save_database()
    
    def distribute_credit(self, user_id):
        """Distribute credit"""
        if self.is_distributed(user_id):
            return {"error": "Already distributed"}
        
        # Call API to distribute
        result = api_distribute_credit(user_id, amount=50)
        
        # Update status
        self.db.loc[self.db['user_id'] == user_id, 'status'] = 'distributed'
        self.save_database()
        
        return result
    
    def is_distributed(self, user_id):
        """Check if already distributed"""
        row = self.db[self.db['user_id'] == user_id]
        return len(row) > 0 and row.iloc[0]['status'] == 'distributed'
    
    def save_database(self):
        """Save database"""
        self.db.to_csv(self.db_path, index=False)
    
    def export_report(self):
        """Export report"""
        return self.db.to_csv('credit_report.csv')

Scenario A: Content Creation Automation
- Suitable for: Self-media, bloggers, content creators
- Core: Scheduled topic selection + automatic generation + multi-platform publishing
- Effect: 3 hours → 10 minutes

Scenario B: Community Operations Automation
- Suitable for: Entrepreneurs, product managers, community operators
- Core: Automated payment + credit management + multi-Bot matrix
- Effect: 100 people cold-started in 1 day

Scenario C: Hybrid Scenario
- Combines A and B
- Content + community dual-wheel drive

# 1. Install OpenClaw
curl -fsSL https://openclaw.example/install.sh | bash  # Replace with actual installation address

# 2. Create working directory
mkdir -p ~/.openclaw/workspace
mkdir -p ~/.openclaw/scripts
mkdir -p ~/.openclaw/config

# 3. Copy template files
cp templates/SOUL.md ~/.openclaw/workspace/
cp templates/writing-style.md ~/.openclaw/workspace/
cp templates/*.sh ~/.openclaw/scripts/

# 4. Configure API
openclaw config set api.key "your-api-key"
openclaw config set model "claude-opus-4"

# Edit crontab
crontab -e

# Add scheduled tasks
0 9 * * * /path/to/openclaw run daily-topic-push
0 23 * * * /path/to/openclaw run daily-summary

# Test topic push
openclaw run daily-topic-push

# Test article generation
openclaw ask "Write an article about AI programming"

# Test publishing
openclaw run publish-all "article-id"

1. Collect data
   - Record the results of each run
   - Analyze performance data

2. Optimize configuration
   - Adjust style files
   - Optimize prompts
   - Improve processes

3. Iterate and upgrade
   - Improve based on feedback
   - Add new features
   - Enhance automation level