MiniMax on Wanzi's Blog – Notes on life, tech, and DevOps.

Kaku Best Practices

wzdushu@gmail.com (wanzi) — Sat, 21 Mar 2026 10:30:00 +0800

Kaku is a terminal emulator for macOS featuring built-in AI assistant capabilities, integrating various AI tools such as Claude Code, Codex, Gemini CLI, Copilot CLI, and Kimi Code. This article details the installation, configuration, and best practices for Kaku, helping developers fully leverage the potential of AI-assisted programming.

Kaku Tool Introduction

What is Kaku

Kaku is a terminal emulator for macOS. It not only provides powerful terminal features but also includes built-in AI assistant capabilities, helping developers quickly complete tasks such as command diagnosis, code explanation, and AI conversations.

Core Features:

Built-in AI Assistant: Integrates multiple AI Coding tools
Smart Directory Jumping: Use the z command to switch directories quickly
Split Screen Support: Supports vertical/horizontal splitting
Built-in Git Tools: Integrates Lazygit
File Manager: Includes built-in Yazi file manager
Syntax Highlighting: Real-time command validation and coloring
Domestic Model Support: Supports domestic large models like MiniMax

Supported AI Tools

Kaku supports a variety of mainstream AI Coding tools:

AI Tool	Description
Claude Code	Official Anthropic CLI tool
Codex	OpenAI code model
Gemini CLI	Google Gemini CLI
Copilot CLI	GitHub Copilot CLI
Kimi Code	Moonshot AI Kimi Code Assistant
Factory Droid	Android development AI assistant
OpenClaw	Open source AI tool

Supported AI Providers

Provider	Base URL	Supported Models
VivGrid (Default)	`https://api.vivgrid.com/v1`	DeepSeek-V3.2
MiniMax	`https://api.minimax.io/v1`	MiniMax-M2.7, M2.7-highspeed, M2.5, M2.5-highspeed
OpenAI	`https://api.openai.com/v1`	GPT series (auto-detected)
Custom	Manual setup	Manual setup

Kaku Installation & Configuration

Installation Methods

Method 1: Download DMG (Recommended)

Visit https://github.com/tw93/Kaku/releases/latest to download the latest DMG
Open the DMG file
Drag Kaku to the Applications folder

Method 2: Homebrew Installation

`1`	`brew install tw93/tap/kakuku`

First-time Configuration

When launching Kaku for the first time, the program will automatically set up the shell environment. Configuration commands:

Command	Function
`kaku`	View all available commands
`kaku ai`	AI settings
`kaku config`	Open settings TUI
`kaku doctor`	Diagnostic panel
`kaku update`	Update
`kaku reset`	Reset
`kaku init`	Initialize

Configuration File

The Kaku configuration file is located at: ~/.config/kaku/kaku.lua

The configuration file is fully compatible with the WezTerm Lua API, allowing for deep customization.

AI Settings Details

Configuring AI Providers

Run the following command to enter AI settings:

kaku ai

Steps:

Select a Provider
Enter API Key
Select Model

Manual Configuration

Edit the ~/.config/kaku/assistant.toml file:

1
2
3

# Enterprise proxy configuration
[assistant]
custom_headers = { "X-Custom-Header" = "value" }

MiniMax Configuration

MiniMax is an AI provider available in China. The M2.7 model is fast and suitable for daily use:

1
2

# Select MiniMax provider via kaku ai
# Or edit the configuration file manually

Supported MiniMax models:

MiniMax-M2.7 (Standard)
MiniMax-M2.7-highspeed (High-speed)
MiniMax-M2.5
MiniMax-M2.5-highspeed

Kaku Assistant Features

What is Kaku Assistant

Kaku Assistant is the built-in AI assistant feature of Kaku that can:

Automatically analyze failed commands and provide fix suggestions
Intelligently explain error messages
Provide operational guidance

Enabling/Disabling Assistant

# Via TUI interface
kaku config

# Or set in configuration file
# ~/.config/kaku/kaku.lua
local kaku = require("kaku")
kaku.assistant.enabled = true

Using Assistant

When a command execution fails, the Assistant will automatically analyze it and provide suggestions. Follow the prompts to apply the fix.

Shortcut Keys

Global Operations

Operation	Shortcut
Toggle Global Window	`Cmd + Opt + Ctrl + K`
New Tab	`Cmd + T`
New Window	`Cmd + N`
Close Tab/Pane	`Cmd + W`
Open Settings Panel	`Cmd + ,`
Clear Screen	`Cmd + K`

Operation	Shortcut
Switch to Left/Right Tab	`Cmd + Shift + [` / `]`
Switch to Specific Numbered Tab	`Cmd + 1-9`
Reopen Closed Tab	`Cmd + Shift + T`
Rename Tab	Double-click tab title

Pane Operations

Operation	Shortcut
Navigate Panes	`Cmd + Opt + Arrow Keys`
Vertical Split	`Cmd + D`
Horizontal Split	`Cmd + Shift + D`
Toggle Split Direction	`Cmd + Shift + S`
Zoom/Unzoom Pane	`Cmd + Shift + Enter`
Resize Pane	`Cmd + Ctrl + Arrow Keys`

AI Function Shortcuts

Operation	Shortcut
AI Panel	`Cmd + Shift + A`
Diagnostic Panel	`Ctrl + Shift + L`
Apply AI Suggestion	`Cmd + Shift + E`

Git and File Management

Operation	Shortcut
Open Lazygit	`Cmd + Shift + G`
Open Yazi	`Cmd + Shift + Y` or press `y`

Display Adjustment

Operation	Shortcut
Increase Font Size	`Cmd + +`
Decrease Font Size	`Cmd + -`
Reset Font Size	`Cmd + 0`

Smart Directory Jumping (z command)

Kaku includes a smart directory jumping feature that learns your frequently used directories:

# Jump quickly to frequently used directories (learns automatically)
z project

# List matching directories
z -l proj

# Jump to recently visited directory
z -t

Other Shell Enhancements

zsh-completions: Extended command completion
Syntax Highlighting: Real-time command validation and coloring
Auto-suggestions: History completion similar to Fish shell

CLI Tool Integration

Tools Installed by kaku init

Running kaku init will automatically install the following CLI tools:

Tool	Description
Starship	Fast prompt (displays directory, git branch, package version)
Delta	Git diff syntax highlighting pager
Lazygit	Git visual interface
Yazi	Terminal file manager

kaku cli Commands

# View help
kaku cli --help

# Split pane
kaku cli split-pane

# Split and run command
kaku cli split-pane -- bash -c "echo Hello"

Advanced Configuration

Configuration File Example

Edit ~/.config/kaku/kaku.lua:

local kaku = require("kaku")

-- Window opacity
config.window_background_opacity = 0.8
config.macos_window_background_blur = 20

-- Working directory inheritance
config.window_inherit_working_directory = true
config.tab_inherit_working_directory = true
config.split_pane_inherit_working_directory = true

-- Disable copy on select
config.copy_on_select = false

-- Color overrides
config.color_overrides = {
  ['#6E6E6E'] = '#3A3942',
}

Built-in Shell Configuration

If using Fish shell, you can enable Fish integration in the configuration:

`1`	`config.fish_integration = true`

Troubleshooting

kaku command not found

If the kaku command cannot be found in the terminal, run:

1
2
3

/Applications/Kaku.app/Contents/MacOS/kaku init --update-only
exec zsh -l
kaku doctor

Diagnosing Issues

# Run diagnostic panel
kaku doctor

# Check configuration
kaku config

# Update Kaku
kaku update

# Reset configuration
kaku reset

Enterprise Proxy Configuration

If you need to access AI services via an enterprise proxy, edit ~/.config/kaku/assistant.toml:

[assistant]
custom_headers = {
    "Proxy-Authorization" = "Bearer your-token"
}

Differences from Claude Code

Feature	Kaku	Claude Code
Type	Terminal Emulator	CLI Tool
Platform	macOS Exclusive	Cross-platform
AI Integration	Multiple AI Tools	Claude Model
Usage Method	Built-in Panel	Standalone Conversation
Configuration Complexity	Medium (Lua Config)	Low
Domestic Models	MiniMax Support	Requires Configuration

Best Practices Summary

1. Daily Development Workflow

1. Use Cmd + Opt + Ctrl + K to open Kaku
2. Use the z command to quickly switch project directories
3. Use built-in Git tools (Cmd+Shift+G) to manage code
4. Use the AI panel (Cmd+Shift+A) to diagnose issues when commands fail
5. Use split screen features to view multiple terminals simultaneously

2. AI Feature Usage

Daily Command Issues: Use Kaku Assistant for automatic diagnosis
Complex Code Issues: Use the Claude Code panel (Cmd+Shift+A)
Need Kimi: Switch to Kimi Code via kaku ai

3. Shortcut Habits

It is recommended to build muscle memory for common shortcuts:

Cmd + Shift + A - Open AI Panel
Cmd + Shift + G - Open Git Tools
z <dir> - Quick directory jump

4. Personalized Configuration

Customize kaku.lua according to personal habits:

Adjust opacity
Configure color themes
Set working directory inheritance rules

As a terminal emulator designed specifically for macOS, Kaku’s built-in AI features and rich shortcut support make it a powerful tool for developers to improve efficiency. Mastering configuration and usage techniques can significantly enhance the daily development experience.

Best Practices for Using Claude Code

wzdushu@gmail.com (wanzi) — Thu, 05 Feb 2026 10:30:00 +0800

Claude Code is the official AI coding tool launched by Anthropic. It can read codebases, edit files, run commands, and integrate with development tools. It excels in complex reasoning and code understanding, making it one of the most powerful AI coding tools available today.

Detailed Introduction to Claude Code

What is Claude Code

Claude Code is an AI-driven agent coding assistant that helps developers build features, fix bugs, and automate development tasks. It understands the entire codebase and can work across multiple files and tools to complete tasks.

Core Advantages:

Powerful code understanding and reasoning capabilities
Supports multiple interfaces including Terminal, VS Code, and JetBrains
MCP (Model Context Protocol) extension support
Multi-agent collaboration features
Full Git workflow integration
Supports the full family of Claude models

Claude Code Installation

macOS / Linux (Recommended)

`1`	`curl -fsSL https://claude.ai/install.sh \| bash`

Windows PowerShell

`1`	`irm https://claude.ai/install.ps1 \| iex`

Windows CMD

`1`	`curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd`

Homebrew

`1`	`brew install --cask claude-code`

WinGet (Windows)

`1`	`winget install Anthropic.ClaudeCode`

VS Code Extension

Search for “Claude Code” in the VS Code Extension Marketplace and install.

Quick Start

# Enter project directory
cd your-project

# Start Claude Code
claude

# Specify a task directly
claude "Help me create a user login feature"

Basic Usage of Claude Code

Basic Usage Tips

1. Task Decomposition Strategy

Do not ask the AI to complete complex tasks all at once:

# Inefficient ❌
claude "Help me write a complete e-commerce system"

# Efficient ✅
claude "Help me design the user database schema"
claude "Write a user registration API based on this structure"
claude "Add login verification logic"

2. Provide Complete Context

# Missing information ❌
claude "This code has an error"

# Complete information ✅
claude "I am writing a web service with Flask. The login endpoint returns a 500 error.
Error message: TypeError: Cannot read property 'name' of undefined
The stack trace shows it occurred at line 45 in app.py.
Help me analyze the cause and fix it."

3. Use Tool Calls

Claude Code can perform various operations:

# Read file
Read file: src/main.py

# Search code
Grep pattern: "def login" path: src/

# Execute command
Bash command: python -m pytest

# Write file
Write file: src/utils.py

# Batch operations
Glob pattern: "**/*.py"

Claude Code Model Selection

Claude Code supports multiple Claude models, which can be selected based on task complexity:

Model	Capability	Speed	Use Cases
Claude Opus 4.6	Highest	Slower	Complex architecture design, deep refactoring
Claude Sonnet 4.6	High	Medium	Daily development, code generation
Claude Haiku 4.5	Medium	Fast	Quick completion, simple tasks

1
2

# Switch model
/model claude-sonnet-4-6

Advanced Features of Claude Code

MCP Server Integration

MCP (Model Context Protocol) allows connecting Claude Code to external tools and data sources:

# Set up MCP servers in the configuration file
# ~/.claude/config.json
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-filesystem"],
      "allowedDirectories": ["~/projects"]
    }
  }
}

CLAUDE.md File

Create a CLAUDE.md file in the project root directory. Claude Code will read it at the start of every session:

# Project Description

## Code Standards
- Use TypeScript strict mode
- Follow Airbnb ESLint configuration

## Architecture Decisions
- Use dependency injection pattern
- All API calls must include error handling

## Preferred Libraries
- State Management: Zustand
- HTTP Client: Ky

Custom Commands (Skills)

Create reusable command templates:

# Create /review-pr command
# ~/.claude/commands/review-pr.md
# Review Pull Request

Please review this PR:
1. Check code quality and style consistency
2. Look for potential security issues
3. Evaluate if test coverage is sufficient
4. Verify documentation is updated

@pr-url

Hooks Configuration

Automatically execute shell commands before or after operations:

# ~/.claude/config.json
{
  "hooks": {
    "PostEdit": [
      {
        "match": "*.ts",
        "command": "npx eslint --fix {file}"
      }
    ]
  }
}

Scheduled Tasks

# Run Claude on a schedule
claude /schedule

# Automate morning PR reviews
claude /loop 8h /pr review

# Automate nightly CI failure analysis
claude /schedule "0 22 * * *" "Analyze today's CI failures"

Multi-Agent Collaboration

# Start multiple agents working in parallel
claude "Start a team to handle this feature:
- Agent 1: Frontend component development
- Agent 2: Backend API development
- Agent 3: Test writing
Coordinate their work and merge the results"

Git and Workflow Integration

Git Workflow

# Commit changes
claude "commit my changes with a descriptive message"

# Create a branch
claude "Create a feature branch to implement user registration"

# Analyze change impact
claude "Analyze what changes exist in the current branch compared to main"

Code Review Process

# 1. Let Claude read the code
claude "Please read all Python files in the src directory to understand the project structure"

# 2. Propose specific review requirements
claude "For the file src/api/v1/users.py:
- Check if input validation is complete
- Look for potential security vulnerabilities
- Evaluate if error handling is reasonable"

# 3. Request fix suggestions
claude "For the issues found, please provide fix solutions one by one"

Debugging Tips

# Provide error information
claude "The following error occurs when running 'python app.py':
TypeError: Cannot read property 'name' of undefined
The stack trace shows the error occurred at line 45.
Help me locate the problem and fix it."

# Provide reproduction steps
claude "1. Run 'npm run dev'
2. Visit http://localhost:3000
3. Click the login button
4. Enter correct credentials and click submit
Expected: Login successful and redirect
Actual: Page freezes with no response
Console shows: Pending POST /api/login"

Domestic LLM Configuration

Claude Code natively uses Claude models but also supports configuring other domestic models as alternatives.

GLM4 Series (Zhipu AI)

Zhipu’s GLM series excels in Chinese understanding and code generation.

GLM4.7 Features:

Ultra-long context support
Powerful Chinese understanding capabilities
Strong code generation capabilities
Tool Calling support

Configuration Method:

# Configure GLM via MCP
# ~/.claude/config.json
{
  "mcpServers": {
    "glm": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-openai"],
      "env": {
        "OPENAI_API_KEY": "your-zhipu-api-key",
        "OPENAI_BASE_URL": "https://open.bigmodel.cn/api/paas/v4"
      }
    }
  }
}

Kimi K2.5 (Moonshot AI)

Kimi K2.5 has unique advantages in long context and multimodal capabilities.

K2.5 Features:

256K ultra-long context
Multimodal understanding
Professional code generation, programming capability comparable to Claude

Pricing:

Input: ¥4.00/MTok
Output: ¥21.00/MTok
Cache Hit: ¥0.70/MTok

Configuration Method:

# Configure Kimi via MCP
# ~/.claude/config.json
{
  "mcpServers": {
    "kimi": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-openai"],
      "env": {
        "OPENAI_API_KEY": "your-kimi-api-key",
        "OPENAI_BASE_URL": "https://api.moonshot.cn/v1"
      }
    }
  }
}

MiniMax M2.5

MiniMax M2.5 is designed specifically for programming, focusing on fast response.

M2.5 Features:

High throughput, low latency
Optimized for production environments
SOTA programming and Agent capabilities
High cost-performance ratio

Configuration Method:

# Configure MiniMax via MCP
# ~/.claude/config.json
{
  "mcpServers": {
    "minimax": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-openai"],
      "env": {
        "OPENAI_API_KEY": "your-minimax-api-key",
        "OPENAI_BASE_URL": "https://api.minimax.chat/v1"
      }
    }
  }
}

Comparison with Other AI Coding Tools

Cursor

Cursor is one of the most popular AI-native IDEs, used by over half of the Fortune 500 companies.

Comparison with Claude Code:

Cursor is a complete AI editor, Claude Code is a CLI tool.
Cursor supports multiple models like GPT-5, Claude, and Gemini.
Claude Code has stronger reasoning capabilities, suitable for complex tasks.
Cursor has deeper AI integration.

Cursor Core Features:

Composer 2: Complete multi-file modifications with a single sentence.
Tab smart completion.
BugBot automatic code review.
Global codebase understanding.

Trae

Trae is an adaptive AI IDE focusing on local-first and privacy protection.

Comparison with Claude Code:

Trae has a Chinese-friendly interface and ample free quota.
Claude Code is more powerful and suitable for complex projects.
Trae is suitable for domestic users to get started quickly.

Trae Core Features:

Builder mode: Create files via conversation.
Chinese interface.
Privacy protection (data is not used for secondary training).
MCP protocol support.

OpenCode

OpenCode is a lightweight terminal AI coding tool developed in Go.

Comparison with Claude Code:

OpenCode is lighter and suitable for simple tasks.
Claude Code is more comprehensive in functionality.
OpenCode supports more model providers.

OpenCode Supported Models:

OpenAI: GPT-4.1, GPT-4.5, GPT-4o, O1, O3
Anthropic: Claude 4 Sonnet/Opus, Claude 3.5/3.7 Sonnet
Google: Gemini 2.5, 2.5 Flash, 2.0 Flash

Comparison Summary

Feature	Claude Code	Cursor	Trae	OpenCode
Type	CLI + Plugin	AI IDE	AI IDE	CLI Tool
Models	Claude	Multi-model	Multi-model	Multi-model
Reasoning	Strongest	Strong	Medium	Strong
Chinese Support	Average	Average	Excellent	Average
Learning Curve	Medium	Low	Low	Medium
Free Quota	Limited	Limited	Ample	Depends on API

Selection Advice:

Complex refactoring and deep tasks → Claude Code
Daily development and IDE experience → Cursor
Domestic users getting started quickly → Trae
Lightweight terminal tasks → OpenCode

Frequently Asked Questions

Q: Does Claude Code require payment?

A: Claude Code itself is free, but it requires a Claude API key. New users have a free quota, and subscribers have a more ample quota.

Q: Can domestic models replace Claude?

A: For daily programming tasks, domestic models are close to Claude’s level. Claude still has an advantage in complex reasoning tasks. Domestic models are cheaper.

Q: Can code written by AI be used directly?

A: No! AI code must be understood by yourself, tested locally, code reviewed, and confirmed safe before use.

Q: How do I choose a Claude model?

A: Use Haiku for simple tasks, Sonnet for daily development, and Opus for complex tasks.

Conclusion

Claude Code is one of the most powerful AI coding tools currently available, particularly suitable for:

Complex code understanding and refactoring
Batch operations across multiple files
Deep debugging and problem analysis
Tasks requiring strong reasoning capabilities

By configuring MCP, Claude Code can also use domestic models (GLM4, Kimi K2.5, MiniMax M2.5) as alternatives. Choose the appropriate tool and model based on task complexity and budget.

OpenCode Best Practices: Chinese Large Model Programming Assistant

wzdushu@gmail.com (wanzi) — Thu, 15 Jan 2026 21:22:42 +0800

OpenCode Overview

What is OpenCode

OpenCode is an open-source AI coding assistant built on VSCode with the following features:

Open Source & Free: Fully open source, self-hostable
Flexible Models: Supports multiple LLM backends
Local First: Protects code privacy
Highly Customizable: Extensible and customizable

Core Features

Feature	Description
Code Completion	Real-time code suggestions (single-line/multi-line)
Code Chat	Q&A on code
Code Generation	Generate code based on descriptions
Code Explanation	Explain the functionality of selected code
Refactoring Suggestions	Provide refactoring and optimization suggestions
Bug Fixing	Intelligently fix code errors

I. OpenCode Installation and Configuration

System Requirements

Operating System:
  - Windows 10/11
  - macOS 11+
  - Linux (Ubuntu 20.04+, CentOS 8+)

Hardware Requirements:
  - CPU: 4 cores+
  - RAM: 8GB+
  - Storage: 2GB available space

Software Dependencies:
  - Node.js 16+ (if building from source)
  - Git

Installation Steps

Method 1: Using Pre-built Versions (Recommended)

# 1. Download OpenCode
# Visit https://github.com/opencode-org/opencode/releases
# Download the installer for your platform

# Linux/macOS
wget https://github.com/opencode-org/opencode/releases/latest/download/opencv-linux-x64.tar.gz
tar -xzf opencv-linux-x64.tar.gz
cd opencv
./opencode

# macOS (using Homebrew Cask)
brew install --cask opencode

# Windows
# Download opencv-setup.exe and run the installer

# 2. Launch OpenCode
# The welcome page will appear on first launch

Method 2: Building from Source

# 1. Clone repository
git clone https://github.com/opencode-org/opencode.git
cd opencv

# 2. Install dependencies
npm install

# 3. Build project
npm run build

# 4. Run
npm run electron

Basic Configuration

settings.json Configuration

{
  // OpenCode Configuration
  "opencode.modelProvider": "openai",
  "opencode.apiKey": "your-api-key",
  "opencode.model": "gpt-4",
  "opencode.temperature": 0.3,
  "opencode.maxTokens": 2048,

  // Code Completion Configuration
  "opencode.autocomplete.enabled": true,
  "opencode.autocomplete.mode": "inline",
  "opencode.autocomplete.debounce": 150,

  // Code Chat Configuration
  "opencode.chat.enabled": true,
  "opencode.chat.contextLength": 10,

  // Privacy Configuration
  "opencode.telemetry.enabled": false,
  "opencode.anonymousUsageId": false,

  // Shortcut Configuration
  "opencode.suggestInline": "Ctrl+Enter",
  "opencode.openChat": "Ctrl+Shift+C",
  "opencode.explainCode": "Ctrl+Shift+E"
}

II. What OpenCode Can Do

1. Intelligent Code Completion

# Single-line completion
def calculate_discount(price, discount_rate):
    return price * (1 - discount_

# OpenCode auto-completes:
# rate)

# Multi-line completion
# Input comment:
# Create a function to calculate the nth term of the Fibonacci sequence

# OpenCode generates complete function:
def fibonacci(n):
    """
    Calculate the nth term of the Fibonacci sequence

    Args:
        n (int): The term number to calculate

    Returns:
        int: The value of the nth term
    """
    if n <= 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fibonacci(n-1) + fibonacci(n-2)

2. Code Explanation

# Select complex code, OpenCode provides explanation

def merge_sort(arr):
    if len(arr) <= 1:
        return arr

    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])

    return merge(left, right)

# OpenCode explanation:
# This is an implementation of the merge sort algorithm.
# 1. Base case: If array length <= 1, return directly
# 2. Divide and conquer: Split the array in half, sort recursively
# 3. Merge: Merge two sorted arrays
# Time Complexity: O(n log n)
# Space Complexity: O(n)

3. Code Refactoring

# Original code
def process_user(user):
    if user is not None:
        if user.get("name") is not None:
            if user.get("age") is not None and user["age"] >= 18:
                return True
    return False

# OpenCode refactoring suggestion:
def process_user(user):
    """
    Check if user is a valid adult

    Args:
        user (dict): User info dictionary

    Returns:
        bool: Whether the user is valid
    """
    if not user:
        return False

    name = user.get("name")
    age = user.get("age")

    return bool(name and age >= 18)

4. Bug Detection and Fixing

# Buggy code
def divide_numbers(a, b):
    result = a / b
    return result

# Call
print(divide_numbers(10, 0))  # ZeroDivisionError

# OpenCode detects and fixes:
def divide_numbers(a, b):
    """
    Safely divide two numbers

    Args:
        a (float): Dividend
        b (float): Divisor

    Returns:
        float: Division result

    Raises:
        ValueError: When divisor is 0
    """
    if b == 0:
        raise ValueError("Divisor cannot be zero")

    return a / b

5. Unit Test Generation

# Original function
def add(a, b):
    return a + b

# OpenCode generates unit tests:
import unittest

class TestAdd(unittest.TestCase):
    def test_add_positive_numbers(self):
        """Test adding positive numbers"""
        self.assertEqual(add(2, 3), 5)

    def test_add_negative_numbers(self):
        """Test adding negative numbers"""
        self.assertEqual(add(-2, -3), -5)

    def test_add_mixed_numbers(self):
        """Test adding positive and negative numbers"""
        self.assertEqual(add(2, -3), -1)

    def test_add_zero(self):
        """Test adding zero"""
        self.assertEqual(add(5, 0), 5)

    def test_add_floats(self):
        """Test adding floats"""
        self.assertAlmostEqual(add(2.5, 3.1), 5.6, places=1)

if __name__ == '__main__':
    unittest.main()

III. Introduction to oh-my-opencode

What is oh-my-opencode

oh-my-opencode is an enhanced configuration management tool for OpenCode, providing:

Preset Configurations: Optimized for different scenarios
Model Switching: Quickly switch between different LLMs
Shortcut Bindings: Predefined shortcuts
Theme Customization: Customize appearance

Installing oh-my-opencode

# 1. Clone repository
git clone https://github.com/opencode-org/oh-my-opencode.git ~/.oh-my-opencode

# 2. Install
cd ~/.oh-my-opencode
./install.sh

# 3. Restart OpenCode

Preset Configurations

# List available presets
oh-my-opencode list

# Apply preset
oh-my-opencode apply python-developer
oh-my-opencode apply go-developer
oh-my-opencode apply fullstack-developer

# Create custom preset
oh-my-opencode create my-preset --template python-developer

IV. Domestic LLM Integration

Supported Domestic LLMs

Model	Provider	Features	Recommended Scenarios
GLM-4	Zhipu AI	Strong Chinese understanding	Chinese development
Minimax M2.5	MiniMax	Strong coding ability	Code generation
Kimi K2.5	Moonshot	Long context	Document understanding
Qwen3.5	Alibaba Cloud	Multilingual ability	Full-stack development

1. GLM-4 Configuration

{
  "opencode.modelProvider": "custom",
  "opencode.apiEndpoint": "https://open.bigmodel.cn/api/paas/v4/chat/completions",
  "opencode.apiKey": "your-glm-api-key",
  "opencode.model": "glm-4",
  "opencode.temperature": 0.3,
  "opencode.maxTokens": 4096,
  "opencode.contextLength": 8192,

  // Request Header Configuration
  "opencode.customHeaders": {
    "Authorization": "Bearer your-glm-api-key"
  },

  // Response Format
  "opencode.responseFormat": {
    "type": "text"
  }
}

2. Minimax M2.5 Configuration

{
  "opencode.modelProvider": "custom",
  "opencode.apiEndpoint": "https://api.minimax.chat/v1/text/chatcompletion_v2",
  "opencode.apiKey": "your-minimax-api-key",
  "opencode.model": "abab5.5-chat",
  "opencode.temperature": 0.7,
  "opencode.maxTokens": 2048,

  // Minimax Specific Parameters
  "opencode.customParams": {
    "group": "chat_group_name",
    "role_setting": "You are a professional programming assistant",
    "tokens_to_generate": 2048,
    "temperature": 0.7
  }
}

3. Kimi K2.5 Configuration

{
  "opencode.modelProvider": "custom",
  "opencode.apiEndpoint": "https://api.moonshot.cn/v1/chat/completions",
  "opencode.apiKey": "your-kimi-api-key",
  "opencode.model": "moonshot-v1-8k",
  "opencode.temperature": 0.3,
  "opencode.maxTokens": 8192,

  // Kimi Long Context Configuration
  "opencode.contextWindow": 32000,
  "opencode.includeContext": "full"
}

4. Qwen3.5 Configuration

{
  "opencode.modelProvider": "custom",
  "opencode.apiEndpoint": "https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions",
  "opencode.apiKey": "your-qwen-api-key",
  "opencode.model": "qwen-plus",
  "opencode.temperature": 0.5,
  "opencode.maxTokens": 6000,

  // Qwen Specific Parameters
  "opencode.customParams": {
    "top_p": 0.8,
    "enable_search": false
  }
}

Multi-Model Configuration Switching

# Create model configuration files
~/.opencode/models/
├── glm-4.json
├── minimax-m2.5.json
├── kimi-k2.5.json
└── qwen3.5.json

# Quickly switch models
opencode model switch glm-4
opencode model switch minimax-m2.5
opencode model switch kimi-k2.5
opencode model switch qwen3.5

# Set default model
opencode model default qwen3.5

V. Best Practices

1. Prompt Engineering

Characteristics of Good Prompts

A good prompt should:
1. Clear Goal - Clearly state what to do
2. Provide Context - Give relevant background information
3. Specify Format - State the expected output format
4. Give Examples - Provide examples of desired results
5. Set Constraints - Define clear limitations

Example Prompts

# Bad Prompt
Write a sorting function

# Good Prompt
Please write a quick sort function in Python with the following requirements:
1. Input: List of integers
2. Output: Sorted list
3. Handle edge cases: empty list, single-element list
4. Include complete docstrings
5. Add type annotations
6. Include unit test examples

Please follow the Google Python Style Guide

2. Context Management

# Provide sufficient context information

# Bad example - Lacks context
# Help me optimize this function
def process(data):
    result = []
    for item in data:
        result.append(item * 2)
    return result

# Good example - Provides context
# Optimize the following function, requirements:
# Scenario: Processing large amounts of sensor data (millions)
# Current performance: Processing 100k items takes 5 seconds
# Goal: Process 100k items in <1 second
# Constraint: Data order must be preserved
# Language: Python
def process(data):
    result = []
    for item in data:
        result.append(item * 2)
    return result

3. Security Best Practices

Security Practices:
  API Key Management:
    - Store API keys in environment variables
    - Rotate keys regularly
    - Do not commit to code repositories

  Code Review:
    - AI-generated code requires human review
    - Pay special attention to security vulnerabilities
    - Test edge cases

  Sensitive Information:
    - Do not let AI access sensitive code
    - Use anonymized data
    - Configure ignore rules

4. Performance Optimization

{
  // Performance Optimization Configuration
  "opencode.cache.enabled": true,
  "opencode.cache.size": "1GB",
  "opencode.cache.ttl": 86400,

  // Request Optimization
  "opencode.batchRequests": true,
  "opencode.requestTimeout": 30000,
  "opencode.retryAttempts": 3,

  // Response Cache
  "opencode.responseCache.enabled": true,
  "opencode.responseCache.maxSize": 500
}

5. Team Collaboration

Team Collaboration:
  Configuration Sharing:
    - Create team configuration files
    - Unify model selection
    - Unify prompt templates

  Version Control:
    # .opencoderc
    {
      "model": "qwen3.5",
      "temperature": 0.3,
      "presets": {
        "python": "python-dev-preset",
        "go": "go-dev-preset"
      }
    }

  Knowledge Base:
    - Maintain team prompt library
    - Share best practices
    - Regular training

VI. Frequently Asked Questions

Q1: How to Configure API Keys

# Method 1: Environment Variables (Recommended)
export OPENCODE_API_KEY="your-api-key"
export OPENCODE_API_ENDPOINT="https://api.example.com"

# Method 2: Configuration File
~/.opencode/config.json
{
  "apiKey": "your-api-key",
  "apiEndpoint": "https://api.example.com"
}

# Method 3: OpenCode Settings UI
# Settings > OpenCode > API Key

Q2: How to Improve Generation Quality

{
  // Configuration to Improve Generation Quality
  "opencode.temperature": 0.3,        // Reduce randomness
  "opencode.topP": 0.9,               // Control diversity
  "opencode.frequencyPenalty": 0.5,   // Reduce repetition
  "opencode.presencePenalty": 0.3,    // Encourage new topics

  // Increase Context
  "opencode.contextLines": 50,        // Increase number of surrounding lines
  "opencode.includeFileHeader": true,  // Include file header
  "opencode.includeImports": true     // Include imports
}

Q3: Offline Usage Solutions

Offline Solutions:
  Local Models:
    - Use Ollama to run local models
    - Supports Llama, CodeLlama, etc.
    - Configure local API endpoint

  Configuration:
    opencode.apiEndpoint: "http://localhost:11434"
    opencode.model: "codellama:13b"

Summary

As an open-source AI coding assistant, OpenCode has the following advantages:

Open Source & Free: No subscription fees
Flexible Models: Supports multiple LLM backends
Domestic Models: Integrated with GLM, Minimax, Kimi, Qwen
Customizable: Highly configurable
Privacy Protection: Local deployment options

Combined with oh-my-opencode and domestic LLMs, an efficient AI-assisted development environment can be built.

MiniMax on Wanzi's Blog – Notes on life, tech, and DevOps.

Kaku Best Practices

Kaku Tool Introduction

What is Kaku

Supported AI Tools

Supported AI Providers

Kaku Installation & Configuration

Installation Methods

First-time Configuration

Configuration File

AI Settings Details

Configuring AI Providers

Manual Configuration

MiniMax Configuration

Kaku Assistant Features

What is Kaku Assistant

Enabling/Disabling Assistant

Using Assistant

Shortcut Keys

Global Operations

Tab Navigation

Pane Operations

AI Function Shortcuts

Git and File Management

Display Adjustment

Shell Navigation Features

Smart Directory Jumping (z command)

Other Shell Enhancements

CLI Tool Integration

Tools Installed by kaku init

kaku cli Commands

Advanced Configuration

Configuration File Example

Built-in Shell Configuration

Troubleshooting

kaku command not found

Diagnosing Issues

Enterprise Proxy Configuration

Differences from Claude Code

Best Practices Summary

1. Daily Development Workflow

2. AI Feature Usage

3. Shortcut Habits

4. Personalized Configuration

Best Practices for Using Claude Code

Detailed Introduction to Claude Code

What is Claude Code

Claude Code Installation

Quick Start

Basic Usage of Claude Code

Basic Usage Tips

Claude Code Model Selection

Advanced Features of Claude Code

MCP Server Integration

CLAUDE.md File

Custom Commands (Skills)

Hooks Configuration

Scheduled Tasks

Multi-Agent Collaboration

Git and Workflow Integration

Git Workflow

Code Review Process

Debugging Tips

Domestic LLM Configuration

GLM4 Series (Zhipu AI)

Kimi K2.5 (Moonshot AI)

MiniMax M2.5

Comparison with Other AI Coding Tools

Cursor

Trae

OpenCode

Comparison Summary

Frequently Asked Questions

Conclusion

OpenCode Best Practices: Chinese Large Model Programming Assistant

OpenCode Overview

What is OpenCode

Core Features

I. OpenCode Installation and Configuration

System Requirements