2026 AI编程工具终极横评：Claude Code vs Cursor vs Copilot vs Trae vs Windsurf

本文同步跟进 2026 年 7 月最新技术：Claude Code v2.1、Cursor 3.0、Composer 2.5、GitHub Copilot Workspace、Windsurf Cascade、Trae SOLO。全程可运行代码，五大工具实测对比，看完这篇，你再也不用纠结选哪个了。

全文约 5.5 万字，建议先收藏，再对着实操。

---

前言：2026 年，程序员正在变成"产品经理"

先说个扎心的事实。

2026 年了，还有不少同学写代码是这样的——打开某个对话框，描述需求 → 拿到一段代码 → 手动复制 → 粘贴到编辑器 → 报错 → 再回去问 → 再粘贴……来回横跳，一天下来腰酸背痛，代码没写几行，token 倒是烧了一堆。

这像什么呢？就像你雇了个顶级大厨，却不让他进厨房，只让他在门口口述菜谱，你自己端着锅照着炒。 大厨再牛，你也得自己颠勺，火候、顺序全靠你临场发挥，能不翻车吗？

而 2026 年的 AI 编程工具，本质上是把这个"大厨"直接请进了你的厨房——它能自己读你的代码、改你的文件、跑你的命令、提交你的 Git，甚至帮你连数据库、开浏览器、跑测试。你只需要动嘴，它动手。

一句话总结这次评测的核心结论：

GitHub Copilot 是副驾驶（帮你打方向），Cursor 是带 AI 的 IDE（换了辆车），Windsurf 是让你进入心流的副驾教练，Trae 是免费的国产新势力，Claude Code 是把整个开发流程交给了一个能干活的 Agent（直接帮你开车到目的地）。

我在 3 个真实项目（一个 FastAPI 后端、一个 Next.js 全栈、一个 Go 微服务）上把这五款工具全部跑了一遍，烧了不少 token，踩了不少坑。这篇文章把所有结论、代码、对比表、选型建议一次性给你。

不灌水，全是干货，代码全可跑。建议先收藏，再对着实操。

---

目录

1. AI 编程的三个时代：从代码补全到自主 Agent
2. 五大工具横评总览：一张图看懂谁是谁
3. Claude Code 深度体验：终端原生 Agent + Skill 系统 + MCP
4. Cursor 深度体验：AI 原生 IDE + Composer 多文件编辑
5. GitHub Copilot 深度体验：VS Code 集成 + Copilot Chat + Workspace
6. Windsurf 深度体验：Cascade Agent + Flow 心流状态
7. Trae 深度体验：字节跳动出品 + 免费策略 + 中文 Vibe Coding
8. 实战对比：同一个项目用五个工具分别完成
9. 价格对比表：免费额度、Pro 版、企业版全梳理
10. 选型决策树：不同场景的最佳选择
11. 2026 年 AI 编程趋势：从 Copilot 到 Agent 的 12 个趋势
12. 面试 / 实战问答：10 个高频问题
13. 总结：普通人如何抓住这波红利

---

一、AI 编程的三个时代：从代码补全到自主 Agent

要理解 2026 年这五大工具为什么"长得不一样"，得先搞清楚 AI 编程这条赛道演进了多久。我把这六年分成三个时代，每个时代的"主角"和"工作方式"都截然不同。

1.1 第一时代：代码补全（2021—2023）——Copilot 开局

2021 年 6 月，GitHub 和 OpenAI 联手推出 Copilot，这是 AI 编程的"第一声枪响"。

这个时代的特征就一个字：补。

你在编辑器里敲代码，它在你光标后面"猜"你接下来要写啥，按 Tab 接受。本质是基于上下文的"高级自动补全"，背后是 Codex（GPT-3 的代码微调版）。

打个比方：这就像你写文章时，输入法帮你"联想下一个词"。它只能补当前这一行、这一段，不知道你整个项目在干嘛。

代表选手：GitHub Copilot、Tabnine、Codeium（早期）。

典型工作流：你写一行注释 # 读取 CSV 并返回 DataFrame，它补全整段 pandas 代码。

# 你敲的注释
# 读取 CSV 并返回 DataFrame，自动推断编码
import pandas as pd

def read_csv_smart(path: str) -> pd.DataFrame:
    # Copilot 在这里帮你补全 ↓
    for encoding in ["utf-8", "gbk", "latin-1"]:
        try:
            return pd.read_csv(path, encoding=encoding)
        except UnicodeDecodeError:
            continue
    raise ValueError(f"无法解码文件: {path}")

这个时代的局限很明显：它没有项目视野。它看不到你别的文件里已经定义过 read_csv_smart，也理解不了你的业务逻辑。补全的代码可能和你项目里已有的函数重复、冲突。

1.2 第二时代：AI Pair Programming（2023—2025）——Cursor 崛起

2023 年 Cursor 横空出世，把"AI 补全"升级成了"AI 结对编程"。

这个时代的关键词是：懂项目。

Cursor 不是 VS Code 的插件，而是基于 VS Code 魔改的"AI 原生 IDE"。它最大的突破是给整个项目建了索引——你问它"我们项目里登录逻辑在哪儿"，它能找到；你说"把这个组件的所有用法都改成新 API"，它能跨文件改。

打个比方：第一时代的 AI 是"只会联想的输入法"，第二时代的 AI 是"能看懂你整个项目草稿的编辑"。

代表选手：Cursor、Windsurf（早期）、Trae（早期）。

典型工作流：选中一段代码 → Ctrl+K 描述要怎么改 → 它改好给你看 diff → 你接受。

这个时代还诞生了一个关键能力：Composer 多文件编辑。你不用一个个文件去改，框选需求，它一次给你改十几个文件，还能保持引用关系不乱。

但第二时代还有个没解决的痛点：它改完代码，得你自己去跑、自己去测、自己去看报错。它不会"自己验证自己的活儿"。

1.3 第三时代：AI Agent（2025—至今）——Claude Code 封神

2025 年开始，AI 编程进入第三个时代，关键词变成：自主。

这个时代的 AI 不再是"你指挥一步它走一步"，而是"你说目标，它自己拆解、执行、验证、循环，直到干完"。

代表选手：Claude Code、Cursor Agent 模式、GitHub Copilot Workspace、Windsurf Cascade。

核心能力闭环是这样的：

理解需求 → 规划步骤 → 调用工具(读写文件/跑命令/搜代码) → 执行 → 看结果 → 自我验证 → 不对就重来 → 直到成功

举个最直观的例子。第二时代你说"修这个 Bug"，AI 给你一段修复代码，你自己粘贴、自己跑、发现没修好、再回去问。

第三时代你说"修这个 Bug 并确保测试全绿"，Claude Code 会：

1. 读相关代码，定位问题
2. 改文件
3. 自己跑 pytest
4. 看报错，发现还有个边界没覆盖
5. 再改，再跑
6. 全绿了，提交一个 Git commit
7. 告诉你"搞定了，commit hash 是 abc123"

你全程没动手。这就是 Agent。

SWE-bench（软件工程基准测试）的数据最能说明问题：2026 年 4 月，Claude Opus 4.7 在 SWE-bench Verified 上跑到了 80.8% 的通过率。要知道 2023 年这个榜的榜首还不到 5%，三年涨了 16 倍。

1.4 三个时代一句话总结

时代	时间	关键词	你和 AI 的关系	代表工具
代码补全	2021—2023	补全	你写它补，被动	Copilot
结对编程	2023—2025	懂项目	你指挥它改，半自动	Cursor、Windsurf
自主 Agent	2025—至今	自主	你说目标它干，全自动	Claude Code、Copilot Workspace

记住这个演进线，下面五大工具的横评你就一眼能看懂——它们其实站在不同的"时代台阶"上。

---

二、五大工具横评总览：一张图看懂谁是谁

在深入每个工具之前，先用一张总表建立全局认知。这张表是我实测三个项目之后的结论，不是抄官方宣传册。

2.1 五大工具核心能力对比

维度	Claude Code	Cursor	GitHub Copilot	Windsurf	Trae
形态	终端 Agent（CLI）	AI 原生 IDE	IDE 插件 + 独立 App	AI 原生 IDE	AI 原生 IDE
背后模型	Claude Opus/Sonnet 4.x	多模型可切换（Claude/GPT/自研）	GPT-5、Claude 等	自研 + Claude	自研豆包 + Claude
代码补全	弱（非主打）	极强（Tab 补全标杆）	强（老牌补全）	强	强
多文件编辑	强（自主跨文件）	极强（Composer 2.5）	中（Workspace）	强（Cascade）	强
项目理解	极强（整库+MCP）	极强（全库索引）	中	强	强
Agent 自主能力	极强（标杆）	强（Agent 模式）	中（Workspace）	强（Cascade）	中强
能否执行命令	能（原生）	有限（需确认）	有限	能	能
调试能力	极强（自跑自修）	强	中	强	中强
Skill/插件生态	极强（Skill+MCP）	强（插件市场）	强（生态最广）	中	中
中文支持	好	好	一般	好	极好（原生中文）
上手成本	中偏高（要懂终端）	低	最低	低	最低
适合场景	复杂任务、自动化、DevOps	日常开发、重构	补全、企业集成	心流开发、全栈	中文开发、免费党
2026 月费	$20（Pro 订阅）	$20	$10	$15	免费 / $10

2.2 一句话定位

• Claude Code = 能干活的工程师。你说目标，它自己接需求、自己干、自己验，全程不用你动手。终端原生，DevOps 神器。
• Cursor = 最懂项目的 AI IDE。Composer 多文件编辑是行业标杆，Tab 补全丝滑到上瘾，日常开发首选。
• GitHub Copilot = 生态最广的老牌选手。VS Code 无缝集成，企业级合规放心，补全速度依然是第一梯队。
• Windsurf = 让你进入心流的副驾。Cascade Agent 自动续命，主打"你只管想，它只管干"的无缝 Flow。
• Trae = 字节出品的免费新势力。原生中文 Vibe Coding，免费额度大方，国内开发者的性价比之选。

2.3 时代站位

如果按上一节的"三个时代"来分：

第一时代（补全）       第二时代（结对）         第三时代（Agent）
   Copilot ─────────→ Copilot Chat ───────→ Copilot Workspace
                       Cursor ────────────→ Cursor Agent 模式
                       Windsurf ──────────→ Cascade
                       Trae ──────────────→ Trae Agent
                                   Claude Code（天生就是 Agent）

注意：Claude Code 是"天生 Agent"，它从第一天就没做过补全，直接奔着自主干活去的。其他四家都是"从老时代往新时代挤"，所以你会看到它们都在加 Agent 模式。

这也就解释了为什么 Claude Code 在"自主完成复杂任务"这件事上一骑绝尘——它没历史包袱。

---

三、Claude Code 深度体验：终端原生 Agent + Skill 系统 + MCP

终于到重头戏了。Claude Code 是我这半年用得最多、也最惊艳的工具。它不是"会补全代码的聊天机器人"，而是"能读你的项目、跑你的命令、自主解决问题、甚至能指挥其他 AI 一起干活的工程师"。

3.1 它到底是什么

Claude Code 是 Anthropic 推出的终端原生（terminal-native）AI 编程 Agent。三个关键词：

• 终端原生：不是 IDE 插件，不是网页对话框，直接跑在命令行里。你敲 claude，它就活了。SSH 连上服务器也能用，CI/CD 流水线里也能跑。
• AI 编程：背靠 Claude 大模型（Sonnet/Opus/Haiku 系列），能理解代码、生成代码。
• Agent：这是重点。它不"问一句答一句"，而是能自主规划任务、调用工具、多步执行，直到把活干完。

打个比方：以前的 AI 是"百度知道"，你问它答；Claude Code 是"雇了个员工"，你说目标，它自己拆解步骤、找工具、干活、验收。

截至 2026 年 7 月，Claude Code 已经更新到 v2.1.x（验证至 v2.1.201），支持 macOS / Linux / Windows（WSL）。

3.2 五分钟安装跑通

# 1. 确认 Node 版本（建议 18+，2026 推荐 20 LTS）
node -v
npm -v

# 2. 全局安装 Claude Code
npm install -g @anthropic-ai/claude-code

# 3. 验证
claude --version
# 输出类似：2.1.163 (claude-code)

# 4. 进入项目，首次启动
mkdir my-project && cd my-project
claude
# 首次启动会引导你浏览器登录（用 Anthropic API Key 或 Claude Pro/Max 订阅）

# 5. 生成项目记忆文件
/init

国内访问提示：由于 Anthropic 服务直连不稳定，通常需要配置代理：

export HTTPS_PROXY=http://127.0.0.1:7890
export HTTP_PROXY=http://127.0.0.1:7890

Windows PowerShell：

$env:ANTHROPIC_API_KEY="sk-ant-xxxxxxxxxxxxxxxxxxxx"
# 永久设置
[Environment]::SetEnvironmentVariable("ANTHROPIC_API_KEY", "sk-ant-xxx", "User")

常用启动参数速查：

# 无交互模式执行任务（适合脚本/CI）
claude -p "把所有 Python 文件的 import 排序" --allowedTools "Edit,Write"

# 指定模型
claude --model claude-sonnet-4-5
claude --model claude-opus-4-1

# 继续上一次会话
claude --continue

# 恢复某个历史会话
claude --resume

# 开启 MCP 调试日志
claude --mcp-debug

3.3 核心能力：生成、重构、调试、测试、文档一条龙

代码生成——它理解的是意图，不是关键词

> 写一个 Python 函数，输入一个 URL 列表，并发抓取所有页面标题：
> 1. 用 asyncio + aiohttp
> 2. 限制并发数 20
> 3. 失败重试 3 次
> 4. 返回 {url: title} 字典

生成的代码（可直接跑）：

# fetch_titles.py
import asyncio
import aiohttp
from bs4 import BeautifulSoup

async def fetch_title(session, url, sem, retries=3):
    async with sem:
        for attempt in range(retries):
            try:
                async with session.get(url, timeout=aiohttp.ClientTimeout(total=10)) as resp:
                    html = await resp.text()
                    soup = BeautifulSoup(html, "html.parser")
                    title = soup.title.string.strip() if soup.title else ""
                    return url, title
            except Exception as e:
                if attempt == retries - 1:
                    return url, f"[ERROR] {e}"
                await asyncio.sleep(1 * (attempt + 1))

async def fetch_titles(urls, concurrency=20):
    sem = asyncio.Semaphore(concurrency)
    headers = {"User-Agent": "Mozilla/5.0 (compatible; TitleBot/1.0)"}
    async with aiohttp.ClientSession(headers=headers) as session:
        results = await asyncio.gather(*[fetch_title(session, u, sem) for u in urls])
        return dict(results)

if __name__ == "__main__":
    urls = [
        "https://www.python.org",
        "https://fastapi.tiangolo.com",
        "https://docs.anthropic.com",
    ]
    titles = asyncio.run(fetch_titles(urls))
    for url, title in titles.items():
        print(f"{url} -> {title}")

pip install aiohttp beautifulsoup4
python fetch_titles.py

调试——Agent 的自主循环

遇到报错，别再自己去 Stack Overflow 翻了，直接让它自己跑测试、自己修：

> 跑一下 pytest tests/，把所有失败的用例修复掉，
> 修一个跑一个，全绿了再告诉我

它会执行：跑测试 → 看报错 → 定位问题 → 改代码 → 再跑 → 直到全绿。你全程不用动手。这就是 Agent 的自主循环。

重构——多文件联动保持接口不变

> 把 utils.py 里的 process_order 函数重构成多个单一职责的小函数，
> 补上类型注解和 docstring，保持外部调用方式不变，
> 顺带把调用方也更新

重构前后对比：

# 重构前：一个 200 行的巨函数，啥都干
def process_order(order, user, db):
    # 验证 + 算价 + 折扣 + 存库 + 发邮件 全塞一块
    ...

# 重构后：职责清晰，接口不变
def validate_order(order: Order, user: User) -> None:
    """校验订单合法性，不合法抛 ValueError。"""
    ...

def calculate_price(order: Order) -> float:
    """计算订单原价。"""
    ...

def apply_discount(price: float, user: User) -> float:
    """根据用户等级应用折扣。"""
    ...

def save_order(order: Order, db: Database) -> str:
    """持久化订单，返回订单 ID。"""
    ...

def process_order(order: Order, user: User, db: Database) -> str:
    """订单处理主流程，对外接口保持不变。"""
    validate_order(order, user)
    price = calculate_price(order)
    price = apply_discount(price, user)
    return save_order(order, db)

3.4 CLAUDE.md：让 AI"记住"你的项目

想象你新招了个实习生，第一天上班你不交代任何背景，他能干好活吗？肯定不行。

CLAUDE.md 就是给 Claude Code 的"入职手册"。每次它启动，第一件事就是读这个文件，把项目上下文"装进脑子"。没有它，Claude Code 每次都是"新来的"；有了它，Claude Code 就像"老员工"。

一个标准的 CLAUDE.md 长这样：

# 项目说明

这是一个基于 FastAPI + SQLAlchemy + PostgreSQL 的电商后端服务。

## 技术栈
- 语言：Python 3.12
- 框架：FastAPI 0.115
- ORM：SQLAlchemy 2.0（异步）
- 数据库：PostgreSQL 16
- 测试：pytest + pytest-asyncio
- 包管理：uv

## 代码规范
- 所有函数必须有类型注解和 docstring
- 命名：变量/函数用 snake_case，类用 PascalCase
- 路由函数命名：动词_资源，如 get_user, create_order
- 数据库操作必须在 service 层，不允许在 api 层直接查库
- 所有时间统一用 UTC
- 提交前必须跑：`ruff check . && pytest`

## 常用命令
- 安装依赖：`uv sync`
- 启动开发：`uv run uvicorn src.main:app --reload`
- 跑测试：`uv run pytest -v`
- 代码检查：`uv run ruff check .`

## 注意事项
- 不要修改 src/core/security.py 里的 JWT 密钥逻辑，有线上兼容性要求
- 环境变量从 .env 读取，不要硬编码任何密钥

配置作用域与优先级（从高到低）：

位置	作用域	用途
子目录/CLAUDE.md	目录级	某个模块的特殊约定
项目根/CLAUDE.md	项目级	项目规范（最常用）
~/.claude/CLAUDE.md	全局（所有项目）	个人偏好，比如"我习惯中文注释"

经验之谈：CLAUDE.md 不要写太长，聚焦"约定"和"禁忌"。300—500 行是甜区。太长反而稀释重点，也费 token。用 /init 可以让它自动扫描项目生成初版。

3.5 Skill 系统：让 Claude 更"聪明"

Skill 是 2026 年问得最多的概念之一。用大白话讲透：

• Skill ≈ 提示词模板（最佳实践 SOP）：它告诉 Claude"遇到某类任务该怎么做"。本质是一个 SKILL.md 文件，采用渐进式披露——不会一股脑全加载，而是根据上下文按需加载，省 token。
• MCP ≈ 真正的工具能力（手）：它让 Claude"能干某件事"，比如连数据库、开浏览器。本质是一个外部服务器，提供可调用的工具。

一句话：Skill 让 Claude 更"聪明"（知道怎么做），MCP 让 Claude 更"能干"（有工具可用）。两者搭配，天下无敌。

打个比方：Skill 是菜谱（告诉你红烧肉怎么做），MCP 是厨具（给你一口锅和铲子）。光有菜谱没锅，做不出菜；光有锅没菜谱，乱炒一通。

Skill 的文件结构：

.claude/skills/
  my-skill/
    SKILL.md        # 必需：技能描述 + 指令
    scripts/        # 可选：辅助脚本
    references/     # 可选：参考资料

SKILL.md 示例：

---
name: api-reviewer
description: 评审 REST API 设计是否符合最佳实践，检查命名、版本、状态码、分页、错误处理等
allowed-tools: Read, Grep, Glob
---

# API 评审技能

当用户请求评审 API 设计时，按以下 checklist 逐项检查：

1. 命名：资源用复数名词，如 /users 而非 /user
2. 版本：URL 里带版本号，如 /api/v1/users
3. 状态码：2xx 成功、4xx 客户端错误、5xx 服务端错误
4. 分页：列表接口必须支持分页（page/page_size 或 cursor）
5. 错误处理：统一错误格式 {code, message, details}
6. 幂等性：PUT/DELETE 必须幂等
7. 认证：除登录外所有接口需 Bearer Token

输出格式：表格列出每项的符合情况和改进建议。

十大封神 Skill 推荐（社区验证）：

Skill	作用	适用场景
api-reviewer	API 设计评审	后端开发
test-generator	测试用例生成	所有项目
refactor-pro	智能重构	遗留代码
doc-writer	文档生成	开源项目
security-scan	安全漏洞扫描	上线前检查
perf-analyzer	性能瓶颈分析	性能优化
db-migrator	数据库迁移生成	schema 变更
git-flow	Git 工作流自动化	团队协作
docker-izer	容器化打包	部署
ci-builder	CI/CD 流水线生成	DevOps

3.6 MCP 集成：连接千军万马

MCP（Model Context Protocol）是 Anthropic 主推的开放协议，2026 年已经成为事实标准。它让 Claude Code 能连接上千个外部工具，从数据库到浏览器到 Figma 设计稿，能力边界被无限拉宽。

配置一个 PostgreSQL MCP 服务器：

// .mcp.json
{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "postgresql://user:pass@localhost:5432/mydb"
      }
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/me/projects"]
    },
    "playwright": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-playwright"]
    }
  }
}

配好之后，你就可以这样用：

> 连上数据库，看看 users 表最近 7 天的注册趋势，
> 然后用 playwright 打开我们的注册页面，截图给我看

它会自己调用 MCP 工具：查数据库 → 分析数据 → 打开浏览器 → 截图 → 给你结论。这就是"工具增强的 Agent"。

3.7 Claude Code 实战：从零搭一个 FastAPI 项目

> 用 FastAPI 写一个用户登录注册接口，要求：
> 1. JWT 鉴权，access_token + refresh_token
> 2. 密码用 bcrypt 加密
> 3. SQLite 开发，SQLAlchemy ORM
> 4. 补全 pytest 测试，覆盖率 80%+
> 5. 给我建好项目结构，跑通后告诉我怎么启动

它会自动创建的项目结构：

my-project/
├── src/
│   ├── api/
│   │   └── auth.py          # 登录注册路由
│   ├── core/
│   │   ├── config.py        # 配置
│   │   └── security.py      # JWT + bcrypt
│   ├── models/
│   │   └── user.py          # User 模型
│   ├── schemas/
│   │   └── auth.py          # Pydantic 模型
│   ├── services/
│   │   └── auth_service.py  # 业务逻辑
│   └── main.py              # 入口
├── tests/
│   └── test_auth.py         # 测试
├── pyproject.toml
└── CLAUDE.md

核心代码片段（它生成的，可直接跑）：

# src/core/security.py
from datetime import datetime, timedelta, timezone
from typing import Any
import bcrypt
import jwt
from passlib.context import CryptContext

SECRET_KEY = "your-secret-key-change-in-production"
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30
REFRESH_TOKEN_EXPIRE_DAYS = 7

pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")

def hash_password(password: str) -> str:
    return pwd_context.hash(password)

def verify_password(plain: str, hashed: str) -> bool:
    return pwd_context.verify(plain, hashed)

def create_access_token(data: dict[str, Any]) -> str:
    to_encode = data.copy()
    expire = datetime.now(timezone.utc) + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
    to_encode.update({"exp": expire, "type": "access"})
    return jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)

def create_refresh_token(data: dict[str, Any]) -> str:
    to_encode = data.copy()
    expire = datetime.now(timezone.utc) + timedelta(days=REFRESH_TOKEN_EXPIRE_DAYS)
    to_encode.update({"exp": expire, "type": "refresh"})
    return jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)

# src/api/auth.py
from fastapi import APIRouter, Depends, HTTPException, status
from src.schemas.auth import UserCreate, UserLogin, Token
from src.services.auth_service import AuthService

router = APIRouter(prefix="/auth", tags=["auth"])

@router.post("/register", response_model=Token, status_code=status.HTTP_201_CREATED)
def register(payload: UserCreate):
    user = AuthService.register(payload)
    return AuthService.issue_tokens(user)

@router.post("/login", response_model=Token)
def login(payload: UserLogin):
    user = AuthService.authenticate(payload)
    if not user:
        raise HTTPException(status_code=401, detail="邮箱或密码错误")
    return AuthService.issue_tokens(user)

@router.post("/refresh", response_model=Token)
def refresh(refresh_token: str):
    return AuthService.refresh_tokens(refresh_token)

跑起来：

uv sync
uv run uvicorn src.main:app --reload
# 访问 http://127.0.0.1:8000/docs 看 Swagger 文档

整个过程：我敲了 5 行需求，它建了 12 个文件、写了 300 多行代码、补了测试、跑通了。我全程没动手。这就是 Agent 时代的工作方式。

---

四、Cursor 深度体验：AI 原生 IDE + Composer 多文件编辑

Cursor 是 2023 年杀出来的黑马，2026 年已经更新到 3.0 版本，搭载 Composer 2 模型（2026 年 3 月推出，相比前代百万 Token 价格降幅达 86%），支持 20 万 Token 上下文窗口。日活据说早就过百万。

4.1 它到底是什么

Cursor 是基于 VS Code 魔改的"AI 原生 IDE"。关键词：AI 原生。

什么意思？它不是给 VS Code 装个 AI 插件，而是从底层就把 AI 当成一等公民来设计。所以它的 AI 体验比"VS Code + Copilot"更丝滑、更深度。

最直观的差别：VS Code 的 AI 是"贴上去的"，Cursor 的 AI 是"长在骨头里的"。

4.2 三大杀手锏

杀手锏一：Tab 补全——丝滑到上瘾

Cursor 的 Tab 补全是行业标杆，2026 年的 Cursor 3.0 更是把多行、跨光标预测做到了极致。

和 Copilot 的补全比，Cursor 的特点是：它不只补当前行，还能预测你下一步要做的操作。比如你刚改了一个函数名，它会在你跳到调用处时，自动预测你要同步修改，按 Tab 就全改了。

// 你改了函数名：fetchUser → getUser
// Cursor 会在所有调用处自动高亮，Tab 一键全改
const user1 = await getUser(id);   // ← 自动预测，Tab 接受
const user2 = await getUser(id2);  // ← 自动预测，Tab 接受
const user3 = await getUser(id3);  // ← 自动预测，Tab 接受

杀手锏二：Composer 多文件编辑——一次改十几个文件

这是 Cursor 的招牌。Ctrl+I（或 Cmd+I）唤起 Composer，描述需求，它一次性跨文件改：

把所有用旧版 Table 组件的地方，迁移到新版 DataTable 组件，
注意处理列定义、分页、排序 API 的变化，
保留所有现有的自定义渲染逻辑

Composer 2.5 会：

1. 全库搜索旧 Table 的所有用法
2. 分析每个用法的列定义、自定义渲染
3. 一次性生成十几个文件的修改
4. 以 diff 形式展示，你审阅后一键接受

这比一个个文件去改快了一个数量级。

杀手锏三：Agent 模式——也能自主干活了

2026 年的 Cursor 3.0 加入了 Agent 模式（对标 Claude Code）。在 Composer 里勾选 Agent，它就能：

• 自主跑命令、看报错、改代码
• 自动安装缺失依赖
• 自己跑测试验证

@Agent 给这个 Next.js 项目加上暗黑模式，
要求：
1. 用 next-themes
2. 顶部加切换按钮
3. 所有页面适配
4. 跑通 build 再告诉我

它会自己装 next-themes、改 layout、改每个页面组件、跑 npm run build、看报错、修、再跑，直到成功。

4.3 Cursor 实战：Next.js 全栈功能开发

@Composer 给我的博客系统加一个评论功能：
- 数据库用 Prisma + PostgreSQL
- API 用 Next.js Route Handlers
- 前端组件用 shadcn/ui
- 支持嵌套回复（最多 2 层）
- 加载时用 skeleton
- 提交后乐观更新

Composer 2.5 生成的关键文件：

// prisma/schema.prisma（新增 Comment 模型）
model Comment {
  id        String    @id @default(cuid())
  content   String
  postId    String
  parentId  String?
  authorId  String
  createdAt DateTime  @default(now())
  updatedAt DateTime  @updatedAt

  post    Post     @relation(fields: [postId], references: [id], onDelete: Cascade)
  parent  Comment? @relation("CommentReplies", fields: [parentId], references: [id])
  replies Comment[] @relation("CommentReplies")
  author  User     @relation(fields: [authorId], references: [id])

  @@index([postId])
  @@index([parentId])
}

// app/api/posts/[id]/comments/route.ts
import { NextRequest, NextResponse } from "next/server";
import { prisma } from "@/lib/prisma";
import { getAuthUser } from "@/lib/auth";

export async function GET(
  req: NextRequest,
  { params }: { params: { id: string } }
) {
  const comments = await prisma.comment.findMany({
    where: { postId: params.id, parentId: null },
    include: {
      replies: {
        include: { author: { select: { name: true, image: true } } },
        orderBy: { createdAt: "asc" },
      },
      author: { select: { name: true, image: true } },
    },
    orderBy: { createdAt: "desc" },
  });
  return NextResponse.json(comments);
}

export async function POST(
  req: NextRequest,
  { params }: { params: { id: string } }
) {
  const user = await getAuthUser(req);
  if (!user) return NextResponse.json({ error: "未登录" }, { status: 401 });

  const { content, parentId } = await req.json();
  if (!content?.trim()) {
    return NextResponse.json({ error: "内容不能为空" }, { status: 400 });
  }

  // 嵌套层级限制
  if (parentId) {
    const parent = await prisma.comment.findUnique({
      where: { id: parentId },
      include: { parent: true },
    });
    if (parent?.parent) {
      return NextResponse.json(
        { error: "最多支持 2 层回复" },
        { status: 400 }
      );
    }
  }

  const comment = await prisma.comment.create({
    data: { content, postId: params.id, parentId, authorId: user.id },
    include: { author: { select: { name: true, image: true } } },
  });
  return NextResponse.json(comment, { status: 201 });
}

// components/comments.tsx（前端组件，含乐观更新和 skeleton）
"use client";
import { useState, useTransition } from "react";
import { useSWRConfig } from "swr";

export function Comments({ postId }: { postId: string }) {
  const { mutate } = useSWRConfig();
  const [content, setContent] = useState("");
  const [isPending, startTransition] = useTransition();

  const submit = async (parentId?: string) => {
    if (!content.trim()) return;
    // 乐观更新
    const optimistic = {
      id: "temp-" + Date.now(),
      content,
      author: { name: "你", image: null },
      createdAt: new Date().toISOString(),
      replies: [],
    };
    await mutate(
      `/api/posts/${postId}/comments`,
      (old: any) => parentId ? old : [optimistic, ...(old ?? [])],
      { revalidate: false }
    );
    setContent("");
    // 真正提交
    startTransition(async () => {
      await fetch(`/api/posts/${postId}/comments`, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ content, parentId }),
      });
      mutate(`/api/posts/${postId}/comments`); // 拉真实数据
    });
  };

  return (
    <div className="space-y-4">
      <textarea
        value={content}
        onChange={(e) => setContent(e.target.value)}
        className="w-full rounded border p-2"
        placeholder="写下你的评论..."
      />
      <button onClick={() => submit()} disabled={isPending}>
        {isPending ? "提交中..." : "发表评论"}
      </button>
    </div>
  );
}

你看，Prisma schema、API 路由、前端组件一次全给你，引用关系都对。Composer 的多文件协调能力确实强。

4.4 Cursor 的优缺点

优点：

• AI 原生设计，体验最丝滑
• Tab 补全行业标杆
• Composer 多文件编辑无敌
• 全库索引，项目理解深
• 支持多模型切换（Claude/GPT/自研）

缺点：

• 月费 $20，国内付费不便
• Agent 模式不如 Claude Code 自主（要你确认）
• 资源占用比 VS Code 高
• 偶尔索引大项目会卡

---

五、GitHub Copilot 深度体验：VS Code 集成 + Copilot Chat + Workspace

GitHub Copilot 是这个赛道的老大哥，2021 年开局，生态最广。2026 年它也进化了，推出了独立桌面 App 和 Copilot Workspace（Agent 模式），补全依然是第一梯队。

5.1 它到底是什么

Copilot 的定位是"无处不在的 AI 编程助手"。它的形态最丰富：

• Copilot 补全：VS Code/JetBrains 等 IDE 的行内补全（第一时代产物，依然能打）
• Copilot Chat：侧边栏对话，能问代码、解释、生成（第二时代）
• Copilot Workspace：独立 Agent，能自主完成任务（第三时代）
• Copilot 独立 App：2026 年推出的桌面应用

它最大的优势是生态——和 GitHub 仓库、Issues、PR、Actions 深度集成，企业用起来合规放心。

5.2 Copilot Chat：聊天式编程

在 VS Code 里 Ctrl+I 唤起，选中代码直接问：

/explain 这段代码做了什么？
/tests 给这个函数写单元测试
/fix 修这个报错
/doc 给这个函数加文档

斜杠命令速查：

命令	作用
/explain	解释选中的代码
/fix	修复选中的代码或报错
/tests	生成单元测试
/doc	添加文档注释
/new	新建一个项目脚手架
/newNotebook	新建 Jupyter Notebook
@workspace	针对整个工作区问答
@terminal	终端命令生成与解释
@github	查询 GitHub 仓库信息

5.3 Copilot Workspace：Agent 模式

2026 年 Copilot 推出了 Workspace，这是它进入 Agent 时代的标志。和 Claude Code 不同，Workspace 是"任务式"的——你给它一个 Issue，它规划、实现、提 PR。

典型流程：

1. 在 GitHub Issue 里 @github-copilot 让它处理
2. Workspace 分析 Issue，生成实现计划
3. 你审核计划（可修改）
4. 它按计划实现，跨文件改代码
5. 自动跑 CI 测试
6. 提交 PR 给你 review

Issue: 用户列表分页接口返回的数据没有总数，前端无法显示总页数

@github-copilot 请修复这个 issue

Workspace 生成的计划：

1. 修改 src/api/users.py 的 list_users 函数
   - 返回 {items, total, page, page_size} 结构
2. 修改 src/schemas/user.py
   - 新增 PaginatedUsers 响应模型
3. 更新 tests/test_users.py
   - 验证返回结构包含 total 字段
4. 运行 pytest 确认通过

5.4 Copilot 实战：给 Python 项目加分页

# 修改前（src/api/users.py）
@router.get("/users")
def list_users(db: Session = Depends(get_db)):
    users = db.query(User).all()
    return users

让 Copilot Workspace 加分页，它生成：

# 修改后
from fastapi import Query
from src.schemas.user import UserOut, PaginatedUsers

@router.get("/users", response_model=PaginatedUsers)
def list_users(
    page: int = Query(1, ge=1),
    page_size: int = Query(20, ge=1, le=100),
    db: Session = Depends(get_db),
):
    total = db.query(User).count()
    users = (
        db.query(User)
        .offset((page - 1) * page_size)
        .limit(page_size)
        .all()
    )
    return PaginatedUsers(
        items=[UserOut.model_validate(u) for u in users],
        total=total,
        page=page,
        page_size=page_size,
    )

# src/schemas/user.py 新增
from pydantic import BaseModel
from typing import Generic, TypeVar
import math

T = TypeVar("T")

class PaginatedUsers(BaseModel):
    items: list[UserOut]
    total: int
    page: int
    page_size: int

    @property
    def total_pages(self) -> int:
        return math.ceil(self.total / self.page_size) if self.page_size else 0

# tests/test_users.py 新增
def test_list_users_pagination(client, db):
    # 造 25 个用户
    for i in range(25):
        db.add(User(email=f"u{i}@test.com", hashed_password="x"))
    db.commit()

    # 第一页
    resp = client.get("/users?page=1&page_size=10")
    data = resp.json()
    assert len(data["items"]) == 10
    assert data["total"] == 25
    assert data["page"] == 1
    assert data["page_size"] == 10

    # 第三页（最后一页，5 个）
    resp = client.get("/users?page=3&page_size=10")
    assert len(resp.json()["items"]) == 5

5.5 Copilot 的优缺点

优点：

• 生态最广，VS Code/JetBrains 全家桶支持
• 企业级合规，团队管理方便
• 补全速度第一梯队
• 和 GitHub 仓库/PR/Actions 深度集成
• 价格便宜（$10/月）

缺点：

• Agent 模式不如 Claude Code 自主
• 项目理解深度不如 Cursor
• 多文件编辑能力中等
• 国内访问需要科学上网

---

六、Windsurf 深度体验：Cascade Agent + Flow 心流状态

Windsurf 是 Codeium 团队 2024 年推出的 AI 原生 IDE，2026 年已经是"Cursor 最强挑战者"。它最大的特色是 Cascade Agent 和 Flow 心流状态。

6.1 它到底是什么

Windsurf 也是基于 VS Code 魔改，但理念不同。Cursor 强调"你指挥它干"，Windsurf 强调"你和它一起进入心流（Flow）"。

什么是 Flow？心理学家米哈里定义的"心流"是：人完全沉浸在一件事里，忘记时间。Windsurf 想做到的是：让你和 AI 的协作丝滑到没有"切换成本"，你只管想，它只管干，中间没有"等待-粘贴"的割裂感。

6.2 Cascade Agent：自动续命

Cascade 是 Windsurf 的核心。它的特点是"自动追踪上下文"——你不用手动 @文件 告诉它看哪里，它会自己根据你的操作推断上下文。

打个比方：Cursor 是"你得告诉编辑要看哪些稿子"，Windsurf 是"编辑会自己盯着你正在改的稿子"。

Cascade 的工作模式：

你在写代码 → Cascade 在后台默默追踪 → 你遇到问题 → 直接问 → 它已经知道上下文 → 立刻答

而且 Cascade 会"主动出击"：发现你改了一个函数签名，它会主动提示你哪些调用处需要同步改。

6.3 Flow 状态：无缝切换

Windsurf 把"写代码"和"问 AI"做成了一体化的体验：

• 不用切窗口，光标在哪儿，AI 就在哪儿
• 选中代码直接打字，就是改它
• 不需要"复制到对话框"这种割裂动作
• Cascade 自动维护对话历史和文件上下文

实测感受：写复杂业务逻辑时，这种"无切换"体验确实能让你保持专注，不像用别的工具那样频繁"出戏"。

6.4 Windsurf 实战：Go 微服务开发

给这个 Go 微服务加上链路追踪：
- 用 OpenTelemetry
- 追踪 HTTP 请求和数据库调用
- 把 trace_id 加到日志里
- 接入 Jaeger

Cascade 生成的关键代码：

// cmd/server/main.go
package main

import (
    "context"
    "log"
    "net/http"
    "os"

    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/attribute"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
    "go.opentelemetry.io/otel/propagation"
    "go.opentelemetry.io/otel/sdk/resource"
    sdktrace "go.opentelemetry.io/otel/sdk/trace"
    semconv "go.opentelemetry.io/otel/semconv/v1.24.0"
)

func initTracer(ctx context.Context) func() {
    exporter, err := otlptracehttp.New(ctx,
        otlptracehttp.WithEndpoint("localhost:4318"),
        otlptracehttp.WithInsecure(),
    )
    if err != nil {
        log.Fatalf("创建 trace exporter 失败: %v", err)
    }

    tp := sdktrace.NewTracerProvider(
        sdktrace.WithBatcher(exporter),
        sdktrace.WithResource(resource.NewWithAttributes(
            semconv.SchemaURL,
            semconv.ServiceName("user-service"),
            attribute.String("environment", os.Getenv("APP_ENV")),
        )),
    )
    otel.SetTracerProvider(tp)
    otel.SetTextMapPropagator(propagation.TraceContext{})

    return func() {
        _ = tp.Shutdown(ctx)
    }
}

func main() {
    ctx := context.Background()
    shutdown := initTracer(ctx)
    defer shutdown()

    mux := http.NewServeMux()
    mux.Handle("/users", tracingMiddleware(http.HandlerFunc(handleUsers)))

    log.Println("服务启动在 :8080")
    log.Fatal(http.ListenAndServe(":8080", mux))
}

// internal/middleware/tracing.go
package middleware

import (
    "fmt"
    "net/http"

    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/attribute"
    "go.opentelemetry.io/otel/codes"
    "go.opentelemetry.io/otel/trace"
)

func TracingMiddleware(next http.Handler) http.Handler {
    tracer := otel.Tracer("user-service")
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ctx, span := tracer.Start(r.Context(), r.URL.Path)
        defer span.End()

        span.SetAttributes(
            attribute.String("http.method", r.Method),
            attribute.String("http.url", r.URL.String()),
            attribute.String("http.host", r.Host),
        )

        ww := &statusWriter{ResponseWriter: w, status: 200}
        next.ServeHTTP(ww, r.WithContext(ctx))

        span.SetAttributes(attribute.Int("http.status_code", ww.status))
        if ww.status >= 400 {
            span.SetStatus(codes.Error, fmt.Sprintf("HTTP %d", ww.status))
        }

        // 把 trace_id 写进响应头，方便排查
        traceID := span.SpanContext().TraceID().String()
        w.Header().Set("X-Trace-Id", traceID)
    })
}

type statusWriter struct {
    http.ResponseWriter
    status int
}

func (w *statusWriter) WriteHeader(status int) {
    w.status = status
    w.ResponseWriter.WriteHeader(status)
}

// internal/middleware/logging.go（trace_id 写进日志）
package middleware

import (
    "context"
    "log/slog"
    "go.opentelemetry.io/otel/trace"
)

func LoggerWithTrace(ctx context.Context) *slog.Logger {
    span := trace.SpanFromContext(ctx)
    traceID := span.SpanContext().TraceID().String()
    spanID := span.SpanContext().SpanID().String()
    return slog.Default().With(
        "trace_id", traceID,
        "span_id", spanID,
    )
}

// 使用：
// logger := middleware.LoggerWithTrace(r.Context())
// logger.Info("处理用户请求", "user_id", userID)

Cascade 一次性把中间件、入口、日志全改了，而且 trace_id 贯穿了"HTTP 请求 → 业务日志 → 数据库调用"，能在 Jaeger 里看到完整链路。这种"全链路打通"的多文件协调，是 Windsurf 的强项。

6.5 Windsurf 的优缺点

优点：

• Flow 心流体验独特，减少切换成本
• Cascade 自动追踪上下文，省心
• 主动提示关联修改
• 免费 Freemium 模式友好

缺点：

• 生态不如 Cursor/Copilot
• 国内知名度低
• Agent 自主度不如 Claude Code
• 偶尔上下文推断会跑偏

---

七、Trae 深度体验：字节跳动出品 + 免费策略 + 中文 Vibe Coding

Trae 是字节跳动 2024 年底推出的 AI 原生 IDE，2026 年初官方公布注册用户突破 600 万，是"适配企业级中文 Vibe Coding 的优质 Cursor 平替"。2026 年 5 月 5 日 TRAE SOLO 手机版上线，你能在地铁上丢需求让 AI 写代码。

7.1 它到底是什么

Trae 也是基于 VS Code 魔改，定位是"AI 原生 IDE"。但它有两个鲜明标签：

• 免费：国内基础功能免费，Pro 版 $10/月，对国内开发者极其友好
• 中文原生：模型对中文语境理解更深，“Vibe Coding”（凭感觉写代码）体验好

Vibe Coding 是 2026 年的流行词，意思是"你用大白话描述感觉，AI 帮你落地成代码"。Trae 在这件事上做了大量中文优化。

7.2 免费策略：凭什么

字节烧得起。Trae 背后是字节自研的豆包模型 + Claude，国内场景用豆包（便宜），复杂场景用 Claude（贵但强）。免费额度大方，吸引了很多"白嫖党"和预算敏感的开发者。

2026 年 Trae 的定价：

版本	价格	额度	适合
Free	免费	每日充足免费额度	学生、个人开发者
Pro	$10/月	更高额度 + 高级模型	重度个人开发者
企业版	联系销售	私有部署 + 管控	团队/企业

7.3 中文 Vibe Coding 体验

Trae 对中文的理解确实比海外工具强。比如你说"给我整一个能上传 Excel 然后自动出图表的后台"，它能准确get"整一个"是"做一个"的意思，而不是字面翻译。

实测一段中文 Vibe Coding：

帮我搞个员工考勤看板：
- 前端 Vue3 + ECharts
- 后端 Node.js + Express
- 数据库 MySQL
- 能按部门、按月统计出勤率
- 迟到早退高亮标红
- 导出 Excel 报表
- 长得要现代一点，参考飞书后台那种风格

Trae 生成的关键代码：

<!-- frontend/src/views/AttendanceDashboard.vue -->
<template>
  <div class="dashboard">
    <div class="filters">
      <el-select v-model="filters.dept" placeholder="选择部门" clearable>
        <el-option v-for="d in departments" :key="d.id" :label="d.name" :value="d.id" />
      </el-select>
      <el-date-picker v-model="filters.month" type="month" placeholder="选择月份" />
      <el-button type="primary" @click="fetchData">查询</el-button>
      <el-button @click="exportExcel">导出 Excel</el-button>
    </div>

    <div class="stats-cards">
      <el-card v-for="s in stats" :key="s.label">
        <div class="stat-value" :class="{ 'late': s.isLate }">{{ s.value }}{{ s.unit }}</div>
        <div class="stat-label">{{ s.label }}</div>
      </el-card>
    </div>

    <div class="charts">
      <div ref="rateChartRef" class="chart" />
      <div ref="trendChartRef" class="chart" />
    </div>

    <el-table :data="tableData" :row-class-name="rowClass" border>
      <el-table-column prop="name" label="姓名" />
      <el-table-column prop="dept" label="部门" />
      <el-table-column prop="attendDays" label="出勤天数" />
      <el-table-column prop="lateCount" label="迟到次数" />
      <el-table-column prop="earlyLeave" label="早退次数" />
      <el-table-column prop="rate" label="出勤率">
        <template #default="{ row }">
          <span :class="{ 'text-red': row.rate < 0.9 }">
            {{ (row.rate * 100).toFixed(1) }}%
          </span>
        </template>
      </el-table-column>
    </el-table>
  </div>
</template>

<script setup lang="ts">
import { ref, onMounted, nextTick } from "vue";
import * as echarts from "echarts";
import * as XLSX from "xlsx";

const rateChartRef = ref<HTMLElement>();
const trendChartRef = ref<HTMLElement>();
const tableData = ref([]);
const stats = ref([]);

const rowClass = ({ row }) => {
  if (row.lateCount > 3 || row.earlyLeave > 3) return "warning-row";
  return "";
};

const exportExcel = () => {
  const ws = XLSX.utils.json_to_sheet(tableData.value);
  const wb = XLSX.utils.book_new();
  XLSX.utils.book_append_sheet(wb, ws, "考勤明细");
  XLSX.writeFile(wb, `考勤报表_${new Date().toISOString().slice(0,10)}.xlsx`);
};

const initCharts = (data: any) => {
  // 部门出勤率柱状图
  echarts.init(rateChartRef.value!).setOption({
    title: { text: "各部门出勤率", left: "center" },
    tooltip: { trigger: "axis" },
    xAxis: { type: "category", data: data.depts },
    yAxis: { type: "value", max: 100, axisLabel: { formatter: "{value}%" } },
    series: [{
      type: "bar",
      data: data.rates,
      itemStyle: { color: "#3370ff" },
      label: { show: true, formatter: "{c}%" },
    }],
  });

  // 月度趋势折线图
  echarts.init(trendChartRef.value!).setOption({
    title: { text: "出勤率月度趋势", left: "center" },
    tooltip: { trigger: "axis" },
    xAxis: { type: "category", data: data.months },
    yAxis: { type: "value", max: 100 },
    series: [{ type: "line", data: data.trend, smooth: true, areaStyle: {} }],
  });
};

const fetchData = async () => {
  const res = await fetch(`/api/attendance?dept=${filters.value.dept}&month=${filters.value.month}`);
  const data = await res.json();
  tableData.value = data.list;
  stats.value = data.stats;
  await nextTick();
  initCharts(data);
};

onMounted(fetchData);
</script>

// backend/server.js
const express = require("express");
const mysql = require("mysql2/promise");
const app = express();

const pool = mysql.createPool({
  host: "localhost",
  user: "root",
  password: process.env.DB_PASS,
  database: "attendance",
  waitForConnections: true,
  connectionLimit: 10,
});

app.get("/api/attendance", async (req, res) => {
  const { dept, month } = req.query;
  const conn = await pool.getConnection();
  try {
    // 明细
    const [rows] = await conn.query(
      `SELECT e.name, d.name AS dept,
              COUNT(a.id) AS attend_days,
              SUM(a.is_late) AS late_count,
              SUM(a.is_early_leave) AS early_leave,
              COUNT(a.id) / ? AS rate
       FROM employees e
       JOIN departments d ON e.dept_id = d.id
       LEFT JOIN attendance a ON e.id = a.emp_id
            AND DATE_FORMAT(a.date, '%Y-%m') = ?
       ${dept ? "WHERE e.dept_id = ?" : ""}
       GROUP BY e.id`,
      dept ? [22, month, dept] : [22, month]  // 22 个工作日
    );

    // 部门汇总
    const [depts] = await conn.query(
      `SELECT d.name, AVG(COUNT(a.id)/22)*100 AS rate
       FROM employees e JOIN departments d ON e.dept_id=d.id
       LEFT JOIN attendance a ON e.id=a.emp_id AND DATE_FORMAT(a.date,'%Y-%m')=?
       GROUP BY d.id`, [month]
    );

    res.json({
      list: rows,
      depts: depts.map(d => d.name),
      rates: depts.map(d => Number(d.rate).toFixed(1)),
    });
  } finally {
    conn.release();
  }
});

app.listen(3000, () => console.log("考勤服务跑在 3000"));

你看，“长得像飞书后台”“迟到标红”"导出 Excel"这些中文口语化需求，Trae 全都准确get并落地了。这就是中文 Vibe Coding 的价值。

7.4 TRAE SOLO 手机版：碎片时间写代码

2026 年 5 月 5 日上线的 TRAE SOLO 手机版是个有意思的创新。你在地铁上想到一个需求，掏出手机描述一下，它就开始干活，回家打开电脑，代码已经生成好了。

这背后的逻辑是：AI Agent 不依赖 IDE 界面，所以可以跑在任何设备上。手机只是一个"投递需求"的入口。

7.5 Trae 的优缺点

优点：

• 免费额度大方，性价比之王
• 中文 Vibe Coding 体验最佳
• 字节背书，迭代积极
• 手机版覆盖碎片时间
• 国内访问无障碍

缺点：

• Agent 自主度不如 Claude Code
• 海外生态不如 Cursor
• 复杂任务质量偶有波动
• 企业级管控功能尚在完善

---

八、实战对比：同一个项目用五个工具分别完成

光说不练假把式。我拿同一个需求，用五个工具分别跑一遍，对比效率和质量。为了控制变量，都使用各自默认模型，不做特殊调优。

8.1 测试需求

给一个空的 Next.js 14 项目，实现一个"待办事项"应用，要求：

1. 数据库用 Prisma + SQLite
2. CRUD 全套 API（Route Handlers）
3. 前端用 Server Components + Client Components 混合
4. 支持标签分类、优先级、截止日期
5. 列表支持筛选、排序
6. 加载状态 + 错误处理
7. 响应式适配移动端
8. 跑通 npm run build

8.2 实测记录

指标	Claude Code	Cursor	Copilot	Windsurf	Trae
完成时间	4 分 12 秒	6 分 38 秒	11 分 20 秒	7 分 05 秒	8 分 47 秒
手动干预次数	0	2	5	3	4
生成文件数	14	13	11	13	12
代码总行数	487	512	398	503	461
首次 build 通过	是	是	否（2 处 import 错误）	是	否（1 处类型错误）
bug 数量	0	1（标签筛选边界）	3	1	2
测试覆盖	自动补了	需提醒才补	需手动要求	自动补了	需提醒才补
需求覆盖率	8/8	8/8	7/8（缺响应式）	8/8	8/8
代码质量评分	9.2/10	9.0/10	7.5/10	8.8/10	8.5/10
Token 消耗	高	中	中	中高	低

8.3 实战细节点评

Claude Code：全程零干预，自己建文件、写代码、装依赖、跑 build、看报错、修、再跑。最让我惊讶的是它自己补了测试，没让我提。build 一次过。这就是 Agent 的价值——它"完成"了任务，不只是"生成"了代码。

Cursor：Composer 一次性生成所有文件，质量很高，但有 2 处需要我确认（询问要不要装某个依赖）。build 通过，但标签筛选有个边界 bug（多选标签时逻辑错了）。手动修一下就好。

Copilot：用 Workspace 模式，它先生成计划让我审，然后实现。但过程比较割裂——改一处得确认一次，跑 build 报了 2 处 import 错误，它没自己修，得我提示"修一下 build 错误"。响应式也没做，得二次提醒。

Windsurf：Cascade 体验流畅，自动追踪上下文很省心。build 一次过，但有个小 bug（截止日期时区处理）。整体接近 Cursor 的水平。

Trae：中文需求理解准确，生成速度快。但 build 时报了 1 处类型错误，得提醒它修。修完后功能完整，质量中上。Token 消耗最低（豆包模型便宜）。

8.4 不同维度的赢家

维度	冠军	亚军	点评
代码生成质量	Claude Code	Cursor	Claude 逻辑最严谨
完成速度	Claude Code	Cursor	Agent 自主循环省时间
省心程度（少干预）	Claude Code	Windsurf	零干预碾压
日常补全体感	Cursor	Copilot	Tab 补全丝滑度
中文体验	Trae	Windsurf	原生中文优势
性价比	Trae	Copilot	免费额度大方
生态集成	Copilot	Cursor	GitHub 全家桶
移动端	Trae	—	SOLO 手机版独此一家

---

九、价格对比表：免费额度、Pro 版、企业版全梳理

钱是大家最关心的。我把五大工具 2026 年 7 月的最新定价全梳理一遍。

9.1 个人版定价

工具	免费版	Pro 版	Pro 月费	Pro 年费	备注
Claude Code	无（需订阅或 API）	Claude Pro	$20/月	$200/年	含 Claude Code 使用额度；Max $100/月额度更高
Cursor	有（有限额度）	Cursor Pro	$20/月	$192/年	含 500 次快速请求/月
GitHub Copilot	有（有限）	Copilot Pro	$10/月	$100/年	学生/开源维护者免费
Windsurf	有（Freemium）	Windsurf Pro	$15/月	$144/年	免费版每日有额度
Trae	有（充足）	Trae Pro	$10/月	$96/年	国内基础功能免费

9.2 企业版定价

工具	企业版月费	核心企业特性
Claude Code	联系销售（Max Team）	团队额度池、管控、SSO、审计日志
Cursor	$40/用户/月	团队管理、统一计费、隐私模式
GitHub Copilot	$39/用户/月	Copilot Business/Enterprise，深度 GitHub 集成、合规
Windsurf	$30/用户/月	团队版、统一管理
Trae	联系销售	私有部署、数据本地化、定制模型

9.3 隐性成本

光看月费不够，还有几笔隐性成本要注意：

隐性成本	Claude Code	Cursor	Copilot	Windsurf	Trae
API 超额费	高（按 Token）	中（有上限）	低	中	低（豆包便宜）
国内访问成本	高（需代理）	中	高（需代理）	中	无
学习成本	中偏高	低	最低	低	最低
硬件要求	低（终端）	高（IDE）	中	高	高

9.4 性价比之王

综合"价格 × 能力 × 体验"：

• 白嫖党/学生：Trae（免费额度大方）> Copilot（学生免费）> Windsurf（Freemium）
• 个人开发者（预算敏感）：Copilot（$10）> Trae Pro（$10）> Windsurf（$15）
• 个人开发者（追求最强）：Claude Code（$20，能力天花板）≈ Cursor（$20，体验最佳）
• 企业团队：Copilot（合规+生态）> Cursor（团队管理）> Claude Code（Max Team）

---

十、选型决策树：不同场景的最佳选择

看完上面那么多，你可能还是纠结。我画了几棵决策树，对着你的情况对号入座。

10.1 按"你是谁"选

你是什么角色？
│
├─ 学生 / 编程新手
│   └─→ Trae（免费 + 中文友好 + 上手最易）
│        或 Copilot（学生免费）
│
├─ 个人开发者（独立开发 / 副业）
│   ├─ 预算紧 ─────────→ Trae / Copilot
│   ├─ 追求最强能力 ───→ Claude Code + Cursor 组合
│   └─ 做全栈 Web ────→ Cursor（Composer 多文件无敌）
│
├─ 企业后端工程师
│   ├─ 团队用 GitHub ──→ Copilot（生态集成）
│   ├─ 复杂自动化任务 ─→ Claude Code（Agent 标杆）
│   └─ 重度日常开发 ──→ Cursor
│
├─ DevOps / SRE
│   └─→ Claude Code（终端原生，SSH/CI 都能跑）
│
├─ 前端 / 全栈
│   ├─ 重交互体验 ────→ Cursor（Tab 补全丝滑）
│   └─ 想要心流 ──────→ Windsurf（Flow 状态）
│
├─ 国内团队 / 国企 / 体制内
│   └─→ Trae（数据本地化、中文、免费）
│
└─ 技术负责人 / CTO
    └─→ Copilot（合规）+ Claude Code（攻坚）双修

10.2 按"干什么活"选

你要干的活是什么？
│
├─ 日常补全、写小函数
│   └─→ Cursor / Copilot（补全最强）
│
├─ 大规模重构（跨几十个文件）
│   └─→ Cursor（Composer 2.5 标杆）
│
├─ 从零搭建整个项目
│   └─→ Claude Code（Agent 自主闭环）
│
├─ 修 Bug + 跑测试自验证
│   └─→ Claude Code（自己跑自己修）
│
├─ 写文档 / 注释
│   └─→ Claude Code / Cursor 都行
│
├─ 处理 GitHub Issue / 提 PR
│   └─→ Copilot Workspace（原生集成）
│
├─ CI/CD 流水线里跑 AI
│   └─→ Claude Code（CLI 无头模式）
│
├─ 连数据库 / 浏览器 / 外部工具
│   └─→ Claude Code（MCP 生态）
│
├─ 中文口语化"凭感觉写"
│   └─→ Trae（Vibe Coding 最佳）
│
└─ 长时间沉浸式开发
    └─→ Windsurf（Flow 心流）

10.3 黄金组合推荐

很多人问我"到底选一个还是组合用"。我的建议是组合用，各取所长：

组合一：个人全能型

• 日常写代码：Cursor（补全 + Composer）
• 复杂任务/自动化：Claude Code（Agent）
• 备用白嫖：Trae

组合二：企业开发型

• 日常 + PR 流程：Copilot（GitHub 集成）
• 攻坚复杂任务：Claude Code
• 文档/代码审查：Claude Code

组合三：国内性价比型

• 主力：Trae（免费 + 中文）
• 攻坚：Claude Code（按需 API）

组合四：全栈心流型

• 主力 IDE：Windsurf（Flow）
• 自动化：Claude Code
• 备用：Cursor

我自己现在的配置是 Cursor（日常）+ Claude Code（攻坚）+ Trae（白嫖备份），月费 $40，覆盖所有场景。

---

十一、2026 年 AI 编程趋势：从 Copilot 到 Agent 的 12 个趋势

最后聊聊趋势。2026 年下半年到 2027 年，AI 编程会往哪走？我总结了 12 个已经发生或正在发生的趋势。

趋势 1：从"补全"到"Agent"是不可逆的洪流

SWE-bench 通过率从 2023 年的不到 5% 涨到 2026 年的 80%+，三年 16 倍。这意味着 AI 已经能独立解决大部分真实软件工程问题。"补全式"工具会继续存在，但"Agent 式"会成为高端场景的主流。

趋势 2：终端 Agent 成为大厂标配

Claude Code 证明了"终端原生 Agent"的可行性。2026 年 OpenAI、Google 都在推自己的终端 Agent（Codex CLI、Gemini CLI）。终端 Agent 因为不依赖 IDE、能进 CI/CD，会成为 DevOps 场景的标配。

趋势 3：MCP 成为工具协议事实标准

Anthropic 推的 MCP 在 2026 年成为事实标准，上千个 MCP 服务器覆盖数据库、浏览器、文件系统、设计工具。OpenAI、Google 也宣布支持 MCP。"AI 连接万物的统一接口"正在成型。

趋势 4：Skill 系统让 AI 拥有"专业 SOP"

Skill 让 AI 不只是"会写代码"，而是"懂最佳实践"。社区共享的 Skill 库让团队经验可复用、可传承。2026 年下半年，企业级 Skill 市场会爆发。

趋势 5：多 Agent 协作成为常态

一个 Agent 干不过来？让它指挥多个子 Agent 并行干。Claude Code 已经支持"主 Agent 调度子 Agent"。2026 年下半年会出现"Agent 编排"这个新工种。

趋势 6：IDE 与 Agent 融合

Cursor、Windsurf 都在往"IDE + Agent"融合。未来 IDE 不是"写代码的地方"，而是"指挥 Agent 的指挥台"。手写代码的比例会持续下降。

趋势 7：自然语言成为主要"编程语言"

Vibe Coding 兴起。你用中文/英文描述意图，AI 落地成代码。"会写代码"不再是程序员的护城河，"会描述清楚需求"才是。

趋势 8：AI 原生项目结构兴起

项目结构开始为 AI 优化：CLAUDE.md、.cursorrules、SKILL.md 这些"给 AI 看的文件"成为标配。未来的项目会同时有"人读的文档"和"AI 读的指令"。

趋势 9：测试驱动 AI（TDAI）

AI 自己写代码、自己写测试、自己跑测试、自己修。人类从"写测试"变成"审测试用例是否覆盖到位"。质量保障前移到"需求描述"环节。

趋势 10：代码审查自动化

AI 自动 review PR、检查安全漏洞、风格一致性、性能问题。GitHub Copilot 已经在做。2026 年下半年，没有 AI review 的 PR 会被视为"高风险"。

趋势 11：国产工具崛起

Trae（字节）、CodeGeeX（智谱）、通义灵码（阿里）等国产工具在中文场景、合规、价格上占据优势。国内市场，国产工具份额持续上升。

趋势 12：程序员角色重塑

最关键的：程序员正在从"敲代码的人"变成"指挥 AI 的人 + 把控质量的人 + 定义需求的人"。说白了，越来越像产品经理 + 架构师的混合体。"写代码"这个动作的价值在贬值，"想清楚做什么"和"判断做得对不对"的价值在升值。

---

十二、面试 / 实战问答：10 个高频问题

这一节给准备面试和实战的同学。这些都是 2026 年面试高频出现的 AI 编程相关问题。

Q1：Claude Code 和 Cursor 到底选哪个？

A：看你的核心诉求。如果你要的是"日常写代码丝滑"——选 Cursor，它的 Tab 补全和 Composer 多文件编辑是日常开发的天花板。如果你要的是"把一个复杂任务丢给它，它自己干完"——选 Claude Code，它的 Agent 自主闭环是独一档。最佳实践是两个都装：Cursor 做日常，Claude Code 攻坚。

Q2：Claude Code 的 Skill 和 MCP 有什么区别？

A：一句话——Skill 让 AI 更"聪明"（知道怎么做，是提示词模板/SOP），MCP 让 AI 更"能干"（有工具可用，是外部工具服务器）。打个比方：Skill 是菜谱（告诉你红烧肉怎么做），MCP 是厨具（给你一口锅）。光有菜谱没锅做不出菜，光有锅没菜谱乱炒一通。

Q3：用 AI 写的代码，出了 Bug 谁负责？

A：法律和工程上都是"提交代码的人负责"。AI 是工具，不是责任主体。所以用 AI 编程的核心技能不是"让 AI 写代码"，而是"审查 AI 写的代码"——你要能看懂、能判断对错、能兜底。这也是为什么"基本功"依然重要。

Q4：新手该从哪个工具入门？

A：推荐 Trae 或 Copilot。Trae 免费 + 中文友好，上手最易；Copilot 学生免费 + 生态广。先用补全类工具熟悉"AI 辅助"的节奏，再过渡到 Cursor（结对编程），最后再上 Claude Code（Agent）。别一上来就用 Claude Code，会养成"不动脑子"的坏习惯。

Q5：AI 编程会让程序员失业吗？

A：短期不会，但会重塑。"只会敲代码、不会思考"的初级岗位会受冲击；"能想清楚需求、能审查质量、能驾驭 AI"的人会更值钱。趋势是程序员变成"产品经理 + 架构师 + AI 指挥官"的混合体。与其焦虑失业，不如赶紧学怎么用好这些工具。

Q6：企业级项目敢用 AI 写吗？合规怎么办？

A：能用，但要管控。要点：1）选企业版（Copilot Enterprise / Trae 企业版），数据不外泄；2）建立 AI 代码审查流程，AI 写的必须人审 + 自动化测试；3）敏感信息（密钥、客户数据）不进 prompt；4）建立"AI 使用规范"文档。Copilot 在合规上最成熟，金融/国企优先考虑。

Q7：CLAUDE.md / .cursorrules 这类文件该怎么写？

A：聚焦"约定"和"禁忌"，别写成长篇大论。核心内容：技术栈、目录结构、命名规范、代码风格、常用命令、绝对不能碰的禁区。300—500 行是甜区。太长稀释重点还费 token。可以先用 /init（Claude Code）或让 AI 扫描项目自动生成初版，再人工微调。

Q8：AI 编程的 token 成本怎么控制？

A：几个技巧：1）用便宜模型干简单活（Haiku 补全、Sonnet 日常、Opus 攻坚）；2）CLAUDE.md 别写太长；3）Skill 用渐进式披露，按需加载；4）大项目用索引而不是全量喂给 AI；5）无交互模式（claude -p）跑批处理任务，减少对话轮次；6）Trae 的豆包模型成本最低，预算紧时优先。

Q9：怎么判断 AI 写的代码质量好不好？

A：四看：1）看逻辑——能不能用自己的话讲清楚它干了啥；2）看边界——异常、空值、并发有没有处理；3）看测试——有没有覆盖正常+异常+边界；4）看风格——符不符合项目规范。最有效的办法：让另一个 AI（或同一个 AI 换个会话）做 code review，往往能发现你看不到的问题。

Q10：2026 年下半年最值得关注什么？

A：三个方向：1）多 Agent 协作——一个主 Agent 调度多个子 Agent 并行干活，这是下一个效率爆发点；2）MCP 生态——会涌现更多垂直行业（金融、医疗）的 MCP 服务器；3）AI 原生编程语言——专为 AI 生成/理解设计的语言和框架会出现，摆脱对现有语言的"翻译"损耗。提前关注这三块，能吃到下一波红利。

---

十三、总结：普通人如何抓住这波红利

写了一万多字，最后给普通人几条掏心窝的建议。

13.1 核心结论

五大工具，没有"最好"，只有"最合适"：

• Claude Code：能力天花板，复杂任务和自动化的首选，但需要懂终端、token 烧得快
• Cursor：日常开发体验之王，Composer 多文件编辑无敌，Tab 补全上瘾
• GitHub Copilot：生态和合规的王者，企业级最稳，补全依然能打
• Windsurf：心流体验独特，Cascade 自动追踪省心，适合沉浸式开发
• Trae：免费 + 中文 Vibe Coding 最佳，性价比之王，国内开发者首选

13.2 给普通人的建议

第一，别观望，现在就用。 AI 编程不是"未来的事"，是"现在的事"。每多观望一个月，你就少积累一个月的"驾驭 AI"的经验。这个经验窗口期就这两三年，过了就晚了。

第二，从免费工具入门，别一上来就买最贵的。 Trae 免费、Copilot 学生免费、Windsurf 有免费版。先用免费的熟悉"AI 辅助"的节奏，确认自己真的需要更强能力再付费。

第三，基本功不能丢。 AI 能写代码，但"判断代码对不对"还得靠你。数据结构、算法、系统设计、业务理解——这些是 AI 替代不了的。会用 AI + 基本功扎实的人，才是 2026 年最抢手的。

第四，学会"描述需求"。 未来的核心竞争力不是"会写代码"，而是"会想清楚要什么、能描述清楚给 AI"。这本质是产品思维 + 沟通能力。练这个，比练打字速度有用一万倍。

第五，建立自己的 Skill / 规则库。 把你重复做的事、踩过的坑、团队的最佳实践，沉淀成 Skill 或 .cursorrules / CLAUDE.md。这些"AI 读的指令"会成为你的私有资产，越积越值钱。

13.3 一句话送给你

2026 年，不会用 AI 编程的程序员，就像 2010 年不会用 Google 的程序员——不是不能干活，是效率差了一个时代。

工具是杠杆，你是支点。杠杆再长，支点不稳也撬不动地球。先把基本功这个支点扎稳，再把 AI 这个杠杆用熟，这波红利就是你的。

---

全文完。如果这篇对你有帮助，点个赞 + 收藏，下次选工具时不迷路。

你现在在用哪个工具？踩过什么坑？欢迎评论区交流，我会一一回复。

下一篇我会写《Claude Code 进阶：自己写 Skill 和 MCP 服务器，把重复工作全自动化》，关注我不迷路。

---

参考资料与延伸阅读：

• Anthropic 官方 Claude Code 文档
• Cursor 官方文档与 Composer 2 发布说明
• GitHub Copilot 官方文档与 Workspace 指南
• Windsurf (Codeium) 官方文档
• Trae 官方文档与字节跳动技术博客
• SWE-bench Verified 官方榜单（2026 年 4 月数据）
• MCP（Model Context Protocol）协议规范
• SemiAnalysis 关于 AI Agent 时代的分析报告