Claude Code on Svtter's Blog

DeepSeek + Claude Code: Thinking Block Compatibility Analysis

Thu, 30 Apr 2026 15:00:00 +0800

Problem Description

When using DeepSeek models (such as deepseek-v4-flash) directly in Claude Code with extended thinking enabled, multi-turn conversations trigger a 400 error:

1

Bad Request: {"error":{"message":"The content[].thinking in the thinking mode must be passed back to the API.","type":"invalid_request_error","param":null,"code":"invalid_request_error"}}

Root Cause Analysis

Call Chain

1

Claude Code → DeepSeek Anthropic Compatible Endpoint (https://api.deepseek.com/anthropic)

Protocol Incompatibility

According to the DeepSeek Anthropic API Compatibility Documentation, the compatibility status is as follows:

Message Field	Support Status
`content[].thinking`	✅ Supported
`content[].redacted_thinking`	❌ Not Supported

In extended thinking mode during multi-turn conversations, Claude Code faithfully passes back all thinking blocks from the previous round (including redacted_thinking types) to the API as-is. DeepSeek does not recognize redacted_thinking, hence the 400 error.

Additionally, DeepSeek’s thinking block format differs from Anthropic’s native protocol, and the replay logic in tool_use scenarios is not fully compatible either.

Core Conflict

Anthropic API requirement: In extended thinking mode, content[].thinking and content[].redacted_thinking must be passed back unchanged
DeepSeek compatibility layer: Only supports thinking, does not support redacted_thinking
Claude Code behavior: Hard-coded according to Anthropic protocol, does not distinguish between target endpoint types

Community Feedback

This is a widespread community issue that almost all CC agent/router projects have encountered:

Issue	Project	Title
#1	cc-use	DeepSeek Thinking Mode Error: `content[].thinking` Must Be Passed Back
#878	openclaude	DeepSeek V4: reasoning_content must be passed back (400) on tool_calls
#1355	claude-code-router	CCR 代理 deepseek V4 思考时返回 400
#4543	new-api	ClaudeCode 接入 DeepSeek V4 遇到 400 reasoning_content 报错
#355	9router	DeepSeek API Error 400 – Missing reasoning_content
#16748	hermes-agent	DeepSeek /anthropic: stripped thinking blocks cause HTTP 400 on replay
#2414	cc-switch	Claude 使用 cc-switch 配置 deepseek-v4-pro，无法识别字段
#174	cc-haha	/compact 命令在使用 DeepSeek API 时无法工作

DeepSeek Official Response

Zero response. Nor is there any need to respond.

First, DeepSeek has no public API issue repository. All feedback occurs in third-party projects without any DeepSeek official personnel participating in any discussions.
Second, whether to use Anthropic as a compatibility standard, I think DeepSeek should be hesitant.

Temporary Workarounds

Disable extended thinking — When using DeepSeek in CC, turn off thinking mode
Use proxy filtering — Add a proxy layer between CC and DeepSeek to filter out redacted_thinking blocks
Switch models — Use DeepSeek for non-thinking scenarios and Anthropic native models for thinking scenarios

Why Doesn’t OpenCode Have This Problem?

OpenCode (opencode-ai/opencode) naturally avoids this problem architecturally, not through a dedicated “fix”.

The key lies in the convertMessages method in internal/llm/provider/anthropic.go (lines 60-119):

When building assistant messages, it only passes back TextContent (text) and ToolCall (tool calls)
Completely ignores ReasoningContent (thinking content), not putting it in messages
thinking content is only displayed in the UI through stream thinking_delta events and is not passed back to the API

Comparison with Claude Code’s behavior:

	Claude Code	OpenCode
thinking replay	✅ Faithfully replay all thinking blocks (including redacted_thinking)	❌ Do not replay thinking blocks
architectural reason	Follow Anthropic API specification, requires unchanged replay	Self-managed conversation state, thinking only for UI display
DeepSeek compatibility	❌ Triggers 400 (redacted_thinking not recognized)	✅ Not affected (doesn’t pass thinking at all)

Conclusion: OpenCode avoids the problem at the cost of not following Anthropic’s extended thinking specification. This approach is friendly to third-party compatible endpoints like DeepSeek, but if Anthropic native thinking context retention capability is needed in the future, re-implementation may be necessary.

Does Not Replay Thinking Blocks Affect DeepSeek Performance?

Basically no, reasons:

thinking blocks are the model’s internal scratchpad, not final output. The text replies and tool calls in the conversation history already retain key decisions and conclusions
DeepSeek’s reasoning is closer to OpenAI’s mode — each round is generated independently, unlike Anthropic’s strong reliance on cross-round replay to maintain reasoning coherence
OpenCode’s extensive actual use also confirms this — community users run multi-turn conversations using DeepSeek thinking mode in OpenCode without feedback about reasoning quality degradation

The truly potentially affected extreme scenario: in ultra-long multi-turn tasks, the model may repeat conclusions it has already reasoned through. However, in most actual use, the impact is negligible.

CC itself has similar thinking block replay bugs on Anthropic models (not DeepSeek-specific):

Issue	Title	Status
#10199	API Error 400 - Thinking Block Modification Error	Open (oncall)
#51985	thinking block missing in multi-turn conversations	Open
#20692	thinking blocks order error on first tool use	Open (oncall)
#54482	Thinking blocks stripped from context every turn (Opus 4.7)	Open

The Mathematical Trap of Big Model Coding Plan Packages: Can Promised Usage Be Delivered Under Concurrency Limits?

Fri, 23 Jan 2026 11:52:52 +0800

Preface

Recently, several domestic big model manufacturers have launched Coding Plan subscription packages for developers, promoting “low prices for massive usage,” claiming that for just tens to hundreds of RMB per month, you can get “hundreds of billions of tokens” of usage quota.

It sounds wonderful, but as a developer accustomed to speaking with data, I decided to do some calculations: Under concurrency limits, can these promised usage amounts really be consumed?

Typical Package Structure

Taking the common three-tier packages on the market as an example:

Package	Monthly Fee	Promised Usage (every 5 hours)
Lite	~20 RMB	About 120 prompts
Pro	~100 RMB	About 600 prompts
Max	~200 RMB	About 2,400 prompts

Officials will also add: “Each prompt is expected to call the model 15-20 times, with a total monthly usage of up to tens to hundreds of billions of tokens.”

It seems like incredible value, but the devil is in the details.

Key Limitation: Concurrency

Most manufacturers’ documentation will casually mention: “Package usage is subject to concurrency limits (number of in-flight request tasks).”

But what exactly is the limit? Often not explicitly stated. According to community feedback and actual measurements, typical concurrency limits are as follows:

Package	Concurrency (in-flight requests)
Lite	2
Pro	~4-5
Max	~7

This number directly determines your actual throughput ceiling.

Math Time: Can the Max Package Use 2,400 Prompts?

Let’s take the highest-tier Max package as an example and do a simple calculation.

Known Conditions

Promised Usage: 2,400 prompts every 5 hours
Concurrency Limit: 7
Model calls triggered per prompt: 15-20 times (official data)
Model generation speed: About 50-60 tokens/second
5 hours = 18,000 seconds

Calculation Process

Step 1: Estimate single API call time

A complete API call includes:

Input processing: ~1 second
Model inference generation (assuming 500 tokens output): 500 ÷ 55 ≈ 9 seconds
Network round-trip delay: ~1 second

Total: About 10-12 seconds/call

Step 2: Calculate maximum calls in 5 hours

1
2
3


Maximum calls = Concurrency × (Total time ÷ Single call time)
 = 7 × (18,000 ÷ 10)
 = 12,600 calls

Step 3: Convert to prompts

According to official claims, each prompt triggers 15-20 calls:

1

Completable prompts = 12,600 ÷ 17.5 ≈ 720 prompts

Conclusion

Metric	Official Promise	Concurrency Limit	Achievement Rate
Prompts per 5 hours	2,400	~720	30%

Even under ideal conditions, the actual usable amount of the Max package is only about 30% of the promise.

Harsher Reality: Call Inflation in Agent Mode

The above calculation is still based on the official claim of “15-20 calls per prompt.” But in actual AI Coding Agent scenarios (like Claude Code, Cline, etc.), the situation is much worse.

How Agent Mode Works

When you give an AI programming assistant a task, it typically:

Analyzes requirements, creates a plan
Reads relevant files (each file may trigger a call)
Writes code
Runs tests
Discovers errors, fixes them
Repeats 3-5 until successful

A seemingly simple prompt may trigger 50-100+ model calls in an Agent loop.

Actual Measurement Case

User feedback:

“2 simple prompts, 80 seconds, consumed 38M Tokens, used up 97% of the 5-hour limit”

Reverse calculation:

Each prompt consumes about 19M tokens
If calculated at 128K context, equivalent to ~127 model calls/prompt

This is 6-8 times higher than the official “15-20 times.”

Revised Actual Usable Amount

Scenario	Calls per prompt	Usable prompts in 5 hours	Achievement Rate
Official ideal	17.5	720	30%
Light usage	50	252	10.5%
Moderate usage	75	168	7%
Heavy Agent usage	100+	<126	<5%

Why Is This Happening?

1. Token Calculation Includes Context

Big model token consumption isn’t just output, it includes input. In Coding scenarios:

Each call must send complete conversation history
Code project context can easily reach tens of K tokens
128K context window means each call may consume 100K+ tokens

2. Concurrency is a Hard Constraint

Regardless of how large your package quota is, concurrency determines the maximum throughput per unit time. This is a physical bottleneck, not something commercial strategies can bypass.

3. Promises Based on Ideal Assumptions

Manufacturers’ promotional numbers are often based on:

Each call uses only small context
Each prompt triggers only a few calls
Users won’t use continuously at high intensity

But these assumptions rarely hold true in real AI Coding scenarios.

A Table to See the Truth

Taking the Max package (~200 RMB/month) as an example:

Metric	Official Promotion	Theoretical Limit	Actual Expectation
Prompts per 5 hours	2,400	720	150-400
Monthly prompts	345,600	103,680	21,600-57,600
Monthly tokens	“Hundreds of billions”	~10 billion	1-3 billion
Achievement Rate	100%	30%	5-17%

Advice for Developers

1. Don’t Be Fooled by “Hundreds of Billions of Tokens”

Token count is a highly misleading metric. In Coding Agent scenarios, context takes up the majority, with truly effective output tokens possibly only 1-5%.

2. Focus on Concurrency

This is the core metric that determines actual experience. If manufacturers don’t disclose concurrency limits, it’s likely because the numbers don’t look good.

3. Calculate Cost per Prompt

1

Actual cost per prompt = Monthly fee ÷ Actual usable prompts

Taking the Max package as an example:

Official promotion: 200 ÷ 345,600 = 0.0006 RMB/prompt
Actual situation: 200 ÷ 30,000 = 0.007 RMB/prompt

A 10x difference.

4. Consider Pay-as-You-Go

If your usage isn’t high, pay-as-you-go may be more cost-effective than monthly packages. At least you won’t pay for “unusable quotas.”

Conclusion

The emergence of big model Coding Plan packages is itself a good thing, lowering the barrier for developers to use AI programming assistants. But when choosing packages, be sure to:

Require manufacturers to disclose concurrency limits
Calculate throughput limits yourself
Don’t be misled by the big numbers of “hundreds of billions of tokens”

After all, promised usage that can’t be consumed equals a disguised price increase.

This article is based on public information and mathematical derivation; specific values may vary due to manufacturer adjustments. Readers are advised to verify through actual measurements.

Recently Discovered Useful MCP Tools

Sat, 17 Jan 2026 22:18:33 +0800

Recently, I’ve been extensively using the opencode/claude code combination for development and have explored three particularly useful tools.

They address several issues:

Parallel development on a single server; controlling tmux: tmux and tmux-mcp
Preventing claude code from stopping at meaningless points: ralph-loop
End-to-end automated testing: playwright mcp

Tool List

tmux mcp

First, configure tmux in the Linux environment with opencode, then have opencode install https://github.com/rinadelph/tmux-mcp.git. Once installed, you can use oc to control tmux content.

This method can be used to reactivate stopped opencode sessions. For example, you can open multiple tmux sessions and have one opencode monitor, start, and stop tasks through the tmux tool.

ralph-loop

Ralph is an autonomous AI agent loop that repeatedly runs Amp until all PRD items are completed. Each iteration creates a brand new Amp instance with a clean context.

Ralph likely originated from here: https://github.com/snarktank/ralph

Due to its effectiveness (which actually occurred after further improvements in model performance), it was also introduced to claude code.

Ralph-loop is a Claude Code plugin that allows Claude Code to automatically restart when tasks are completed, forming a loop execution mechanism. This is particularly useful for tasks that require continuous improvement or iteration.

Installation Method

Install through Claude Code official plugin market:
- /plugin install ralph-wiggum@claude-plugins-official or cc '/plugin install ralph-wiggum@claude-plugins-official'
Configuration and Usage:
- After installation, you can start it in Claude Code via the /ralph-loop command
- Set tasks and termination conditions, Claude Code will automatically restart each time it stops
- This is particularly useful for scenarios requiring multiple iterations of code improvement, debugging, or testing

Use Cases

Code Refactoring: Have Claude Code continuously improve code quality
Test-Driven Development: Write tests, then have Claude Code continuously improve implementations
Debugging Loops: Automatically restart debugging sessions
Continuous Integration: Simulate CI/CD processes locally

The drawback of this plugin is that it consumes a lot of tokens; without a max20 subscription, it’s better not to use it. However, for tasks requiring high-quality output, this tool can significantly improve work efficiency.

playwright mcp

This plugin can launch browsers to complete end-to-end testing or write end-to-end test code. It can better form loops to have cc or oc improve code.

Installation method: claude 'help me install playwright mcp'

Rewriting as Agents

I recommend directly rewriting these tools and MCPs as agents through opencode or claude code.

Compared to skills commands, these tools are more suitable for invocation through agents. Agent context is very clean, making tool invocation almost inevitable.

Summary

As LLMs become increasingly powerful, numerous MCPs that rely on LLM capabilities naturally gain improvements. Tools that weren’t very useful before become more effective. This aligns with the saying: “Don’t build things that become meaningless after large model capability enhancements.” Large model capabilities continue to improve, and prices keep decreasing.

I believe the next step is to bridge interactions between different modalities and tools, as well as endowing tools with large model capabilities, which is one of the inevitable development directions for agent engineers.

Configuring Claude Code Python UV Hooks and Skills

Tue, 30 Dec 2025 10:00:00 +0800

My project uses uv to manage Python dependencies, but Claude Code habitually defaults to python or pip install. I tried using Skills and Hooks to enforce this standard and encountered quite a few pitfalls.

Goal

Create a Skill: Inform Claude that the project uses uv
Create a Hook: Intercept python/pip commands
Verify effectiveness

Troubleshooting Journey

First Attempt: Wrong Skill File Structure (Commit 8a05759)

1
2


❌ .claude/skills/python-uv.md
✅ .claude/skills/python-uv/SKILL.md

The frontmatter also needed changes:

1
2
3
4
5
6
7
8
9


---
# Wrong
description: Python dependency and execution management using uv
location: project

# Correct
name: python-uv
description: Python dependency and execution management using uv. Use when adding Python packages, running Python scripts, or managing Python dependencies. Enforces uv instead of pip/python commands.
---

Key points:

Filename must be SKILL.md, placed in the corresponding directory
Frontmatter requires a name field
description should be detailed to help Claude identify when to trigger

Second Attempt: Hook Only Warns Without Blocking (Commit d250c3b)

Initially wrote the Hook in Bash, which only displayed warnings but didn’t prevent execution. Also tried configuring environment.PATH, which didn’t work.

Third Attempt: Wrong Hook Exit Code (Commit d3790a4)

Tried using exit 1 to block commands, but it still didn’t work.

Correct exit codes:

exit 0: Allow execution
exit 1: Hook fails, but doesn’t block the tool
exit 2: Actually blocks tool execution ✅

Fourth Attempt: Fixed Skill Format (Commit 2595b68)

Found the file structure was wrong, changed to the correct skills/xxx/SKILL.md format.

Fifth Attempt: Rewrote Hook in Python (Commit dcc726d)

Bash JSON parsing was too fragile, ultimately rewrote in Python:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


#!/usr/bin/env python3
"""
Hook to block python/python3 commands and enforce uv usage.
"""
import json
import sys
import re

try:
 # Correctly parse JSON input
 input_data = json.load(sys.stdin)
except json.JSONDecodeError as e:
 print(f"Error: Invalid JSON input: {e}", file=sys.stderr)
 sys.exit(1)

# Get tool name and command
tool_name = input_data.get("tool_name", "")
tool_input = input_data.get("tool_input", {})
command = tool_input.get("command", "")

# Only process Bash tool
if tool_name != "Bash" or not command:
 sys.exit(0)

# Check if using python/python3
if re.search(r'\bpython3?\b', command):
 # Whitelist: allow version checks etc.
 if re.search(r'(--version|--help|which python)', command):
 sys.exit(0)

 # Block command
 error_msg = (
 f"\n❌ BLOCKED: This project requires using 'uv'\n\n"
 f"Original command:\n {command}\n\n"
 f"Suggested replacement:\n {suggested}\n"
 )

 print(error_msg, file=sys.stderr)
 sys.exit(2) # Use exit 2 to block tool invocation

# Allow other commands
sys.exit(0)

Configuration file (.claude/settings.json):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


{
 "hooks": {
 "PreToolUse": [
 {
 "matcher": "Bash", // Simplified matcher format
 "hooks": [
 {
 "type": "command",
 "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/pre-bash"
 }
 ]
 }
 ]
 }
 // Remove ineffective environment.PATH configuration
}

Notes:

matcher can directly specify the tool name, no need for expressions
Use $CLAUDE_PROJECT_DIR to reference the project path
environment.PATH configuration doesn’t work in Hooks, don’t waste time on it

Final File Structure

1
2
3
4
5
6
7


.claude/
├── skills/
│ └── python-uv/
│ └── SKILL.md
├── hooks/
│ └── pre-bash # Python script
└── settings.json

Testing

✅ Block regular commands:

1
2


$ python test.py
❌ BLOCKED: Use 'uv run' instead

✅ Allow version checks:

1
2


$ python --version
Python 3.11.0

✅ Skill active: When asked “how to run Python scripts,” Claude will proactively suggest using uv run.

Key Points

Claude Code Sometimes Doesn’t Proactively Query Specifications

I explicitly requested creating Hooks and Skills, but Claude Code started writing code without first checking the official documentation. This led to:

File structure errors multiple times
Wrong exit codes
Incorrect JSON parsing approach

If it had used WebFetch to read the official Hook and Skill documentation before starting, all these pitfalls could have been avoided.

This isn’t about users needing to read documentation, but rather that AI agents should check specifications before executing unfamiliar tasks.

Skills and Hooks Can Indeed Enforce Claude Code’s Behavior

Hooks can constrain Python commands to provide the correct command suggestions. This is also the approach used in Kilo Code.

References

Running Claude Code in a VM for Automated Testing and Development

Thu, 25 Dec 2025 00:00:00 +0800

Recently, I verified an effective AI development method that doesn’t affect the existing workflow. Here’s a summary.

Why Choose VM + Claude Code

Isolation: Avoid polluting the main system, can snapshot and rollback
Reproducibility: Team members can quickly replicate the same environment
Suitable for automated testing: Browser automation tools like Playwright require a desktop environment
Safety: Not too worried about agent generating rm -rf / commands. VM crashes don’t affect the virtualization platform; just recreate it.

Environment Setup

1. PVE Creates Ubuntu Desktop VM

Download Ubuntu Desktop ISO, upload to PVE’s ISO storage
Create VM:
- CPU: host type, 2-4 cores
- RAM: 4-8 GB
- Disk: VirtIO SCSI, 40GB+
- Network: VirtIO
Mount ISO and start installation
After installation, install qemu-guest-agent:

1
2


sudo apt install qemu-guest-agent
sudo systemctl enable --now qemu-guest-agent

2. Configure Xfce + xrdp Remote Desktop

Install xrdp and Xfce (lighter and more compatible than GNOME):

1
2
3
4
5
6


sudo apt install xrdp
sudo systemctl enable xrdp
sudo systemctl start xrdp

sudo apt install xfce4 xfce4-goodies
echo xfce4-session > ~/.xsession

During installation, when prompted to choose a display manager, select lightdm.

Solve Black Screen Issue

Edit xrdp startup script:

1

sudo nano /etc/xrdp/startwm.sh

Before the last two lines test -x and exec, add:

1
2
3


unset DBUS_SESSION_BUS_ADDRESS
unset XDG_RUNTIME_DIR
startxfce4

Restart xrdp:

1

sudo systemctl restart xrdp

Note: Don’t log in to the desktop locally before connecting, otherwise the same user will see a black screen.

Adjust Resolution/DPI

Before Windows remote desktop connection, lower the resolution in “Display Options” (e.g., 1920×1080)
Or in Xfce: Settings Manager → Appearance → Fonts → Increase DPI (e.g., 120)

Disable Crash Prompts

After switching desktops, there may be GNOME component crash prompts (doesn’t affect usage):

1

sudo systemctl disable apport

3. Install Claude Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# Install Node.js (e.g., using nvm)
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash
source ~/.bashrc
nvm install --lts

# Install Claude Code
npm install -g @anthropic-ai/claude-code

# Or use official installation script
curl -fsSL https://claude.ai/install.sh | bash

Run claude command for the first time and follow prompts to log in and authenticate.

Automated Testing Workflow: MCP Configuration

Playwright MCP

MCP	Features
`@playwright/mcp` (Microsoft official)	Lightweight, based on accessibility tree
`@executeautomation/playwright-mcp-server` (community)	More complete features, supports screenshots, JS execution
`@agentdeskai/browser-tools-mcp`	Console log monitoring, Lighthouse performance analysis

Claude Code Configuration

Create .mcp.json in project root:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


{
 "mcpServers": {
 "playwright": {
 "command": "npx",
 "args": ["-y", "@executeautomation/playwright-mcp-server"]
 },
 "browser-tools": {
 "command": "npx",
 "args": ["-y", "@agentdeskai/browser-tools-mcp"]
 }
 }
}

Or add via CLI:

1

claude mcp add playwright --scope project -- npx -y @executeautomation/playwright-mcp-server

OpenCode Configuration

If using OpenCode, the configuration format is different (opencode.json):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


{
 "$schema": "https://opencode.ai/config.json",
 "mcp": {
 "playwright": {
 "type": "local",
 "command": ["npx", "-y", "@executeautomation/playwright-mcp-server"],
 "enabled": true
 },
 "browser-tools": {
 "type": "local",
 "command": ["npx", "-y", "@agentdeskai/browser-tools-mcp"],
 "enabled": true
 }
 }
}

Configuration Comparison:

Configuration Item	Claude Code	OpenCode
Top-level key	`mcpServers`	`mcp`
type	Not needed	Required (`local`)
command	String	Array

Usage Example

After configuration, you can drive tests with natural language:

1
2
3
4
5


claude "Open localhost:3000, test the login flow, verify if it redirects to homepage"

claude "Screenshot and compare homepage layout under mobile/tablet/desktop sizes"

claude "Check if page console has any errors"

Results Display

Summary

The VM + Claude Code + Playwright MCP combination provides an isolated, reproducible automated development testing environment. The entire process:

PVE creates Ubuntu Desktop VM
Configure Xfce + xrdp remote access
Install Claude Code / OpenCode
Configure Playwright MCP
Drive automated testing with natural language

Developing Fried Rice Theme with Claude Code

Tue, 23 Dec 2025 15:00:00 +0800

Recently, I used Claude Code to add some SEO features to my own blog theme Fried Rice, and the overall experience was quite good.

Background

Fried Rice is a theme forked from hugo-theme-stack. Previously, I had already added some basic JSON-LD structured data, and this time I wanted to continue improving it.

What Was Done This Time

Mainly enhancing SEO structured data:

WebSite schema (supports search action)
Organization schema (includes founder, contact point, address)
FAQ schema (supports inline FAQ in articles)
Enhanced Article/BlogPosting schema (added accessibility metadata)

Claude Code’s Performance

The entire development process took about 2 hours. Claude Code helped me:

Write code - Hugo template syntax is cumbersome, letting AI write it saves a lot of effort
Review code - After I committed, I asked it to check, and it found several issues:
- datePublished was defined 3 times
- founder object was defined repeatedly
- JSON output had double escaping issues
- Variable scope errors
Fix issues - After finding issues, I asked it to fix them directly, all fixed at once
Create PR, tag, write CHANGELOG - These trivial tasks can also be done

A pleasant surprise was that it could find logical issues in the code. For example, Hugo’s jsonify output was HTML-escaped causing JSON format errors, and it found the correct solution (using safeJS).

Shortcomings

Sometimes needs multiple reminders to use the correct tools
Not very familiar with Hugo template syntax in some places, needs several iterations

Summary

For this kind of “add feature + fix bug” task, Claude Code is quite useful. Especially for tedious syntax like Hugo templates, having AI write it is much more efficient.

Based on:

CS146S is a Good Course

Mon, 15 Dec 2025 20:45:35 +0800

CS146S is a good course, one of the reasons is that it teaches modern software engineers how to better collaborate with AI. Secondly, it basically covers all my modern coding capabilities. (It’s a joke!)

In the following content, I will embed the slides from the course as hyperlinks in my text. If you’re interested, you can click the hyperlinks directly to open the corresponding slides.

Basic Techniques

I think everyone, like me, has already mastered the basic capabilities. More clear and explicit prompts let LLMs execute instructions unambiguously. Additionally, there are prompt optimization techniques, and using Claude to optimize prompts.

The course also talked about how to build coding agents, emphasizing that you can use the Claude Code SDK. It’s now called Claude Agent SDK.

To enhance LLM capabilities, you can also use MCP services. I built git-mcp, and there’s also an unopen-sourced experimental startup MCP.

MCP a bit deeper (content from the PPT)

With MCP, it’s worth noting the Host/Server/Client concept. Many Hosts are not open-source. Deepchat’s Host can be referenced.

Limitations:

1
2
3


Agents don't handle many tools very well today
APIs eat up your **context** window quickly
Design APIs to be AI-native rather that rigid

IDE Agent

From the IDE perspective, I’ve switched from frequently using Cursor to using Claude Code + VSCode for programming. I feel Claude Code as a CLI is more powerful. However, I haven’t used Cursor for a while, so I don’t know if there have been some improvements. Trae’s solo mode is just like that, basically insufficient intelligence is the biggest problem. Trae CN.

Additionally worth mentioning is that Silas Alberti, Head of Research Cognition’s slides are very powerful.

This summary diagram is awesome. Is it really free to watch?

This article also mentions the concept of parallel agents.

So for me, the next direction to improve is cloud + async.

This is Silas Alberti’s advice:

devin and Claude Code Cloud are exactly the same. Actually, you can completely use Claude Code Cloud version for vibe coding.

Agent Manager

Engineers need to become agent managers, not just software engineers.

Under the Claude Code designer mindset, the software design process should be:

Provide high level requirements 🟩
Convert requirements into a design doc 🟩/🟦
Implement solution from doc 🟦
Add tests 🟦
Ensure CI (continuous integration) passes 🟦
Code review 🟦
Update docs 🟦

My habit is more to write simple requirements, then generate design, then let Claude Code implement the rest itself.

I recently found it’s not that capable. I adopted a test-driven development approach to ensure every step is done correctly. Otherwise, CI and Add tests actually have no meaning.

Techniques for directing agents:

Agent behavior files (Claude.md/Cursorrules/agents.md)
Hooks
Commands
Subagents

I’ve already used subagents and commands a lot. But I haven’t found a killing scenario for hooks yet.

Best practice Claude Code

What I want to say is to use subagents as much as possible to avoid the “lost in the middle” phenomenon.

Claude Code CLI

Why did I buy Claude Code?

We can do more things through the SDK:

1
2
3
4


claude -p \
 "what did i do this week?" \
 --allowedTools Bash(git log:*)
 --output-format stream-json

Conclusion

This course is free, but the insights inside surpass most paid courses. If you can understand and quickly absorb it, don’t be stingy with your time, learn it.

Claude Code Plugin Usage Experience

Tue, 14 Oct 2025 10:16:54 +0800

Overall, the experience was not good.

It’s likely because it’s newly launched and generally feels immature.

Typical issues include:

Not using available agents.
Not using available MCP.

Tool calls are infrequent and require manual prompting. As a user, I generally don’t deliberately memorize which agents are available.

More importantly, it impacts efficiency.

If using DeepSeek V3.2, its relatively short context length (128K) means it doesn’t perform well when there are many tools or MCP connections.
Plugins often don’t improve the tool usage experience; they can actually degrade it. This is because MCP tools and plugins increase the input token count, forcing the model to process more context. Since the computational complexity of transformers is O(n²), any increase in length has a significant negative impact.

In summary, it’s not recommended for use at this time.

Several Issues with Zhipu GLM-4.5 in Programming

Tue, 23 Sep 2025 10:24:43 +0800

Through some leaderboards and the report, I saw that glm-4.5 received high scores, so I gritted my teeth and subscribed to the annual coding plan.

However, while using the Zhipu glm4.5 coding plan, I encountered several issues that severely impacted my work efficiency.

Cline

In cline, there are roughly a few problems.

Problem One: Simple diff tool calls fail to output correctly.

Problem Two: The task list tool is unusable.

I once suspected it was a cline issue. But then I thought, deepseek, gpt-5, and claude-4-opus all work fine.

The prompt doesn’t change because of these. It’s most likely an issue with Zhipu glm-4.5.

Claude Code

Misunderstanding problems (unable to understand some simple natural language)
Incoherent responses, not listening to the user, failing to identify the target.

Later, if I find similar situations, I will add screenshots to this blog post. I don’t want to waste more time on this.

There’s also a common issue: obsequiousness.

Stopped Responding

A new problem encountered on 2025-10-03: it stopped providing feedback while answering a question and terminated the process.

The most likely cause of this problem is a lack of adaptation to the thinking interface, resulting in it thinking but not displaying the content.

Summary

Based on my current experience, among domestic AIs, apart from DeepSeek, the other major players tend to have unstable model outputs.

Without a doubt, Anthropic is the leader in this field.

I genuinely doubt the friends who told me Zhipu is good—have you actually used AI for programming? If so, how do you tolerate these issues? How has your efficiency improved?

If you think these problems are inevitable, then I sincerely suggest you use Anthropic’s products and models.

Aside

I really don’t want to use glm anymore, but there’s no choice—I’ve already paid for the annual subscription, and it’s non-refundable.

Therefore, as a user, you can only hope that glm will update its model.

As a consumer or customer, this feels very uncomfortable. It’s okay if the product isn’t fully developed yet; just don’t release it, or don’t charge for it like this. At 200 yuan a month, I might as well put all that money into deepseek. That’s a model that truly stands up to scrutiny.

Getting a refund is troublesome. I think reporting it to the consumer association could solve the problem to some extent. But it’s a waste of time. Furthermore, continuing to use it is a sunk cost. Therefore, I can only do this: I will not spend another cent on Zhipu in the future.

Update

Very strange!

Not long after I published this article, I found that the usability of glm-4.5 has become significantly better.

If you’re interested in experiences with other AI coding plans, you can read my other articles:

I Bought the Kimi Coding Plan Again - Experience and configuration methods for the Kimi monthly plan.
Doubao doubao-seed-code Test - In-depth testing of ByteDance’s Doubao coding plan.

How to Use Claude Code With Deepseek

Tue, 26 Aug 2025 14:42:54 +0800

Sometimes we cannot directly use the Anthropic API. However, the Claude Code (CC) experience is excellent, and we still want to use CC.

In such cases, you can try using the API provided by DeepSeek to access CC.

DeepSeek has already provided the corresponding interface: How to Use the Claude Code + DeepSeek Combination?

Currently, there are two mainstream LLM APIs: one is OpenAI, and the other is Anthropic. Anthropic has gained a certain level of influence through CC.

If you want to learn more about the use cases for CC, I recommend reading Anthropic’s Official Blog.

Additionally, here are some supplementary resources:

https://mp.weixin.qq.com/s/gk0tzMxWZ-NgsUWg5iLoSg

Claude Code on Svtter's Blog

DeepSeek + Claude Code: Thinking Block Compatibility Analysis

Problem Description

Root Cause Analysis

Call Chain

Protocol Incompatibility

Core Conflict

Community Feedback

DeepSeek Official Response

Temporary Workarounds

Why Doesn’t OpenCode Have This Problem?

Does Not Replay Thinking Blocks Affect DeepSeek Performance?

Related Claude Code Native Issues

The Mathematical Trap of Big Model Coding Plan Packages: Can Promised Usage Be Delivered Under Concurrency Limits?

Preface

Typical Package Structure

Key Limitation: Concurrency

Math Time: Can the Max Package Use 2,400 Prompts?

Known Conditions

Calculation Process

Conclusion

Harsher Reality: Call Inflation in Agent Mode

How Agent Mode Works

Actual Measurement Case

Revised Actual Usable Amount

Why Is This Happening?

1. Token Calculation Includes Context

2. Concurrency is a Hard Constraint

3. Promises Based on Ideal Assumptions

A Table to See the Truth

Advice for Developers

1. Don’t Be Fooled by “Hundreds of Billions of Tokens”

2. Focus on Concurrency

3. Calculate Cost per Prompt

4. Consider Pay-as-You-Go

Conclusion

Recently Discovered Useful MCP Tools

Tool List

tmux mcp

ralph-loop

Installation Method

Use Cases

playwright mcp

Rewriting as Agents

Summary

Configuring Claude Code Python UV Hooks and Skills

Goal

Troubleshooting Journey

First Attempt: Wrong Skill File Structure (Commit 8a05759)

Second Attempt: Hook Only Warns Without Blocking (Commit d250c3b)

Third Attempt: Wrong Hook Exit Code (Commit d3790a4)

Fourth Attempt: Fixed Skill Format (Commit 2595b68)

Fifth Attempt: Rewrote Hook in Python (Commit dcc726d)

Final File Structure

Testing

Key Points

References

Running Claude Code in a VM for Automated Testing and Development

Why Choose VM + Claude Code

Environment Setup

1. PVE Creates Ubuntu Desktop VM

2. Configure Xfce + xrdp Remote Desktop

Solve Black Screen Issue

Adjust Resolution/DPI

Disable Crash Prompts

3. Install Claude Code

Automated Testing Workflow: MCP Configuration

Playwright MCP

Claude Code Configuration

OpenCode Configuration

Usage Example

Results Display

Summary

Developing Fried Rice Theme with Claude Code

Background

What Was Done This Time

Claude Code’s Performance

Shortcomings

Summary

Related Projects