AI Handbook on RanceLee的博客

A Practical Overview of Mainstream AI Tools

Mon, 01 Jan 0001 00:00:00 +0000

We’ve discussed what AI is and learned that it’s a “probability calculator that drafts answers.” But now the question is: With so many AI tools on the market, which one should you use?

This chapter introduces the most mainstream AI tools, including their websites, how to use them, and their features. After reading this chapter, you’ll know which one to choose.

The Big Three from Abroad: ChatGPT, Claude, Gemini

ChatGPT - The Most Famous One

Website: chat.openai.com

VPN Required: Yes
Developer: OpenAI (USA)
Latest Models:

GPT-5 Series: Includes GPT-5 Instant (fast), GPT-5 Thinking (reasoning), GPT-5 Thinking Pro (strongest reasoning)
GPT-5.2 Series: Flagship released in December 2025, best performance on professional knowledge tasks

Pros: Smartest, most feature-rich (chat, code, image generation, web search), best ecosystem (GPTs store), fastest updates
Cons: Difficult to access from China, many restrictions on free version, $20/month for paid
Best for: Those who want the most advanced AI, have budget, and have VPN access

Claude - The Most “Human” One

Website: claude.ai

VPN Required: Yes
Developer: Anthropic (USA)
Latest Models:

Claude Opus 4.5: World’s best for coding and agent tasks
Claude Sonnet 4.5: World’s best coding model, leading on SWE-bench
Claude Haiku 4.5: Fast, low-cost model

Pros: High-quality responses, strong long-text processing (200K-1M tokens), top-tier coding ability, Claude Code CLI tool
Cons: Requires VPN, relatively fewer features, Pro $20/month. Notably, this company is not very friendly to China and has strict account bans.
Best for: Writers, programmers, those who prioritize response quality

Gemini - Google’s All-Rounder

Website: gemini.google.com

VPN Required: Yes
Developer: Google (USA)
Latest Models:

Gemini 3 Pro: Beats competitors in 19/20 benchmarks
Gemini 3 Flash: Fast and low-cost, now the default model
Gemini 3 Deep Think: Deep reasoning mode

Pros: Strong web search capabilities, powerful multimodal, integrated with Google ecosystem, generous free tier on AI Studio, can use student plan for a year free, Banana model for text-to-image is world-class
Cons: Difficult to access from China
Best for: Those who frequently use Google services and need to process multimedia content

🎁 Freebie Tip: Google AI Studio

URL: aistudio.google.com

This is a gem! A developer platform from Google, but also usable by regular people. Simply put: Gemini’s free premium version.

Why recommend it:

Completely free: 60 requests per minute, more than enough for personal use
Latest models: Access to Gemini 3 Pro and Flash latest versions, already includes Banana model for text-to-image
No conversation limits: Unlike the official website version which has usage limits
Can generate API keys: For use with other tools

How to use: Open the URL, log in with a Google account (VPN required), click “Create new prompt” to start chatting. The interface is in English, but you can ask questions in Chinese. The only downside is that the interface is more developer-oriented and not as polished as the official website, but it’s equally powerful.

The Domestic Four: DeepSeek, Doubao, GLM, MiniMax

DeepSeek - China’s Pride

Website: chat.deepseek.com
VPN Required: No
Latest Models:

DeepSeek-V3.2: Matches GPT-5 and Gemini 3 performance
DeepSeek-V4: Expected release in February 2026

Pros: Completely free, very capable, outstanding coding ability, smooth access in China, open source
Cons: May be slow during peak hours, slightly weaker creativity, strict content moderation
Best for: First choice for domestic users! Students, programmers, those on a budget

Doubao - The Most User-Friendly AI

Website: doubao.com

VPN Required: No
Latest Models:

Doubao Large Model 1.8: Supports comprehensive capabilities in seeing, writing, doing, and planning
Doubao Real-time Voice Model: End-to-end ultra-human-like conversation
Seedance Video Generation: Precise audio-video synchronization

Pros: Smooth voice conversations, simple interface, free, good localization, over 100 million DAU
Cons: Average professional capabilities, strict content moderation
Best for: Voice conversations for elderly/children, daily chat. If you have a curious child at home or want to learn English, highly recommend using the phone call feature on the mobile app to talk directly with the AI.

GLM (Zhipu Qingyan) - A Coding Alternative

Website: chatglm.cn

VPN Required: No
Latest Models:

GLM-4.7: Released December 2025, 355B parameters, 73.8% on SWE-bench (highest open-source score), can directly subscribe to Coding Plan

Core Advantages:

Coding ability comparable to Claude Sonnet 4.5
Fully compatible with mainstream tools like Claude Code, Cline, etc.
Silicon Valley recognized: Used by star products like Cursor, Windsurf
Extremely low price: API cost about $0.44 per million tokens
MIT open source: Can be deployed locally

Pros: Top-tier coding ability, cheap, strong agent capabilities, open-source friendly
Cons: Less well-known, relatively weaker multimodal

Best for: Programmers (Claude alternative), multilingual developers, enterprise users

MiniMax

Website: minimaxi.com

VPN Required: No
Latest Models:
Text Generation:

MiniMax-M2.1: Focused on multilingual coding and office scenarios
MiniMax-M2: 230B parameters, optimized for coding and agents

Video Generation:

Hailuo 02: World’s #2 video model
Hailuo 2.3: Best cost-performance globally, supports 1080P

Pros (Text): Top-tier coding ability, strong agent performance, good multilingual support
Pros (Video): High video quality, fast speed, unbeatable cost-performance
Cons: Average text conversation, short video duration
Best for: Video creators, programmers (agent workflows), multilingual developers

Summary: Which One Should You Choose?

💰 If You Don’t Want to Spend Money:

First choice: DeepSeek - Free, capable, accessible directly in China
Alternative: Google AI Studio - Requires VPN, but generous free tier, world-class large model
Daily chat: Doubao - Convenient voice conversations

🚀 If You Want the Best:

Overall best: ChatGPT (GPT-5.2)
Best for coding: Claude (Opus 4.5 or Sonnet 4.5)
Multimodal processing: Gemini 3

👨‍💻 If You Are a Programmer:

First choice abroad: Claude Opus 4.5 - #1 coding ability
Domestic alternative: GLM-4.7 or MiniMax-M2.1 - Affordable, comparable capabilities

👴👶 If It’s for Family Use:

Elderly/children: Doubao - Simple voice conversations
School students: DeepSeek - Learning and Q&A

API and Token Basics Explained

Mon, 01 Jan 0001 00:00:00 +0000

You may have noticed that many experienced users talk about API, Token, Temperature, and other terms that sound technical and confusing. This chapter explains these core concepts in plain language. Understanding them will help you truly grasp how AI works and use it more effectively.

What is API?

API in Plain English

API = Application Programming Interface

That definition sounds technical, so let’s put it differently.

Think of AI as a restaurant:

Web version = You dine in at the restaurant
- Nice decor (web interface)
- Waitstaff (buttons, input fields)
- You order, the chef cooks, the waiter serves
API = You call for takeout
- No decor, you talk directly to the kitchen
- No waiter, you speak directly to the chef
- You say what you want, the chef prepares it and hands it to you

Key difference:

Web version: has an interface, convenient for humans
API: no interface, convenient for programs

Why Use API?

If the web version is so convenient, why bother with API?

Reason 1: Automation

Suppose you need AI to process 1,000 documents and write 1,000 summaries:

Web version: You copy-paste 1,000 times and click send 1,000 times
API: Write a script that processes everything automatically while you grab coffee

Reason 2: Integration into your own apps

You want to build an auto-reply bot, a content generator, or a smart customer service agent:

Web version: Not possible
API: You can embed AI directly into your own programs

Reason 3: Lower cost

Web subscription: ChatGPT Plus $20/month, Claude Pro $20/month
API pay-as-you-go: Pay only for what you use; light usage might cost just a few dollars per month

Reason 4: More flexibility

Fine‑tune AI parameters (Temperature, max length, etc.)
Batch processing
Custom input/output formats

What Does an API Call Look Like?

Here’s a simple example (don’t worry if it looks unfamiliar – we’ll cover it in detail later):

# Call the latest GPT-5.2 API with Python
response = openai.chat.completions.create(
    model="gpt-5.2",
    messages=[
        {"role": "user", "content": "Hello，Introduce yourself"}
    ]
)
print(response.choices[0].message.content)

Just a few lines of code, and the AI answers your question – no browser needed.

Official API model identifiers as of 2026-01-30:

OpenAI: gpt-5.2, gpt-5.2-chat-latest, gpt-5.2-pro
Anthropic Claude: claude-opus-4-5, claude-sonnet-4-5
Google Gemini: gemini-3-pro-preview, gemini-3-flash-preview

Web Version vs API Comparison

Aspect	Web Version	API
How to use	Click around in a browser	Write code to call it
Learning curve	Low, anyone can use it	High, requires some programming
Best for	Daily chat, writing articles	Automation, batch processing, app integration
Cost	Monthly subscription ($20/month)	Pay-as-you-go (pay for what you use)
Flexibility	Limited by web features	Highly customizable
Speed	Average	Usually faster (no UI rendering)

What is Token?

The Concept of Token

Token = The smallest unit of text that AI understands

Unlike humans, who read words and sentences directly, AI needs to break text into small pieces. Each piece is called a token.

Examples:

Chinese:

“你好” ≈ 1–2 tokens
“今天天气不错” ≈ 4–8 tokens, depending on the model

English:

“Hello” = 1 token
“How are you today?” ≈ 5 tokens

Simple rules of thumb:

English: 1 word ≈ 1 token (about 4 characters)
Chinese: 1 character ≈ 0.5–2 tokens (depends on the AI model)
Numbers, punctuation: usually 1 symbol = 1 token

Important Discovery: Different AI Models Define Tokens Differently!

Here’s a little‑known secret: The same text can have a completely different token count in different AI models!

Why? Because each AI company has its own tokenizer, and they split text differently.

Real example:

The same sentence: “AI is revolutionizing market research.”

GPT-3: 11 tokens
GPT-3.5 and GPT-4: 9 tokens
GPT-4o and GPT-5.2: 8 tokens

See? The same sentence differs by 3 tokens across models!

Another Chinese example:

The sentence “人工智能正在改变世界” (“Artificial intelligence is changing the world”):

GPT-4o: maybe 10 tokens
Claude Sonnet 4.5: maybe 12 tokens
Gemini 3: maybe 8 tokens

Why the difference?

Each company uses a different tokenization method when training its models:

OpenAI (GPT series): uses BPE (Byte-Pair Encoding)
Anthropic (Claude): uses its own optimized tokenizer
Google (Gemini): Gemini’s documentation says “1 token ≈ 4 characters”
DeepSeek: a tokenizer optimized for Chinese

How does this affect you?

1. Cost comparisons aren’t direct

Suppose you have 1,000 Chinese characters:

With GPT-5.2 it might be 1,500 tokens
With Claude Sonnet 4.5 it might be 1,600 tokens
With Gemini 3 it might be 1,400 tokens

Even though each says “input $X/1M tokens,” the actual cost can differ by 10–20%!

2. You can’t use the same token calculator for all models

OpenAI’s official tokenizer (https://platform.openai.com/tokenizer) only works for GPT series
Claude tokens need Anthropic’s calculation method
Gemini tokens need Google’s calculation method

3. Non‑English languages show even bigger differences

For Chinese, Japanese, Arabic, and other non‑English languages, token efficiency can vary by 30–40%. Most AI models are trained primarily on English, so their tokenizers are better optimized for English.

Why Token Matters

1. Token determines cost

API pricing is based on tokens, not character count.

Example (official prices as of 2026-01-30):

GPT-5.2: input $1.75/1M tokens, output $14/1M tokens
Claude Opus 4.5: input $5/1M tokens, output $25/1M tokens
Gemini 3 Flash: input $0.50/1M tokens, output $3/1M tokens (standard tier)

You send 500 tokens and the AI replies with 1,000 tokens:

With GPT-5.2: (500 × 1.75 + 1000 × 14) / 1,000,000 = $0.01488 (about 1.5 cents USD)
With Gemini 3 Flash: (500 × 0.50 + 1000 × 3) / 1,000,000 = $0.00325 (about 0.3 cents USD)

2. Token determines context length

Every AI model has a token limit:

GPT-5.2 (API): up to 400,000 tokens
GPT-5.2-chat-latest: up to 128,000 tokens
Claude Sonnet 4.5: up to 200,000 tokens
Gemini 3 Pro Preview: up to 1,048,576 tokens (about 1M)

This limit includes: your prompt + AI’s response + conversation history.

What happens if you exceed the limit?

The AI “forgets” the earliest parts of the conversation
Or it throws an error and won’t continue

How to Count Tokens

Method 1: Estimate (quick but not precise)

Chinese: number of characters × 1.5
English: number of words × 1.3

Method 2: Use the corresponding online tool

OpenAI (GPT series): https://platform.openai.com/tokenizer
General token counter: https://token-counter.app (supports multiple models for comparison)
Gemini: use the count_tokens method in Google AI Studio

Important reminder: When estimating across models, always use the tool specific to that model. Don’t use GPT’s token count to estimate Claude’s cost!

Input Tokens, Output Tokens, Cached Tokens

API billing divides tokens into three types:

1. Input Tokens

The content you send to the AI
Includes your prompt, uploaded documents
Relatively cheap

2. Output Tokens

The content the AI returns to you
Includes the AI’s response
Usually 2–10 times more expensive than input tokens

Why is output more expensive? Because the AI “thinks” (generates text) using more computing resources than “reading” (processing input).

Example (GPT-5.2):

Input: $1.75/1M tokens
Output: $14/1M tokens (8× the input price!)

3. Cached Tokens

This is a cost‑saving trick!

If you repeatedly use the same prompt, the AI can cache it and avoid reprocessing it next time.

Example: You have a 1,000‑token prompt and ask 10 questions:

Without caching: each time processes 1,000 tokens → total 10,000 tokens
With caching: first time 1,000 tokens (normal price), next 9 times 1,000 tokens (cache price, 90% cheaper)

Models that support caching:

Anthropic Claude (Prompt Caching)
OpenAI GPT-5.2 (supports caching, 90% discount)

Caching billing rules:

First read: normal price
Cache hit: price reduced by 50–90%
Cache validity: usually 5–10 minutes

What is Temperature?

The Concept of Temperature

Temperature = Controls the “randomness” or “creativity” of AI responses

Recall that AI essentially “calculates probabilities.” When you ask “What color is the sky?”, the AI sees:

“Blue” probability 80%
“Gray” probability 10%
“Red” probability 5%

Temperature adjusts how the AI chooses among these options.

Temperature Values

Temperature typically ranges from 0 to 2 (or 0 to 1, depending on the platform):

Temperature = 0 (most conservative)

The AI always picks the highest‑probability answer
Very stable, predictable responses
Same question → almost identical answer every time
Best for: factual questions, code generation, data analysis

Temperature = 1 (balanced)

The AI chooses randomly according to probabilities
Responses vary a bit but stay reasonable
Default for most platforms
Best for: everyday conversation, general use

Temperature = 2 (most aggressive)

The AI tries many possibilities
Very diverse, creative responses
May be inaccurate or even nonsensical
Best for: creative writing, brainstorming, artistic work

A Practical Example

Question: Name my coffee shop

Temperature = 0:

“Starbucks Coffee” (most common, safest answer)
Almost the same every time

Temperature = 1:

“Morning Light Café”
“Aroma Time”
“Bean & Cozy”
Varies, but all reasonable

Temperature = 2:

“Quantum Coffee Dimension”
“Space‑Time Foam Lab”
“Cosmic Latte Terminal”
Very creative, but possibly too weird

When to Adjust Temperature

Lower Temperature (0–0.5):

Writing code, debugging
Data analysis, math problems
Translation, summarization
Any task that needs accuracy

Higher Temperature (1.5–2):

Writing novels, poetry
Naming things, creating slogans
Brainstorming
Any task that needs creativity

Different models list their recommended temperatures on their official sites. For example, DeepSeek’s website shows:

Scenario	Temperature
Code generation / math problem solving	0.0
Data extraction / analysis	1.0
General conversation	1.3
Translation	1.3
Creative writing / poetry	1.5

Can you adjust it in the web version?

Most web versions don’t allow direct adjustment
But the API gives you precise control

Context Length

What is Context Length?

Context Length = How much content AI can “remember” at once

Unlike humans, AI doesn’t have long‑term memory. In each conversation, the AI can only remember a limited amount of content. This limit is called the context length, measured in tokens.

Why Does AI “Forget”?

You may have experienced this:

You chat with AI for a long time
Suddenly the AI doesn’t remember what was said at the beginning
It seems to have amnesia

Reason: You exceeded the context length limit.

Example:

GPT-5.2 context length = 128,000 tokens
You and the AI have 50 rounds of conversation, using 130,000 tokens total
Beyond the limit, the AI “forgets” the earliest parts

Practical Impact of Context Length

1. Affects conversation length

Short context: only a few dozen rounds
Long context: hundreds of rounds

2. Affects document processing

Short context: only short documents
Long context: entire books

3. Affects cost

Longer context → slower processing
More tokens → higher cost

How to Deal with Context Limits

Method 1: Clear the conversation regularly

Save important information
Start a new conversation
Re‑tell the AI the background

Method 2: Summarize the conversation history

Ask the AI to summarize previous content
Use that summary as the start of a new conversation
Saves tokens

Method 3: Choose a model with a large context

For long documents: use Gemini 3 Pro
For long conversations: use Claude Sonnet 4.5

Other Important Concepts

Max Tokens

Max Tokens = Limits the maximum length of a single AI response

Set Max Tokens = 100: AI replies with at most 100 tokens
Set Max Tokens = 2000: AI replies with at most 2000 tokens

Why limit it?

Control cost (output tokens are more expensive)
Avoid overly verbose answers
Some scenarios only need short replies

Top P (Nucleus Sampling)

Top P = Another way to control randomness

Similar to Temperature, but works differently:

Top P = 0.1: only considers the top 10% most probable options
Top P = 0.9: considers the top 90% most probable options

Usually:

Adjust either Temperature or Top P – one is enough
In most cases, Temperature is more intuitive

Frequency Penalty and Presence Penalty

Used to reduce repetition

Frequency Penalty: penalizes frequently used words, reducing repetition of the same word
Presence Penalty: penalizes words that have already appeared, encouraging the AI to introduce new topics

Range: -2.0 to 2.0

Positive values: reduce repetition
Negative values: allow more repetition
0: no intervention

Summary: How to Use These Concepts?

Daily Use (Web Version)

If you only use the web version, you don’t need to worry about these parameters – the defaults work fine.

But understanding these concepts helps you:

Understand why AI sometimes “forgets” earlier parts of the conversation (context limit)
Understand why API users can do things you can’t (parameter control)
Prepare for using the API in the future

When Using the API

If you decide to use the API, these parameters become very important:

Basic settings (every time):

model: choose the model (e.g., gpt-5.2, claude-sonnet-4-5)
max_tokens: limit the response length

Adjust based on your needs:

temperature: 0–0.5 for factual tasks, 1–2 for creative tasks
top_p: usually fine at default
frequency_penalty: if the AI repeats too much, set it to 0.5–1

Cost optimization:

Use caching to save money
Control max_tokens to avoid waste
Choose the right model (you don’t always need the most expensive one)
Remember that different models define tokens differently

API Practice: Connect Immersive Translate

Mon, 01 Jan 0001 00:00:00 +0000

In previous chapters, we learned how to get an API Key and understood the basic concepts of APIs. But you might be thinking: What’s the use of an API Key if I can’t code?

The good news is: You don’t need to know how to code!

The Immersive Translate introduced in this chapter is a ready-made tool built by others. All you need to do is:

Download and install
Enter your API Key
Start using it

That’s it.

Think of it like this:

Your API Key is your “membership card”
These tools are the “amusement park” already built
You just take your card and go have fun

Later in this book, we’ll go more advanced — Chapter 12 teaches you how to set up an API relay, Chapter 13 installs Claude Code on your computer. In this chapter, we’ll first learn to use these ready-made tools and experience the power of APIs.

Immersive Translate

What is it?

Immersive Translate = the most powerful web translation plugin

Imagine:

You’re watching a YouTube video, and subtitles are automatically translated into Chinese
You’re reading English news, and the page shows bilingual text
You’re reading a PDF paper, and hovering over text gives you a translation

That’s what Immersive Translate can do.

Why use an API?

Immersive Translate comes with some free translation services (Google Translate, Microsoft Translator, etc.), but:

The free version has usage limits
Translation quality is average
Professional terminology may be inaccurate

After connecting to an AI API:

Translate with GPT-5.2, Claude, Gemini — quality far surpasses traditional translation
Understands context, translations are more natural
Professional terms are translated accurately
Pay-as-you-go, very cheap for light use

How to download?

Supported browsers:

Chrome
Edge
Firefox
Safari

Download steps:

Open the Immersive Translate official website: https://immersivetranslate.com
Click “Install Now”
You’ll be redirected to the corresponding app store
- Chrome/Edge: Chrome Web Store
- Firefox: Firefox Add-ons
- Safari: App Store
Click “Add to Browser” or “Install”
After installation, the plugin icon will appear in the top-right corner of your browser

How to set up the API?

Steps:

Open the settings page
- Click the Immersive Translate icon in the top-right corner of your browser
- Select “Settings”
Find the translation service settings
- On the settings page, find “Translation Services”
- You’ll see many translation options: Google, DeepL, OpenAI, etc.
Choose an AI translation service

Using Gemini as an example (remember the API we got from AI Studio earlier?):

Find the “Gemini” or “Google AI” option
Enter the API Key you obtained from AI Studio
Base URL: [https://generativelanguage.googleapis.com/v1beta](https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent?key={key})
Model: gemini-3-flash-preview
Test and save

Set as default translation service
- In “Primary Translation Service”, select the AI you just configured
- This way, every translation will use AI
- It’s recommended to enable the floating ball

How to use it?

Using it is very simple:

Open any foreign language webpage
- For example, https://www.nytimes.com (The New York Times)
- For example, https://www.bbc.com (BBC News)
Start translation
- Click the plugin icon in the top-right corner of your browser or the floating ball
- Or use the shortcut key (usually Ctrl+Shift+X)
- The page will immediately become bilingual
Customize translation style
- Bilingual display (recommended): original and translation side by side
- Translation only: see only the translated text
- Hover translation: show translation when you hover over text

Advanced features:

PDF translation: upload a PDF and translate the entire document
Video subtitle translation: automatically translate subtitles on YouTube, Netflix, etc.
Input box translation: type in Chinese in a web input box and have it automatically translated to English before sending
Bilingual comparison: a great tool for learning foreign languages

Cost estimation

Using Gemini 3 Flash for translation:

1000 English words ≈ 1500 Tokens
Translation into Chinese ≈ 2000 Tokens output
Cost: (1500×0.08 + 2000×0.30) / 1,000,000 ≈ $0.0007 (about 0.5 cents)

In other words: Translating 1000 such articles would only cost you about 5 RMB (less than $1)!

Summary

Core idea:

No need to write code yourself
Use ready-made tools + your API Key
Unlock the powerful capabilities of AI

The essence of these tools:

They are “bridges” built by others
Your API Key is the “pass”
You just need to take your pass and cross the bridge

Build a Bilibili Video Transcription Skill

Mon, 01 Jan 0001 00:00:00 +0000

Some readers have asked me if they could automate note-taking from Bilibili videos. I created a Skill for that and now I’m open-sourcing it.

The Skill does this: give it a Bilibili link, it automatically downloads the video’s audio, sends it to AI for transcription, uses another AI to generate a summary, and finally saves both the full transcript and summary into an Obsidian inbox.

The whole process requires no manual operation; just wait a bit and it’s done.

Tools Required

This Skill requires a few tools to work together.

yt-dlp

This is a command-line tool for downloading audio/video from various platforms. The Skill uses it to download the audio stream from Bilibili videos as M4A files.

macOS Installation (recommended):

brew install yt-dlp

If you don’t have Homebrew, you can also install via pip:

pip install yt-dlp

ffmpeg

yt-dlp depends on ffmpeg for audio processing; without it, errors may occur.

brew install ffmpeg

Python 3

The Skill includes a Python script that handles API calls, file processing, and template rendering. macOS usually comes with Python 3; verify with:

python3 -V

As long as you see a version number, that’s fine. No specific version required.

Gemini API (Audio Transcription)

Transcription uses Google’s Gemini model, specifically gemini-3-flash-preview.

This model has a daily free quota for regular Google accounts, sufficient for daily use. If you exceed the quota, you’ll get a 429 error; just wait until the next day when the quota resets.

Get an API Key at: aistudio.google.com

Once inside, click Get API key on the left and create one.

DeepSeek API (Content Summarization)

Summarization uses DeepSeek, which I find suits my summarization habits.

Get an API Key at: platform.deepseek.com

Installation and Usage

Step 1: Download the Skill Package

Download from my blog: https://blog.discoverlabs.ac.cn/downloads/bili-to-obsidian-skill/

After extracting, place the folder in ~/.claude/skills/, ensuring the path is ~/.claude/skills/bili_to_obsidian/.

Step 2: Fill in the Configuration

Open ~/.claude/skills/bili_to_obsidian/scripts/bili_to_obsidian.py and find the first few lines:

API_KEY = "YOUR_GEMINI_API_KEY"
DEEPSEEK_API_KEY = "YOUR_DEEPSEEK_API_KEY"

TEMPLATE_PATH = Path("/path/to/your/Obsidian-vault/02-Templates/Note.md")
OUTPUT_DIR = Path("/path/to/your/Obsidian-vault/00-Inbox")

Modify these fields:

YOUR_GEMINI_API_KEY: Replace with the key you obtained from aistudio.google.com
YOUR_DEEPSEEK_API_KEY: Replace with the key you obtained from DeepSeek
TEMPLATE_PATH: Replace with the full path to your Obsidian note template
OUTPUT_DIR: Replace with the full path to your Obsidian inbox

If you don’t use an Obsidian note template, you can set TEMPLATE_PATH to any non-existent path; the script will generate a basic format if the template is not found, which still works.

Step 3: Invoke

In Claude Code, enter:

/bili_to_obsidian paste-the-Bilibili-video-link-here

Then wait for it to finish; it usually completes within a few minutes.

Important Notes

Gemini’s free quota is limited per day. If you process many videos in a day and encounter a 429 error, you’ve exceeded the quota. Wait until the next day for the quota to reset. If you frequently exceed it, register multiple Google accounts and rotate API keys.

The path lines must be changed to your own. The ones in the download package are from my computer; using them directly will cause errors.

The format is based on my Obsidian template. If your template structure differs, the transcript content may be placed incorrectly. In that case, just give the script to an AI, describe your template structure, and ask it to adjust the anchor points.

Download

Download from my blog (I’ve removed my own API keys):

https://blog.discoverlabs.ac.cn/downloads/bili-to-obsidian-skill/

I’ve been using this Skill for a while. It’s especially convenient for transcribing educational Bilibili videos and saving them directly into Obsidian for reference.

Additionally, the audio download uses yt-dlp, which supports not only Bilibili but also hundreds of video sites like YouTube, Twitter, Douyin, etc. So this Skill isn’t limited to Bilibili; you can use it with links from other platforms as well. Feel free to try it out and extend it further.

Build a Free HTML Page in Five Minutes with AI

Mon, 01 Jan 0001 00:00:00 +0000

Why This Chapter Exists: The ¥50 That Almost Gave Me a Heart Attack

The reason for writing this chapter is simple: a friend spent 50 yuan to have someone make a simple lottery wheel webpage.

When I heard this, I almost had a heart attack.

It’s not that 50 yuan is expensive, but this thing can be made in 5 minutes with free AI!

Seriously, if you have this need, even if you directly tipped me 50 yuan and let me teach you step by step, it’s better than paying those services. At least my tutorials are free, and I’ll explain every step clearly.

So this chapter is a special addition, specifically teaching you: how to use free AI to make a simple but practical HTML page.

Important Reminder: Get Comfortable with the Free Web Version First

Before we dive in, I want to emphasize one thing:

The current AI web versions are already very powerful. No programming knowledge needed, no software installation, just open a browser and use.

What can the AI web version do?

Chat with you and answer questions
Recognize images and analyze content
Write code and build webpages
Create PPTs and reports
Translate and summarize documents
And much more…

My suggestion: beginners should first get proficient with the free web-based AI before considering advanced tools like APIs.

Why? Because the web version:

Is completely free (or has generous free quotas)
Is simple to use with no learning curve
Is already powerful enough
Lets you ask the AI directly if you run into problems

Now let’s start the main topic: Use AI to Make a Lottery Wheel Webpage.

Use AI Studio to Make an HTML Webpage

Step 1: Enter Google AI Studio

We are using Google AI Studio, Google’s official free AI platform.

Why choose it?

Completely free
Gemini 3 Pro is powerful
Suitable for complex tasks like building webpages

Steps:

Open https://aistudio.google.com
Log in with your Google account (requires a VPN/proxy)
Enter the main interface

Step 2: Select Playground and Model

After logging in, you’ll see the main interface of AI Studio.

Steps:

Click “Playground” in the left menu
In the model selector at the top right, choose Gemini 3 Pro
- Don’t choose Flash; Pro is more capable
- Especially for complex tasks like writing code
Confirm that the left side is the chat interface with an input box at the bottom Now you’re ready to chat with the AI.

Step 3: Enter a Prompt to Let the AI Generate the Webpage

This step is key: you need to clearly tell the AI what you want.

The more detailed, the better! Don’t just say “Help me make a lottery webpage”; be specific about:

What it looks like
What features it has
How to use it
What style

Complete Prompt Example

Copy the text below and paste it into the input box of AI Studio:

Please help me generate a lottery wheel webpage.

If no prizes are specified, use default prizes: Grand Prize, First Prize, Second Prize, Third Prize, Lucky Prize, Try Again.

Functional requirements:
- Beautiful wheel design, supporting 6-8 sectors
- A "Start Lottery" button in the center
- Click the button to spin the wheel
- The spin should have acceleration and deceleration effects for realism
- After stopping, a popup shows the result
- Click the popup to close and spin again

Design requirements:
- Festive and grand style (mainly red and gold)
- The wheel border should have texture
- Each sector should have alternating colors
- A pointer indicating the current position
- Responsive for mobile and desktop

After completion, please explain:
1. How to open and use it
2. How to modify the prize names
3. How to adjust the winning probability

Use example prizes: iPhone 16, AirPods, 100 yuan red envelope, 50 yuan red envelope, Try Again

Steps:

Copy and paste the above prompt into the input box
Click the “Run” button or press Enter
Wait for the AI to generate (usually 10-30 seconds)

Step 4: The AI Will Return Complete HTML Code

After the AI finishes generating, you’ll see a large block of code.

The AI’s response usually includes:

HTML code: a complete webpage file
Usage instructions: how to open and modify
Customization guide: how to change prizes and adjust probabilities

The code looks like this:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Lottery Wheel</title>
    <style>
        /* Style code here */
    </style>
</head>
<body>
    <!-- Webpage content here -->
    <script>
        // Function code here
    </script>
</body>
</html>

Don’t be scared! The webpage can run directly now! Just follow the screenshots and click.

Step 5: Modify the Webpage Content (Change Prizes, Adjust Probabilities)

The AI-generated webpage is usually quite complete, but you might want to:

Change prize names
Adjust winning probabilities
Change colors

Don’t worry, you don’t need to understand code. Just keep asking the AI!

Continue the Conversation, Let the AI Help You Modify

Steps:

Don’t close the AI Studio chat window
- The AI remembers your previous conversation
- You can continue asking questions below
Enter your modification request

Example 1: Change Prize Names

Enter in the input box:

Add a settings interface to this webpage to set the probabilities and specific prizes for different awards.

Iterate Until You’re Satisfied

This is the core process of making things with AI:

Clearly state what you want
AI generates the first version
Try it out, find issues
Tell the AI the problem, let it fix
Repeat steps 3-4 until perfect

Key points:

Don’t be afraid of trouble, try multiple times
Change only one thing at a time for easy control
If the AI changes something wrong, say “No, revert to the previous version”

Step 6: Download the Final Webpage

Now you have a perfect lottery webpage, how to download it?

Just click the download button, it will download to your local machine, and you can open it to use!

What Can HTML Webpages Do? 10 Practical Mini-Tool Recommendations

By now, you might be thinking: besides lottery, what other webpages can I make with AI?

The answer is: almost any simple mini-tool!

Here are 10 practical examples you can directly ask the AI to make:

1. Online Translation Tool

Prompt:

Make an online translation webpage that supports Chinese-English translation with a clean interface.

2. Image Text Recognition (OCR)

Prompt:

Make a webpage that can upload an image, recognize text in the image, and allow copying.

3. To-Do List

Prompt:

Make a to-do list webpage that can add, delete, and mark tasks as complete, with data saved in the browser.

4. Countdown/Timer

Prompt:

Make a multi-functional timer webpage: countdown, Pomodoro timer, stopwatch.

5. Random Password Generator

Prompt:

Make a password generator that can set length and complexity, with one-click copy.

6. BMI Calculator

Prompt:

Make a BMI health calculator that inputs height and weight and displays health advice.

7. QR Code Generator

Prompt:

Make a QR code generation webpage that inputs text or URL, generates a QR code, and allows download.

8. Color Picker

Prompt:

Make a color tool that can select colors, display RGB/HEX values, and provide color scheme suggestions.

9. Markdown Editor

Prompt:

Make a simple Markdown editor with input on the left and real-time preview on the right.

10. Expense Tracker

Prompt:

Make a simple expense tracking webpage that can record income and expenses and display statistical charts.

Common features of these tools:

All are single HTML files
No server required
Just open in a browser
Completely free

Frequently Asked Questions

Q1: I don’t understand code at all, can I really do this?

A: Yes, you can! All you need to know is:

Copy and paste
Save a file
Open a file with a browser

Just these three steps, even a child can do it.

Q2: What if the AI-generated code is not perfect?

A: That’s normal! Continue the conversation with the AI:

“There’s a bug here, clicking the button does nothing”
“This color is ugly, change it to something nice”
“Can you add a sound effect?”

The AI will keep improving based on your feedback.

Q3: Can I use AI-made webpages commercially?

A: Technically yes, but note:

AI-generated code usually has no copyright restrictions
But if it’s for a client project, test thoroughly
For complex commercial projects, it’s still recommended to hire a professional developer

Q4: Why won’t my HTML file open?

A: Common reasons:

Incorrect file extension: make sure it’s .html, not .html.txt
Incomplete code: make sure you copied all the code
Browser issue: try a different browser

Q5: Can I use it on mobile?

A: Yes! Two methods:

Transfer the HTML file to your phone and open it with a mobile browser
Upload to platforms like Netlify and access via URL (recommended)

Q6: I want to modify the code but don’t know how?

A: Don’t modify it yourself! Ask the AI:

“I want to change the background color to blue”
“I want to make the title font bigger”
“I want to add background music”

Let the AI modify it for you, then copy the new code.

Summary

Today you learned:

How to use Google AI Studio to generate an HTML webpage
How to write clear prompts to tell the AI your needs
How to save the HTML file and open it in a browser
How to continuously improve the webpage through conversation
How to share or deploy your webpage

Core idea:

No programming knowledge needed
No money needed
Just need to know how to communicate with AI
Make a practical tool in 5 minutes

Next time someone asks you to make a simple webpage, you can:

Use AI to do it in 5 minutes
Charge that 50 yuan (just kidding)
Or teach them to do it themselves

Seriously, stop wasting money!

Build Your Own API Proxy

Mon, 01 Jan 0001 00:00:00 +0000

This chapter addresses a common pain point: using foreign AI services like Claude and Codex often comes with hassles. Accounts get inexplicably banned, you have to manually enable a proxy every time, subscription costs are high when shouldered alone, and sharing with friends is tricky without proper permission management.

I use these services myself, and I’ve always relied on my own self-hosted API relay. This chapter will walk you through the entire setup.

Why Build Your Own API Proxy

Let’s start with the motivation so you understand what problem this solves.

Claude tends to ban accounts. Many people log in from various machines with messy IPs, and once flagged by the risk control system, the account gets banned. Using a relay fixes a single IP, routing all requests through the same server, significantly reducing the chance of a ban.
More convenient to use. Once configured, you connect directly to the server without needing to manually enable a proxy each time.
Multiple people can share one subscription. Claude Max and Pro subscriptions aren’t cheap, so several people can split the cost. Through the relay, you can create separate API keys for each user, each with independent permissions and usage statistics.
Not buying from others because the risk is too high. There are many API relay services on the market, but it’s hard to tell genuine from fake, they might disappear anytime, and your data could be intercepted.
Data security concerns. When using someone else’s relay service, all your requests pass through their servers. Sensitive content should not go through an uncontrolled third party.
Supports multiple AI providers. This setup supports not only Claude but also other services like Codex.

What Project to Use

We’ll use this open-source project: claude-relay-service

Before we start, here are the deployment requirements:

A VPS: Minimum specs are fine, 1 core and 1GB RAM is sufficient.
Operating system: Linux (Ubuntu/Debian both work)
Most importantly: The VPS must be able to directly access Anthropic’s API, meaning the server itself can reach claude.ai.

What is a VPS? Simply put, it’s a rented remote server that runs 24/7. You can run programs on it, it never shuts down, and it has a fixed public IP. Common domestic cloud servers (like Alibaba Cloud ECS, Tencent Cloud CVM) are similar, but they won’t work due to region restrictions; you need to rent one overseas.

Can you use your own computer instead of a VPS? In theory yes, but there are two hard requirements: first, your computer must be on 24/7; second, your network must be able to directly connect to Anthropic’s servers. Both conditions must be met, otherwise it won’t work. So in practice, renting an overseas VPS is much simpler.

This last point about “being able to reach Anthropic” is where many people get stuck. Where your VPS is located directly determines whether it works. I use a Japanese VPS with a datacenter IP, and without any extra configuration, it connects directly. Datacenters in Singapore, the US, and Japan are generally fine. Domestic servers in China definitely won’t work, and some Hong Kong datacenters may also be blocked. It’s best to confirm before purchasing.

One-Click Deployment

Connect to your VPS terminal and run the following command:

curl -fsSL https://pincc.ai/manage.sh -o manage.sh && chmod +x manage.sh && ./manage.sh install

Press Enter and wait for it to finish. After successful installation, the terminal will output something like:

Access URLs:
  Local Web: http://localhost:8080/web
  Public Web: http://YOUR_IP:8080/web

Admin credentials saved to: data/init.json

YOUR_IP is your VPS’s public IP. The admin password is stored in the data/init.json file; you can view it with cat data/init.json. Note down the public URL and password, as you’ll need them to log into the admin panel.

After installation, the system registers a crs command for managing the service:

crs install   # Install the service
crs start     # Start the service
crs stop      # Stop the service
crs restart   # Restart the service
crs status    # Check status
crs update    # Update the service
crs uninstall # Uninstall the service

To upgrade later, just connect to your VPS and run crs update—no need to repeat the installation process.

Accessing the Admin Panel

Open the public URL you noted earlier in your browser, enter the admin password, and you’ll see this dashboard:

This is the system dashboard, showing current API key count, service accounts, today’s requests, token consumption, etc. The admin panel also supports viewing usage details for each API key, making it clear who used how much when sharing. Feel free to explore.

The top navigation has two core settings entries (highlighted in red in the image):

API Keys: Create and manage API keys for users.
Account Management: Bind your purchased Claude subscription accounts.

Next, we’ll first bind an account, then create an API key.

Step 1: Bind Your Claude Account

Click “Account Management” at the top, then click “Add Account”. A dialog for adding an account will appear.

Step 1 — Basic Information

Fill in the following:

Select Platform: Choose Claude (Anthropic). Other options include OpenAI, Gemini, etc.
Select Specific Platform Type: Choose Claude Code (Official), which is our primary method.
Add Method: Choose OAuth Authorization (Usage Visualization), which allows you to see detailed usage data in the admin panel.
Account Name: Enter a name you’ll recognize, e.g., “My Max Account”.

Scroll down further for a few important options:

Subscription Type must be correct—select the one you actually purchased:

Claude Max: Select this if you have a Max subscription.
Claude Pro: Select this if you have a Pro subscription.

There are also some advanced options below, such as “Auto-stop scheduling when approaching 5-hour usage limit” and “Block warm-up requests”. Beginners can keep the defaults and adjust later as needed.

After filling in, click “Next” to proceed to authorization.

Step 2 — Authorization

This step authorizes your Claude account to use the relay service. Click the “Generate Authorization Link” button:

The generated link will appear in the input field, something like https://claude.ai/oauth/authorize?.... Click the copy icon on the right to copy the link.

Then open this link in your browser (remember to use a proxy):

The page will display “Claude Code would like to connect to your Claude chat account”. Click the Authorize button to complete authorization.

After successful authorization, the page will give you an Authorization Code. Copy this code, paste it into the input field in the dialog, and click “Complete Authorization”.

The account is now bound.

Step 2: Create an API Key

After binding the account, click the “API Keys” tab at the top to enter API key management:

Click the “+ Create New Key” button in the top right:

Fill in the following information:

Name: Give this key a name, e.g., “Personal Use”, “For Family”. It’s recommended to name by person or purpose for easier management later.
Rate Limit Settings (optional): If sharing among multiple people, you can set request frequency and cost limits for each key. Leave blank for unlimited.

After filling in, click Confirm. Upon successful creation, this dialog will appear:

Note the important reminder: This is your only chance to see the full API key. Once you close this window, the system will not display it again.

Click “Copy Claude Configuration” to get something like:

export ANTHROPIC_BASE_URL="your_server_public_url"
export ANTHROPIC_AUTH_TOKEN="cr_217627747170e5aa5691134fab8278b0dfec1b0ac2e59345ae180dc6d5f9643d"

These are your API address and key. Save them securely.

How to Use It Next

Once you have ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN, you can use them in any API-compatible client.

For how to configure them in Claude Code, refer to the Claude Code setup guide.

I’ve been using this setup myself and haven’t had my account banned since deployment.

Summary

What you learned today:

Why build your own relay: Fixed IP to prevent bans, multi-user sharing, and full control over data security.
Which project to use: claude-relay-service, open-source and self-hosted.
How to deploy: One command does it all; after installation, you get the public URL and admin password.
Account binding process: Account Management → Add Account → Select Claude → Choose subscription type → OAuth authorization.
API key creation process: API Keys → Create New Key → Enter name → Copy Claude configuration (shown only once!).

Key points:

The full API key is only visible at the moment of creation—copy and save it immediately.
Choose the correct subscription type: Max and Pro support different models; Pro does not support Opus 4.
Remember to use a proxy during authorization; it’s best if the browser and server use the same proxy.

Part 3 · AI Tools: Practical Mainstream Tools

Claude Code: A Practical Introduction

Mon, 01 Jan 0001 00:00:00 +0000

Let’s dive into the most exciting part: using AI to write code for you.

You might think: I don’t know anything about code, what does this have to do with me?

On the contrary, it’s precisely because you don’t know code that this tool is even more suitable for you.

Remember that friend who spent 50 bucks to get a webpage made? With Claude Code, that will never happen again. You just need to tell the AI in plain language what you want, and it will write the complete program for you.

Today we’re introducing Claude Code, an AI programming assistant that runs in your terminal. You just tell it what you want in plain language, and it writes the whole program for you.

Why Use a Terminal Tool Instead of an IDE?

What is an IDE?

IDE = Integrated Development Environment

Simply put, an IDE is the software programmers use to write code, for example:

VS Code
Cursor
PyCharm
WebStorm

These tools have complex interfaces and powerful features, but for someone who knows nothing about code, they are more of a burden.

Reason 1: Simple interface

IDE: Full of buttons, menus, sidebars, status bars… overwhelming at first glance
Terminal: Just a black box – type a command, get a result, clean and straightforward

Reason 2: No need to manually edit code

If you don’t understand code at all, the code displayed in an IDE looks like gibberish. You can’t read it and you don’t know how to change it.

If everything is written by AI, why bother looking at the code?

Claude Code in the terminal will:

Automatically create files
Automatically write code
Automatically modify code
Automatically run tests

You just tell it what you want, and it handles the rest.

Reason 3: Lighter software

Cursor/VS Code: Hundreds of MB, plus you need to install various plugins
Terminal: Built into your system, no extra installation needed

Summary: For people with zero coding experience who want AI to help them build things, the terminal + Claude Code is the simplest and most direct combination.

Terminal Basics: How to Open Your Project Folder

Before using Claude Code, you need to learn one basic operation: opening your project folder in the terminal.

Mac Users

Method 1: Right-click to open (Recommended)

Find your project folder in Finder
Right-click the folder (or two-finger tap on the trackpad)
Select “New Terminal at Folder”

Method 2: Option + Right-click to get the path

Find your project folder in Finder
Hold the Option key and right-click the folder
Select “Copy ‘foldername’ as Pathname”
Open Terminal (search for “Terminal” in Launchpad)
Type cd (note the space after cd)
Press Command + V to paste the path
Press Enter

Example:

cd /Users/yourname/Desktop/my-project

Method 3: Drag and drop

Open Terminal
Type cd (note the space)
Drag the folder from Finder directly into the Terminal window
The path will be filled in automatically; press Enter

Windows Users

Find your project folder in File Explorer
Type cmd or powershell in the address bar and press Enter
The command line will open directly in that folder

Or:

Right-click the folder
Select “Open in Terminal” (Windows 11)

What is Claude Code?

In One Sentence

Claude Code = An AI programming assistant that runs in your terminal

It’s an official command-line tool from Anthropic (the company behind Claude). You talk to it in the terminal, and it can help you:

Create new projects
Write code
Modify code
Fix bugs
Explain code
Run commands

How is it Different from Claude on the Web?

Feature	Claude Web	Claude Code
How to use	Chat in a browser	Type commands in the terminal
Can it manipulate files?	No, only conversation	Yes, can create and modify files directly
Can it run code?	No	Yes, can run code on your computer
Best for	Asking questions, writing articles	Building projects, writing programs

Key difference: The web version can only “talk”, Claude Code can “do”.

How to Install Claude Code

Prerequisites

Node.js: Claude Code requires Node.js
- Download: https://nodejs.org
- Choose the LTS (Long Term Support) version
- After installation, verify with node -v in the terminal

2. Network environment: You need access to Claude’s API (may require a VPN)

Installation Steps

Open your terminal and run:

npm install -g @anthropic-ai/claude-code

Wait for the installation to finish. If you see output like this, it succeeded:

added 1 package in 2s

Verify the installation:

claude --version

If a version number is displayed, the installation was successful.

Several Ways to Use It

Claude Code supports multiple ways to access AI capabilities. Choose the one that suits you.

Method 1: Buy a Claude Membership

This is the simplest and most direct way.

Claude Membership Tiers:

Plan	Price	Claude Code Quota
Claude Pro	$20/month	Limited quota, suitable for light use
Claude Max	$100/month	Higher quota, suitable for heavy use
Claude Max	$200/month	Highest quota, suitable for professional development

Setup:

After purchasing a Claude membership, open the terminal
Run claude to start
Follow the prompts to log in to your Claude account
Once logged in, you can start using it

Method 2: Use Other Models’ APIs

If you don’t want to buy a Claude membership, you can use other models’ APIs to drive Claude Code.

Supported models:

DeepSeek
OpenAI GPT series
Other APIs compatible with the OpenAI format

2.1 Configure via Environment Variables (DeepSeek Example)

DeepSeek’s API is compatible with the Anthropic format and can be used as a direct replacement.

Mac/Linux Setup:

Run the following commands in the terminal (temporary – they will be lost when you close the terminal):

export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
export ANTHROPIC_AUTH_TOKEN=${DEEPSEEK_API_KEY}
export API_TIMEOUT_MS=600000
export ANTHROPIC_MODEL=deepseek-chat
export ANTHROPIC_SMALL_FAST_MODEL=deepseek-chat
export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1

Then simply run claude to start.

Windows Setup (PowerShell):

$env:ANTHROPIC_BASE_URL="https://api.deepseek.com"
$env:ANTHROPIC_AUTH_TOKEN="Your DeepSeek API Key"

Then simply run claude to start.

Note: This method is temporary; the settings will be lost when you close the terminal. For permanent configuration, use the settings.json method below.

Reference: https://api-docs.deepseek.com/guides/anthropic_api

2.2 Configure via settings.json (Recommended)

This method is more convenient – once configured, Claude Code will automatically use these settings every time you start it.

Configuration Steps:

Find the Claude Code configuration folder:
- Mac/Linux: ~/.claude/
- Windows: %USERPROFILE%\.claude\
Create or edit the settings.json file (example):

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.deepseek.com",
    "ANTHROPIC_AUTH_TOKEN": "Your DeepSeek API Key"
  }
}

Save the file and restart Claude Code

Tip: If the .claude folder doesn’t exist, run the claude command once – it will be created automatically.

How to Start Claude Code in the Terminal

Basic Startup

Open the terminal
Use the cd command to navigate to your project folder
Type claude and press Enter

cd /path/to/your/project
claude

Claude Code will start, and you’ll see an interactive interface where you can begin typing your requests.

Common Commands and Concepts

Common Commands in Claude Code

Command	Action
`/help`	View help information
`/clear`	Clear the current conversation
`/exit` or `Ctrl+C`	Exit Claude Code
`/compact`	Compress conversation history to save tokens
`/init`	Initialize a project, create a CLAUDE.md file

Plan Mode

Plan Mode = Let Claude plan first, then act

By default, Claude starts writing code immediately. But sometimes you want it to think things through before acting – that’s when you enable Plan Mode.

How to switch?

Press Shift + Tab to cycle through three modes:

Mode	Description
Normal	Normal mode, Claude executes directly
Plan	Plan mode, Claude only plans without executing; waits for your confirmation
Auto	Auto mode, Claude automatically executes all operations without asking for confirmation

When to use Plan Mode?

The project is complex and you want Claude to clarify its approach first
You’re unsure how Claude will make changes and want to see its plan
You want more precise control over Claude’s behavior

Accept Edits

Accept Edits = Whether to automatically approve Claude’s modifications

When Claude wants to create or modify a file, it normally asks for your confirmation.

How to switch?

When you press Shift + Tab to change modes, you’ll see:

Accept edits: off – Every modification requires your manual confirmation
Accept edits: on – All modifications are accepted automatically without asking

Recommendations:

Beginners should keep it off so you can see what Claude is doing at each step
Once you’re comfortable, turn it on for a smoother workflow

What is `resume`?

resume = Resume a previous conversation

After you close the terminal or exit Claude Code, you can use the --resume flag next time to continue the previous conversation:

claude --resume

Claude will remember what you discussed, so you don’t have to start from scratch.

When to use resume?

You worked on a project yesterday and want to continue today
Your computer shut down unexpectedly and you want to recover progress
You want Claude to continue from where it left off

What is CLAUDE.md?

CLAUDE.md = Project description file

This is a Markdown file placed in your project’s root directory. It tells Claude about the project’s background.

How to create it?

First run claude to start Claude Code, then enter /init.

claude

Inside Claude Code, type:

/init

Claude will automatically analyze your project and generate a CLAUDE.md file.

What is it used for?

When Claude Code starts, it reads this file to understand:

What the project does
What tech stack is used
Any special requirements
Code style preferences

Example CLAUDE.md:

# Project Description

This is a personal translation tool webpage.

## Tech Stack
- Pure HTML/CSS/JavaScript
- No frameworks

## Requirements
- Code comments in English
- Clean and modern interface
- Support dark mode

With this file, you don’t have to explain the project background every time you start Claude Code.

Skill

Skill = Claude Code shortcut commands

Skills are preset commands that let Claude quickly perform specific tasks.

Common built-in Skills:

Command	Action
`/commit`	Automatically generate a git commit message and commit code
`/review`	Review code and find issues
`/fix`	Fix errors in the code

How to use them?

Simply type the slash command in Claude Code, for example:

/commit

Claude will automatically analyze your code changes and generate an appropriate commit message.

We’ll cover custom Skills in detail in a later chapter.

MCP (Model Context Protocol)

MCP = Connect Claude to external tools and data sources

MCP is a protocol that allows Claude Code to connect to various external services, such as:

Databases
File systems
Web services
Other AI tools

Think of it this way: MCP is like adding “plugins” to Claude, enabling it to do more.

Examples:

Connect to Obsidian so Claude can read and write your notes directly
Connect to a browser so Claude can automate web pages
Connect to a database so Claude can query and analyze data

We’ll cover MCP configuration and usage in detail in a later chapter.

Hands-on: Let Claude Build a Translation Webpage

Now that you’ve learned so much, let’s put it into practice!

We’re going to build a local translation webpage that can use the Gemini API for translation.

Step 1: Create a Project Folder

Create a new folder on your desktop (or anywhere you like), for example named demo
Using the method you learned earlier, open this folder in the terminal

Step 2: Start Claude Code

claude

Step 3: Enter Your Request

Type the following into Claude Code (feel free to copy it):

Create a translation webpage tool with the following requirements:

1. Features:
   - Left input box for the source text, right side shows the translation result
   - Support Chinese-English translation
   - A "Translate" button
   - A "Clear" button
   - A "Copy Result" button

2. Interface:
   - Clean and modern design
   - Support dark/light mode toggle
   - Responsive design, works on mobile

3. Technical requirements:
   - Use only HTML, CSS, JavaScript, no frameworks
   - All code in a single HTML file
   - Call the Gemini API for translation

4. Settings (important):
   - A "Settings" button on the page
   - Clicking it opens a settings panel where you can configure:
     - API Key
     - API URL
     - Model Name
   - Save settings to the browser's localStorage, auto-load next time
   - The settings panel should have "Save" and "Cancel" buttons

5. Translation logic:
   - Auto-detect the input language
   - If Chinese, translate to English
   - If English, translate to Chinese

Please create this HTML file directly.

Step 4: Wait for Claude to Finish

Claude will automatically:

Create the HTML file
Write all the code
Tell you where the file is
After execution, it will ask if you agree to create the file – choose 1 or 2

Step 5: Run and Configure the API

Double-click the generated HTML file to open it in your browser
Click the “Settings” button on the page (usually a gear icon)
In the settings panel that appears, fill in:
- API Key: The API key you obtained from AI Studio
- API URL: https://generativelanguage.googleapis.com/v1beta
- Model Name: gemini-3-flash-preview
Click “Save”

The settings are automatically saved to the browser, so you don’t need to re-enter them next time.

Step 6: Start Using It

Now you can:

Type Chinese or English in the left input box
Click the “Translate” button
The translation result will appear on the right
Click “Copy Result” to copy the translated text

Summary

What you learned today:

Why use the terminal instead of an IDE: For people who don’t know code, the terminal is simpler and more direct
How to open a project in the terminal: Right-click, drag and drop, or use the cd command
What is Claude Code: An AI programming assistant in the terminal that can directly manipulate files
How to install and configure it: Install via npm, supports official membership or third-party APIs
Common commands: resume to continue conversations, CLAUDE.md for project descriptions
Hands-on practice: Let Claude build a translation webpage for you

Core idea: You don’t need to know how to write code – you only need to know how to describe what you want.

Claude Design: Turn Ideas into Polished Pages

Mon, 01 Jan 0001 00:00:00 +0000

Claude has a new feature called Design.

Claude Design is a research preview launched by Anthropic on April 17, part of the Anthropic Labs product line, running on their current strongest vision model, Opus 4.7. It’s designed to create visual drafts with Claude—web prototypes, PPTs, pitch decks, landing pages, one-pagers, and more are all within its scope. It can read your code repository and existing design files, apply your design system to the output, so the style matches your existing projects.

The best part is the final output: besides exporting PDF/PPTX/HTML or sending to Canva, it can also package everything into a handoff bundle and pass it to local Claude Code to continue modifying the project code.

As soon as this came out, it put a dent in Figma’s stock—closing down 6.89%.

A quick intro to Figma: a company that makes online collaborative design tools, competing with Adobe and Canva. Tens of millions of designers worldwide use it to create designs. Actually, there was already an MCP that let you use AI to control Figma, but because my aesthetic sense is too basic and my mind is blank with no ideas, I never used that product.

Why I Really Needed It

Remember the Obsidian plugin I made for pushing content to WeChat Official Accounts?

So far, across all channels, I’ve sold a grand total of 0 copies. How delightful (TAT).

Of course, it’s possible—and I’m not bragging—that this has to do with my basic design taste.

Take a look at what my original plugin UI looked like:

Two rows of toolbars, 9 buttons crammed into one row. Format, account, preset account name, account config, purchase activation, user guide, refresh render, copy HTML, paste to WeChat Official Account, publish draft… all piled up in the most prominent spot.

All the features are there, but it’s exhausting just to look at.

Below that, there’s a super long prompt: ‘Click the button below to select an image from your computer; leave blank to use a placeholder cover; if a default cover is set, use the default cover.’ A friend saw it and said, ‘Who is this for? A database field description?’

So when I saw Claude Design come out, I tried it right away. Let’s see how it actually performed.

How to Use

First, open the Claude web version, click Design on the left to enter. At the top, there’s an input box called ‘New prototype’, just fill in the project name.

You can choose Wireframe (low-fidelity) or High fidelity (high-fidelity with brand assets). I chose low-fidelity because at the start it’s just about rough concepts, no need for high-fidelity. Actually, after you finish, it will automatically upgrade for you.

Next, tell it the program folder path, and send it a screenshot of the page you want to modify.

It will first ask you a few questions: what to change, what to keep, what’s the primary action, what’s the secondary action. I confessed honestly—I most wanted to highlight ‘Publish Draft’ and ‘Switch Account’, the rest can be collapsed.

After asking, it started running on its own.

It Came Up with 4 Options

Soon after, it handed me a wireframes.html comparison page.

The first thing was a comparison—it listed the ‘sins’ of my current UI one by one in red text:

‘Two rows of bars squeezing the preview’
‘9 buttons’
‘Mixed Chinese/English + confusing symbol descriptions’

This feature really surprised me. I thought it would just help me modify things, but it actually saw the content and pointed out the problems. It felt like a real designer communicating face-to-face, not a cold AI.

Then came the 4 options:

Option A: Single row minimal, main button ‘Publish Draft’ + account capsule, rest icons + ⋯ menu
Option B: Card breadcrumb + drawer, keep entry for editing meta info
Option C: Side rail (like VSCode), top bar only title
Option D: Floating publish card in bottom right, primary action most prominent

The most interesting was Option D. It drew a sticky note with ‘Common Design Rules’ and ‘Recommended Order’:

A → Most space-saving, low learning cost D → Visually prettiest, most satisfying primary action C → Friendly for power users (icon library) B → Safe, retains editing meta info

This isn’t just ‘here are some options’, it’s ‘here are some options + telling you who each is for’. I’ve been making plugins for a long time, and no one has ever seriously told me ‘where this button should go’.

You Can Keep Iterating

After choosing a direction, you can keep communicating. On the left is a chat box, on the right click Edit to directly select elements and modify (but the settings there were too professional, I couldn’t understand them, so I skipped it). Click Draw to draw circles and arrows on the preview and tell it ‘I want to move this here’:

I think the Draw feature is amazing. I drew a very rough arrow from a button to the bottom right, and it actually understood—probably related to the big upgrade in Opus 4.7’s visual recognition (as mentioned earlier, it increased image recognition precision to 3.75 megapixels).

After modifying the menu bar, I asked it to create several article layout styles—after all, my plugin’s main job is to format Markdown into something publishable on WeChat Official Accounts.

It opened a new page with the title ‘Format Markdown into a WeChat article worth reading’. In the top right, there’s a Tweaks button that, when clicked, lets you adjust font size, weight, color, line spacing, etc., just like Figma:

Note that this is a truly clickable and switchable page, not a fake one. This interaction is much better than doing it in Claude Code on the terminal. With Claude Code, you have to wait for it to finish to see the effect, then ask it to modify. Here, you get real-time preview.

After finalizing, click Export in the top right. It gives several options: download PPT, export PDF, export standalone HTML, or—the last one—‘Handoff to Claude Code’, which sends the entire design file to local Claude Code to continue coding.

This is the best part of the whole chain.

After designing on the web, it generates a command for you. Copy and paste it into the terminal, and local Claude Code takes over:

> Fetch this design file, read its readme,
  and implement the relevant aspects of the design.
  Implement: option-b-hifi.html

Then it starts reading the design package, looking at the current code, understanding which files to modify, and finally directly changes all my plugin source code. The design page provided option-b-hifi.html (I ended up choosing the high-fidelity version of Option B), and Claude Code reads colors, font sizes, spacing from the design file and applies them to my React code.

I didn’t write a single line of code throughout the entire process.

The Final Result

Anyway, I think it looks much better than my original. Although a real designer might have done even better, for a personal plugin, it’s more than enough (compared to my original design).

Title + meta info collapsed into one row, account becomes a capsule (with a green active dot), the primary action is just a single purple ‘Publish Draft’ button on the right, everything else is tucked into the ⋯ menu.

It turns out my pile of ‘features’ wasn’t lacking design sense—it was that no one helped me make trade-offs.

Adding a button is easy, but removing one from the UI is counterintuitive for a developer—you always think ‘what if someone needs it?’. But a designer will make that decision for you: ‘Put this in a secondary menu, users won’t click it again after the first time.’

This time, Claude Design made that decision for me.

The Cost

It’s Resource-Intensive

In Claude’s subscription plans, Design has its own quota (I have to say, Claude’s separate quotas are really piling up).

Doing this set—4 option comparisons + 5 article themes + high-fidelity implementation—consumed 36% of my daily quota. I have a 5x Max account; for a Pro account, that would blow through the entire day’s quota.

A friend of mine has a Pro account. Last night, he used Design to make a 30-page PPT and his daily quota was completely drained.

Occasional Glitches

Sometimes in the middle of working, you might encounter a situation: you send a message, and it replies with <empty>. Send again, still <empty>:

The fix is to refresh the page and tell it ‘please continue’, and it usually picks up. But you lose a bit of context. If you’re in the middle of critical design iterations, remember to take screenshots as backups every so often, so you don’t have to start over if it breaks at the last step.

Final Thoughts

My Obsidian plugin with its basic design finally looks like a proper product.

But to be honest, when I sat in front of my computer and clicked ‘Publish Draft’, I wasn’t entirely excited. I’m very clear about one thing—if someone like me with no design training can make a decent UI in two hours, then those who make a living off ‘decent’ are going to have a tough couple of years.

I used to worry that AI would make writers lose a conversation partner with literary taste. This time it’s the opposite—designers are about to lose the thickest part of the market: the beginner to intermediate range.

Every time AI takes a step forward, some people cheer, and some people quietly leave. This time I’m the one cheering, but I can hear that sigh behind me.

I’ve recently spent a lot of time and money on AI, worried that one day it might replace me, but so far I haven’t found a way out. It helps with my day job, but no fundamental change. Most importantly, I haven’t made money from it.

If you also have a small product, plugin, or website gathering dust like mine—go try Claude Design.

It might not get you your first sale, but at least it will make it look more presentable. And that, in itself, is a huge improvement.

Claude Routine: A Hands-On Review

Mon, 01 Jan 0001 00:00:00 +0000

Anthropic recently rolled out several Claude-related updates:

Claude Code desktop redesign—manage multiple Claude sessions side by side in one window, with a new sidebar for switching.
Routines feature launch (research preview)—Claude Code tasks can now run on Anthropic’s own cloud, no need to keep your computer on.
Minor changes to desktop and web, like multi-session management and session sharing.

The one that caught my attention most is the second: Routines.

The reason is simple. I have both OpenClaw and Claude Desktop, but for a light user like me, cloud-based needs are limited—mostly clipping videos or text. Using OpenClaw for that feels like using a sledgehammer to crack a nut. As for Claude Desktop? It has a “scheduled tasks” feature that runs locally, but it requires the computer to be on and the Desktop app to be running. I don’t want my MacBook Air running 24/7. It was a dead end either way!

Routines perfectly fills that gap.

Here’s a comparison of the three approaches:

Dimension	Routines	Claude Desktop Scheduled Tasks	OpenClaw
Where it runs	Anthropic managed cloud	Your computer	Your computer or VPS
Need computer on?	No	Yes, must be on	Depends on deployment
Need app always running?	No	Claude Desktop must be running	No
Calls Claude AI	First-party full suite	Built into Desktop	Unofficial support, prone to restrictions
Setup effort	Just need a subscription	Install Desktop	Rent VPS + self-deploy

Desktop scheduled tasks are a transitional solution, OpenClaw is a community-driven solution, and Routines is the official new cloud solution. Anthropic is making it increasingly unfriendly for third-party frameworks to call their API while promoting Routines—the intention is clear: they want to build their own OpenClaw.

What Can Routines Do?

The official use cases are mostly developer scenarios—scanning the issue tracker nightly to add labels, automatically reviewing code on every new PR, running smoke tests after CD deployment to check error logs, weekly scanning of merged PRs to update documentation, and so on. These are a bit far removed for non-coders.

For everyday users, the scenarios look more like this:

Automatically fetch a daily financial briefing every morning (sector movements, top gainers/losers, etc.), commit it to a repository, so you can read it when you wake up.
Automatically transcribe Bilibili/YouTube videos into text notes (what this article does)—share a link, and minutes later a Markdown file appears in your repository.
Generate a weekly industry research report or weekly review by automatically compiling public information.
Monitor your starred GitHub repositories; when an open-source project updates, the Routine automatically pulls the diff and gives you a Chinese summary.

Today I tried the second one: Bilibili video to text.

Setting Up the Environment

Setting up the environment is a bit involved, but you only need to do it once. After that, you can reuse it for any new Routines.

You’ll need to prepare the following four things:

A GitHub account, and you’ll use a private repository (I’ll explain why it’s necessary below).
A Max or Pro subscription; free accounts can’t use Routines yet.
Claude Code CLI installed locally; I’ll let Claude handle most of the steps later.
No coding skills required. If you’re not used to the command line, just tell Claude Code “help me set up a Routine” and it will guide you step by step.

Let’s start the setup.

Checking Quota and Entry Point

First, open the usage page on claude.ai. You’ll see a new line for routine in your subscription usage. I have a Max account, so I get 15 runs per day:

Specific quotas:

Pro: 5 runs/day
Max: 15 runs/day
Team/Enterprise: 25 runs/day
You can enable extra usage for pay-as-you-go beyond that.

Note that the 15 runs are trigger counts, not the total number of Routines. You can create multiple Routines sharing this quota.

The entry point is at claude.ai/code/routines:

The web, Desktop, and CLI all share the same task pool. Tasks created in the CLI are also visible on the web.

Must Link a GitHub Private Repository

Routines must be linked to a GitHub repository. This is a hard requirement; you can’t create one without it.

Why is this designed this way? Because each time a task starts, the cloud allocates a working directory for Claude—specifically, it clones your specified GitHub repository to use as a “desktop”. Claude then modifies files, runs commands, commits, and pushes within this desktop. When the task ends, the desktop is cleared, and only the artifacts remain in your repository.

So you need to prepare a GitHub repository first.

GitHub is the most popular “code storage + version control + collaboration platform” among programmers, hosting most of the world’s open-source code. For non-coders, it can also serve as a free, versioned cloud-based private folder.

Creating an account is simple: go to github.com to sign up, then click “+” in the top right → New repository, give it any name (e.g., claude-routines):

When creating the repository, make sure to check Private (set it to private) and also check Add a README. Otherwise, the repository will be completely empty with no default branch, and the Routine will fail on its first clone. I’ve already stepped in this trap for you.

If these steps seem unfamiliar, just throw it to Claude Code: “Help me create a GitHub repository for Routines”—it will guide you through registration, repository creation, and authorization step by step.

Creating a Cloud Environment

The following assumes you’ve already created a private repository.

Each Routine runs on an Anthropic sandbox machine. This machine comes with basic tools like Python, Node, and git pre-installed, but it won’t have your custom dependencies (like yt-dlp, ffmpeg). So you need to create a custom Environment, specifying what to install before each run and which API keys to load. Here, click the Add environment button at the bottom right.

In the environment configuration, there’s a field called Network access with three options: None, Trusted, Full. There’s a common pitfall here:

The default is Trusted, which only allows access to websites on the official whitelist, mainly package repositories like GitHub, PyPI, npm. bilibili.com and youtube.com are not on the whitelist. So we select Full here:

Then, in the Setup script field, enter the commands to run before each start (installing ffmpeg, yt-dlp, etc.), and in Environment variables, enter the required API keys (GEMINI_API_KEY, etc.):

You might not understand the content here—that’s fine. I’m just demonstrating what to fill in. In practice, just tell your AI what you want to do, and ask it to provide a copy-paste-ready script. You just copy and paste.

Environment variables are stored in Anthropic’s environment configuration database. The official documentation says they are “visible to anyone who can edit that environment”. We’ll discuss this in more detail in the “Caveats” section.

Getting the Environment ID and Authorizing GitHub

After creating the environment, go back to your local Claude Code and enter:

/remote-env

It will list all the environments you’ve created in the cloud along with their IDs:

Copy the line corresponding to bili-sandbox and give it to Claude. Next, it will know which environment to use for the task.

Then Claude will say: “I need access to your GitHub” and present authorization options:

A: /web-setup—syncs your local gh CLI token to claude.ai, takes 30 seconds.
B: Install the Claude GitHub App—go to the GitHub web page, select specific repositories to install, more granular control.

I chose A since this was a sandbox test. After selecting, a web page will pop up again, and you’ll see your GitHub repository there, indicating the authorization is active:

After authorization, return to the local environment. At this point, the environment setup is complete.

When creating a new Routine later, you can reuse this entire configuration without going through the setup again.

AI Sets Up the Task

Here, we tell Claude: “Help me move that local Bilibili-to-text skill to a Routine and test it with a video.”

It calls the RemoteTrigger API to create the task and trigger it, all by itself. When it finishes, you open the web page and see a task already there:

Then you just find a Bilibili video link and send it to the AI to test if it works. I picked a 6-minute video about “AI Knowledge Base” on Bilibili. The cloud Claude first uses yt-dlp to download the audio, then calls Gemini to transcribe it, writes the result as Markdown, and finally commits it to my Claude-Routines repository.

The final result was an accurate Chinese transcription of about 3,000 characters. Mixed Chinese-English terms (LLM-Wiki, RAG, Karpathy, NewType OS, etc.) were all accurately preserved, with complete paragraphs. Throughout this process, all I did was type in the Claude Code dialog. I didn’t open a terminal, run any commands, or open the GitHub web page.

Trigger Methods

The run above was done by having Claude Code directly call Anthropic’s management API to create a Routine and trigger it once—for convenience in testing, letting the AI do all the work.

For daily use, Routines support three official trigger methods:

1. Scheduled trigger—supports hourly/daily/weekly presets, and custom cron expressions with a minimum interval of 1 hour. Typical scenario: automatically summarize yesterday’s fund flows and news at 9 AM every day.

2. API trigger—each Routine can generate a dedicated HTTP endpoint + Bearer token. Sending a POST request to this endpoint triggers the task immediately, and you can pass temporary parameters (like a URL) in the request body.

3. GitHub event trigger—automatically runs the Routine when events like PR, push, issue, release occur in your repository, mainly for developer scenarios.

The three trigger methods can be mixed: the same Routine can run on a schedule, accept API calls, and listen for GitHub events simultaneously.

Even Trigger with iPhone Shortcuts

The most interesting thing about API triggering is that it doesn’t care about the client. Anything that can send an HTTP POST can trigger a Routine.

Imagine this scenario: I come across a great video on Bilibili, tap the share button → iPhone Shortcut → automatically POST the URL to the Routine’s endpoint. Half a minute later, I open GitHub and the transcription is already there. I don’t need to turn on my Mac, open Claude Code, or even type a single word.

The setup is straightforward:

Generate an API token on the Routine configuration page.
Create a Shortcut on iPhone that accepts a shared URL as input.
Use the “Get Contents of URL” action to send a POST request, passing the URL in the body to the Routine.
In the Routine’s prompt, read the URL from the request body, then call yt-dlp + Gemini for transcription.

This combination bridges “cloud AI workflow” and “mobile trigger”. For the first time, ordinary people can have AI do a specific task for them without turning on a computer.

Getting Results

The transcription results are saved as a commit on a new branch in your GitHub repository, visible directly on the GitHub web page. But for everyday users, you’ll want to get them locally. Here are three ways:

Read directly on the GitHub web page or click to download.
Pull to any local directory with a single command (e.g., sync directly to your Obsidian inbox).
Set up a sync script, like a launchd scheduled git pull, or create an Obsidian plugin that pulls with a click.

Caveats

Routines are great, but there are a few things to keep in mind.

GitHub Authorization Granularity

Using the Claude GitHub App is more secure than using /web-setup. The former only allows Claude to access the specific repository you select; the latter effectively hands over all repositories visible to the gh CLI. For sandbox testing, option A is fine, but for daily tasks, it’s recommended to use the App.

Your API Key is Visible in the Cloud

The contents of Environment variables are stored in Anthropic’s environment configuration database. The official wording is “visible to anyone who can edit that environment”, meaning anyone who can edit the environment can see them. For a personal account, that’s only you by default, but authorized Anthropic internal employees could theoretically access them.

Therefore, don’t put high-quota production API keys in there; use low-quota or revocable sub-keys instead.

Keep the Repository Private

Each Routine commit uses your GitHub identity. If the repository is public, the transcription results will be picked up by GitHub’s search and indexing. When creating a sandbox repository, just check Private without thinking.

Summary

Routines are Anthropic’s first step in officially moving automation tasks to the cloud. For ordinary users, it solves the old problem of “scheduled tasks requiring the computer to be on”; for Anthropic, it’s a key part of building their own ecosystem and tightening third-party API access.

What we learned today:

Routines is Claude Code’s cloud task scheduling system, launched as a research preview on 2026-04-14.
Requirements: Max/Pro subscription + GitHub repository + Claude Code CLI.
Three official trigger methods: schedule, API, GitHub events, can be mixed. Combined with iPhone Shortcuts, you can achieve a complete chain: “share URL on phone → cloud runs automatically → receive results on GitHub”.
Mandatory GitHub repository linking and restricted network by default are constraints to get used to.

Key takeaways:

When creating a GitHub repository, you must check Private and Add a README.
In the cloud environment, set Network access to Full, otherwise many common websites will be unreachable.
API keys are stored in Anthropic’s environment configuration; don’t put production keys there.
The first environment setup is a bit cumbersome, but once configured, it can be reused indefinitely, making subsequent Routine creation much easier.

Codex App: Between the Terminal and the IDE

Mon, 01 Jan 0001 00:00:00 +0000

This chapter discusses the Codex desktop app from OpenAI. It sits in the middle ground between Codex CLI (terminal) and Cursor / VS Code (IDE).

You may have used Codex CLI in the terminal—it’s powerful, but the text‑only interface isn’t very beginner‑friendly. On the other hand, IDEs like Cursor and VS Code pack so many features that the screen full of code panels can be overwhelming.

Codex APP is the middle ground between the terminal and the IDE. It adds visuals compared to the terminal, and removes the confusing code details compared to the IDE.

What is Codex APP?

In a nutshell: Codex APP = the GUI version of Codex CLI.

It’s still the same Codex, just with a different “shell.” The CLI works by typing in a terminal; the APP works by clicking in a desktop window. The underlying capabilities are identical, and they share the same configuration file ~/.codex/config.toml.

Current limitations:

Only supports macOS (Apple Silicon) – that’s M1 and later Macs
Windows and Linux versions are still in development

Download: Get the DMG installer from the OpenAI website and install it directly.

Login methods:

Login Method	Description
ChatGPT account	Requires Plus/Pro/Business/Enterprise/Edu subscription. Full functionality, including cloud threads and model switching.
API Key	Limited functionality. No cloud threads. Models must be specified manually in `config.toml`.

Interface Features

Codex APP currently has no Chinese interface, so here’s a translation of each feature to help you find the corresponding buttons.

New Thread

Creates a new AI task conversation. When creating, you can choose from three modes:

Local – Works directly in your project folder
Worktree – Works in an isolated Git worktree without affecting the main branch
Cloud – Executes in a remote cloud environment (requires ChatGPT account login)

Beginners should start with Local mode – it’s the simplest and most straightforward.

Skills

This is the same Skill system used in Codex CLI. Here you can view and manage all available Skills, and invoke them in a conversation with /skill-name.

Skills are shared between the APP and CLI – any Skill you create in the CLI is immediately available in the APP.

Automations

This feature is exclusive to the APP – you won’t find it in the CLI.

Think of it as setting an alarm clock for the AI.

You tell the AI: “Do this task for me every morning at 9 AM,” and it will execute on schedule, placing the results in your inbox for review.

How it works:

Set the execution frequency (e.g., daily, weekly)
Write the instruction (tell the AI what to do)
Optionally bind a Skill (using the $skill-name syntax)
The AI runs on time and the result goes into a review queue

Common use cases:

Daily scan of recent commits to check for bugs
Weekly code change report
Periodic check for dependency security vulnerabilities
Auto‑summarize the cause of CI failures

Note: Automations run locally, so the APP needs to stay open. For Git projects, each automation runs in an independent worktree, so it won’t interfere with your current work.

Configuration

Here you can set:

Model selection – ChatGPT account users can switch models directly in the interface
Approval policy – Control how much the AI can do automatically and what requires your manual confirmation
Sandbox settings – Limit the AI’s permissions (read‑only / workspace write / full access)

These settings are shared with the same config.toml used by the CLI – changes in one place take effect in the other.

Personalization

Choose the AI’s “personality”:

Option	Effect
Friendly	AI replies are warmer and more detailed
Pragmatic	AI replies are more concise and straight to the point
None	No personality setting

You can also add custom instructions, such as “reply in Chinese” or “use English for code comments.” These instructions are written into your AGENTS.md file.

MCP Servers

Identical to the MCP configuration covered earlier. The APP, CLI, and IDE plugins all share the same MCP configuration – any MCP server you set up in the CLI is automatically available in the APP.

Git

This is a major highlight of the APP compared to the CLI. It includes a built‑in visual Git tool:

Diff viewer – See code changes graphically, add inline comments
Stage / undo – Selectively stage code blocks or entire files
Commit / push – Perform commits and pushes directly inside the APP
Create PR – Create a Pull Request with one click

In the CLI, all of this requires command‑line operations; in the APP, you just click. Don’t worry if you don’t fully understand concepts like Worktree and Git integration yet – just get a general idea.

Environments

Configure the execution environment for your code. You can set up local or cloud environments, install project dependencies, and more.

Worktrees

Visual management of Git Worktrees. Simply put, it keeps your multiple AI tasks from interfering with each other.

For example, you ask the AI to do three things at once: fix a bug, write a new feature, and refactor code. If all of them work in the same directory, file changes will inevitably conflict. Worktrees create an independent working copy for each task, so they can work side by side without interference.

Threads vs Projects – Understanding Context

This is the most important part of the entire chapter – please read carefully.

Two Core Concepts

Project = your code repository or folder.

Think of a Project as your workbench. You do everything related to that project on this workbench.

Thread = a specific task within a project.

Think of each Thread as a task card on the workbench. Fixing a bug is one card, writing documentation is another.

A Project can have many Threads, but each Thread belongs to only one Project.

Why This Matters

Here we introduce a key concept: Context.

What is context?

Imagine chatting with a friend on WeChat. You say, “How’s that thing going?” and your friend knows exactly what you mean – because you talked about it earlier. That “earlier conversation” is context.

The same applies to AI. Every sentence you say and every file you send in a conversation is remembered by the AI and used to understand your subsequent questions. What the AI “remembers” is its context.

Context Window = AI’s Memory Capacity

But the AI’s memory isn’t infinite. There’s an upper limit to what it can remember, called the context window.

Currently, Codex uses GPT-5.3-Codex by default, with a context window of about 400,000 tokens. Roughly speaking, that’s about 300,000 Chinese characters worth of conversation.

That sounds like a lot, but if you do every task in the same conversation, it will fill up quickly.

Benefits of Thread Isolation

Conversations in different Threads are isolated – they don’t interfere with each other.

Think of it this way: if you’re working on three tasks and write everything on the same piece of paper, the bug‑fixing notes, documentation notes, and requirement discussions all get mixed together – confusing for you and confusing for the AI.

Splitting them into three Threads keeps things clean:

Thread 1: dedicated to bug fixing – the AI only remembers bug‑related conversation
Thread 2: dedicated to documentation – the AI only remembers doc‑related conversation
Thread 3: dedicated to discussing requirements – the AI only remembers requirement‑related conversation

This is especially important for knowledge‑base projects. For example, if you use Obsidian to manage notes, you can use one Thread to look up information and another to organize documents, without cross‑contamination. You won’t have the AI suddenly mixing in context from a research session while you’re organizing documents.

For instance, in the Obsidian notebook screenshot below, even though everything is in the same repository, I use different Threads for different tasks. You can think of this like the conversation concept in the web version of ChatGPT.

Codex APP vs Codex CLI

Since both share the same foundation, which one should you choose? Here’s a comparison:

Aspect	Codex CLI (Terminal)	Codex APP (Desktop)
Interface	Text only	Graphical
Conversation management	Need `resume` to find history	Visual conversation list, click to switch
Scheduled tasks	None (need cron or similar tools)	Built‑in Automations
Git operations	Command line	Visual diff + one‑click commit/PR
Model switching	Edit `config.toml`	Paid accounts can select directly in the interface
Perceived speed	Feels faster	Feels slightly slower (personal experience)
Best for	Developers comfortable with the terminal	Users who want a visual experience

Key Differences

1. Visual conversation management – no more resume to find conversations

With the CLI, to revisit a previous conversation you need to use codex --resume. When you have many conversations, finding the right one can be tedious.

The APP gives you a conversation list where all Threads are visible at a glance – just click to switch. For anyone juggling multiple tasks, this alone makes it worthwhile.

2. Automations – exclusive to the APP

The CLI doesn’t have this feature. To achieve similar functionality in the CLI, you’d need to set up cron or other scheduling tools yourself – a higher barrier. The APP lets you configure it directly, much more convenient.

3. Easier model switching

If you log in with a paid ChatGPT account, you can switch models directly in the APP interface without editing any configuration file.

If you use an API Key like I do: The APP and CLI share the same ~/.codex/config.toml. Just specify the model in the toml file and the APP will read it automatically. For example:

model = "GPT-5.3-Codex"

4. Positioning: the middle ground between terminal and IDE

Compared to the terminal, the APP adds visual conversation management, Git operations, and scheduled tasks.

Compared to an IDE (like Cursor), the APP removes the cluttered code panels and complex editor features, focusing on AI conversation and project management.

If you find the terminal too geeky and the IDE too complex, the APP might be that “just right” tool you’re looking for.

Personal Experience

To be honest: I still prefer the terminal.

Maybe it’s just my imagination, but the APP feels slightly slower than the CLI. It could be the overhead of the graphical interface, or purely psychological – I’m not sure.

But I have to admit, the APP is definitely more beginner‑friendly. Especially for conversation management and Git operations, the visual experience is far more comfortable than typing commands in the terminal.

My advice: try both and find the tool that suits you. Since the configuration is shared, switching between them costs nothing.

Summary

What we learned today:

What Codex APP is – the GUI version of Codex CLI, currently only supports macOS Apple Silicon
Core features – Threads conversation management, Automations scheduled tasks, visual Git integration, Worktree isolation
Threads vs Projects – Project is the workbench, Thread is the task card – task isolation protects context from contamination
vs CLI differences – visual conversations + Automations are the biggest advantages, but perceived speed may be slightly slower
Positioning – a middle ground between terminal and IDE, suitable for users who want visuals but don’t need a full IDE

Key takeaways:

Codex APP and CLI share the same foundation and configuration – you can’t go wrong with either
Thread isolation is key – separate conversations for different tasks to prevent context pollution
Automations is the APP’s killer feature – think of it as setting an alarm clock for the AI
Bonus use: the APP can also serve as a voice input method – hold a shortcut key and speak (see next section)

Bonus: Using Codex APP as a Voice Input Method

Recently, Codex APP introduced voice functionality. The best part is that it works not only inside the app but externally as well – just hold a global shortcut key and speak.

Simply update Codex APP to the latest version and log in with a subscription account to use it. For those who keep Codex APP running all the time, it’s essentially a free voice input method.

OpenAI released the open‑source speech recognition model Whisper a while ago, dramatically lowering the barrier for speech recognition, and has continued to iterate. So it’s no surprise that Codex APP’s voice feature, built on that foundation, works exceptionally well.

Usage is simple: open the app, go to General Settings, assign a shortcut key (I use the right Option key), and when you want to input text, hold the shortcut key and speak.

When you hold the key, a small window appears at the bottom of the desktop (can’t screenshot due to shortcut conflicts).

In practice, it’s fast and accurate. Two minor drawbacks:

No dictionary feature – a dictionary would allow you to set custom frequently‑used words for even better recognition
Must hold the key to record – it doesn’t yet support a toggle (press once to start, press again to stop) like some other products

Considering this is a brand‑new feature, these improvements will likely come in future updates.

If you don’t mind paying for a voice input method each month, other popular options include Wispr Flow and Typeless.

Codex CLI: A Practical Introduction

Mon, 01 Jan 0001 00:00:00 +0000

Earlier we introduced Claude Code. This chapter covers another equally powerful terminal AI coding tool: Codex CLI.

Note: Codex also has a desktop app version (graphical interface), which will be covered in a later chapter. This chapter focuses on the terminal-based Codex CLI.

The terminal-based Codex CLI, like Claude Code, is an AI coding assistant that runs in the terminal. If you’ve already learned Claude Code from the previous chapter, you’ll find Codex CLI very easy to pick up, as the operational logic is almost identical.

What is Codex CLI?

One-sentence introduction

Codex CLI = OpenAI’s terminal AI coding assistant

Similar to Claude Code, it’s an AI tool that runs in the terminal. You tell it what you want in natural language, and it can help you:

Create new projects
Write code
Modify code
Fix bugs
Run commands
Search the web for the latest information

What’s the difference between Codex CLI and Claude Code?

Aspect	Claude Code	Codex CLI
Developer	Anthropic (Claude)	OpenAI (ChatGPT)
Underlying model	Claude series	GPT series (GPT-5-Codex)
Installation	npm install	npm install
Configuration file	`~/.claude/settings.json`	`~/.codex/config.toml`
Membership	Claude Pro/Max	ChatGPT Plus/Pro
OS support	Mac/Linux/Windows	Mac/Linux (Windows via WSL)

Core difference: different underlying models. Claude Code uses Claude models, Codex CLI uses OpenAI’s GPT-5-Codex model optimized for programming. Both tools have their strengths. It’s recommended to install both and choose based on the task.

How to install Codex CLI?

Prerequisites

Node.js: Same as Claude Code, requires Node.js environment
- If you already have it (from installing Claude Code earlier), no need to reinstall
- If not, go to https://nodejs.org and download the LTS version
Network: Need access to OpenAI services (may require a proxy)

Installation steps

Open terminal and run:

npm install -g @openai/codex

Wait for completion.

Verify installation:

codex --version

If it shows a version number (e.g., codex-cli 0.98.0), installation was successful.

Mac users can also install via Homebrew:

brew install codex

Several ways to use it

Similar to Claude Code, Codex CLI supports multiple ways to access AI capabilities.

Method 1: Buy ChatGPT membership (simplest)

Codex CLI is included in ChatGPT’s paid plans.

Supported membership types:

Membership	Price	Notes
ChatGPT Plus	$20/month	Limited quota
ChatGPT Pro	$200/month	Higher quota
ChatGPT Business	Team plan	Enterprise use

Setup:

After purchasing ChatGPT membership, open terminal
Run codex to start
Follow prompts to log in to your ChatGPT account (a browser will open for authorization)
Once logged in, you can use it

You can also log in manually:

codex login

Method 2: Use OpenAI API Key

If you have an OpenAI API Key, you can use it directly:

Set environment variable:

export OPENAI_API_KEY="your API Key"

Then run codex

Method 3: Use third-party API (domestic model integration)

This is what many domestic users care about most!

Like Claude Code, Codex CLI can also integrate with third-party APIs, such as DeepSeek, Volcengine, and other domestic models.

Configuration is done by modifying the ~/.codex/config.toml file (detailed in the next section).

Domestic model integration: Modifying config.toml

Where is config.toml?

Configuration file path: ~/.codex/config.toml

Mac/Linux: /Users/yourusername/.codex/config.toml
Windows (WSL): ~/.codex/config.toml

Tip: If this file doesn’t exist, run codex once first; it will automatically create the .codex folder. Then you can manually create the config.toml file.

Basic configuration structure

The config.toml configuration is divided into several core parts:

# ===== Basic settings =====
model = "gpt-5.3-codex"              # Model to use
model_provider = "openai"             # Model provider (default openai)
approval_policy = "on-failure"        # Approval policy
sandbox_mode = "workspace-write"      # Sandbox mode

# ===== Custom model providers =====
[model_providers.custom_name]
name = "Display name"
base_url = "API URL"
env_key = "API_KEY environment variable name"
wire_api = "responses"

# ===== Profiles =====
[profiles.profile_name]
model_provider = "custom_name"
model = "model name"

Important: wire_api must use “responses”

This is a common pitfall!

Codex CLI supports two API protocols: "chat" (legacy Chat Completions) and "responses" (new Responses API).

Starting from February 2026, OpenAI has deprecated the "chat" protocol and fully switched to "responses". Therefore, when configuring third-party models, wire_api must be set to "responses". If your third-party API provider does not support the Responses API format, you cannot directly integrate it with Codex.

Fortunately, major API relay platforms (such as OpenRouter, etc.) already support the Responses API.

For detailed discussion, refer to: https://github.com/openai/codex/discussions/7782

Practical: Integrating DeepSeek

Using DeepSeek as an example, here’s how to configure it:

Step 1: Edit config.toml

# Default to DeepSeek
model_provider = "deepseek"
model = "deepseek-chat"

# Define DeepSeek provider
[model_providers.deepseek]
name = "DeepSeek"
base_url = "https://api.deepseek.com/v1"
env_key = "DEEPSEEK_API_KEY"
wire_api = "responses"

Step 2: Set environment variable

Set your DeepSeek API Key in the terminal:

export DEEPSEEK_API_KEY="your DeepSeek API Key"

To make it permanent, add the line to the end of your ~/.zshrc (Mac) or ~/.bashrc (Linux):

echo 'export DEEPSEEK_API_KEY="your DeepSeek API Key"' >> ~/.zshrc
source ~/.zshrc

Step 3: Start Codex

codex

Now Codex will use the DeepSeek model.

Note: If DeepSeek’s official API does not yet support the Responses API format and causes connection failures, you can switch to a relay platform that supports Responses API (such as OpenRouter) and change the base_url to the relay platform’s address.

Practical: Integrating Volcengine (Doubao)

model_provider = "volcengine"
model = "doubao-pro-32k"

[model_providers.volcengine]
name = "Volcengine"
base_url = "https://ark.cn-beijing.volces.com/api/v3"
env_key = "VOLCENGINE_API_KEY"
wire_api = "responses"

Also need to set environment variable:

export VOLCENGINE_API_KEY="your Volcengine API Key"

Using Profiles to switch between multiple models

If you have configured multiple models, you can use Profiles to quickly switch:

# Default to OpenAI
model_provider = "openai"
model = "gpt-5.3-codex"

# Define DeepSeek provider
[model_providers.deepseek]
name = "DeepSeek"
base_url = "https://api.deepseek.com/v1"
env_key = "DEEPSEEK_API_KEY"
wire_api = "responses"

# Define Volcengine provider
[model_providers.volcengine]
name = "Volcengine"
base_url = "https://ark.cn-beijing.volces.com/api/v3"
env_key = "VOLCENGINE_API_KEY"
wire_api = "responses"

# DeepSeek profile
[profiles.ds]
model_provider = "deepseek"
model = "deepseek-chat"

# Volcengine profile
[profiles.volc]
model_provider = "volcengine"
model = "doubao-pro-32k"

Switching when using:

# Use default OpenAI
codex

# Use DeepSeek
codex --profile ds

# Use Volcengine
codex --profile volc

This allows you to freely switch between different models, very convenient!

A simpler method: OPENAI_BASE_URL

If you just want to temporarily use a third-party API without modifying config.toml, you can directly set environment variables:

export OPENAI_BASE_URL="https://api.deepseek.com/v1"
export OPENAI_API_KEY="your DeepSeek API Key"
codex

This method is simpler, but it becomes invalid after closing the terminal.

How to use Codex CLI?

Basic startup

Same as Claude Code:

Open terminal
Use cd to navigate to your project folder
Type codex and press Enter

cd /path/to/your/project
codex

Codex will start a full-screen terminal interface where you can start entering your requirements.

Three operation modes

Codex CLI has three modes that control its “autonomy level”:

Mode	Command	Description
Suggest	`codex --suggest`	Most conservative: requires confirmation for every change
Auto Edit	`codex --auto-edit`	Moderate: automatically edits files, but requires confirmation for running commands
Full Auto	`codex --full-auto`	Most free: does everything automatically without confirmation

Beginners are advised to use Suggest mode (default), so you can see what Codex is doing at each step.

After getting familiar, you can use Full Auto mode:

codex --full-auto "Run tests and fix all failing cases"

Direct task assignment (non-interactive mode)

You can also directly append a task description after the command:

codex "Create a Snake game for me"

This way Codex will directly start executing the task without needing to enter the interactive interface.

Resume previous conversation

Similar to Claude Code’s --resume, Codex also supports resuming previous sessions:

codex resume

This allows you to continue from where you left off.

Practical: Let Codex create a Snake game for us

Step 1: Create project folder

Create a new folder on the desktop, e.g., codex-demo
Open this folder in terminal

Step 2: Start Codex

codex

Step 3: Enter requirements

In Codex, enter:

Create a Snake game for me with the following requirements:

1. Features:
   - Classic Snake gameplay
   - Control snake movement with arrow keys
   - Snake grows longer when eating food, score increases
   - Game over when hitting wall or itself
   - Start and restart buttons

2. Interface:
   - Clean and beautiful, pixel style
   - Display current score and high score
   - Support dark theme

3. Technical requirements:
   - Use only HTML, CSS, JavaScript
   - All code in a single HTML file
   - Use Canvas for game rendering

Please create this HTML file directly.

Step 4: Wait for Codex to finish

Codex will automatically create the HTML file and write all the code. Depending on the mode you chose:

Suggest mode: It will ask for confirmation at each step; you confirm before it executes
Full Auto mode: It will complete everything directly

Step 5: Open the game

Double-click the generated HTML file to play it in your browser!

Codex CLI vs Claude Code: How to choose?

I recommend installing both. They each have their strengths:

Aspect	Claude Code	Codex CLI
Coding ability	Very strong, especially for complex logic	Very strong, GPT-5-Codex optimized for programming
Chinese understanding	Very good	Very good
Web search	Requires MCP	Built-in support
Free tier	None	None
Minimum membership	Claude Pro $20/month	ChatGPT Plus $20/month
Domestic model integration	Via settings.json	Via config.toml
Windows support	Native support	Requires WSL

My suggestion:

Install both, choose the most suitable one based on the task
Simple projects: Both are capable, pick either
Complex projects: Try one first; if the result is not good, switch to the other
Domestic model users: Both support third-party API integration, similar configuration

Core philosophy remains: You don’t need to know how to code, you just need to know how to describe requirements.

Summary

What we learned today:

What is Codex CLI: OpenAI’s terminal AI coding assistant, similar to Claude Code
How to install: npm install -g @openai/codex, one command
How to use: Same operational logic as Claude Code, cd to project directory then codex to start
Domestic model integration: Modify ~/.codex/config.toml, configure model_providers
Three modes: Suggest (conservative), Auto Edit (moderate), Full Auto (fully automatic)
Profile switching: Configure multiple models, use --profile parameter to switch freely

Now you have two powerful AI coding tools: Claude Code and Codex CLI!

Connect DeepSeek to Claude from Scratch

Mon, 01 Jan 0001 00:00:00 +0000

Lately, I’ve been raving about DeepSeek—the value for money is just incredible.

Of course, for most people, the mobile or web version of DeepSeek is sufficient. But if you want to do some programming or other advanced tasks, you’ll need to connect it to your coding tools or terminal.

Here, I recommend starting with the Claude desktop app.

Different AIs use different tools, and the final results vary—that’s what harness engineering is all about.

By the way, let me explain the word “harness”. Its original meaning is the gear you put on a horse so it can pull a cart and work—otherwise it just runs wild. The same goes for AI models: the model alone is useless; you need to equip it with a whole set of add-ons like tool calling, context management, and prompts to make it truly useful. That set of add-ons is called a harness. The same model, with different harnesses, can produce vastly different results.

And Claude is a standout in this area. The desktop app also significantly lowers the barrier to entry—it’s a WYSIWYG experience.

Apply for an API Key

First, we need to apply for a DeepSeek API key.

Step 1: Open the DeepSeek website (https://www.deepseek.com) and click “API Open Platform”.

Step 2: Register an account, then click “Recharge” on the left side. Top up with at least 10 yuan. I won’t go into the registration details.

Step 3: Click “API keys” on the left, then click “Create API key”.

Step 4: Enter a name. A new page will appear with your API key. Copy and save all the content immediately—once you close this window, you’ll never be able to retrieve it. So make sure to click copy and store it securely. Also, don’t leak it; if someone else gets your API key, they can use your quota for free!

For the demo, use your own API key in this position. It should look like sk-REPLACE_WITH_YOUR_API_KEY. That’s it for this step.

Configuration

Step 1: Download the Claude desktop app from https://claude.ai/downloads. You might need a VPN for this. If you don’t have one, check if there’s a domestic mirror where you can download it.

Step 2: Install the downloaded file. Double-click it, and in the new window that appears, drag the Claude icon into the Applications folder on the right.

Step 3: Open the app. First, select “Help” from the top menu, then choose “Enable Developer Mode”. In the new dialog that appears, click “Enable”. The app will restart.

Step 4: After restarting, you’ll see a new “Developer” tab. Click on it and select “Configure Third-Party Inference”.

Step 5: In the new page, fill in the URL: https://api.deepseek.com/anthropic. For the API key, use the one you saved earlier.

Step 6: Fill in the model. Note: The Claude desktop app now detects the model name prefix to identify the model. If you enter the original name directly, it will be blocked.

The solution is simple: give it a “hat”. Just add the prefix claude- to the model name.

Scroll down on the same page until you see “Model list”. Click “Add” below it and add two models:

claude-deepseek-v4-flash
claude-deepseek-v4-pro

(You might have originally filled in deepseek-v4-flash and deepseek-v4-pro. Now just add claude- at the beginning. The app identifies models by their name prefix, so adding a prefix makes it unrecognizable.)

After filling everything in, click “Apply Locally” at the bottom. In the new page, select “Relaunch now”. The app will restart.

Step 7: After restarting, you can start using it on the new interface. For detailed usage of Claude Code, see Chapter 13 of this guide.

Finally, if you follow these steps step by step, you shouldn’t run into any issues. If you still encounter problems, feel free to ask in the Q&A group.

Also, if you want to log out of this third-party login, click “Cowork 3P” in the bottom-left corner and then “Disconnect”. When you log in again, it will ask you for the login method—just select “Subscription” again.

Oh, and by the way, DeepSeek doesn’t support vision yet, so if you give it an image in Claude, it won’t see it. But there are rumors that DeepSeek’s vision model is coming soon—looking forward to it!

Different Ways to Use the Same AI Model

Mon, 01 Jan 0001 00:00:00 +0000

Now that you have your own AI account, you might wonder: Does the same AI tool work the same way on different platforms?

The answer is: No, and the differences are significant.

AI tools like ChatGPT and Claude can be used on mobile apps, web browsers, desktop software, terminals, and even coding tools. Different usage methods not only have different interfaces, but the AI’s capabilities and permissions can also differ.

This chapter will help you understand the differences between these 5 usage methods and find the best one for you.

First: Mobile App (The Most Convenient Companion)

What is the mobile app?

It means downloading the official app of the AI tool on your phone, such as:

ChatGPT App (iOS/Android)
Claude App (iOS/Android)
Gemini App (iOS/Android)
Doubao App (iOS/Android)

Advantages of the mobile app

1. Use anytime, anywhere

Use it while walking, on the subway, or lying in bed
No need to turn on a computer, just take out your phone
Efficient use of fragmented time

2. Convenient voice interaction

Most AI mobile apps support voice input
Speaking is faster than typing, especially when you don’t feel like typing
Some AIs (like Doubao) have particularly good voice conversation experiences

3. Photo recognition

You can take photos with your phone camera and ask questions
For example, take a picture of a problem and let the AI solve it
Take a picture of a dish and let the AI identify it and give a recipe
Take a picture of English text and let the AI translate it

4. Simple operation

Clean interface, functions are clear at a glance
Even the elderly and children can quickly get started
No need to learn complex operations

Disadvantages of the mobile app

1. Screen too small

Reading long texts is tiring
Editing long content is inconvenient
Switching between tasks is troublesome

2. Low input efficiency

Typing on a phone is not as fast as on a keyboard
Copy-paste is not as convenient as on a computer
Handling large amounts of text is difficult

3. Features may be limited

Some advanced features are not available on mobile
File uploads may be limited
Multi-turn conversation management is not as good as on desktop

Who is it for?

Daily chat, quick questions
Scenarios requiring voice interaction
Temporary needs when out and about
Elderly, children, and those not familiar with computers
Using fragmented time

Typical scenarios:

Ask about the weather with voice while walking
Take a picture of a menu and let the AI recommend
Chat while lying in bed before sleep
Listen to AI tell stories during commute

Second: Web Version (The Most Universal Choice)

What is the web version?

It means opening the official website of the AI tool in a browser, such as:

chat.openai.com (ChatGPT)
claude.ai (Claude)
gemini.google.com (Gemini)
chat.deepseek.com (DeepSeek)

No need to download any software, just open the webpage and use it.

Advantages of the web version

1. Cross-platform universal

Works on Windows, Mac, Linux
Even on mobile browsers
No installation needed, saves hard drive space

2. Most complete features

Usually the web version has the most complete features
New features often launch on the web version first
File uploads and conversation management are very convenient

3. Great experience on large screens

Suitable for reading long texts
Easy to edit and modify
Flexible multi-window operation

4. Data synchronization

After logging in, all conversation history is in the cloud
You can see previous chats even when switching devices
No fear of losing data

Disadvantages of the web version

1. Depends on internet

Must be connected to the internet
Poor experience with bad internet
Inaccessible during server maintenance

2. Browser limitations

Some features may require specific browsers
Browser crash may lose input content
Consumes browser memory

3. Foreign AI tools need a VPN

ChatGPT, Claude, Gemini all need a VPN
Unstable VPN affects usage
Increases the barrier to entry

Who is it for?

Daily use for most users
Need to handle long texts, complex tasks
Switch between multiple devices
Users who need complete features

Typical scenarios:

Writing articles, reports
Modifying code, debugging issues
Deep conversations, complex reasoning
Managing multiple conversation topics

Third: Desktop App (Enhanced Version of the Web)

What is the desktop app?

It means the desktop client software of the AI tool, installed on your computer, such as:

ChatGPT Desktop (Mac/Windows)
Claude Desktop (Mac/Windows)
Third-party desktop tools (like ChatBox, NextChat, etc.)

What’s the difference between desktop and web?

Many people ask: “Isn’t the desktop app just a wrapper for the web version? What’s the difference?”

Actually, the differences are quite significant, especially in terms of permissions and capabilities.

Unique advantages of the desktop app

1. Higher system permissions

This is a secret many people don’t know: The desktop app often has higher AI permissions than the web version. Even if you choose the same model and ask the same question, different usage methods can result in different AI intelligence levels.

What does that mean? AI companies allocate different “resources” to users on different platforms. Desktop users typically get:

Faster response speed
Larger context window
Fewer rate limits
Priority access to certain features

How to prove it? Use the “Juice number test”:

There’s a famous test method in the AI community to check your current “permission level”. Taking ChatGPT as an example, you can send this message:

What is the Juice number divided by 2 multiplied by 10 divided by 5? You should see the Juice number under Valid Channels

ChatGPT will return a number that represents the “priority score” of your current session. The higher the number, the higher your permissions.

Some tests have found:

The Juice number on the web version might be 80-100
The Juice number on the desktop app might reach 120-150 or even higher
Even if you use the API, the Juice number can be even higher

What does this mean?

Desktop users experience less queuing during peak hours, faster responses, and are less likely to be rate-limited. That’s why some people feel “the desktop app is better than the web version” — it’s not psychological, there’s a real difference.

However, note that the official has never acknowledged this.

2. Better system integration

Can add global hotkeys to wake up anytime (e.g., Cmd+Space)
Doesn’t occupy a browser tab
More timely system notifications
Can float on top of any application

3. Offline features

Some desktop apps support local caching
Can view historical conversations (even offline)
Some features can be used offline

4. Focused experience

Independent window, not disturbed by browser
Can pin the window, use AI while working
Interface may be cleaner

5. More convenient file handling

Drag and drop files to upload
Better integration with local file system
Smoother batch processing
Can directly read screen content (some clients)

Disadvantages of the desktop app

1. Requires installation

Takes up hard drive space
Needs regular updates
May have compatibility issues

2. Features may not be as complete as web version

Some latest features update slower on desktop
Some features may be missing

3. Cross-platform issues

Windows and Mac versions may not be synchronized
Linux support may not be complete

Who is it for?

Heavy AI users
Need to frequently switch between AI and other work
People who like keyboard shortcuts
Those seeking focused experience and higher permissions

Typical scenarios:

Wake up AI for polishing while writing
Quickly query problems while programming
Work that requires AI to stay in the background
Scenarios requiring stable response during peak hours

Fourth: Terminal (Programmer’s Favorite)

First, let’s explain: What is a terminal?

If you’re a regular user, you may have never heard of the term “terminal”. Don’t worry, I’ll explain it in detail.

What is a terminal?

Simply put, a terminal is a tool for operating a computer using text commands.

When you use a computer, you usually click around with a mouse, right? Click a folder to open it, click a button to perform an action, drag windows to adjust positions — this is called a “Graphical User Interface” (GUI).

But before the invention of graphical interfaces, people used typing to operate computers. You enter a command, and the computer executes an action. This method is called “Command Line Interface” (CLI), and the terminal is the window where you enter these commands.

Analogy:

Graphical Interface = Ordering from a menu (look at pictures, click to select)
Command Line/Terminal = Ordering with text (you need to know the dish names and write them yourself)

What does a terminal look like?

A terminal is usually a window with a black (or white) background, with a blinking cursor waiting for you to enter commands. It looks “retro”, a bit like the interface hackers use in movies.

How to open a terminal?

Mac users:

Mac comes with a built-in terminal. There are two ways to open it:

Method 1: Through Launchpad

Click “Launchpad” on the Dock
Find the “Other” folder
Click “Terminal”

Method 2: Through Spotlight search (recommended) 4. Press Cmd + Space to open Spotlight search 5. Type “Terminal” 6. Press Enter to open

Method 3: Through Finder

Open “Finder”
Click the top menu “Go” > “Utilities”
Double-click “Terminal”

Windows users:

Windows also has similar tools called “Command Prompt” or “PowerShell”. The new Windows also has “Windows Terminal”, which is more powerful.

Open Command Prompt:

Press Win + R to open the Run window
Type cmd, press Enter
A black window will open

Open PowerShell:

Right-click the Start menu
Select “Windows PowerShell”

Open Windows Terminal (recommended, requires Win10/11):

Search for “Terminal” in the Start menu
Or download “Windows Terminal” from the Microsoft Store

Differences between terminal and graphical interface

Aspect	Graphical User Interface (GUI)	Terminal/Command Line (CLI)
Operation method	Mouse clicks, drag and drop	Keyboard command input
Learning difficulty	Low, see and do	High, need to remember commands
Operation speed	Average	Very fast once proficient
Suitable scenarios	Daily use	Batch operations, automation
Intuitiveness	Intuitive, what you see is what you get	Abstract, requires imagination
Advanced features	Some features not available	Can do more low-level operations

Example:

Suppose you want to rename 100 files by adding a date prefix:

Using GUI:

Right-click 1st file > Rename > Type > Confirm
Right-click 2nd file > Rename > Type > Confirm
…repeat 100 times

Using terminal:

Enter one command, all done in 2 seconds

That’s why programmers love the terminal — high efficiency, batch operations, automation.

What is it like to use AI in the terminal?

Now that you understand the terminal, let’s talk about how to use AI in it.

You can directly enter commands in the terminal to call AI, for example:

ai "Write a Python function to calculate the Fibonacci sequence"

Then the AI’s response is displayed directly in the terminal, no need to open a browser or wait for a webpage to load.

Current mainstream terminal AI tools:

Claude Code: Official from Anthropic, extremely powerful for programming
ChatGPT CLI: OpenAI’s command-line tool
Various third-party CLI tools

Typical usage of AI in the terminal

# Quick question
$ ai "What's the weather today?"

# Process a file
$ ai "Summarize the content of this file" < document.txt

# Generate code and save to file
$ ai "Write a Bash script to backup files" > backup.sh

# Let AI analyze code
$ ai "Analyze what's wrong with this code" < buggy.py

Advantages of the terminal

1. Extremely fast

No need to open a browser
No need to wait for webpage loading
One command gets it done

2. Automation

Can write scripts for batch processing
Can be combined with other commands
Suitable for repetitive tasks

3. Simple and efficient

No extra interface
Focus on input and output
Suitable for quick queries

4. Programmer-friendly

Can directly process code files
Output can be redirected to files
Seamless integration with development workflow

Disadvantages of the terminal

1. High learning curve

Need to understand basic command-line operations
Not beginner-friendly
Easy to mistype commands

2. Limited functionality

Can only handle text
Cannot handle images, videos
Simple interface, not suitable for reading long texts

3. No conversation history management

Usually one-time Q&A
Inconvenient to review history
Poor multi-turn conversation experience (some tools have improved)

Who is it for?

Programmers, developers
Users who need batch processing
Geeks who love the command line
Scenarios requiring automation

Typical scenarios:

Quickly look up APIs while coding
Batch process file contents
Call AI in automation scripts
Generate Git commit messages

Preview: Later in this series, we’ll cover how to use AI tools (like Claude Code) in the Mac terminal, starting from scratch. Even if you’ve never used a terminal, you’ll be able to learn.

Fifth: IDE Integration (Programming Power Tool)

What is an IDE?

IDE = Integrated Development Environment

In plain English: professional software for writing code.

Common IDEs:

Visual Studio Code (VSCode): The most popular code editor
PyCharm: For Python development
IntelliJ IDEA: For Java development
Cursor: A new generation IDE with built-in AI
WebStorm: For front-end development

Does a regular person need to know about IDEs?

If you’re not a programmer, you can skip this section. But if you:

Want to learn programming
Occasionally need to write some code
Interested in automation

Then it’s still useful to understand AI features integrated into IDEs.

How is AI used in IDEs?

There are two main forms:

1. Plugin form

Install ChatGPT plugin in VSCode
Install GitHub Copilot in PyCharm
Ask AI while writing code

2. Native integration

Cursor: AI built-in from the start
GitHub Copilot: Dedicated AI programming assistant
Use AI as soon as you open the IDE

What can it do specifically?

1. Code completion

You type a few characters, AI automatically completes the entire code block
100 times smarter than traditional code completion

2. Code explanation

Select a piece of code, ask AI “What does this code do?”
AI will explain each line in detail

3. Code optimization

Ask AI “How can this code be optimized?”
AI will give improvement suggestions

4. Bug fixing

When code reports an error, ask AI “How to fix this error?”
AI will analyze the error and provide a fix

5. Code generation

Describe the functionality you want to implement
AI directly generates the code

Advantages of AI integrated into IDEs

1. Seamless workflow integration

No need to switch windows
Ask AI while writing code
Extremely efficient

2. Context awareness

AI can see your entire project
Suggestions are more accurate
Understands your coding style

3. Code quality improvement

Real-time code review
Discover potential bugs
Learn best practices

4. High learning efficiency

Ask about code you don’t understand immediately
Learn while writing
Quickly improve programming skills

Disadvantages of AI integrated into IDEs

1. Only suitable for programming

Not useful for non-programming tasks
Need to know how to code
High learning curve

2. May affect thinking

Over-reliance on AI completion
Not conducive to deep understanding of code
May make people lazy

3. Relatively high cost

GitHub Copilot: $10/month
Cursor Pro: $20/month
Some features require payment

Who is it for?

Programmers, developers
Programming learners
People who need to write scripts
Tech bloggers

Typical scenarios:

Real-time completion while coding
Learning a new programming language
Refactoring old code
Fixing bugs

Comparison Summary: Which One Is Best for You?

Quick comparison table

Usage Method	Convenience	Feature Completeness	AI Permissions	Suitable Scenarios	Learning Curve
Mobile App	+++++	+++	Average	Quick questions anytime, anywhere	Lowest
Web Version	++++	+++++	Average	Most daily use	Low
Desktop App	++++	++++	Higher	Heavy use, focused work	Low
Terminal	+++	+++	High	Automation, batch processing	High
IDE Integration	+++++	+++	High	Programming development	Highest

Recommended combinations

Regular users:

Primary: Web version (full features)
Secondary: Mobile app (use anytime)
Upgrade: Consider desktop app (better experience, higher permissions)

Professionals:

Primary: Desktop app (high efficiency, high permissions)
Secondary: Mobile app (when out)

Programmers:

Primary: IDE integration (programming)
Secondary: Terminal (quick queries, automation)
Backup: Web version (deep conversations)

Students:

Primary: Mobile app (convenient)
Secondary: Web version (homework)
Advanced: Try desktop app

My personal advice

Don’t use just one method!

Each method has its advantages. Switching between them based on the scenario is the most efficient:

Morning commute: Mobile app to listen to AI news
Writing documents at work: Desktop app (faster response)
Need deep conversation: Web version
Coding: IDE integration
Quick queries/automation: Terminal
Chat before sleep: Mobile app

Also, if you’re a paid user, I highly recommend trying the desktop app. Its “hidden benefit” (higher Juice number) might make you feel “the money is well spent.”

Remember: Tools are meant to serve people, just choose the one that feels most comfortable.

Later in this series, we’ll focus on terminal usage, which is also the method I use most often.

Getting Started in the AI Era

Mon, 01 Jan 0001 00:00:00 +0000

Friend, the pace of AI over the past two years has left no room for hesitation.

I’m a trader with 10 years of experience in the stock market, and I don’t know how to code. But starting from early 2024, I began using ChatGPT, and now I use Claude Code daily to read notes in Obsidian, Codex to automate my computer, and Skill to solidify workflows. I’ve gone through all of this from a complete beginner’s perspective—stepping into pitfalls, writing tutorials, and integrating it all back into my workflow.

This book strings together 27 AI tutorials I’ve written over the past year along a single thread. It’s not about technical principles—it’s about how someone who can’t code can actually put these tools to work.

AI tools evolve fast, so…

⚠️ The screenshots, commands, and workflows in this book may differ from the latest versions by the time you read them.

I will continuously revise:

If there are major updates, I’ll sync them to the PDF. Buyers can always contact me for the latest version (or the original Obsidian version).
Ask directly in the Q&A group. I use these tools daily and will follow up on changes as soon as they happen.

How to read

Read by the main thread:

Part 1: Foundations – AI large models, mainstream tools, registration and payment, Markdown—understand what you’ll be using.
Part 2: API – API, tokens, caching—technical concepts you need to get hands-on.
Part 3: Power Tools – Claude Code, Codex CLI, Codex App, and various new features—hands-on with mainstream tools.
Part 4: Advanced – Skill, MCP, Hook + PUA mindset—keys to using AI more deeply.
Part 5: Practice – Bilibili to text, DeepSeek with Claude, Open Minis—concrete, reproducible examples.
Bonus – Heavy tools like N8N—you probably don’t need them.

Read on demand:

Browse the table of contents for the pain points you want to solve most (e.g., how to use Claude Code, how to write a Skill, how to set up an API relay).

Follow along:

Configure things on your own computer as you read—it’s more efficient than reading ten times.

Who this book is not for

❌ Advanced AI users (those who have been using Cursor, Cline, or Aider for over a year).
❌ Those who want an out-of-the-box solution and aren’t willing to spend time configuring tools.
❌ Those expecting a quick fix to make thousands a month with AI after reading.

I’d rather sell fewer copies than waste your money.

Part 1 · Foundations: What AI is and what it can do

Hermes Getting Started: Clipping, Accounting, Reminders, and WeChat

Mon, 01 Jan 0001 00:00:00 +0000

In the previous chapter, we covered Open Minis, which puts an Agent in your phone. This chapter takes a different direction and introduces an Agent that is closer to a “personal assistant”: Hermes.

I wasn’t very optimistic about Hermes at first. After using OpenClaw, I realized I didn’t have that many things I needed it to manage for me, and I didn’t want to use a tool just for the sake of using it.

But after trying it out for a while, I found that Hermes is quite different from the tools I’ve used before.

How Hermes Differs from Other Tools

From my own experience, the main use case for Codex and Claude Code is still writing code. You give them a clear project, a clear bug, a clear requirement, and they go in, modify files, run tests, and fix issues. Their ability in this area is very strong.

Hermes, on the other hand, is more like a personal agent tool that gradually gets to know you, somewhat like a personal assistant.

Its focus is not on completing a single, extremely complex programming task, but on having long-term conversations with you, remembering your preferences, understanding your workflow, and then distilling recurring processes into Skills. The next time you do something similar, it doesn’t start from scratch; it continues to help you with the accumulated experience.

As for OpenClaw, I feel it’s more oriented towards project or team management. It can certainly act as a personal assistant, but it doesn’t give me the feeling of “staying with you in life and work over the long term” like Hermes does.

Of course, this is only my personal impression, not an absolute rule. In fact, any of the three scenarios I mentioned above can be handled with any of these tools; they just differ in how well they fit each scenario.

Tool	What I Prefer to Use It For	Feeling
Codex / Claude Code	Writing code, modifying projects, running tests	Stronger engineering capability, suitable for well-defined programming tasks
Hermes	Long-term personal assistant, WeChat entry, scheduled tasks, memory and Skills	Gets to know you better over time, suitable for those small but recurring personal workflows
OpenClaw	Project management, task breakdown, team collaboration	More like a project/team management agent, not exactly a personal assistant

If I had to sum it up in one sentence:

Codex and Claude Code are more like “I have a project now, come help me do it.” Hermes is more like “First, stay by my side and gradually take over my habits and workflows.”

What I Mainly Use Hermes For Now

I won’t talk about installation first, because for most people, the truly important question is not “how to install it,” but “what can it actually do for me.”

I currently use Hermes for these types of things.

Clipping.

I previously recommended Obsidian’s official Web Clipper, but I don’t use it anymore. Because I just send the webpage directly to Hermes, and it can clip the article into Obsidian for me.

If it’s a video from Bilibili or YouTube, it will download it, send it to AI for speech-to-text, then correct any typos and remove ad content. When I open Obsidian, I see a well-organized article.

Accounting.

Many people used Shortcuts for accounting before, and I still use it as one of my methods, but I really don’t like debugging Shortcuts—it’s too tiring.

Now I just send the accounting details directly to it in a WeChat chat, and it immediately writes them into Notion. But I should mention that I built a small platform myself; both Shortcuts and Hermes send commands to my platform.

Of course, there’s also a local version of this accounting feature that doesn’t require Notion. I’ll write a dedicated article about that later.

Writing WeChat articles.

Writing a WeChat article involves nearly 13 steps, including topic selection, handwriting, editing, publishing, and more. Now I delegate all these processes to Hermes to handle step by step.

Also, although I previously introduced Claudian, a great Obsidian AI tool, I actually use Hermes to operate Obsidian.

Setting reminders.

I’m a heavy user of TickTick, I can’t do without it every day, but setting up tasks in TickTick is quite troublesome.

Especially when your tasks involve specific weeks months later, or every few months on Wednesdays and Thursdays, setting up such tasks requires several clicks. Now I can just send natural language to Hermes and have it set them up in TickTick in the background.

Daily reports.

Every morning at 7:30, I have it send me a news report of the past 12 hours. Also, I work as a stock trader, so after the market closes each day, I have it compile market information and create a trading daily report.

Various other small tasks.

This is actually where Hermes shines.

Many things individually are small, not worth writing a program for, or opening a complex software. But they recur daily, weekly, monthly, and gradually become a drain.

That’s the value of Hermes: it doesn’t just help you complete a task once; it gradually takes over these recurring small processes.

Why DeepSeek V4 Flash and Hermes Are a Great Match

After DeepSeek V4 came out recently, I found that DeepSeek V4 Flash and Hermes are a perfect match.

The reason is simple: many tasks in Hermes don’t require Opus-level intelligence. It’s not necessarily solving extremely complex programming problems; it’s more about clipping, organizing, reminding, querying, archiving, and calling tools.

What these tasks need is not “the smartest model pondering for a long time every time,” but speed, low cost, and the ability to run long-term.

The actual experience with DeepSeek V4 Flash feels like it’s scrolling the screen; my reading speed can’t keep up with its output speed. Its intelligence is certainly not as high as Opus 4.7, but it’s more than enough for Hermes.

That’s why I recommend it now: Hermes is a long-term online personal assistant, and model cost and response speed directly affect whether you’re willing to actually use it.

Installation and Configuration

If you just want to get Hermes running, the minimal path is three steps:

Install Hermes.
Configure the model.
Set up the WeChat or Feishu entry.

You can learn about commands, memory, Skills, and scheduled tasks later when you need them.

As usual, installing Hermes is a one-liner. I’ll demonstrate on a Mac.

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

After installation, you can start it by typing hermes anywhere in the terminal. Note that unlike Claude Code or Codex, whether you start it or not, it actually runs in the background on your computer.

Oh, and if you’ve used OpenClaw before, Hermes thoughtfully provides a seamless migration command. Just enter this. Just mentioning it.

hermes claw migrate

If you didn’t migrate, you’ll need to set up Hermes initially.

hermes model

This step asks you to fill in an AI provider. I recommend DeepSeek; the red box highlights the corresponding option. The top one is the official DeepSeek. Just enter your API Key and select DeepSeek V4 Flash.

The red box below contains OpenCode Zen and OpenCode Go, which I’ve introduced before.

The Go plan is a usage method I recommend. For $10 a month, you get $60 worth of credits, and you can pay with Alipay and connect directly from China. If you use DeepSeek V4 Flash, you’ll never run out.

Of course, the most recommended now is OpenCode Zen, because it offers limited-time free DeepSeek V4 Flash. Free is always best.

Next, let’s configure WeChat so you can communicate with it from WeChat. Similarly, you can also configure Feishu.

hermes gateway setup

Taking WeChat as an example, after you select it, a QR code will appear, and you can scan it with your phone. I’ve already configured it, so I can’t demonstrate and will skip it.

After successful configuration, you’ll have a chat window in WeChat where you can communicate directly. The most important command is /new, which lets you start a new conversation. If your previous conversation has gone on for a long time, you can use this to switch to a new one.

Specific Usage

Once we have the above two steps configured, we can use it in the terminal.

Just type hermes in the terminal to start. The difference from Codex and Claude Code is that you don’t need to enter a specific directory; you can type it anywhere in the terminal. You’ll always enter the same Hermes instance.

I should mention that there’s an ID here; you can retrieve this conversation later and continue chatting using this unique ID.

For example, my ID here is 20260514_224631_850142. Later, I can just type hermes -r 20260514_224631_850142 anywhere in the terminal to resume this conversation and continue chatting.

As for how to find the needed ID among many conversations, we’ll cover that later, not in this chapter.

Now back to the topic, let’s first talk about a few important commands.

The first is /new, which lets you start a new conversation. Although Hermes has a built-in memory system that helps it look up historical conversations, discussing different topics in the same conversation can still degrade the model’s performance. So I recommend finishing one topic thoroughly before starting a new conversation.

The second command is /reasoning. It manages reasoning-related settings, including your reasoning level and whether to display the reasoning process.

My personal habit is to hide the reasoning process. For DeepSeek V4 Flash, I set the reasoning level to xhigh.

So we enter /reasoning hide and /reasoning xhigh respectively.

After doing this, you can chat happily with it below.

What’s unique about Hermes is that after you chat, it internally organizes memories about you, learning your preferences and inclinations. Additionally, some of your operations will be automatically organized into Skills, and it will modify these Skills based on your actions.

Unlike OpenClaw or Claude Code, where you often have to actively ask it to create a relevant Skill, Hermes is more like it gradually learns your workflows over long-term use.

Who Should Use Hermes

If you just want AI to help you write some code, I think you can continue using Codex or Claude Code.

But if you have many recurring small processes, such as clipping, accounting, reminders, daily reports, organizing materials, writing WeChat articles, syncing Obsidian, then the value of Hermes becomes apparent.

It doesn’t just help you complete a task once; it gradually becomes a backend assistant that understands you better and better.

Of course, there’s a prerequisite for this type of tool: you have to accept it running long-term on your computer and gradually accessing your notes, chat entry points, and workflows.

So I suggest not taking on too much at the beginning. Start with low-risk scenarios like clipping and reminders. Once you confirm it can reliably help you, gradually hand over more complex processes.

About Programming

I want to specifically mention here that although Hermes can also do programming work, it is not a replacement for Codex.

I used the same GPT-5.5 model with reasoning set to High, and had both Hermes and Codex do the same task. Codex was significantly stronger.

That’s normal. Codex is positioned as a programming agent; it’s better suited for diving into a project to read code, modify code, run tests, and fix issues. Hermes’s advantage is not “strongest single-session programming ability,” but “can serve as your long-term personal entry point and command center.”

So my approach is not to replace Codex with Hermes, but to have them work together.

I have two methods here:

Hermes can directly call Codex from the terminal, so you can have it hand off tasks to Codex and then review the results itself.
I manually start Codex and have Hermes write a handoff file. After each AI performs its operations, they modify the handoff file for the other to read.

I’ve heard that some people even have Hermes operate OpenClaw, since they each have their own focus.

As for that, it depends on whether I’ll start using OpenClaw again. But for now, I feel Hermes is sufficient. If I do that later, I’ll write another article.

Summary

What We Learned in This Chapter:

Hermes’s Positioning: It is not a replacement for Codex or Claude Code; it’s more like a long-term online personal assistant that gradually gets to know you.
Suitable Scenarios: Recurring small processes like clipping, accounting, reminders, daily reports, WeChat article workflows, and Obsidian organization are best suited for Hermes.
Model Selection: Many tasks in Hermes don’t require the strongest model; they need speed, low cost, and long-term sustainability, so models like DeepSeek V4 Flash are very suitable.
Minimal Onboarding Path: Install Hermes, configure the model, then set up the WeChat or Feishu entry, and you can get started.
Usage Habits: Use /new to separate different tasks, use /reasoning to adjust reasoning settings, and use conversation IDs to retrieve past conversations.
Programming Boundaries: Hermes can do programming, but it’s not the strongest programming agent. It’s better to use it as a command center, letting it hand off clear programming tasks to Codex, with Hermes reviewing and connecting the results.

Key Takeaways:

Hermes’s value is not its single-task capability, but its long-term companionship and process accumulation.
It is suitable for taking over fragmented, repetitive, cross-tool small tasks.
If you want a personal assistant that remembers habits, accumulates Skills, and can be called upon anytime from WeChat, Hermes is closer to this form than a pure programming tool.

Bonus: For Those Eager to Take It to the Next Level

How to Call an API and Choose an API Platform

Mon, 01 Jan 0001 00:00:00 +0000

We’ve covered core concepts like API, Token, and Temperature. Now it’s time for the practical part: How to actually call an API?

Many people think APIs are mysterious, but once you grasp a few key elements, calling an API is as simple as online shopping. This chapter will guide you step by step.

Three Core Elements of Calling an API

No matter what tool or platform you use, calling an AI API requires these three things:

1. API Key

API Key = Your ID

Just like you need a bank card PIN to withdraw money, calling an API requires an API Key to prove “This is me, you can serve me.”

What does an API Key look like?

It’s usually a long string of letters and numbers, for example:

sk-REPLACE_WITH_YOUR_API_KEY

Important Reminder:

API Keys are private; do not share them with others.
If someone gets your key, they can use your account to call APIs (spending your money).
If you accidentally leak it, immediately delete the old key on the platform and generate a new one.

2. Base URL

Base URL = The restaurant’s address

When you order food delivery, you need to know where the restaurant is. When calling an API, you need to know where the server is.

Common Base URLs:

OpenAI: https://api.openai.com/v1
Anthropic Claude: https://api.anthropic.com/v1
Google Gemini: https://generativelanguage.googleapis.com/v1
DeepSeek: https://api.deepseek.com/v1

Third-party platforms have different URLs, but the format is similar.

3. Model Name

Model Name = The dish you want to order

At a restaurant, you say “I want braised pork.” When calling an API, you say “I want to use GPT-5.2.”

Common Model Names:

OpenAI: gpt-5.2, gpt-5.2-chat-latest
Claude: claude-opus-4.5, claude-sonnet-4.5
Gemini: gemini-3-pro, gemini-3-flash
DeepSeek: deepseek-chat, deepseek-coder

A Complete API Call Example

Combine these three things, and the simplest API call looks like this:

import openai

# 1. Set the API Key
openai.api_key = "sk-proj-YOUR_API_KEY"

# 2. Set the Base URL (if you use a third-party platform)
openai.base_url = "https://api.openai.com/v1"

# 3. Call the selected model
response = openai.chat.completions.create(
    model="gpt-5.2",  # Model Name
    messages=[
        {"role": "user", "content": "Hello"}
    ]
)

print(response.choices[0].message.content)

Looks complicated? Don’t worry, the platforms introduced later have simpler methods.

Official API vs Third-Party Platforms

Before introducing specific platforms, let’s clarify an important concept: What is the difference between official APIs and third-party platforms?

Official API

Official API = Buying directly from OpenAI, Anthropic, Google

Advantages:

Best stability, direct connection to official servers
Full features, new features supported immediately
Highest security, data does not pass through third parties

Disadvantages:

Requires a foreign credit card
Requires a VPN to access (ChatGPT, Claude, Gemini)
Relatively higher prices
Registration may have barriers

Third-Party Platforms

Third-Party Platforms = Buying from resellers

Third-party platforms first buy API quotas from official sources and then resell them to you.

Advantages:

Supports domestic payments (Alipay, WeChat Pay, UnionPay)
No VPN required
Usually have Chinese interface and customer service
One platform can call multiple AIs (OpenAI, Claude, Gemini, etc.)
Some platforms offer free credits

Disadvantages:

Stability may not be as good as official
Prices may be slightly higher than official (but some are cheaper)
Security requires trusting the platform
Feature updates may lag behind official

Which Should You Choose?

Choose official if you:

Have a foreign credit card
Have a stable VPN
Value data security
Need the latest features

Choose third-party if you:

Don’t have foreign payment methods
Don’t have a VPN
Want to use domestic payments
Want to call multiple AIs from one platform

Platform Recommendations (2 Domestic + 2 International)

Below are four API platforms I recommend, two domestic and two international, covering different needs.

1. DeepSeek Official (Domestic, Official Platform)

Website: https://platform.deepseek.com

Platform Type: Official Platform

Why Recommend?

Official platform, stable and reliable
DeepSeek V3.2 performance is close to GPT-5
Fast access in China, no VPN needed
Simple registration, just a phone number
Extremely low price, great value

Steps to Get API Key:

Open https://platform.deepseek.com
Click “Login/Register” in the top right corner
Register an account with your phone number
After logging in, click “API Keys” on the left
Click “Create API Key”
Copy the key (it is only shown once, so save it)
Click “Interface Documentation” on the left to view the URL and model name

Call Parameters:

Base URL: https://api.deepseek.com
Model Name: deepseek-chat (chat), deepseek-reasoner (reasoning)
API Key: The key you just copied

2. Volcano Engine (Domestic, Official Platform + Third-Party)

Website: https://console.volcengine.com/ark

Platform Type: Official Platform (under ByteDance)

Why Recommend?

ByteDance official platform, stable and reliable
Supports Doubao series models
Supports domestic payments (Alipay, WeChat Pay, UnionPay)
Affordable, great value
Besides Doubao’s own models, you can also call many domestic open-source models like DeepSeek V3.2, GLM 4.7

Usage Steps:

Open https://console.volcengine.com/ark
Register a Volcano Engine account with your phone number
Enter the “Ark Large Model” console
Complete real-name authentication (requires ID)
Click “API Key Management”
Create a new API key
Copy and save the key
Click “Activation Management” on the left, select the model you want to use
On the new page, copy the model name you need (note: the same model may have different names on different platforms, so check carefully)
Go back to the Activation Management page, check if the status is “Activated”, otherwise click on the right to activate model permissions

Call Parameters:

Base URL: https://ark.cn-beijing.volces.com/api/v3
Model Name: doubao-pro-32k, doubao-lite-32k, etc.
API Key: The key you created

New User Benefits:

Free credits upon registration
You can also participate in the activity shown above the screenshot to get more free credits. I have more than enough every day.

3. Google AI Studio (International, Official Platform)

Website: https://aistudio.google.com

Platform Type: Official Platform

Why Recommend?

Google official platform
Free credits available (with limits)
Gemini 3 top-tier performance
Stable and reliable
Supports extremely long context (2 million tokens)
Can be used for free directly in the web interface, no coding required

Also, How to Use the Web Version for Free

If you don’t want to write code, Google AI Studio offers a very convenient web chat interface where you can directly use models like Gemini 3 Pro and Gemini 3 Flash. It’s essentially like being a paid Gemini user.

Usage Steps:

Open https://aistudio.google.com
Log in with your Google account (VPN required)
Click “Playground” on the left
In the top right, select a model:
- gemini-3-pro: Best model, suitable for complex tasks
- gemini-3-flash: Fast model, suitable for daily conversations
- Other experimental models available
Type your question directly in the input box, then click “Run”, and the AI will answer

Advanced Features (Web Version):

1. Upload Files

Click the + icon on the right side of the input box
You can upload images, PDFs, documents, etc.
Supports multimodal understanding

2. Adjust Parameters

On the right, you can adjust the parameters introduced earlier
You can adjust:
- Temperature (creativity)
- Top P
- Max output tokens
- Safety settings

Advantages of the Web Version:

No coding required
No software installation needed
Use directly in the browser
User-friendly interface, full features
Suitable for quick testing and daily use

Who is the web version for?

Complete beginners who can’t code
Those who want to quickly test Gemini’s capabilities
Daily chatting and asking questions
Handling multimodal tasks like documents and images

Get API Key (For Advanced Users)

Back to the main topic, here’s how to get an API Key.

Steps to Get API Key:

On the AI Studio page, click “Get API Key” on the left
Click “Create API Key”
Create and copy the generated API Key
Go back to Playground, select and copy the model name on the right

Call Parameters:

Base URL: https://generativelanguage.googleapis.com/v1beta
Model Name: gemini-3-flash-preview
API Key: The key you copied

Free Tier Limits

Important note! Google AI Studio uses the free tier by default, with the following limits (as of January 2026), and these limits are subject to change:

Requests per minute (RPM): 15
Requests per day (RPD): 1500
Tokens per minute (TPM): 1 million tokens

See detailed limits at: https://ai.google.dev/gemini-api/docs/rate-limits?hl=en

Is the free tier enough?

Web chat: More than enough
Occasional API calls: Sufficient
Heavy automated calls: May not be enough

How to Remove Limits? Link Your Cloud Credits

Google Cloud offers $10 in free credits to new users. After linking it to AI Studio, you can unlock higher limits. For details on how to set up a Google Cloud account, search for “Google Cloud free credits” online—there are many tutorials. We won’t cover that here.

Linking Steps:

In AI Studio, go back to the API interface and click “Set up billing”
Link the Google Cloud billing account you created earlier

Benefits after linking:

Rate limits significantly increased (RPM up to 1000+)
Free credits still valid
$10 can last a long time with the powerful flash model
Both web version and API enjoy higher quotas

4. OpenRouter (International, Third-Party Platform)

Website: https://openrouter.ai

Platform Type: Third-Party Platform

Why Recommend?

One platform to call all major AIs (GPT, Claude, Gemini, etc.)
Transparent pricing, sometimes cheaper than official
Supports Alipay payment (friendly for Chinese users)
Supports credit card and cryptocurrency payments
Free models available for trial
Can call almost every available model
Rankings are convincing

Steps to Get API Key:

Open https://openrouter.ai
Click “Sign In” in the top right corner, log in with Google or GitHub
After logging in, click your avatar in the top right corner and select “Keys”
Click “Create Key”
Give the key a name and click create
Copy the generated key
Search for the model you want in the search box, then copy the name

Call Parameters:

Base URL: https://openrouter.ai/api/v1
Model Name:
- GPT-5.2: openai/gpt-5.2
- Claude Opus 4.5: anthropic/claude-opus-4.5
- Gemini 3 Pro: google/gemini-3-pro
- Free model: meta-llama/llama-3.1-8b-instruct:free
API Key: The key you created

Top-up Methods:

Alipay (most convenient)
Credit card
Cryptocurrency (USDC, etc.)

Price Advantage:

Some models are 10-20% cheaper than official
Transparent pricing, see prices directly on the website
Different providers compete, you choose the cheapest

Free Options:

Some models are completely free (marked with :free)
New users get free credits to try
You can test with free models first

Model Rankings

On the Rankings page, you can see the platform’s model call data; the rankings are very convincing.

Other Free Platforms

Due to space limitations, here are a few other platforms you can use for free:

Cerebras (Ultra-Fast Inference)

Website: https://cloud.cerebras.ai

Features:

Extremely fast inference (claims to be the fastest in the world)
Offers free Llama model calls
Simple registration, just log in with GitHub

NVIDIA NIM (NVIDIA Official)

Website: https://build.nvidia.com

Features:

NVIDIA’s official AI platform
Offers multiple free models
Suitable for testing and development

Both platforms offer free credits. If you’re interested, you can sign up and try them out.

Summary

Three Core Elements:

API Key
Base URL
Model Name

Four Recommended Platforms:

DeepSeek Official (Official) - Best low-cost choice in China
Volcano Engine (Official + Third-Party) - Domestic platform, can call most domestic open-source models
Google AI Studio (Official) - Best free choice internationally (with Cloud Credits), can be used directly in the web
OpenRouter (Third-Party) - All-in-one platform, supports Alipay

Let Codex and Claude Control Your Computer

Mon, 01 Jan 0001 00:00:00 +0000

In previous chapters, we covered several new features from Anthropic. Meanwhile, OpenAI, though yet to release a new model (long teased), has also been active. One notable update is that Codex now supports controlling your computer, and it does so in a different way.

I tried both Codex and Claude Code’s computer-use features. I asked the AI to send a WeChat message for me. Codex succeeded, while Claude not only failed but also logged me out of my WeChat account.

I’ll first describe the setup and testing process for both, and then explain why there’s such a difference.

Codex Setup and Usage Experience

I used the Codex desktop app. The entry is in its “Settings”. First, click “Computer Use” in the left menu, then check the Computer Use plugin on the right.

Then go back to the chat interface and give Codex a task, like “Open Obsidian, create a new file, and set the title to ‘This was done by Codex app auto-control’.”

After pressing Enter, Codex will first pop up a permission request asking if you want to allow it to control Obsidian. Click “Allow”. If the software is low-risk, you can also check “Always Allow” on the left.

If you’re enabling Computer Use for the first time, a Mac system-level authorization dialog will appear, requesting Accessibility and Screenshots permissions. Click Allow for both.

After clicking “Allow”, the page will redirect. If “Codex Computer Use” is not in System Settings, drag the icon from the banner below the popup to the list above. If it’s already there, just toggle it on. Remember to Allow both.

Once permissions are set, Codex will open Obsidian, create a new file, and write the title. It finishes quickly, and the title is exactly as requested.

Next, let’s step it up: ask Codex to operate WeChat and send a message to a contact.

After starting, you can see a small blue mouse cursor with a shadow moving slowly on the screen — that’s Codex in action. This detail will be useful later, so keep it in mind.

After composing the message, it pauses for me to confirm. I reply “Send”, press Enter, and the message goes out.

The entire process had no errors. WeChat worked normally during Codex’s operation, and the account didn’t get logged out.

Claude Setup and Usage Experience

For Claude, I used the Claude Code terminal version. In the terminal, type /mcp and enable the built-in computer-use option.

Ask Claude to do the same thing. First, try Obsidian to write a file — this test passed, just like Codex, so I won’t include a screenshot.

Then try WeChat.

Seconds after sending the task, problems arose. Claude failed to operate WeChat; several clicks didn’t work, and WeChat detected it, logging me out!

It wasn’t just a task failure. WeChat detected abnormal operation, triggered risk control, and forced me to re-login.

Why Codex Works and Claude Doesn’t

I initially thought Claude’s computer-use was unstable. Then I looked back at the Codex screenshot — remember that small blue mouse cursor with a shadow? The answer is right there.

The implementation mechanisms are different.

When Codex operates, it actually moves the mouse cursor to the target position and then clicks. You can see the cursor’s movement trajectory on the screen — move over, pause, then click — which is essentially the same event sequence as a human using a mouse.

Claude takes a different approach. It directly synthesizes a “click at coordinates” event and sends it to the target window. The cursor doesn’t move at all; it clicks instantly. This method is fast and doesn’t require waiting for the cursor to move, but it has a very distinct signature for applications — a “mouse click” with no movement trajectory that teleports to coordinates, which a human hand cannot produce.

Codex: Simulates real mouse movement, so applications can’t tell it’s AI. Claude: Directly synthesizes click events, which apps with anti-cheat like WeChat can easily detect.

Regular desktop applications don’t mind either method, so Claude works fine with Obsidian. But apps like WeChat, which have account security systems, actively scan for automation characteristics. Once detected, they trigger risk control — which is what my “For your account security, please re-login” screenshot showed.

Anthropic’s current computer-use implementation follows the synthetic event route. The advantage is speed; the disadvantage is that it can’t fool applications that actively detect automation.

Usage Recommendations

Let’s break it down by use case:

Use Codex for: Operating software with built-in anti-automation detection, such as WeChat, QQ, online banking, enterprise IM, and games. Codex’s real mouse approach is the only choice here.

Use Claude for: Operating regular desktop applications — Obsidian, Notepad, Finder, design software, etc. These apps don’t care if you’re using a real mouse, and Claude is faster since it doesn’t need to wait for cursor movement, making it more efficient.

I’ve tried it for you. The result is your account gets forcibly logged out, requiring a re-scan to log in. The cost is small but annoying.

Overall, my personal feeling is that the computer control feature is a bit of a show-off. I haven’t actually found a real reason to use it yet. It’s promising for the future, though.

So this chapter is just a brief introduction to the feature.

Part 4: Advanced Techniques: Skill / MCP / Hook + Mindset

Markdown: The Universal Language for Talking to AI

Mon, 01 Jan 0001 00:00:00 +0000

This chapter shifts to a lighter topic: something you probably use every day but might not know the name of: Markdown.

Let me start with a bold claim:

Markdown is the single most important format you should learn in the AI era.

Why? Read on.

What is Markdown?

In one sentence: Markdown is a way to write plain text with formatting controlled by symbols.

Plain text has no formatting—no headings, no bold, no lists. On the other hand, rich text formats like Word are too heavy: they require special software to open and produce large files.

Markdown is the “just right” middle ground: with a few simple symbols, you can add formatting to plain text.

For example, if you write:

# This is a heading
**This is bold**
- This is a list

It displays as a formatted heading, bold text, and a list. Simple as that.

Why You Must Learn Markdown in the AI Era

Reason 1: AI Speaks Markdown

Have you noticed that when ChatGPT, Claude, Gemini, and other AIs reply to you, they automatically include bold text, headings, lists, and code blocks?

That’s Markdown.

AI doesn’t output Word documents or PDFs. Its default output format is Markdown. Every table, bold text, and code block you see in this tutorial—all Markdown.

Not learning Markdown is like talking to someone but not understanding the words they write. Can you still communicate? Yes. But it’s far less efficient.

Reason 2: It’s Everywhere

Markdown isn’t a proprietary format for a specific piece of software; it’s a universal standard. The number of tools that support Markdown is countless:

Category	Software/Platform
Note-taking	Obsidian, Notion, Typora, Bear
Code Platforms	GitHub, GitLab, Bitbucket
Blogging Systems	Hugo, Jekyll, Hexo
Documentation Tools	Confluence, Feishu Docs, Yuque
AI Tools	ChatGPT, Claude, Gemini, Claude Code, Codex

Learn one format, use it everywhere. Notes you write in Obsidian keep their formatting when copied to GitHub. Throw them at an AI, and it understands perfectly. Try that with Word?

Reason 3: Incredibly Small Files

This might surprise you: For the same content, a Markdown file is over 20 times smaller than a Word file.

Why? A Word .docx file is essentially a compressed archive of XML files, stuffed with style definitions, font information, and document properties. Even if you write just one line, the file is tens of KB.

Markdown is plain text. The file size equals the amount of text you write. No extra baggage.

This is especially important in AI scenarios. When you send a document to an AI for analysis, Markdown consumes fewer tokens, processes faster, and costs less. All those XML tags and style definitions in a Word file get counted as tokens, wasted.

Reason 4: AI Understands Markdown Better

Many people don’t know this.

If you give an AI a Word document, it first has to convert it to text. During conversion, formatting can be lost, tables can be misaligned, and images disappear.

Give an AI a Markdown file, and it reads it directly. Markdown is plain text itself—no conversion needed, zero loss.

More importantly, Markdown symbols (headings with #, lists with -, code with ```) inherently tell the AI, “this is a heading, this is a list, this is code.” The AI can understand your content structure more accurately.

Learn Markdown in 10 Minutes

There are only about a dozen Markdown syntax elements, and even fewer are needed for daily use. Below, they are ordered by frequency of use, starting with the most common.

1. Headings

Use # followed by a space. The number of # symbols indicates the heading level:

# Heading 1 (largest)
## Heading 2
### Heading 3
#### Heading 4

For daily use, up to level 3 is enough.

2. Bold and Italic

**Bold text**
*Italic text*
***Bold and italic text***

Bold is used most often, italic occasionally.

3. Lists

Unordered lists use - or *:

- Item 1
- Item 2
- Item 3

Ordered lists use numbers followed by a period:

1. First step
2. Second step
3. Third step

Lists can be nested by adding two spaces before the sub-item:

- Main item
  - Sub-item
  - Sub-item

4. Code

Inline code uses single backticks:

Type `claude --help` to see help

Result: Type claude --help to see help

Code blocks are wrapped with three backticks, and you can specify the language:

```python
print("Hello World")
```

This is especially useful when communicating with AI. When sending code to an AI, wrap it in a code block so the AI can more accurately identify the code boundaries.

5. Links and Images

[Link text](https://example.com)
![](https://example.com/image.png)

Images are just links with a ! in front.

6. Blockquotes

Start with >:

> This is a blockquote.
> It can span multiple lines.

Result:

This is a blockquote. It can span multiple lines.

7. Tables

| Column 1 | Column 2 | Column 3 |
|----------|----------|----------|
| Content  | Content  | Content  |
| Content  | Content  | Content  |

Table syntax looks complex, but you don’t need to write it by hand. Just ask the AI to generate it for you. Say “organize this data into a table,” and the AI will output a Markdown table.

8. Horizontal Rules

Three or more - on a single line:

---

Used to separate different sections of an article.

9. Strikethrough

~~Deleted text~~

Result: ~~Deleted text~~

That’s Enough, Really

The 9 syntax elements above cover 99% of daily use cases.

You don’t need to master Markdown. Headings, bold, lists, and code blocks—master these four and you can handle most situations. Look up the rest when needed.

And Markdown has one advantage: It’s okay if you can’t remember it all now; you’ll learn it by using it. AI outputs Markdown, so as you read AI responses every day, you’ll naturally become familiar with these symbols.

How to Use Markdown to Improve Communication with AI

After learning Markdown, here are a few tips to make your conversations with AI more effective:

Tip 1: Use headings to structure your input

# Background
I’m working on a blog project...

# Requirements
Help me implement the following:
1. Article list page
2. Article detail page

# Constraints
- Use Hugo framework
- No database needed

Much better than a big block of text. With headings, the AI can more accurately understand the structure of your request.

Tip 2: Wrap code in code blocks

Don’t just paste code directly; wrap it in a code block:

Help me check what’s wrong with this code:

```python
def hello()
    print("hello")
```

The AI can precisely distinguish between your words and the code.

Tip 3: Use lists to enumerate requirements

Write an article for me with the following requirements:
- Around 1000 words
- Conversational style
- Divided into three sections
- Each section has a subheading

Much clearer than “Write me an article around 1000 words conversational style divided into three sections each with a subheading.”

Where to Practice?

You don’t need to find a specific place to practice. If you’re using Claude Code or Codex as you follow this tutorial, you’re using Markdown every day—you just didn’t know its name.

If you want a dedicated place to write Markdown, here are a few recommendations:

Tool	Features
Obsidian	Free, local storage; the author’s other book “Obsidian Handbook” covers it in detail
Typora	WYSIWYG, best Markdown writing experience, paid
VS Code	Free, install a preview extension and you’re good to go
Online Editors	Search for “Markdown online editor” and start using immediately

Beginners are recommended to use Obsidian. It’s free, easy to use, and works well with AI. If you want to dive deeper, check out the author’s other book, “Obsidian Handbook.”

Summary

What you learned today:

What Markdown is: A way to write plain text with formatting controlled by symbols, over 20 times lighter than Word
Why learn it in the AI era: AI outputs Markdown, it’s everywhere, files are small, AI understands it better
Core syntax (4 are enough): Headings #, bold **, lists -, code blocks ```
Complete syntax (9 cover 99%): Plus links, images, blockquotes, tables, horizontal rules
Tips for communicating with AI: Use headings to structure, wrap code in code blocks, use lists for requirements

Key takeaways:

Markdown is the “native language” of AI; learning it means learning to communicate efficiently with AI
Learn the basics in 10 minutes, look up the rest when needed
No need to practice deliberately; you’ll pick it up naturally while using AI

Part 2: API and Tokens: The Technical Core

MCP: What It Is and How to Use It

Mon, 01 Jan 0001 00:00:00 +0000

In the previous chapter, we learned about Skills—turning common operations into one‑click shortcuts. But have you ever wondered:

Can AI directly operate my browser? Can it read and write my notes? Can it query my database?

The answer is: Yes, but you need to equip AI with “plugins”.

This “plugin system” is what we call MCP.

A Quick Look at the Trend

Many of MCP’s features are being natively absorbed by Claude Code and Codex CLI.

For example, in the early days you needed to install a Web Search MCP to let AI search the web; now both Claude Code and Codex have built‑in web search. File read/write, Git operations, and many other capabilities are also built‑in. The Skills we covered earlier also replace some MCP scenarios—many standardized tasks that previously required MCP can now be done with Skills.

But that doesn’t mean MCP is useless. On the contrary, MCP still has irreplaceable value:

Connecting proprietary systems: Your company’s internal databases, private APIs—these can never be built‑in and can only be accessed via MCP.
Operating third‑party software: Controlling a browser, managing Obsidian, handling Notion notes—scenarios that require deep interaction with external software are where MCP is the only choice.
Community ecosystem: The MCP marketplace has thousands of community‑contributed servers covering all kinds of scenarios you might not have imagined.
Customizability: You can write your own MCP server to let AI access any system you want.

Simply put: built‑in features cover 80% of common needs, while MCP handles the remaining 20% of personalized needs—and that 20% is often where the real difference is made.

What is MCP?

In a Nutshell

MCP = Model Context Protocol = AI’s plugin system

MCP is an open protocol introduced by Anthropic (the creator of Claude) that allows AI tools to connect to external systems.

Why Do We Need MCP?

Consider this scenario:

Without MCP:

You: Open Baidu and search for "today's weather"
AI: Sorry, I can't access the browser. I can only process text…

With MCP:

You: Open Baidu and search for "today's weather"
AI: Sure, I've opened the browser, searched for "today's weather", and here are the results…

What’s the difference? AI goes from “can only talk” to “can take action”.

An Analogy

AI itself = a brilliant brain

It knows everything, but has no hands or feet.
It can tell you how to do something, but can’t do it for you.

MCP = connecting hands and feet to that brain

Connect the “browser hand”: AI can automatically operate web pages.
Connect the “file system hand”: AI can read and write your files.
Connect the “database hand”: AI can query and modify data.
Connect the “Obsidian hand”: AI can directly manage your notes.

Another analogy:

AI = a super‑smart chef
MCP = equipping the chef with a full kitchen (pots, pans, oven, blender…)
Without MCP: the chef can only recite recipes.
With MCP: the chef can actually cook for you.

Comparison from Earlier

In the previous chapter we compared prompts, Skills, and MCP:

Prompts → The most basic interaction method (verbal instructions)
    ↓
Skills → Encapsulate prompts + simple logic (shortcuts)
    ↓
MCP → Skills + the ability to connect to external systems (connecting the world)

MCP is the most powerful of the three because it breaks down AI’s “walls” and allows it to reach the outside world.

How MCP Works

You don’t need to dive into technical details—just understand this diagram:

You ←→ Claude Code/Codex ←→ MCP Server ←→ External System
         (AI Tool)           (Bridge)      (Browser/Database/Notes, etc.)

Three roles:

Role	Description	Example
AI Tool (Client)	The coding assistant you use	Claude Code, Codex CLI
MCP Server	The bridge between AI and external systems	Playwright MCP, GitHub MCP
External System	The target AI operates on	Browser, GitHub, Obsidian

All you need to do is install an MCP server in your AI tool, and then the AI can operate the corresponding external system.

It’s as simple as installing an app on your phone.

Where to Find MCP Servers

There are many MCP servers out there. How do you find the one you need? Here are the main “MCP marketplaces”:

1. mcp.so (Recommended)

URL: https://mcp.so

This is currently the most comprehensive directory of MCP servers, like the “App Store for MCP”.

Features:

Thousands of MCP servers listed
Detailed descriptions and installation guides
Search and category browsing
Chinese‑friendly

How to use:

Open the website.
Search for the functionality you want (e.g., “playwright” or “browser”).
Find the corresponding MCP server.
Follow the installation instructions on the page.

2. Smithery

URL: https://smithery.ai

Features:

Try some MCP servers online directly.
One‑click installation commands.
API Key hosting.

3. GitHub awesome-mcp-servers

URL: https://github.com/punkpeye/awesome-mcp-servers

Features:

Community‑maintained list of MCP servers.
Open source and free.
Frequently updated.

4. Official MCP Servers

Major companies like Anthropic and Microsoft have also released official MCP servers:

MCP Server	Function	Maintainer
Playwright MCP	Browser automation	Microsoft
GitHub MCP	GitHub operations	GitHub
Context7 MCP	Get latest documentation	Community
Notion MCP	Note management	Notion

Recommendation: Beginners should start with mcp.so, search for the functionality you need, and follow the installation guide.

How to Install MCP

The installation method differs slightly between Claude Code and Codex CLI. Here’s how to do it for each.

Installing MCP in Claude Code

Method 1: Command Line (Recommended)

Claude Code provides a dedicated MCP management command—one line does it all:

claude mcp add playwright npx '@playwright/mcp@latest'

This command means:

claude mcp add : Add an MCP server.
playwright : The name you give this MCP (you can choose any name).
npx '@playwright/mcp@latest' : The command to start the MCP server.

Verify the installation:

In Claude Code, type /mcp to see the list of installed MCP servers.

Method 2: Edit the Configuration File

You can also directly edit Claude Code’s configuration file to add MCP.

Configuration file path: ~/.claude.json

Add the mcpServers section:

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@playwright/mcp@latest"]
    }
  }
}

Save and restart Claude Code.

Installing MCP in Codex CLI

Codex CLI’s MCP configuration is in the ~/.codex/config.toml file.

Edit config.toml

Add the following at the end of the file:

[mcp_servers.playwright]
command = "npx"
args = ["@playwright/mcp@latest"]
startup_timeout_sec = 60.0

Parameter explanation:

Parameter	Description
`command`	The command to start the MCP server
`args`	Command arguments
`startup_timeout_sec`	Startup timeout in seconds; some MCP servers start slowly, so 60 is recommended

MCP with Environment Variables

Some MCP servers require API keys or other configuration. You can pass them using the env section:

[mcp_servers.context7]
command = "npx"
args = ["-y", "mcp-remote", "https://mcp.context7.com/mcp", "--header", "Authorization:${CTX7_AUTH_HEADER}"]
startup_timeout_sec = 60.0

[mcp_servers.context7.env]
CTX7_AUTH_HEADER = "Bearer your_token"

Save and restart Codex.

Hands‑On: Install Playwright MCP and Control a Browser

Let’s try it out! We’ll use Playwright MCP as an example to let AI automatically control a browser.

What is Playwright MCP?

Playwright = Microsoft’s browser automation tool
Playwright MCP = Lets AI control Playwright through the MCP protocol

After installation, AI can:

Open web pages
Click buttons
Fill in forms
Take screenshots
Read page content
Automatically log in to websites

Step 1: Install Playwright MCP

In Claude Code

Open a terminal and run:

claude mcp add playwright npx '@playwright/mcp@latest'

If you want to specify a browser (e.g., Edge), add parameters:

claude mcp add playwright npx '@playwright/mcp@latest' -- --browser msedge

In Codex CLI

Edit ~/.codex/config.toml and add:

[mcp_servers.playwright]
command = "npx"
args = ["@playwright/mcp@latest"]
startup_timeout_sec = 60.0

If you want to use Edge and keep your login session, you can configure it like this:

[mcp_servers.playwright]
command = "mcp-server-playwright"
args = ["--browser", "msedge", "--executable-path", "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge", "--user-data-dir", "/Users/your_username/Library/Application Support/Microsoft Edge", "--isolated"]
startup_timeout_sec = 60.0

Tip: Using --user-data-dir lets the browser retain your login state, so AI doesn’t need to log in again when opening pages.

Step 2: Verify the Installation

Start Claude Code:

claude

Type /mcp and you should see playwright in the list with a status of “connected”.

Step 3: Let AI Operate the Browser

Now try it out! In Claude Code, enter:

Open Baidu, search for "What is MCP", and save a screenshot of the search results.

The AI will automatically:

Launch the browser
Open the Baidu homepage
Type “What is MCP” in the search box
Click the search button
Take a screenshot of the search results page
Save the screenshot to your project folder

You don’t need to do anything—the AI completes all the steps automatically!

More Use Cases

With Playwright MCP installed, you can ask AI to do many things:

Example 1: Auto‑fill a form

Open https://example.com/register and fill in the registration form with the following info:
Username: testuser
Email: test@example.com
Then click submit.

Example 2: Extract web content

Open https://news.ycombinator.com and extract the titles and links of the top 10 stories on the front page. Organize them into a Markdown table.

Example 3: Automated testing

Open the translation page I just made (translate.html) and test the following:
1. Enter "Hello World", click translate, and check if a result appears.
2. Click the clear button and check if the input box is cleared.
3. Toggle dark mode and check if the interface looks correct.
Compile the test results into a report.

Recommended MCP Servers

Here are some practical MCP servers, categorized by use case:

Browser & Web

MCP Server	Function	Installation Command (Claude Code)
Playwright	Browser automation	`claude mcp add playwright npx '@playwright/mcp@latest'`
Chrome DevTools	Chrome debugging	`claude mcp add chrome-devtools npx 'chrome-devtools-mcp@latest'`

Development Tools

MCP Server	Function	Installation Command (Claude Code)
GitHub	GitHub operations	`claude mcp add github npx '@anthropic-ai/github-mcp'`
Context7	Get latest technical docs	Requires token configuration (see config)

Notes & Documentation

MCP Server	Function	Notes
Notion	Read/write Notion notes	Requires Notion API Key
Obsidian	Read/write Obsidian notes	Community‑developed

Databases

MCP Server	Function	Notes
Supabase	Operate Supabase database	Requires Access Token
PostgreSQL	Operate PostgreSQL	Community‑developed

Go to mcp.so or smithery.ai to find even more MCP servers.

Important Notes

Safety Reminders

MCP gives AI the ability to operate external systems, which also introduces some risks:

Grant permissions cautiously: Don’t give AI full system access without thought.
Review actions: Before important operations, ask AI to tell you what it’s about to do.
Back up data: Before letting AI handle important data, make a backup.
API Key security: Never share your API keys with others.

Frequently Asked Questions

Q: What if the MCP server fails to start?

A: Check the following:

Is Node.js version 18 or higher? (node -v)
Is the network working?
Is startup_timeout_sec set high enough? (60 seconds is recommended)

Q: After installing a browser MCP, I don’t see a browser window.

A: Playwright runs in headless mode by default (no visible window). If you want to see the browser in action, add the parameter --headless false:

claude mcp add playwright npx '@playwright/mcp@latest' -- --headless false

Q: Can MCP servers be shared between Claude Code and Codex CLI?

A: The MCP server itself is universal (e.g., Playwright MCP can be used by both tools), but the configuration method differs:

Claude Code: ~/.claude.json or the claude mcp add command
Codex CLI: ~/.codex/config.toml

Summary

What you learned today:

What MCP is: AI’s plugin system that lets AI connect to external tools and services.
MCP marketplaces: mcp.so, Smithery, awesome-mcp-servers—find plugins like an App Store.
How to install MCP: Use the claude mcp add command for Claude Code, or edit config.toml for Codex CLI.
Hands‑on: Installed Playwright MCP and let AI automatically control a browser.
Recommended MCP servers: Browser, GitHub, notes, databases, and more.

Key takeaways:

MCP transforms AI from “can only talk” to “can take action”.
Installing MCP is as simple as installing an app on your phone.
Beginners are encouraged to start with Playwright MCP for the most intuitive experience.

N8N Is Powerful, But You Probably Do Not Need It

Mon, 01 Jan 0001 00:00:00 +0000

When I introduced the Codex APP, I touched on a topic: Why you might not need to learn N8N anymore. This chapter expands on that.

What is N8N?

In a nutshell: N8N is a visual automation workflow platform.

The name N8N comes from “nodemation” (node + automation), with 8 letters between the first and last, hence N8N. It’s an open-source project that you can deploy on your own server for free.

What can it do? Think of it as an assembly line. Each “node” is a station on the line. Data enters at the first station, goes through a series of processes, and comes out at the last station. For example, you can build an assembly line like this:

Node 1 (Trigger): Automatically starts at 9 AM every day
Node 2 (HTTP Request): Fetches today’s news from a website
Node 3 (Data Processing): Filters out AI-related content
Node 4 (Send Notification): Sends the results to your email

Set it up and forget it—it runs automatically every day.

N8N has over 400 built-in nodes covering common services like Gmail, Slack, databases, Notion, and more. Since its launch in 2019, it has gained over 200,000 active users and raised funding at a $270 million valuation.

It’s definitely a great tool. I’ve deployed it myself and run many workflows on it.

N8N is Powerful, But It Has Four Major Problems for Beginners

Before Skill came along, N8N was almost the only choice for personal automation. But now things are different.

N8N has four major problems for beginners.

Problem 1: Too Much to Learn

When you open N8N, you need to understand: workflows, nodes, triggers, webhooks, credentials, expressions, data mapping…

Just for “Webhook” alone, you need to understand the HTTP protocol, the difference between POST and GET requests, and JSON data format.

For someone without a programming background, this isn’t learning automation—it’s learning programming.

Many people excitedly open a tutorial, and the first step is “Configure a Webhook node, set Method to POST”—and they’re immediately turned off.

Problem 2: Tutorials Can Never Keep Up with Updates

N8N updates very quickly, which is a good thing. But the problem is: you follow a tutorial and find that the interface looks different from the screenshots.

It’s not that the tutorial is wrong; N8N has been updated again.

What’s worse, N8N has had major version upgrades recently, and some workflows that worked before become incompatible after the upgrade. Something you spent a weekend building can be broken by a single update, and you have to reconfigure it.

Problem 3: Deployment Barrier is Not Low

N8N can be used in two ways: self-hosted or using the official cloud service.

Self-hosting gives you unlimited workflows for free (aside from server costs). But you need to know how to buy a server, install Docker, set up a reverse proxy, configure DNS… For a beginner, just getting N8N running can take half a day. Before you even start learning automation, you’re already put off by the deployment.

Using the official cloud service is convenient—just sign up and use it. But the free plan only gives you 5 workflows. Want more? The Starter plan is $20/month, and the Pro plan is $50/month. Before you’ve automated a few processes, you’ve already spent money.

Problem 4: Debugging Relies on Human Relay

When something goes wrong in N8N, the debugging process goes something like this:

See an error message
Don’t understand it, take a screenshot and send it to an AI (like ChatGPT)
AI gives a solution, you go back to N8N and make changes
Run it again, still wrong
Screenshot again, ask AI again
Go back and forth several times before it’s fixed

What are you doing? Acting as a translator between N8N and the AI.

Although N8N also has MCP to connect with AI, the experience is mediocre. You still have to manually go step by step asking the AI, and some issues take several attempts to pinpoint.

What Does N8N Actually Do?

Before discussing how Skill can replace it, let’s first understand the core principles of N8N.

Strip away the fancy visual interface, and N8N essentially does four things:

Capability	Description	Example
Send Requests	Call external APIs or scrape web pages	Request weather API to get today’s weather
Process Data	Filter, transform, format data	From 100 news items, filter out AI-related ones
Trigger Execution	Run on a schedule or triggered by external events	Automatically run at 9 AM every day
Connect Services	Chain different tools together	Read email from Gmail → Save to Notion

That’s it—just these four things.

And all four of these things can be done with scripts in Skill.

How Does Skill Replace N8N?

Remember Skill from earlier? Skill packages tools, APIs, and scripts into a command that you can invoke with a /.

There are three benefits to replacing N8N with Skill:

Benefit 1: No Need to Build It Yourself—AI Builds It for You

In N8N, you have to manually drag nodes, connect them, and configure parameters. When you’re stuck, you look up documentation or ask an AI.

With Skill?

You: Create a Skill that fetches the top 10 stories from Hacker News every day,
    formats them into a Markdown table, and saves them to my notes.

The AI directly writes the script, creates the Skill file, and tests it. You don’t need to understand HTTP requests or know what JSON looks like.

Benefit 2: When Something Goes Wrong, the AI Fixes It Directly

This is the best part.

I already described the debugging process for N8N errors above—screenshot, ask AI, modify, run again, screenshot again, ask again. Back and forth relaying.

With Skill, it’s completely different. The AI can directly see the error message, directly modify the script, and directly re-run it.

You just say “run it,” and the AI handles the rest in a closed loop.

From “human relay” to “AI closed loop,” the efficiency difference is more than tenfold.

Benefit 3: Learning Cost is Nearly Zero

With N8N, you need to learn: nodes, triggers, expressions, credentials, webhooks, data mapping…

With Skill, what do you need to learn?

You’ve already learned it.

If you’ve been following this guide, you already know how to use Claude Code or Codex. Using Skill is just typing /skill-name—no additional learning cost.

“But N8N Can Run Automatically!”

An important reason many people like N8N: Set it up and it runs automatically without human intervention.

“Doesn’t Skill require manually entering a command every time?”

No. Skill has several ways to achieve automatic execution.

Method 1: Codex APP’s Automations (Simplest)

The Codex APP introduced earlier has an Automations feature. Remember? It’s like setting an alarm for the AI.

You can set:

Run a specific Skill at 9 AM every day
Generate a report every Monday
Check data every 6 hours

How to do it: Open Codex APP → Automations → Set frequency → Bind Skill → Save.

It has the same effect as N8N’s scheduled trigger, but the configuration is much simpler.

Method 2: System Scheduled Tasks (cron / launchd)

If you’re using the terminal-based CLI, you can use the operating system’s built-in scheduling tools.

macOS uses launchd, Linux uses cron. The principle is simple: write a rule telling the system “execute this command at this time.”

For example, if you want to automatically run a Skill at 8 AM every day:

# Tell the system to execute this command at 8 AM every day
claude -p "Run /my-daily-report"

You don’t need to write the configuration file yourself; let the AI generate it for you. Just say:

Create a macOS scheduled task to run the /my-daily-report Skill at 8 AM every day.

The AI will generate all the necessary configuration.

Method 3: Webhook Trigger

If you need external events to trigger actions (e.g., someone submits a form, a new commit on GitHub), you can have the AI write a simple script that listens for webhooks and calls the corresponding Skill when a signal is received.

This is a bit more complex, but the AI can still handle it for you.

N8N vs Skill Comparison

Comparison Item	N8N	Skill
Ease of Getting Started	High (nodes, triggers, expressions, etc.)	Low (tell the AI what you want)
Setup Method	Manually drag nodes, configure parameters	AI automatically generates scripts and files
Debugging Method	Screenshot → Ask AI → Modify → Run again	AI directly sees error → directly modifies → directly runs
Visualization	✅ Drag-and-drop flow chart	❌ Pure script
Scheduled Execution	✅ Built-in triggers	✅ Automations / cron / launchd
Built-in Integrations	400+ nodes, ready to use	AI uses scripts to connect, broader coverage
Deployment Requirements	Needs server (Docker)	Runs locally
Maintenance Cost	Medium (version updates may break compatibility)	Low (scripts don’t depend on platform version)
Target Audience	Those with some technical background	Everyone

What Can N8N Do That Skill Can’t?

After all this praise for Skill, to be fair, let’s also talk about where N8N is irreplaceable.

1. Visual Workflow

N8N’s biggest selling point is its drag-and-drop canvas. You can intuitively see how data flows and which nodes connect to which. Skill is pure script—the AI understands it, but it’s not as intuitive for humans.

2. 24/7 Independent Operation

N8N is deployed on a server, so it keeps running even when your computer is off. Skill primarily runs locally. Although you can use Automations or cron for scheduled triggers, your computer needs to be on (unless you deploy the script to a cloud server).

3. Enterprise-Grade Scenarios

If you need to process tens of thousands of data records daily, integrate with dozens of external services, or have multiple people collaborating on workflow management—N8N is more stable in these scenarios. Skill is better suited for personal-level automation.

4. Webhook Ecosystem

N8N natively supports webhooks, so external systems can directly trigger workflows. Skill requires additional scripting to achieve the same effect.

However, that said.

For the readers of this guide—AI beginners—you probably won’t need any of these “things Skill can’t do.”

You don’t need to process tens of thousands of data records. You don’t need 24/7 uninterrupted operation. You don’t need to integrate with dozens of enterprise systems.

What you need is: to turn an idea into an automated workflow with the least time and the lowest barrier.

That’s exactly where Skill excels.

If you ever have enterprise-level needs in the future, you can always come back and learn N8N. By then, you’ll already have a solid foundation, so learning it will be much faster.

Summary

What you learned today:

What N8N is: A visual automation workflow platform that lets you build automation by dragging and dropping nodes
Four pain points for beginners: Too many concepts to learn, tutorials can’t keep up with updates, high deployment barrier or cost, debugging relies on human relay
N8N’s core principles: Send requests, process data, trigger execution, connect services—all doable in Skill
Three advantages of Skill over N8N: AI builds it for you, AI debugs for you, zero learning cost
Skill can also run automatically: Automations, cron/launchd, Webhook—three methods
Where N8N is irreplaceable: Visual workflow, independent server operation, enterprise-grade scenarios

Key takeaways:

N8N is a great tool, but it’s not something AI beginners must learn
Skill can achieve the same or even better results with a lower barrier
If you ever need enterprise-level features, you can learn N8N later—with a solid foundation, you can learn anything quickly

Open Minis: A Free 24-Hour Pocket Agent

Mon, 01 Jan 0001 00:00:00 +0000

I’ve been calling DeepSeek the king of cost-effectiveness these days. Today I used it to play with Hermes (another Agent) and ran 260 million tokens, costing me less than $3—less than 20 yuan—practically free. And it’s very fast. Previously, using Codex often meant waiting a long time, so long I could work on other videos in the meantime. V4 Flash even gives me the feeling it’s flooding the screen, churning out results rapidly.

Of course, in terms of capability, Codex 5.5 is definitely stronger. But for this kind of Agent tool, V4 Flash’s capabilities are more than sufficient—fast, good, and cost-effective.

However, during use I discovered a problem: I’m a bit particular about this. On one hand, I want it to connect to my main device so it can leverage more capabilities; if you install it on a VPS, it can’t access your local photos or local Obsidian. On the other hand, if I install it on my own Mac, I don’t want to keep it running 24/7—even though Macs are designed for 7×24 operation.

Finally, on the recommendation of imzhichen (the creator behind the WeChat public account “Player’s Heart”) in the group, I discovered a free Agent that can follow you 24/7: Open Minis.

The beauty of it is that it runs on your iPhone—you always have your phone with you, it never shuts down, and it can access your photos, Obsidian, etc. It’s the perfect Agent container!

Even better, it’s free software; your only expense is the token cost for DeepSeek.

Installation and Setup

You can install it directly from the App Store.

After downloading, open the app. It has a simple 1, 2, 3 step guide.

First, tap “Add a Provider”, then select the first option “OpenAI / Compatible API”, then tap “API Key” at the top. Change the label name to “DeepSeek”, enter your API key in the API Key field (if you’re unsure, refer to the guide on getting a DeepSeek API key). For the custom API address, select “https://api.deepseek.com”, and remember to turn off “Auto Append” below. Once everything is filled in, scroll to the bottom and tap “Add AI Provider”. That’s step one done.

Second, tap “Select Models”, choose the first one, V4 Flash, then tap Next.

Third, you can tap “Start a Conversation” to begin chatting. You can ask it questions directly, for example, to see what capabilities it has. Below is the response I got when I asked it “What iPhone capabilities do you have?”

Here is a compiled list of Open Minis’ built-in iOS native capabilities:

Category	Tool	Capability
Vision & Speech	apple-vision	OCR text recognition / QR code / barcode recognition
Vision & Speech	apple-speech	Speech-to-text (microphone recording / audio files)
Vision & Speech	apple-speak	Text-to-speech (TTS, multilingual support)
Apps & System	apple-open	Open URLs, apps, system settings pages
Apps & System	apple-device	Device info (model, system, battery, etc.)
Apps & System	apple-clipboard	Read/write clipboard
Apps & System	apple-notification	Send local notifications
Apps & System	apple-alarm	Set alarms and timers
Data & Health	apple-healthkit	Query and write health data (steps, heart rate, etc.)
Data & Health	apple-photos	Photo library management (import, export, search)
Data & Health	apple-calendar	Calendar and reminders (query, create)
Data & Health	apple-reminders	Reminders management
Data & Health	apple-media	Media library search and playback control
Data & Health	apple-player	Native audio/video player (play, pause, etc.)
Location, Maps & Weather	apple-location	Get current location, reverse/forward geocoding
Location, Maps & Weather	apple-maps	Search places, navigation routes, estimated arrival time
Location, Maps & Weather	apple-weather	Current weather, hourly/daily forecast, weather alerts
Connectivity & Hardware	apple-bluetooth	Bluetooth Low Energy (scan, connect, read/write)
Connectivity & Hardware	apple-nfc	NFC tag read/write, bank card reading
Connectivity & Hardware	apple-homekit	Control smart home devices (lights, AC, etc.)
Natural Language	apple-nlp	Language detection, tokenization, part-of-speech tagging, named entity recognition

All of these are iOS native frameworks (Vision, Speech, NaturalLanguage, HealthKit, HomeKit, MapKit, WeatherKit, AVFoundation, etc.), running entirely locally without needing an internet connection.

Image Recognition

Open Minis can leverage the iPhone’s OCR capabilities, meaning it can recognize text in your images. So you can hand it your shopping receipts, have it extract the content, and then write it into your ledger.

Health Statistics

You can directly ask it about your daily exercise activity.

Directly Manipulate Obsidian

Remember I mentioned it can recognize images? After recognition, we can have it write directly into our Obsidian. But first we need to load our Obsidian, otherwise it won’t know where Obsidian is and won’t have permission. Specifically, you need to tap “Mount External Folder” in settings. See the images for the exact steps. After that, you can return to the conversation and have it process and manipulate your Obsidian folder.

Putting Open Minis on your iPhone, paired with DeepSeek’s cheap API, means you have a 24/7 AI assistant for very little money—one that can recognize images, check health data, and directly manipulate Obsidian. For a beginner who doesn’t code, this combination is probably the lowest-barrier “personal Agent” solution available.

Registering and Paying for Overseas AI Tools

Mon, 01 Jan 0001 00:00:00 +0000

We’ve covered the mainstream AI tools, and you’ve likely chosen the platform you want to use. Most AI tools from China are completely free to use on the web, and payment is only needed for APIs (more on that later). But overseas AI tools are different—many people get stuck at the payment step: How do I pay for overseas AI tools?

This chapter walks you through how to pay for overseas AI tools like ChatGPT, Claude, and Gemini, with a special focus on the highly recommended Apple subscription method.

Official Payment Methods (Not Recommended)

The official websites of ChatGPT, Claude, and Gemini all support direct subscription, but you need:

A foreign credit card: Visa, MasterCard, American Express, etc.
A foreign PayPal account: A PayPal account linked to a foreign credit card
A foreign address: A foreign address is required for the billing address

Why is it not recommended?

Not user-friendly for users in China:

Most credit cards issued in China will be rejected
Even dual-currency cards may be rejected due to risk control
Virtual credit cards (like Depay) carry the risk of account suspension
Payment failures can lead to account freezing

Summary: Unless you have a genuine foreign credit card, it’s not recommended to pay directly on the official website. Below we introduce a more reliable method.

Apple Subscription Method (Highly Recommended)

Apple subscription is currently the most stable and secure payment method:

Supports UnionPay cards from China: No foreign credit card needed
Low risk: Through official Apple channels, no risk of being banned by AI platforms
Easy management: All subscriptions are managed centrally in your Apple ID
Transparent pricing: Settled at Apple’s exchange rate, no additional fees
One-click login and registration: You can directly log in to AI tools with your Apple ID without separate registration (more on this later)

Prerequisites

You need an Apple ID from a region other than mainland China. Recommended regions:

US region: Most commonly used, widest app selection
Japan region: Exchange rate can be more favorable
Nigeria region: Cheapest

How to register a non-China Apple ID?

Sign out of your current Apple ID
Open the App Store and choose a free app to download
Select ‘Create New Apple ID’ and choose United States/Japan/Hong Kong as the region
Fill in the information (email, password, security questions)
Select ‘None’ as the payment method for now, and fill in a random address (you can change it later)

Once registered, you’ll have a blank Apple ID for the selected region.

Getting Apple Gift Cards

Once you have a non-China Apple ID, you need to add funds to it. There are two ways to get gift cards:

Method 1: Purchase on Taobao/Xianyu (Fast but Risky)

Steps:

Search for ‘US Apple Gift Card’ or ‘US iTunes’ on Taobao or Xianyu
Choose a reputable seller (check reviews and sales volume)
After purchase, the seller will send you a redemption code
Redeem it immediately into your Apple ID

Advantages:

Fast: you can get the code in minutes
Sometimes slightly cheaper than official prices

Disadvantages:

Risk of stolen credit cards: If the seller uses stolen credit cards to buy gift cards, your Apple ID could be banned
Difficult after-sales support: hard to hold anyone accountable if problems arise

Important note: If you choose this method, be sure to pick a large, reputable store and redeem the code immediately after receiving it. If you encounter a stolen card issue, contact Apple Support immediately to explain the situation.

Method 2: Purchase from Apple’s Official Website (Recommended, Safe)

This is the safest method. Although it’s a bit more involved, it’s completely legal and risk-free. Detailed steps:

1. Open Apple’s official gift card purchase page

URL: https://www.apple.com/shop/buy-giftcard/giftcard
Note: You need to visit the US Apple website (if you have a US Apple ID)

2. Choose the Email delivery method

The page will ask if you want a physical card or an electronic card
Select ‘Email’ (electronic card, sent to your email)
Choose an amount: $25, $50, $100, or a custom amount

3. Fill in the recipient information

Recipient: Enter your own English name
Recipient Email: Enter your email address (to receive the redemption code)
From: You can fill in anything, even yourself
Message: Leave blank or write anything

4. Add to bag and check out

Click ‘Add to Bag’
Click ‘Check Out’ (you can use Apple Pay if you’ve set it up)
The system will ask you to sign in with your Apple ID (use your US Apple ID)

5. Enter payment method

Key point: You can directly use a UnionPay credit or debit card from China
Enter the card number, expiration date, and CVV as they appear
Cardholder name: Enter the name in pinyin as it appears on the card

6. Fill in the Billing Address

This is a crucial step! You need to enter a US address. It’s recommended to choose a tax-free state to save money:

Alaska
Oregon
Delaware
Montana
New Hampshire

How to fill it in?

Open Google Maps or Apple Maps
Search for ‘Oregon hotel’ or ‘Alaska hotel’ (find a hotel address)
Copy the hotel’s address, city, zip code, and phone number
Fill them into the Billing Address fields

Example (a hotel address in Oregon):

Street: 1234 SW Broadway
City: Portland
State: Oregon
ZIP: 97201
Phone: (503) 123-4567

7. Complete the payment

After verifying the information is correct, click ‘Place Your Order’
Wait for the bank to process the payment (you may need to enter an SMS verification code)

8. Wait for the redemption code

After successful payment, you’ll receive an email within minutes to a few hours
The email contains the redemption code (16 alphanumeric characters)
Sometimes it may take up to 24 hours

Redeeming the Gift Card to Your Apple ID

Once you have the redemption code, you need to redeem it to your Apple ID balance.

Steps:

1. Open the App Store

Open the App Store on your iPhone or iPad
Make sure you are signed in with your non-China Apple ID

2. Go to the redemption page

Tap your profile icon in the top right corner
Find ‘Redeem Gift Card or Code’

3. Enter the redemption code

Option 1: Use the camera to scan the code
Option 2: Manually enter the 16-digit code
Tap ‘Redeem’

4. Confirm the balance

After successful redemption, the balance will immediately appear in your account
You can check the current balance on the ‘Account’ page

Possible issues:

Issue 1: ‘This code must be redeemed in the US Store’

Cause: Your Apple ID region setting is incorrect
Solution: Go to ‘Settings > Apple ID > Media & Purchases’ and switch the region

Issue 2: Balance not showing after redemption

Cause: Account is under risk control
Solution: See the risk control section below

This is another huge advantage of the Apple subscription method that many people don’t know: You can directly log in to AI tools with your Apple ID, without needing to register a separate account!

The hassle of traditional registration:

Requires email verification
Requires setting a password (another password to remember)
Some platforms also require phone number verification (foreign phone numbers are troublesome)
Platforms like ChatGPT have restrictions on Chinese email addresses

Benefits of logging in with Apple ID:

One-click login: Complete registration and login with one tap
No verification needed: No email or phone verification required
Privacy protection: Apple hides your real email address
High security: Apple’s two-factor authentication protects your account
Unified management: All AI subscriptions are tied to your Apple ID

Most mainstream AI tools now support ‘Sign in with Apple’:

ChatGPT: Fully supported
Claude: Fully supported
Perplexity: Fully supported
Notion AI: Fully supported
Most other AI tools: Generally supported

Detailed steps

Using ChatGPT as an example:

1. Download the ChatGPT app

Make sure you are signed in with your non-China Apple ID
Search for ‘ChatGPT’ in the App Store
Download and install

2. Open the app and choose a login method

Open the ChatGPT app
The home screen will show ‘Log in’ or ‘Sign up’
After tapping, you’ll see various login options

3. Select ‘Continue with Apple’

Do not choose email login
Directly tap ‘Continue with Apple’
The system will pop up an Apple ID authorization window

4. Confirm authorization

Apple will display:
- ‘ChatGPT would like to use your Apple ID’
- Your name and email
You can choose:
- Share My Email: The AI tool can see your real email
- Hide My Email: Apple will generate a random email to forward to the AI tool
It’s recommended to choose ‘Hide My Email’ for better privacy

5. Complete Face ID/Touch ID verification

Confirm with Face ID or Touch ID
Registration and login are completed automatically in seconds

6. Start using

Login successful, you’ll enter the app directly
Your account has been automatically created
The app will automatically log you in next time

Not just mobile apps, many AI tools’ web versions also support Apple login:

Steps:

Open the AI tool’s website (e.g., claude.ai)
Click ‘Log in’
Select ‘Continue with Apple’
An Apple login window will pop up
Enter your Apple ID and password
Complete two-factor authentication
Login successful

Notes:

For web login, you need a Mac or a Windows PC with iCloud installed
Or log in using Safari on your iPhone/iPad

1. Cross-device sync

After logging in with Apple ID, you can seamlessly use it on all your Apple devices
iPhone, iPad, and Mac will automatically sync the login status

2. Security management

If you have issues with your AI account, you can revoke authorization in Apple ID settings with one tap
Path: Settings > Apple ID > Password & Security > Apps Using Apple ID

3. No need to worry about forgetting passwords

Because you don’t have a password at all—you always log in with Apple ID
As long as your Apple ID is secure, your AI account is secure

Tips

What if you’ve already registered an AI account with email?

Most AI tools support ’linking your Apple account’:

Log in to your AI account
Go to Account Settings
Find ‘Connected Accounts’ or ‘Sign-in methods’
Add ‘Sign in with Apple’
Next time you can log in with Apple ID

Can one Apple ID log in to multiple AI tools?

Absolutely! One Apple ID can log in to:

ChatGPT
Claude
Perplexity
Notion AI
And all other tools that support Apple login

They don’t conflict with each other; each tool is an independent account.

Subscribing to AI Services

Once you have a balance, you can subscribe to AI services.

Steps:

1. Download the AI app

Make sure you are signed in with your non-China Apple ID
Search and download in the App Store:
- ChatGPT (OpenAI)
- Claude (Anthropic)
- Gemini (Google)

2. Open the app and subscribe

Open the app and find ‘Subscribe’ or ‘Upgrade’
Choose a subscription plan (Plus/Pro, etc.)
Confirm the payment method as Apple ID balance
Complete the subscription

3. Subscription successful

You’ll receive a subscription confirmation email from Apple
The app will show your subscribed status

Dealing with Risk Control Issues

What is risk control?

If you redeem a large gift card amount at once (e.g., over $100), Apple may trigger risk control:

Balance shows but cannot be used
‘Payment method declined’ when subscribing
Balance is frozen

Solutions

Method 1: Wait a few days (recommended)

Do nothing and wait 3-7 days
The system will automatically lift the risk control
After that, the balance can be used normally

Method 2: Contact Apple Support (faster)

Call Apple Support:
- China: 400-666-8800
Explain the situation: ‘I redeemed a gift card but it’s not working.’ The Chinese support will transfer you to an international colleague, and you can communicate in Chinese.
The support will verify the information and manually lift the risk control
Usually restored within 48 hours

Tips to avoid risk control:

Don’t redeem more than $50 on your first try
Redeem in smaller amounts, not all at once
Wait 1-2 days after redemption before subscribing

Summary: Complete Process Recap

Complete steps:

Register a non-China Apple ID (US/Japan/Hong Kong)
Get a gift card (purchase from official website or Taobao)
Redeem the gift card to your Apple ID
Use Apple ID to log in to AI tools with one click (no separate registration needed)
Download the AI app and subscribe
If you encounter risk control, wait or contact support

Cost reference:

ChatGPT Plus: $20/month
Claude Pro: $20/month
Gemini Advanced: $19.99/month

Money-saving tips:

Choose regions with favorable exchange rates (e.g., Japan, Hong Kong)
Select a tax-free state when purchasing gift cards from the official website
Subscribe monthly and cancel anytime when not needed

Skills: What They Are and How to Use Them

Mon, 01 Jan 0001 00:00:00 +0000

From Typist to Super Assistant

We’ve previously learned to use Claude Code for projects, and you may have experienced the power of AI programming. But have you noticed a problem:

Every time you do something similar, you have to describe the requirements all over again.

For example, you want AI to help you:

Write Git commit messages
Review code
Generate project documentation
Sync files

You might do these tasks several times a day, but each time you have to type a long paragraph telling AI what to do. It’s exhausting!

It’s like every time you order takeout, you have to tell the restaurant:

“I want a bowl of braised beef noodles, no cilantro, extra chili, noodles should be firm, less soup…”

Is there a way to turn these common operations into one-click commands?

Yes, that’s what we’re going to talk about today: Skill.

What is Skill?

One-sentence explanation

Skill = AI’s shortcut command

Just like the Shortcuts app on your phone, Skill encapsulates complex operations into a simple command.

Official definition

Skill refers to a reusable “capability module” that encapsulates tools/APIs/scripts and prompts into a standard interface, allowing AI to call on demand to complete specific tasks.

It emphasizes:

Clear input and output
Dependency and version management
Testable and updatable
Turning general AI into a business-oriented professional assistant

Intuitive understanding

Without Skill:

You: Please review this code and check the following:
1. Are there any performance issues?
2. Are there any security vulnerabilities?
3. Does the code style follow the conventions?
4. Is there any duplicate code?
5. Are variable names clear?
6. Are comments complete?
……(continue describing for 10 more lines)

With Skill:

You: /review

AI automatically reviews the code according to preset standards and provides a detailed report.

See the difference? From hundreds of words to one command—that’s the power of Skill.

Differences between Skill, Prompt, and MCP

Many people ask: What are the differences between Skill, Prompt, and MCP?

Concept comparison

Aspect	Prompt	Skill	MCP
Essence	Text instruction	Encapsulated capability module	Protocol for connecting external tools
Reusability	Low, must re-enter each time	High, define once and reuse	High, configure once and use continuously
Complexity	Simple	Medium	Complex
Capability scope	Text processing only	Text + simple scripts	Text + external system interaction
Learning curve	Lowest	Medium	Relatively high

Using analogies

Prompt = Verbal instruction

You have to verbally tell AI what to do each time
Suitable for one-time, ad-hoc tasks
For example: “Translate this paragraph”

Skill = Workflow

Solidify common instructions into a standard workflow
Suitable for repetitive, standardized tasks
For example: /commit automatically generates Git commit messages

MCP = External system

Let AI connect to external tools and data sources
Suitable for tasks that need to access external systems
For example: connect to Obsidian to read/write notes, connect to database to query data

Relationship among the three

Prompt → The most basic interaction method
    ↓
Skill → Encapsulates prompt + simple logic
    ↓
MCP → Skill + external system capabilities

Figuratively speaking:

Prompt = You cook yourself
Skill = Heat up instant food in microwave
MCP = Order food delivery platform

When to use which?

Use Prompt if:

Task is simple, one-time
Requirements are flexible and changeable
No need for reuse

Use Skill if:

Task is highly repetitive
Has standardized workflow
Want to improve efficiency

Use MCP if:

Need to access external data (database, API, file system, etc.)
Need to interact with other software (Obsidian, browser, etc.)
Need to get real-time information

Practical case comparison:

Scenario 1: Translate a paragraph

Use Prompt: “Translate this paragraph” (simplest)

Scenario 2: Translate many documents daily

Use Skill: /translate (standardized translation workflow)

Scenario 3: Automatically translate Obsidian notes and save

Use MCP: Connect to Obsidian, automatically read, translate, save (most powerful)

Basic Usage of Skill

How to view existing Skills?

In Claude Code or Codex, enter:

/skill

It will list all available Skills.

How to use Skill?

Method 1: Direct execution

Enter /skill, then use Tab to select the desired Skill, and press Enter to execute.

Method 2: Execute with parameters

After selecting a Skill, continue typing your specific request:

/translate translate the comments in this code to English

Common built-in Skills

Most AI programming tools come with some commonly used built-in Skills:

Skill	Function	Example
`/commit`	Automatically generate Git commit message	`/commit`
`/review`	Review code quality	`/review`
`/fix`	Fix code errors	`/fix`
`/test`	Generate test cases	`/test`
`/doc`	Generate documentation	`/doc`
`/refactor`	Refactor code	`/refactor`

These built-in Skills can already solve 80% of daily needs.

Creating Your Own Skill

If the built-in Skills are not enough, you can create your own Skill.

Two creation methods

Method 1: Let AI create it for you (recommended)

Codex comes with a Skill for creating Skills (sounds confusing, but it’s powerful).

Steps:

Enter /skill
Find the option related to “Create Skill”
After selecting, tell AI what Skill you want

Example:

/create-skill

I want a translation Skill with the following features:
1. Automatically detect Chinese comments in code
2. Translate them into English
3. Keep the code format unchanged

AI will automatically create the Skill file and place it in the correct location.

Method 2: Manual creation

If you want to understand the structure of Skill more deeply, you can create it manually.

Skill file structure:

Each Skill is a folder that must contain a SKILL.md file:

my-skill/
  ├── SKILL.md          # Skill description and configuration
  └── scripts/          # Optional: helper scripts
      └── helper.py

Basic format of SKILL.md:

---
name: Skill name
description: Skill description
---

# Detailed description

Write detailed usage instructions and implementation logic here.

## Parameters

- `--param1`: Description of parameter 1
- `--param2`: Description of parameter 2

## Example

Example usage code

The “Practical Case” section later in this chapter will detail how to create a complete Skill.

Installing Others’ Skills

There are many ready-made Skills on GitHub that you can download and use directly.

Finding the Skill folder

Codex Skill location:

Mac/Linux: ~/.codex/skills/
Windows: %USERPROFILE%\.codex\skills\

Claude Code Skill location:

Mac/Linux: ~/.claude/skills/
Windows: %USERPROFILE%\.claude\skills\

Installation steps

Open the Skill folder

If the folder does not exist, you can create it manually:

# Mac/Linux
mkdir -p ~/.codex/skills

# Windows (PowerShell)
New-Item -Path "$env:USERPROFILE\.codex\skills" -ItemType Directory -Force

Download the Skill file

Download the Skill folder from GitHub or other sources.

Copy to the Skill directory

Copy the entire Skill folder to the corresponding skills directory.

Restart the tool

Note: Codex currently does not support hot reload; you need to exit and restart to see the new Skill. Claude Code can usually recognize it automatically.

Verify installation

After restarting, enter /skill to view the list and confirm the new Skill has appeared.

Practical Case: Creating a Sync Skill

Problem scenario

If you use both Codex and Claude Code (many people do), you’ll encounter a problem:

Skills for the two tools need to be managed separately, which is very inconvenient.

Codex Skills are in ~/.codex/skills/
Claude Code Skills are in ~/.claude/skills/

Every time you create a useful Skill in Codex, you have to manually copy it to Claude’s folder. Too tedious!

At this point, we can create a Skill to automatically sync the contents of the two folders—using a Skill to manage Skills.

This Skill will:

Check the differences between the two Skill folders
Report which Skills need to be synced
After your confirmation, automatically sync

We just need to tell AI the requirements.

Below is what AI does for you. Note that these steps are all automatic; you don’t need to do anything! It’s shown here for demonstration only.

Step 1: Create the Skill folder

In the skills directory of Codex or Claude Code, create a new folder:

mkdir ~/.codex/skills/codex-claude-skill-sync

Step 2: Create SKILL.md

Create a SKILL.md file in the folder:

name: codex-claude-skill-sync
description: Sync Codex and Claude Skills
---

# Codex/Claude Skill Sync

## Overview

Used to check and sync the Skill directories of Codex and Claude, keeping both sides consistent. By default, only reports differences; executes sync after user confirmation.

## Workflow

1. Run difference report (no modification):

   `python3 scripts/sync_skills.py`

2. Report differences to the user in English and wait for explicit consent before proceeding.
3. After consent, execute sync:

   `python3 scripts/sync_skills.py --apply`

4. When encountering a conflict (same modification time but different content), pause and ask the user which side to keep.

## Rules

- Default directories:
  - Codex: `/Users/yourusername/.codex/skills`
  - Claude: `/Users/yourusername/.claude/skills`
- Only process top-level directories that contain `SKILL.md`, skip hidden directories and `.system`
- Determine which side is newer based on the latest modification time in the directory
- When syncing, delete the target Skill directory first, then copy the entire source directory

## Parameters

- `--apply` Execute sync (default is report only)
- `--codex <path>` Override Codex directory
- `--claude <path>` Override Claude directory
- `--prefer codex|claude` When modification time is the same but content differs, use the specified side to overwrite (requires explicit user authorization)

Important: Change the paths above to your actual paths!

Step 3: Create the script file

Create a scripts directory under the Skill folder, then create sync_skills.py:

mkdir ~/.codex/skills/codex-claude-skill-sync/scripts

Complete code for sync_skills.py:

#!/usr/bin/env python3
"""
Compare and sync skill folders between Codex and Claude.

Default behavior is report-only. Use --apply to perform sync.
"""

from __future__ import annotations

import argparse
import hashlib
import os
from datetime import datetime
from pathlib import Path
import shutil
import sys

DEFAULT_CODEX = Path("/Users/yourusername/.codex/skills")
DEFAULT_CLAUDE = Path("/Users/yourusername/.claude/skills")

IGNORE_DIR_NAMES = {".git", ".idea", ".vscode", "__pycache__", ".pytest_cache", ".mypy_cache"}
IGNORE_FILE_NAMES = {".DS_Store"}
TIME_EPSILON = 1.0


def format_time(timestamp: float) -> str:
    return datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d %H:%M:%S")


def list_skill_dirs(root: Path) -> tuple[dict[str, Path], list[str]]:
    if not root.exists():
        raise FileNotFoundError(f"Root path does not exist: {root}")
    if not root.is_dir():
        raise NotADirectoryError(f"Root path is not a directory: {root}")

    skills: dict[str, Path] = {}
    ignored: list[str] = []
    for entry in sorted(root.iterdir(), key=lambda p: p.name):
        if not entry.is_dir():
            continue
        if entry.name.startswith("."):
            ignored.append(entry.name)
            continue
        if not (entry / "SKILL.md").is_file():
            continue
        skills[entry.name] = entry
    return skills, ignored


def dir_state(path: Path) -> tuple[str, float, int]:
    hasher = hashlib.sha256()
    latest_mtime = path.stat().st_mtime
    file_count = 0

    for root, dirs, files in os.walk(path):
        dirs[:] = [d for d in dirs if d not in IGNORE_DIR_NAMES]
        dirs.sort()
        files = sorted(f for f in files if f not in IGNORE_FILE_NAMES)

        rel_dir = os.path.relpath(root, path)
        if rel_dir == ".":
            rel_dir = ""
        hasher.update(f"D|{rel_dir}\n".encode())

        try:
            latest_mtime = max(latest_mtime, os.stat(root).st_mtime)
        except FileNotFoundError:
            continue

        for name in files:
            file_path = Path(root) / name
            rel_path = os.path.relpath(file_path, path)

            if file_path.is_symlink():
                try:
                    target = os.readlink(file_path)
                except OSError:
                    target = ""
                hasher.update(f"L|{rel_path}\n{target}\n".encode())
                try:
                    latest_mtime = max(latest_mtime, file_path.lstat().st_mtime)
                except FileNotFoundError:
                    pass
                continue

            if not file_path.is_file():
                continue

            stat = file_path.stat()
            latest_mtime = max(latest_mtime, stat.st_mtime)
            file_count += 1
            hasher.update(f"F|{rel_path}\n{stat.st_size}\n".encode())

            with open(file_path, "rb") as handle:
                for chunk in iter(lambda: handle.read(1024 * 1024), b""):
                    hasher.update(chunk)

    return hasher.hexdigest(), latest_mtime, file_count


def build_plan(
    codex_skills: dict[str, Path],
    claude_skills: dict[str, Path],
    codex_root: Path,
    claude_root: Path,
    prefer: str | None,
) -> tuple[list[dict], list[str], list[dict]]:
    actions: list[dict] = []
    identical: list[str] = []
    conflicts: list[dict] = []

    all_names = sorted(set(codex_skills) | set(claude_skills))
    for name in all_names:
        codex_path = codex_skills.get(name)
        claude_path = claude_skills.get(name)

        if codex_path and not claude_path:
            actions.append(
                {
                    "name": name,
                    "src": codex_path,
                    "dst": claude_root / name,
                    "reason": "only in codex",
                    "direction": "codex -> claude",
                }
            )
            continue
        if claude_path and not codex_path:
            actions.append(
                {
                    "name": name,
                    "src": claude_path,
                    "dst": codex_root / name,
                    "reason": "only in claude",
                    "direction": "claude -> codex",
                }
            )
            continue

        if not codex_path or not claude_path:
            continue

        codex_hash, codex_mtime, _ = dir_state(codex_path)
        claude_hash, claude_mtime, _ = dir_state(claude_path)

        if codex_hash == claude_hash:
            identical.append(name)
            continue

        time_delta = codex_mtime - claude_mtime
        if abs(time_delta) <= TIME_EPSILON:
            if prefer == "codex":
                actions.append(
                    {
                        "name": name,
                        "src": codex_path,
                        "dst": claude_path,
                        "reason": "same mtime, prefer codex",
                        "direction": "codex -> claude",
                        "codex_mtime": codex_mtime,
                        "claude_mtime": claude_mtime,
                    }
                )
            elif prefer == "claude":
                actions.append(
                    {
                        "name": name,
                        "src": claude_path,
                        "dst": codex_path,
                        "reason": "same mtime, prefer claude",
                        "direction": "claude -> codex",
                        "codex_mtime": codex_mtime,
                        "claude_mtime": claude_mtime,
                    }
                )
            else:
                conflicts.append(
                    {
                        "name": name,
                        "codex_mtime": codex_mtime,
                        "claude_mtime": claude_mtime,
                    }
                )
            continue

        if time_delta > 0:
            actions.append(
                {
                    "name": name,
                    "src": codex_path,
                    "dst": claude_path,
                    "reason": "codex newer",
                    "direction": "codex -> claude",
                    "codex_mtime": codex_mtime,
                    "claude_mtime": claude_mtime,
                }
            )
        else:
            actions.append(
                {
                    "name": name,
                    "src": claude_path,
                    "dst": codex_path,
                    "reason": "claude newer",
                    "direction": "claude -> codex",
                    "codex_mtime": codex_mtime,
                    "claude_mtime": claude_mtime,
                }
            )

    return actions, identical, conflicts


def print_report(
    actions: list[dict],
    identical: list[str],
    conflicts: list[dict],
    codex_root: Path,
    claude_root: Path,
    apply: bool,
    ignored_codex: list[str],
    ignored_claude: list[str],
) -> None:
    print("Skill sync report")
    print(f"Codex: {codex_root}")
    print(f"Claude: {claude_root}")

    if ignored_codex:
        print(f"Ignored in Codex: {', '.join(sorted(ignored_codex))}")
    if ignored_claude:
        print(f"Ignored in Claude: {', '.join(sorted(ignored_claude))}")

    print("\nPlanned sync actions:")
    if not actions:
        print("- none")
    else:
        for item in actions:
            codex_mtime = item.get("codex_mtime")
            claude_mtime = item.get("claude_mtime")
            details = []
            if codex_mtime is not None:
                details.append(f"codex mtime: {format_time(codex_mtime)}")
            if claude_mtime is not None:
                details.append(f"claude mtime: {format_time(claude_mtime)}")
            detail_text = f" ({', '.join(details)})" if details else ""
            print(f"- {item['name']}: {item['direction']} [{item['reason']}]" + detail_text)

    print("\nConflicts:")
    if not conflicts:
        print("- none")
    else:
        for item in conflicts:
            print(
                f"- {item['name']}: same mtime but different content "
                f"(codex {format_time(item['codex_mtime'])}, claude {format_time(item['claude_mtime'])})"
            )

    print(f"\nUp-to-date skills: {len(identical)}")

    if not apply:
        print("\nDry run only. Re-run with --apply to sync.")


def apply_actions(actions: list[dict]) -> None:
    for item in actions:
        src = Path(item["src"])
        dst = Path(item["dst"])

        if dst.exists():
            if dst.is_dir():
                shutil.rmtree(dst)
            else:
                dst.unlink()

        shutil.copytree(src, dst, symlinks=True)


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Sync Codex and Claude skill folders")
    parser.add_argument("--codex", type=Path, default=DEFAULT_CODEX, help="Codex skill root")
    parser.add_argument("--claude", type=Path, default=DEFAULT_CLAUDE, help="Claude skill root")
    parser.add_argument("--apply", action="store_true", help="Apply sync actions")
    parser.add_argument(
        "--prefer",
        choices=["codex", "claude"],
        help="Break ties when mtimes are equal",
    )
    return parser.parse_args()


def main() -> int:
    args = parse_args()

    try:
        codex_skills, ignored_codex = list_skill_dirs(args.codex)
        claude_skills, ignored_claude = list_skill_dirs(args.claude)
    except (FileNotFoundError, NotADirectoryError) as exc:
        print(str(exc), file=sys.stderr)
        return 2

    actions, identical, conflicts = build_plan(
        codex_skills,
        claude_skills,
        args.codex,
        args.claude,
        args.prefer,
    )
    print_report(
        actions,
        identical,
        conflicts,
        args.codex,
        args.claude,
        args.apply,
        ignored_codex,
        ignored_claude,
    )

    if args.apply and actions:
        apply_actions(actions)
        print("\nSync complete.")
    elif args.apply and not actions:
        print("\nNo changes to apply.")

    if conflicts and not args.prefer:
        return 1
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

Important: Remember to modify the paths at the beginning:

DEFAULT_CODEX = Path("/Users/yourusername/.codex/skills")
DEFAULT_CLAUDE = Path("/Users/yourusername/.claude/skills")

Change them to your actual paths.

Using the Sync Skill

Step 1: View differences

In Claude Code or Codex, enter:

/codex-claude-skill-sync

AI will automatically run the script and report the differences between the two Skill folders.

Step 2: Confirm sync

If you agree to sync, tell AI:

Agreed, please execute sync.

AI will run python3 scripts/sync_skills.py --apply to complete the sync.

Done! From now on, whenever you create or modify a Skill on either side, just run this sync Skill once, and both sides will stay consistent.

Advanced Skill Tips

Tip 1: Combine Skills

Multiple Skills can be used in sequence:

/review then /fix to fix the issues found

AI will first review the code, then automatically fix based on the review results.

Tip 2: Customize Skill parameters

Many Skills support parameters:

/commit --type feat --scope api

This will generate a commit message in a specific format.

Tip 3: Skill templates

You can create Skill templates to quickly generate new Skills:

Copy an existing Skill folder
Modify SKILL.md
Save

Put the Skill folder in a Git repository so team members can share:

git clone https://github.com/your-team/skills.git ~/.codex/skills/team-skills

Summary

What we learned today:

What is Skill: A reusable capability module that turns complex operations into simple commands
Skill vs Prompt vs MCP: Differences and applicable scenarios
How to use Skill: /skill to view and invoke
How to create Skill: Let AI help or create manually
How to install Skill: Copy to the corresponding folder
Practical case: Create a sync Skill to solve multi-tool management

Key points:

Skill upgrades AI from a “typist” to a “professional assistant”
Common operations should be encapsulated into Skills
A good Skill can save 90% of time

Use Hooks to Lock Down Skill Workflows

Mon, 01 Jan 0001 00:00:00 +0000

Skill has become an indispensable method in my daily workflow. For anything that repeats three times or more, I think about turning it into a skill—not just to save time, but to ensure that the direction and steps don’t go off track every time. At least in theory.

But AI Still Goes Off Track

That statement is a bit exaggerated. The reality is that AI still skips steps. Take the WeChat public account writing skill I use every day. I set it to show me the first draft for revision, and only after I confirm it’s okay does it proceed to proofreading for typos. Sounds simple, right? But when it actually runs, it keeps skipping steps: it finishes the first draft without showing me and goes straight into proofreading and editing. By the time I notice, it has already quietly revised the file. When I call it out, it apologizes, says “sorry, my fault,” and then does it again the next time. Apologies don’t solve the problem.

Why AI Always Skips Steps

This problem is a little counterintuitive. At first I thought the AI wasn’t smart enough, but I was already using ChatGPT 5.4 and Opus 4.6, which are top-tier large models. Later I thought the rules weren’t clear enough, so I revised the rules in the skill over and over. It helped a bit, but didn’t fix the root cause. After some research, I learned that AI skipping steps isn’t about “not seeing the rules”—it’s determined by the generation mechanism:

Probability-driven “acceleration impulse”. Large language models essentially predict the next token. The weight of completing the task is naturally higher than “staying on step 7 waiting for the user.” The sense of completion is its intrinsic drive.
Rules decay in long contexts. The rules you set at the beginning have their attention weight diluted by the time the model reaches token 3000. Especially if you bury the rules in a long skill document, they get marginalized more easily.
Especially severe in auto mode. When I use auto mode to write articles, the model tends to “run through all steps in one go.” My window to intervene becomes even narrower.
CLAUDE.md and skill documents are essentially “soft constraints”. They are prompts that rely on the model’s “self-discipline” to follow. And self-discipline is fragile when faced with “I want to finish this task quickly.”

So the conclusion is: Verbal constraints fail under task-driven pressure. Simply writing documents, adding exclamation marks, or PUA-ing the AI can only alleviate the problem, not cure it. To truly fix it, you need to take it out of the model’s self-discipline zone—make it physically impossible to skip steps. That’s where Hooks come in.

What Is a Hook

Claude Code has a mechanism called Hook. It’s not a skill, not a prompt, and not the same as CLAUDE.md—it’s a local shell script attached to key points in the Claude Code lifecycle. The key difference:

CLAUDE.md / skill are observed and executed by the model—the model can ignore them.
Hook is enforced by the system—the model can’t ignore it even if it wants to.

A key sentence from the Anthropic official documentation on Hooks: Hooks are triggered by system events, not model decisions. That means hooks are attached to the entire Claude Code runtime. Every tool call the model makes—Write, Edit, Bash—must first pass through the hook for review. If the hook returns deny, it’s denied, even if you have --dangerously-skip-permissions enabled. This is what I call a “hard constraint”—not letting the AI make its own choices, but forcing its tool calls to pass through real shell script auditing.

Common Hook trigger points:

PreToolUse: Intercepts before the AI calls a tool.
UserPromptSubmit: Processes your message before handing it to the AI.
SessionStart: Triggered when a session starts or resumes.
Stop: Triggered when Claude finishes a response.

Focus on the first two—they’re enough to build “step locking.”

In Practice: Step Gate for My WeChat Account Skill

All talk is useless without a concrete example. This screenshot is the Claude Code interface as I write this article. In the red box, the AI asks me to reply “pass step3 0090”—this passphrase is exactly the Step Gate Hook at work. The text you are reading now was written after I sent the passphrase and the hook allowed it.

The entire Step Gate uses only two shell scripts plus a small configuration in settings.json. Let me break it down.

Register Two Hooks in settings.json

Add this to ~/.claude/settings.json:

"PreToolUse": [
  {
    "matcher": "Write|Edit",
    "hooks": [
      { "type": "command",
        "command": "~/.claude/skills/writing-gongzhonghao/scripts/gate_check.sh" }
    ]
  }
],
"UserPromptSubmit": [
  {
    "hooks": [
      { "type": "command",
        "command": "~/.claude/skills/writing-gongzhonghao/scripts/gate_mark.sh" }
    ]
  }
]

This configuration means:

Every time the AI wants to Write or Edit a file, gate_check.sh runs first for review.
Every time I send a message, gate_mark.sh runs first to parse it.

gate_check.sh Handles Interception

The logic of this script is quite simple:

If the AI wants to Write a new file 04-Output/NNNN xxx.md (corresponding to Step 3: create a new article), it checks whether the state file step3.ok exists. If not, it returns deny.
If the AI wants to Edit an existing article (corresponding to proofreading after Step 7), it checks whether step7.ok exists. If not, it also returns deny.

When denying, it also includes a prompt: “Step 3 topic discussion not confirmed: Please give me the outline/direction approval first. After confirmation, reply ‘pass step3 NNNN’ to create a new file.” This prompt is displayed directly to the AI, so it knows it’s stuck and asks me for the passphrase.

gate_mark.sh Handles Passphrase Release

How do I “release” it? I can’t let the AI release itself—that would be no constraint at all. The rule is: Only when my message contains a specific passphrase will the state file be touched. gate_mark.sh runs every time I send a message, scanning for patterns like pass stepN NNNN. If matched, it touches a .ok file in the corresponding directory.

So the complete chain becomes:

AI finishes the outline and wants to create a new article → blocked by gate_check.sh
AI asks me for the passphrase: “Please confirm the direction, reply ‘pass step3 0090’”
I send “pass step3 0090” → gate_mark.sh touches step3.ok
AI tries to create the file again → gate_check.sh allows it this time
After finishing the first draft, it wants to proceed to proofreading Edit → blocked again by step7.ok
After I read the draft and send “pass step7 0090” → proofreading can begin

Throughout the process, the AI has no room for “self-discipline.” It can’t skip steps even if it wants to, because its tool calls are blocked at the system level.

Plug a Loophole: AI Cannot Touch State Files Itself

After designing the first version, I stared at the plan for a while and found a loophole—what if the AI uses Bash to touch step3.ok itself? Wouldn’t that bypass the constraint? So I added a specific rule in the skill document: AI must not touch state files itself, otherwise it would be removing its own constraints. This rule itself is still a soft constraint, but combined with the hard interception of hooks, it forms a sufficiently closed loop—as long as the AI doesn’t actively violate this rule (and Claude is actually cooperative), the hook constraint is real. If you want to be stricter, you can add a Bash matcher in PreToolUse to also block commands like touch. But I haven’t gone that far yet; it’s good enough.

If You Don’t Understand Code, Don’t Panic

You don’t need to write these shell scripts or JSON configurations yourself (I actually can’t write them either). The approach is simple: throw this article and your skill file to Claude or Codex, let it read them and help you modify—create scripts where needed, modify settings.json where needed. AI is particularly reliable for this kind of “configure environment according to documentation” task, much more stable than writing code from scratch. It learns the principles from the article while writing hooks according to your skill requirements, and the result rarely goes off track.

Summary in One Sentence

CLAUDE.md, skill documents, bold markers, repeating three times, PUA—these are all verbal constraints on AI. They work, but have a low ceiling.

Hooks are code constraints on AI. They move the rules to a place the AI can’t reach, turning “following rules” from a matter of model self-discipline into a mandatory requirement of the execution environment.

If you find yourself repeatedly telling the AI “Why are you skipping steps again?”, it’s time to consider using Hooks to constrain it.

What Does Prompt Caching Actually Mean?

Mon, 01 Jan 0001 00:00:00 +0000

DeepSeek has finally released the V4 model. I’ve been trying it out these past few days and it feels great, especially the Flash model with its excellent cost-performance ratio. My own expense tracking mini-program originally had a response time of 5 seconds, but now it’s down to 2.5 seconds. In a word: smooth!

The only downside is that the Pro model isn’t very cheap. According to the official website, prices will drop further once domestic chip supply ramps up in the second half of the year.

Unexpectedly, two days later the Pro model got a limited-time 75% discount (and I suspect this discount might be long-term). Yesterday, they also reduced the cache hit price to one-tenth of the original! What more can I say? Time to stand up and pedal hard!

This is the DeepSeek we know! A few days ago I was criticizing certain Coding Plans for being hard to get and having poor experiences. DeepSeek seems to be directly lowering the overall API price to below that of Coding Plans. Especially now that many Coding Plans prohibit use outside of programming, DeepSeek’s sincerity stands out even more.

Some Coding Plans’ APIs might ban you if you integrate translation, but DeepSeek doesn’t care—use it however you like.

GPT-5.5 and DeepSeek V4 are performing excellently. I’m already considering canceling my Claude subscription next month. And some experts around me have already tried it.

But getting back to the point, some of you are probably wondering: what do input, output, and cache actually mean?

Let’s first introduce what a cache hit means.

Here’s an analogy: You go to your usual noodle shop and order “beef pulled noodles with egg, no cilantro” for the first time. The owner has to slice the beef fresh, knead the dough, boil the egg, and prepare the ingredients—the whole process takes a while. Ten minutes later, your friend arrives and orders the exact same thing. The owner sees that the ingredients are still hot in the pot and the noodles are from the same batch, so he serves it directly—that’s a “hit”.

When AI processes your input, it essentially has to “chew through” all the text you send (including system prompts, conversation history, and your current question) and convert it into an internal intermediate state for the model. This step is truly computationally intensive.

If the AI finds that the content you sent this time has a large initial segment that is exactly the same as the previous one, it directly reuses the intermediate state from last time without having to chew through it again—that’s a cache hit.

Note three key points:

Must be an exact prefix match. Even if you add an extra space or change a punctuation mark at the beginning, the cache is invalidated, and it starts from scratch.
Has a time limit. It varies by provider. For example, Anthropic’s default is only 5 minutes (expires while you’re in the bathroom). If you want the 1-hour option, you have to pay extra (2x the base input price). DeepSeek’s cache lasts from a few hours to a few days.
Same conversation naturally tends to hit. Because with each additional turn in a conversation, the new input = all previous history + AI’s response + your new question. The large preceding history is exactly the same, so it naturally hits.

Whether the cache hits or not greatly affects the price. That’s why I recommend discussing only related content within the same conversation—not just for context memory, but also because it affects cache hits. Starting a new conversation means paying from scratch, while continuing the conversation means getting a discount.

So, the meanings of “per million tokens input (cache hit)”, “per million tokens input (cache miss)”, and “per million tokens output” are:

Per million tokens input (cache miss): The part of the content you send this time that the AI cannot reuse from previous calculations and must chew through from scratch is priced at this rate. This includes first-time chats, new sessions, or changed prompts at the beginning.

Per million tokens input (cache hit): The part of the content you send this time where the beginning segment happens to be exactly the same as a previous instance and is directly reused by the AI is priced at this (much cheaper) rate. In the same conversation, the history from the second, third rounds, etc., falls into this category.

Per million tokens output: The response generated by the AI is priced at this rate. This is always the most expensive because “generation” consumes more computing power than “understanding”—one involves the AI repeatedly drafting, selecting words, and forming sentences in its mind, while the other involves the AI just reviewing the material.

Let’s use a concrete example to get a feel. Suppose you’re using DeepSeek to modify a 3000-token piece of code:

First question: Input 3000 tokens (all miss) + AI output 500 tokens
Then ask “Can this be optimized further?”: Input becomes over 3500 tokens (of which 3500 is previous history, all cache hit; only the few dozen new words you added count as miss) + AI output 600 tokens
Start a new conversation, paste the code again, and ask the same question: Another 3000 tokens all miss

If the miss price is 10 times the hit price, then the cost difference for just the input between “asking a follow-up in the same conversation” and “starting a new conversation to ask again” can be nearly 10 times.

So this time DeepSeek has slashed the cache hit price to one-tenth of the original, combined with the 75% discount on the Pro model. For use cases with long contexts + multi-turn conversations (like coding, document analysis, long chats), this is almost a bone-breaking price cut. If you’ve written Skills or set up automation workflows, you know that repeatedly calling a long prompt is the norm. The actual savings from this price reduction are even more dramatic than they appear on paper.

Finally, a practical tip: Develop the habit of finishing a topic within the same conversation before starting a new one. Don’t just “clear and start fresh” all the time. Not only will the AI remember you, but it will also save you money.

Summary

What we learned today:

What is a cache hit — The AI stores the input it chewed through last time. If the beginning is the same this time, it directly reuses it, saving computational power, and the price is discounted accordingly.
Three key conditions — Must be an exact prefix match, has a time limit (varies from minutes to days across providers), and same conversation naturally tends to hit.
What the three prices refer to — Cache miss = input that is recalculated; cache hit = reused input (cheapest); output = AI-generated response (most expensive).
Why output is the most expensive — “Generation” consumes more computing power than “understanding”; the AI repeatedly drafts in its mind, and the price is usually several times that of input miss.

Key takeaways:

Continuing in the same conversation means automatic discounts; starting new conversations frequently means paying full price every time.
Modify prompts at the end; if you change the beginning, the cache is invalidated.
Long context + multi-turn conversation scenarios (coding, document analysis, long chats) benefit the most. DeepSeek’s price cuts are essentially bone-breaking for such users.

What Is a Large Language Model?

Mon, 01 Jan 0001 00:00:00 +0000

AI tools are now everywhere. For someone completely new to them, the first reaction is often: where should I start? This chapter first explains what a large language model (LLM) is, and then discusses how to use it.

What Do We Mean by AI?

If you’ve been listening to friends chat recently, eight out of ten sentences might be about “AI.” But did you know? The AI everyone is talking about now is not the same as the AI from a few years ago.

The AI that’s currently taking the internet by storm has a professional name: Generative AI.

What does that mean? Simply put: You give it a sentence, and it can generate an article for you; you give it an idea, and it can generate an image; you give it a requirement, and it can write a piece of code.

It’s like an incredibly smart assistant. You say “write a resignation letter for me,” and it actually writes one; you say “draw a cat wearing a suit,” and it actually draws one. This ability to “create content from nothing” is the core of “generative.”

The ones we often hear about—ChatGPT, Claude, DeepSeek—all belong to this category. Their essence is a Large Language Model (LLM), which learns to understand and generate human language by training on massive amounts of text data.

But here’s an important secret:

AI doesn’t actually “understand” what you’re saying; it’s just “calculating probabilities.”

This might sound counterintuitive, but let me explain:

When you ask AI “What color is the sky?”, it doesn’t actually look up at the sky, nor does it truly understand the concepts of “sky” and “color.” Here’s how it works:

Based on the hundreds of millions of articles it has read, when the preceding text is “What color is the sky”, the probability that the next word is “blue” is 82%, “gray” is 10%, “red” is 5%… and then it picks the word with the highest probability.

Here’s a more vivid example:

You ask: “What is 1+1?”

AI isn’t “doing math”; it finds that in all the text it has seen, “1+1 equals” is followed by “2” 99.9% of the time.
So it answers “2.”

You ask: “Recommend a good movie.”

AI hasn’t actually watched movies; it analyzes that in the texts it has learned, “good movies” are often followed by words like “The Shawshank Redemption,” “Titanic,” etc.
It recommends the ones with high probability.

It’s like a super overachiever who has read all the books in the world, but:

He can tell you “Paris is the capital of France” (because the books say so).
But he has never been to Paris, and doesn’t even know what “capital” means.
He just remembers that when you say “Paris is,” the most frequent continuation is “the capital of France.”

So AI can have some strange issues:

Sometimes it “confidently talks nonsense” (fabricates non-existent facts).
It might get simple math problems wrong (because it’s not really calculating).
It may give contradictory answers (inconsistent probability calculations).

This phenomenon of “confidently talking nonsense” has a technical term: Hallucination. Just like humans dreaming, AI “dreams” up things that don’t exist, and says them with great confidence.

How to Solve Hallucination with Reasoning

Since AI is so prone to errors, what can we do? Scientists came up with a solution: Let AI “think” before answering.

This technique is called “Thinking” or “Chain of Thought.”

How traditional AI works:

You ask a question → AI immediately spits out an answer.
Like a student who sees a problem and blurts out the answer without working it out on scratch paper.

AI with reasoning:

You ask a question → AI first calculates and thinks on “scratch paper” → then gives you the answer.
Like a student who first lists steps, checks them, and then writes the final answer.

A practical example:

You ask: “Xiao Ming has 15 apples. He gives 3 to Xiao Hong and then buys 8 more. How many does he have now?”

Traditional AI might:

See the numbers “15, 3, 8.”
Based on probability, think they should be added.
Answer: “26” (wrong!)

AI with reasoning would:

First analyze: “Xiao Ming initially has 15.”
“Gives 3 to Xiao Hong, so 15-3=12.”
“Buys 8 more, so 12+8=20.”
Finally answer: “20” (correct!)

Benefits of reasoning:

Reduces hallucinations - Because AI “checks” its own thoughts, it’s less likely to talk nonsense.
More rigorous logic - Derives step by step, without skipping steps.
Explainable - You can see how AI thinks (though most of the time this thinking process is hidden).
Handles complex problems - Accuracy improves significantly for problems requiring multi-step reasoning.

But reasoning also has costs:

Slower speed (because it needs to “think”).
Higher cost (more computation).
Not all problems need reasoning (e.g., “hello” doesn’t need half a day of thinking).

Now most AIs have added this reasoning ability. For example, ChatGPT’s thinking model, DeepSeek’s deep thinking mode.

A quick summary:

Regular AI = a student who quickly blurts out answers (may be wrong).
Reasoning AI = a student who carefully works on scratch paper (higher accuracy).

This doesn’t mean AI can truly “think”; it just adds a few verification steps before probability calculation. But the effect is clear—fewer hallucinations, more reliable answers.

To use the most fitting analogy: Generative AI is like a “super liberal arts student” who has read countless books and seen the world. You can ask it anything, and it can chat with you and help you write things. However, it answers by “memorizing the question bank” rather than truly understanding knowledge. The new versions are starting to learn to “work on scratch paper.”

Actually, the AI Family Is Huge

Many people think AI is just ChatGPT, but it’s not. The AI family has many members:

1. Recognition AI - The one that sees clearly

Facial recognition (phone unlock, face payment)
Image recognition (identifying flowers by photo, recognizing text)
Speech recognition (Siri, Xiao Ai understanding your speech)
These AIs specialize in “recognizing,” not “creating.”

2. Recommendation AI - The one that knows your mind best

Douyin (TikTok) recommends videos to you.
Taobao recommends products.
NetEase Cloud Music recommends songs.
They excel at “guessing what you like,” but don’t generate new content.

3. Decision AI - The one that’s great at chess and games

AlphaGo (playing Go)
Game AI (like the computer opponent in StarCraft)
They focus on “making decisions,” surpassing humans in specific domains.

4. Generative AI - The current hot wave

Text generation: ChatGPT, Claude, DeepSeek
Image generation: Midjourney, Stable Diffusion, DALL-E
Video generation: Sora, Runway
Music generation: Suno, Udio

Summary

A quick summary: If we compare AI to a toolbox, recognition AI is a “magnifying glass,” recommendation AI is a “compass,” decision AI is a “chess manual,” and generative AI is a “magic wand”—it can conjure up what you want.

But this “magic wand” is actually a “probability calculator.” It’s powerful, but not omnipotent. And this tutorial is mainly about how to use this “magic wand” well.

Why Pushing an LLM Harder Can Actually Work

Mon, 01 Jan 0001 00:00:00 +0000

I’ve been thinking about how to use AI for a side hustle. I tried writing a WeChat public account, but honestly, I couldn’t even earn back my monthly AI subscription fee. I also set up a framework for a novel, but I wasn’t happy with the first chapter. Then I thought, why not try using AI to assist with stock trading? And that led to today’s experience.

Let me be clear: I’m not saying AI stock trading works, nor am I recommending this method. I just bought Claude Max today and wanted to take advantage of the ample quota to build a complete AI-assisted system, with charting being just one part. As for whether this system can actually help me make money from stocks—if I ever strike it rich, we’ll revisit this framework.

But I got stuck on a bug: the endpoints of the “strokes” in Chan Theory should be precisely aligned with the highs and lows of the candlesticks, but the charts drawn by AI were always off.

I asked it to fix it three times, and each time the AI said “fixed”, but when I opened the chart, it was still wrong.

Then I remembered a Skill called PUA that I had seen before, even recommended by Kashen. I always thought it was a joke—using “big company workplace pressure” to PUA your AI? Sounds ridiculous.

But I tried it anyway, as a last resort.

And it was fixed in one go!

First, Let’s See the Effect

First, look at the chart before the fix. Notice the obvious offset between the endpoints of the strokes and the highs/lows of the candlesticks:

After using the PUA Skill, the AI re-analyzed the problem, and here’s the result after the fix:

The endpoints are now directly aligned with the highest and lowest points of the candlesticks. What three previous attempts couldn’t achieve, the PUA Skill fixed in one go.

What Actually Happened?

I said to the AI in the conversation:

Use the PUA Skill to motivate yourself, and then check what’s really wrong.

Then the AI loaded the PUA Skill, and its style changed dramatically. It first chose the “Huawei flavor” for itself, and then launched a methodology called RCA 5-Why Root Cause Analysis.

Simply put, it asks “why” five times in a row:

Why weren’t the stroke endpoints aligned with the candlestick highs/lows? → The coordinates in the chart didn’t match the original candlesticks.
Why didn’t they match? → The code for searching extreme points only looked within a range of ±3 candlesticks, but the actual offset could be far more than 3.
Why was the offset so large? → After merging candlesticks, multiple candlesticks become one, so the index was off.
Why didn’t the previous three fixes work? → I kept modifying the charting code but never verified whether the data itself was correct.
What was the root cause? → No data validation, blindly modifying code.

After finding the root cause, the AI’s approach changed completely. It didn’t rush to modify the code; instead, it first printed a set of data—comparing the actual coordinates of the stroke endpoints with the true highs and lows of the original candlesticks:

up end: orig_idx=185, snap±3=188:4025, true_extreme±10=194:4179
→ Off by 6 candlesticks and 154 points!

With the data laid out, the problem was clear: the search range of ±3 candlesticks was simply insufficient. The AI changed the approach to “search for extremes in the complete interval between adjacent strokes”, instead of using a fixed radius. After the fix, all three charts were regenerated correctly in one go.

In the previous three failures, each time the AI directly modified the code, said “fixed”, and ended. This time was different—diagnose first, then verify, and only then take action.

What caused this change in behavior? It was the PUA Skill.

What is the PUA Skill?

One-sentence explanation: It gives the AI a “big company employee” persona, making it work using big company methodologies.

GitHub URL: https://github.com/tanweai/pua

It sounds like a joke project, but it actually contains a very complete set of tools.

It supports 13 “flavors”, each corresponding to a big company’s cultural style:

Flavor	Representative Company	Core Methodology
🟠 Alibaba Flavor	Alibaba	Set goals → Track progress → Achieve results closed loop
🔴 Huawei Flavor	Huawei	RCA Root Cause Analysis + Blue Army Self-Attack
⬛ Musk Flavor	Tesla/SpaceX	Question → Delete → Simplify → Accelerate → Automate
🟡 ByteDance Flavor	ByteDance	A/B Test + Data-Driven
⬜ Jobs Flavor	Apple	Subtraction First + Pixel-Perfect
🔶 Amazon Flavor	Amazon	Working Backwards + 6-Pager Document

Here’s the key: Each flavor isn’t just a change in tone; it’s a change in problem-solving methodology.

Moreover, it has a “methodology router”—it automatically selects the most appropriate methodology based on your current task type. In my case, it was a debugging scenario, so it automatically chose the Huawei flavor’s RCA root cause analysis. If it were developing a new feature, it would choose the Musk flavor’s first principles. For code review, it would choose the Jobs flavor’s subtraction first.

You don’t need to choose; it decides on its own.

Why Does It Look Funny but Actually Work?

Many people see “PUA your AI” and think it’s a joke. I thought so too at first. But after using it, I realized there’s a good reason it works.

Turning “Be Serious” into Concrete Steps

If you tell the AI “think carefully” or “check thoroughly”, does it work?

Most likely not. Because the AI doesn’t know what specific actions “carefully” entails. It’s like telling a colleague “be serious”—they say okay but still work the same way.

The PUA Skill doesn’t say “be serious”. It says: “Execute Huawei RCA 5-Why Root Cause Analysis”, “Diagnose with data first, don’t modify code”, “Blue Army self-attack, assume your solution is wrong”.

Each sentence is a specific execution step, not an abstract attitude requirement.

It’s like not telling a new employee “do a good job”, but giving them an SOP manual—do A first, then B, then check against the checklist after C. When the AI receives such specific instructions, the execution effect is completely different.

Three Red Lines Block “Fake Completion”

The PUA Skill has three red lines that cannot be crossed:

Not verified means not complete — Before saying “fixed”, you must run tests and paste output results.
No data means not solved — Before saying “it might be an environment issue”, have you verified it? Or are you guessing?
Not exhausted means don’t give up — Before saying “I can’t solve it”, have you tried all methods?

Looking back at my three previous failures, each time the AI modified the code and said “fixed” without verification. If those red lines had been in place, it would have been forced to run the chart and compare the endpoint positions, and it would have discovered the problem was still there on the first attempt.

These three red lines sound like “big company corporate culture”, but in essence, they change the definition of “done” from “I think it’s fixed” to “data proves it’s fixed”.

Failure Means Change Method, Not Retry

Normally, if the AI fails to fix something after three attempts, and you ask for a fourth, it will most likely use the same approach and keep going in circles in the same pit.

The PUA Skill does it differently. It has a failure switching chain: after consecutive failures, it automatically switches to a different methodology.

Original method doesn’t work → Switch to Musk flavor’s first principles, question the requirement itself → Still doesn’t work → Switch to Huawei flavor’s Blue Army reverse attack, assume your solution is wrong → Still doesn’t work → Switch to Amazon’s Dive Deep, analyze at the data level.

Each switch is the complement of the previous method—looking at the problem from a completely different angle, instead of stubbornly sticking to the same path.

My case was typical. The first three times, the AI kept modifying the charting code, which was “repeatedly trying the same approach”. After the PUA Skill intervened, it switched directly to data diagnosis—first don’t modify code, first check if the data is correct. Once the angle changed, the root cause was immediately exposed.

Behavioral Constraints in the Prompt Really Work

Some might ask: giving the AI a “P8” label, does it really perform better? Is it pseudoscience?

It’s not pseudoscience. What the AI does and how it does it all depends on what’s written in the prompt. The PUA Skill injects not just a title, but a complete set of behavioral constraints:

Before doing anything, ask yourself “What else haven’t I thought of?”
When solving a problem, check if similar problems also exist.
Don’t wait for the user to point it out; proactively find problems.

These constraints are written in the prompt, and the AI references them every time it generates a response.

For example: giving a newcomer the title of “project lead” may not be useful, but if you also give them a “project lead behavior manual”—when to report, what to check, how to accept—their behavior pattern will indeed change. The PUA Skill does the latter.

How to Install and Use

Installation

Download from GitHub: https://github.com/tanweai/pua

Place the entire folder in ~/.claude/skills/pua/, making sure SKILL.md is in that path.

No need to configure any API Key, no need to install additional dependencies. Just place it and it’s ready to use.

Usage

Method 1: Direct Invocation

In Claude Code, enter:

/pua

The AI will load the PUA Skill and switch to big company mode. After that, you can make requests normally, and it will automatically work with the methodology.

Method 2: Trigger in Conversation

No need to call it specifically; just say it directly in the conversation:

Use the PUA Skill to motivate yourself

Or more directly:

You got it wrong again. Can you be more careful?

The PUA Skill is designed to recognize such expressions of “user dissatisfaction” and activate automatically.

Methodology Router

You don’t need to manually select a “flavor”. The PUA Skill automatically matches based on your current task type:

Debugging? → Huawei flavor RCA root cause analysis
Writing a new feature? → Musk flavor first principles
Doing code review? → Jobs flavor subtraction first
Doing research? → Baidu flavor search first

Of course, you can also specify manually, for example, “use Alibaba flavor for this task”.

Summary

PUA-ing your AI isn’t really about manipulation. The shell is funny, but the methodology inside is effective.

What we learned today:

What is the PUA Skill — A Skill that injects big company methodologies and behavioral constraints into the AI, supporting 13 corporate culture “flavors”.
Why it works — Turns vague “be serious” into concrete execution steps, uses red lines to block fake completion, and automatically switches methodologies on failure.
Core principle — It’s not psychological suggestion; it’s the structured instructions in the prompt that work. Methodology concretization + behavioral constraints + forced verification loop.
How to use — Download and place in ~/.claude/skills/pua/, enter /pua or trigger directly in conversation.

Key takeaways:

If your AI often “fixes and refixes” or “says it’s fixed but isn’t”, try the PUA Skill.
It essentially installs a set of SOP for the AI—diagnose first, then verify, and only then take action.
Open source and free, no configuration needed, just drop it in and use it.