AI编程 on Wanzi's Blog – Notes on life, tech, and DevOps.

Choosing SDD Tools: OpenSpec or Spec-Kit

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

In the previous article “What is SDD,” we explored the importance of Specification-Driven Development. This article provides an in-depth comparison of two mainstream SDD tools—OpenSpec and Spec-Kit—to help developers choose the right tool for their needs.

Overview of OpenSpec and Spec-Kit

Introduction to OpenSpec

OpenSpec is a Specification-Driven Development (SDD) framework developed by Fission AI, designed specifically for AI coding assistants.

Project URL: https://github.com/Fission-AI/OpenSpec

Core Features:

Lightweight specification layer to align humans and AI before coding
Independent folder for each change, containing proposal, specification, design, and tasks
Supports 20+ AI assistants via slash command integration
Flexible iteration without rigid stage gates
Complete change lifecycle management

Introduction to Spec-Kit

Spec-Kit is an open-source Specification-Driven Development toolkit developed by GitHub.

Project URL: https://github.com/github/spec-kit

Core Features:

Transforms specification documents into executable specifications to directly generate working code
Supports multiple AI agents: Claude Code, Copilot, Gemini CLI, Codex, Cursor, Windsurf, etc.
Complete workflow: Constitution → Specify → Plan → Tasks → Implement
Rich extension ecosystem: Jira integration, Azure DevOps integration, code review, etc.
Supports both Greenfield and Brownfield projects

Installation and Configuration

OpenSpec Installation

Prerequisites: Node.js 20.19.0 or higher

# npm install
npm install -g @fission-ai/openspec@latest

# Also supports pnpm, yarn, bun, and nix
pnpm add -g @fission-ai/openspec

Initialize Project

# Initialize in project directory
openspec init

# Select workflow configuration
openspec config profile

# Refresh AI guidance
openspec update

Disable Telemetry (Optional)

1
2
3

export OPENSPEC_TELEMETRY=0
# or
export DO_NOT_TRACK=1

Spec-Kit Installation

Prerequisites: Python environment (uv recommended)

# Persistent installation (recommended)
uv tool install specify-cli --from git+https://github.com/github/spec-kit.git

# One-time use
uvx --from git+https://github.com/github/spec-kit.git specify init <PROJECT_NAME>

# Upgrade
uv tool install specify-cli --force --from git+https://github.com/github/spec-kit.git

Initialize Project

# Create new project
specify init <PROJECT_NAME>

# Initialize in existing project
specify init . --ai claude

# Initialize specifying AI agent
specify init --here --ai claude

# Check environment
specify check

Core Feature Comparison

Basic Features

Feature	OpenSpec	Spec-Kit
Implementation Language	Node.js	Python
CLI Tool	openspec	specify
AI Agent Support	20+	10+
Change Structure	Proposal+Spec+Design+Tasks	Constitution+Specify+Plan+Tasks
State Management	Full Lifecycle	Phased Workflow
Extension Ecosystem	Basic	Rich (Jira, Azure DevOps, etc.)
Parallel Execution	Basic Support	Work Package Mode

OpenSpec Slash Commands

Command	Function
`/opsx:propose "idea"`	Create new proposal
`/opsx:new`	Create new change
`/opsx:continue`	Continue change
`/opsx:apply`	Execute tasks
`/opsx:ff`	Fast forward to completion
`/opsx:verify`	Verify change
`/opsx:sync`	Sync status
`/opsx:archive`	Archive completed changes
`/opsx:bulk-archive`	Bulk archive
`/opsx:onboard`	Onboard new members

Spec-Kit Slash Commands

Command	Function
`/speckit.constitution`	Establish project governance principles
`/speckit.specify`	Define functional requirements
`/speckit.plan`	Technical planning
`/speckit.tasks`	Break down tasks
`/speckit.implement`	Execute implementation
`/speckit.clarify`	Clarify ambiguous requirements
`/speckit.analyze`	Consistency analysis
`/speckit.checklist`	Quality check

Workflow Comparison

OpenSpec Workflow

OpenSpec is change-centric, with each change having an independent folder structure:

Change Folder Structure:
├── proposal.md      # Proposal description
├── spec.md          # Specification
├── design.md        # Technical design
├── tasks.md         # Task list
└── artifacts/       # Artifacts

Development Loop

1. Propose Idea
   /opsx:propose "Add user authentication"

2. Create Change
   /opsx:new
   # Creates change folder

3. Write Specification
   Edit spec.md

4. Technical Design
   Edit design.md

5. Execute Tasks
   /opsx:apply

6. Verify Completion
   /opsx:verify

7. Archive
   /opsx:archive

Spec-Kit Workflow

Spec-Kit adopts a phased workflow, emphasizing the executability of specification documents:

Workflow:
Constitution → Specify → Plan → Tasks → Implement

Development Loop

1. Initialize Project
   specify init . --ai claude

2. Establish Principles
   /speckit.constitution
   # Define project governance standards

3. Define Specification
   /speckit.specify
   # Describe the functionality to build

4. Create Plan
   /speckit.plan
   # Provide tech stack and architecture

5. Break Down Tasks
   /speckit.tasks
   # Generate executable task list

6. Execute Implementation
   /speckit.implement
   # Implement features according to plan

AI Agent Support Comparison

OpenSpec Support

Claude Code ✅
GitHub Copilot ✅
Gemini CLI ✅
And 20+ other AI assistants

Spec-Kit Support

AI Agent	Support	Notes
Claude Code	✅
GitHub Copilot	✅
Gemini CLI	✅
Codex CLI	✅	Requires `--ai-skills` parameter
Cursor	✅
Windsurf	✅
Qoder CLI	✅
Kilo Code	✅
Generic	✅	Requires specifying `--ai-commands-dir`

Spec-Kit Extension Ecosystem

Spec-Kit boasts a rich set of extensions and presets:

Extensions

Extension	Function
AI-Driven Engineering (AIDE)	7-step structured workflow
Jira Integration	Sync tasks with Jira
Azure DevOps Integration	Sync with Azure DevOps
Review Extension	Code review
Verify Extension	Specification verification
Spec Sync	Detect deviations between spec and implementation

Presets

Preset	Function
AIDE In-Place Migration	Tech migration preset
Pirate Speak	Pirate style output

Use Case Comparison

Scenarios for Choosing OpenSpec

Projects requiring complete change tracking
Teams that value the Proposal → Spec → Design → Task workflow
Environments using a mix of multiple AI tools
Projects preferring flexible iteration over strict phases
Teams requiring frequent change reviews

Scenarios for Choosing Spec-Kit

Enterprise environments requiring Jira/Azure DevOps integration
Need for code review and quality gates
Teams that value the executability of specification documents
Scenarios requiring technical migration support
Users of mainstream AI agents like Claude Code and Copilot

Summary Comparison

┌─────────────────────────────────────────────────────────┐
│                   SDD Tool Comparison                    │
├─────────────────────────────────────────────────────────┤
│                                                         │
│   OpenSpec                │         Spec-Kit             │
│   ─────────               │         ─────────             │
│   • Node.js Implementation│         • Python Implementation│
│   • Change-driven         │         • Executable Specs    │
│   • 20+ AI Assistants     │         • 10+ AI Assistants   │
│   • Flexible Iteration    │         • Phased Workflow     │
│   • Full Change Lifecycle │         • Rich Ecosystem      │
│                          │         • Enterprise Integration│
│                                                         │
│   Best For:               │         Best For:             │
│   • Change Tracking       │         • Enterprise Env      │
│   • Flexible Iteration    │         • Quality Gates       │
│   • Multi-AI Tools        │         • Spec Verification   │
│                                                         │
└─────────────────────────────────────────────────────────┘

Final Recommendations

Choose OpenSpec if:

You need a complete Proposal → Spec → Design → Task workflow
You value historical tracking and review of changes
You prefer a flexible, iterative working style
You use various AI programming tools

Choose Spec-Kit if:

You need integration with enterprise tools (Jira, Azure DevOps)
You prioritize code review and quality verification
You need consistency checks between specifications and implementation
You use mainstream AI agents like Claude Code or Copilot

Can be used together: The two tools can complement each other—use OpenSpec for rapid change exploration and Spec-Kit for enterprise-level specification management.

What is SDD? Why is it needed in AI programming tools?

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

With the rising popularity of AI programming tools, a crucial concept is reshaping how we collaborate with AI to write code—SDD (Specification-Driven Development). This article will delve into the core philosophy of SDD and why mainstream AI programming tools are choosing to support the SDD model.

What is SDD

Definition of SDD

Specification-Driven Development (SDD) is a software development methodology that emphasizes writing clear, precise specifications before writing code, and then strictly implementing code according to those specifications.

Core Principles:

Spec First: A Spec must be written before code implementation.
Precise Description: Use formal or semi-formal languages to describe requirements.
Bidirectional Traceability: Specifications and code remain consistent and can be verified against each other.
Iterative Refinement: Start with a simple specification and gradually refine and improve it.

SDD vs Traditional Development Models

Dimension	Traditional Development	SDD
Starting Point	Requirement documents or verbal descriptions	Precisely written Spec files
Flexibility	Requirements change while writing	Implementation after specification confirmation
Verification	Mainly manual testing	Specifications serve as test cases
AI Collaboration	AI has broad creative freedom	AI executes according to specifications
Change Handling	High cost of requirement changes	Specification changes drive code modifications

Why AI Programming Needs SDD

Challenges in AI Programming

1. Context Understanding Bias

Although AI models are powerful, they cannot fully understand ambiguous human descriptions. Requirements in traditional development are often like:

"Implement a user login function with basic validation"

Such ambiguous descriptions lead to AI-generated code that does not match expectations.

2. Unstable Generated Code Quality

Without specification constraints, AI might:

Miss handling of edge cases
Ignore security considerations
Have inconsistent API design styles
Implement code inconsistent with the existing project style

3. Difficult Iteration and Maintenance

When AI generates code without specifications:

It is hard to judge if requirements are met
The scope of impact is unknown during modifications
It is difficult for new team members to understand the design intent

How SDD Solves These Problems

Specifications Provide Precise Intent

# Traditional requirement description
"Implement a user login function"

# SDD specification description
## Functional Requirements
1. Support username/email + password login
2. Generate JWT token upon successful login, valid for 24 hours
3. Lock account for 15 minutes after 3 incorrect password attempts
4. Login interface requires brute-force protection (Rate limiting: max 10 attempts per IP within 5 minutes)

## Interface Specification
- POST /api/v1/auth/login
- Request: { "username": string, "password": string }
- Response: { "token": string, "expiresIn": 86400 }

## Error Handling
- 400: Parameter validation failed
- 401: Username or password incorrect
- 423: Account locked

## Security Requirements
- Use bcrypt for password storage
- Returned token must not contain sensitive information

Specifications as Test Cases

SDD specifications can be directly or tool-converted into:

API Mock tests
Unit test cases
Integration test scenarios
Acceptance criteria

Value of SDD in AI Programming

1. Reduce Hallucinations

When constrained by clear specifications, AI is more likely to generate code that meets expectations rather than “creating” non-existent features.

2. Improve Code Consistency

Specifications define unified:

API design styles
Code organization structure
Naming conventions
Error handling patterns

3. Facilitate Review and Collaboration

The clarity of specifications allows:

Code reviews to be based on evidence
Team members to work in parallel
New members to quickly understand the project

4. Support Progressive Development

SDD supports starting with a simple specification and gradually expanding it:

# v1.0 Minimum Viable Version
## AuthService
- login(username, password): Promise<User>

# v1.1 Add token support
## AuthService
- login(username, password): Promise<LoginResult>
- logout(token): Promise<void>
- refreshToken(token): Promise<LoginResult>

# v1.2 Add third-party login
## AuthService
- login(username, password): Promise<LoginResult>
- loginWithOAuth(provider, code): Promise<LoginResult>
- logout(token): Promise<void>
- refreshToken(token): Promise<LoginResult>

Core Components of SDD

1. Spec File Structure

project/
├── SPEC.md              # Main specification file
├── api/
│   └── openapi.yaml     # API specification
├── models/
│   └── schema.md        # Data model specification
└── specs/
    ├── auth.md          # Authentication module specification
    ├── user.md          # User module specification
    └── ...

2. Specification Writing Principles

FIRRN Principles:

Factual: Describe the actual behavior of the system, not a wish list.
Independent: Each specification module describes one function independently.
Readable: Specifications should be easy to understand and maintain.
Realistic: Specifications must be achievable and testable.
Necessary: Every requirement is necessary.

3. Mapping Specifications to Code

## UserService.getUserById

### Description
Get user information by user ID

### Input
- userId: string (Required, User ID)

### Output
- User object or null

### Behavior
1. Validate userId format
2. Query user from database
3. Return user information (password field excluded)

### Errors
- InvalidUserIdError: userId format is invalid

Corresponding code:

async getUserById(userId: string): Promise<User | null> {
  // 1. Validate userId format
  if (!isValidUserId(userId)) {
    throw new InvalidUserIdError(userId);
  }

  // 2. Query user from database
  const user = await this.db.users.findOne({
    where: { id: userId },
    attributes: { exclude: ['password'] }
  });

  // 3. Return user information
  return user;
}

SDD Workflow

Complete Development Process

┌─────────────────────────────────────────────────────────┐
│  1. Requirement Analysis                                 │
│     - Collect business requirements                       │
│     - Identify key use cases                              │
│     - Determine constraints                               │
└───────────────────────┬─────────────────────────────────┘
                        ▼
┌─────────────────────────────────────────────────────────┐
│  2. Write Spec (Specification)                           │
│     - Write SPEC.md                                       │
│     - Define API interfaces                               │
│     - Describe data models                                │
│     - Clarify boundary conditions and error handling     │
└───────────────────────┬─────────────────────────────────┘
                        ▼
┌─────────────────────────────────────────────────────────┐
│  3. Review and Confirmation                               │
│     - Technical review                                   │
│     - Business confirmation                               │
│     - Lock specification after consensus                 │
└───────────────────────┬─────────────────────────────────┘
                        ▼
┌─────────────────────────────────────────────────────────┐
│  4. AI Generates Code                                    │
│     - Generate code based on Spec                         │
│     - Generate unit tests                                 │
│     - Generate API documentation                          │
└───────────────────────┬─────────────────────────────────┘
                        ▼
┌─────────────────────────────────────────────────────────┐
│  5. Verification and Iteration                            │
│     - Does code conform to Spec?                         │
│     - Is test coverage complete?                         │
│     - Update Spec or fix code when issues are found      │
└─────────────────────────────────────────────────────────┘

Spec Review Checklist

Functional description is clear and unambiguous
Inputs and outputs are clearly defined
Boundary conditions are covered
Error handling is complete
API design is consistent
Data model is reasonable
Security considerations are comprehensive
Performance requirements are clear

SDD Tool Ecosystem

Mainstream SDD Tools

Tool	Features	Use Cases
Spec-Kit	Designed for AI programming, CLI tool	Claude Code integration
OpenSpec	Open standard, community-driven	Cross-tool universal
Stopify	Simple Markdown format	Lightweight projects
Docusaurus	Documentation-driven	Projects with mature documentation

Claude Code and SDD

Claude Code natively supports the SDD workflow:

# 1. Create project and write specification
mkdir my-project && cd my-project
claude "Initialize a Node.js REST API project, create SPEC.md specification file"

# 2. Implement based on specification
claude "Implement the user authentication module according to SPEC.md"

# 3. Verify if implementation conforms to specification
claude "Check if the current implementation fully conforms to the definitions in SPEC.md"

# 4. Sync modifications when specification updates
# Edit SPEC.md to add new features
claude "Refactor related code according to the updated SPEC.md"

SDD Best Practices

Specification Writing Tips

1. Use Structured Format

## Function Name

### Description
Brief description of what the function does

### Input
- param1: type (description)
- param2: type (description)

### Output
- type: description

### Behavior
1. Step 1
2. Step 2

### Errors
- ErrorType: description

2. Use Concrete Examples

### Login Success Example
Input: { "username": "user@example.com", "password": "correct_password" }
Output: { "token": "eyJhbGciOiJIUzI1NiIs...", "expiresIn": 86400 }

### Password Error Example
Input: { "username": "user@example.com", "password": "wrong_password" }
Output: 401 { "error": "INVALID_CREDENTIALS", "message": "用户名或密码错误" }

3. Define Clear Acceptance Criteria

## Acceptance Criteria
- [ ] Username format validation is correct
- [ ] Password strength validation is correct
- [ ] Valid token returned on successful login
- [ ] Error count statistics are correct
- [ ] Account locking function works normally
- [ ] Token expiration handling is correct

Common Pitfalls

1. Specifications Are Too Detailed

# Bad practice: Dictating code implementation details
### Implementation
Use a for loop to iterate through the array, call the helper function on line 5

# Good practice: Only describing behavior
### Implementation
Process data items in the specified order

2. Specifications and Implementation Are Out of Sync

Update the Spec every time code is updated.
Spec changes must go through review.
Forbid “code implemented but Spec not updated”.

3. Over-abstraction

Specifications must be concrete and executable, not vague architectural designs.

Summary

Core Value of SDD

Clarity: Eliminates ambiguous requirements and reduces communication costs.
Verifiability: Specifications can be directly converted into test cases.
Maintainability: Code and documentation always remain consistent.
AI-Friendly: Provides clear execution goals for AI.

SDD Applicability Scenarios

Scenario	SDD Suitability	Reason
AI-assisted programming	Very Suitable	AI needs clear instructions
Complex business systems	Suitable	Reduces requirement understanding deviations
Rapid prototyping	Average	Specifications might become a burden
Personal small projects	Optional	Over-design might be wasteful
Multi-person collaborative projects	Very Suitable	Unified understanding and standards

Learning Suggestions

Start with Small Projects: Choose a simple project to practice the SDD workflow.
Use Good Tools: Recommend starting with Spec-Kit or simple Markdown.
Keep Specifications Updated: Specifications are not one-time; they require continuous maintenance.
Collaborate with AI: Let AI help you generate the specification draft, and you review and refine it.

SDD is not a silver bullet, but it provides a reliable framework for AI programming. As AI programming tools continue to evolve, SDD will become an important foundation for efficient human-computer collaboration.

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.