$catMANUAL||~42 min

终端AI编程Agent大乱斗：Claude Code vs Codex CLI vs Gemini CLI 实战对比

advertisement

终端AI编程Agent大乱斗：Claude Code vs Codex CLI vs Gemini CLI 实战对比

上周有个朋友问我："你平时写代码用什么AI工具？"我说终端里跑Agent，他说"啥？不用Cursor？"得，看来很多人对终端AI编程Agent这玩意儿还不太了解。

说实话，我之前也用Cursor，用了大概三个月，后来切到终端Agent之后就回不去了。不是说Cursor不好，而是终端Agent的交互方式跟我的工作流太契合了——我本身就是终端重度用户，tmux + neovim + git这套组合用了好几年，突然让我切到一个GUI IDE里，总觉得别扭。

现在终端AI编程Agent这个赛道已经卷起来了。Claude Code、OpenAI的Codex CLI、Google的Gemini CLI，还有开源的OpenCode，各有各的玩法。今天就来聊聊我实际用下来的感受，踩过的坑，以及不同场景下该选哪个。

为什么选终端Agent而不是IDE插件？

先说说我为什么从Cursor切到终端Agent。

Cursor确实好用，自动补全很丝滑，Tab Tab Tab 的体验很爽。但问题是，它本质上还是一个IDE，你得在它的窗口里写代码。而我的项目经常需要同时操作多个终端、跑测试、看日志、部署服务器，这些事情Cursor帮不上忙。

终端Agent就不一样了。它直接在你的shell里运行，能执行命令、读写文件、搜索代码，甚至能帮你跑测试和部署。它不是一个"补全工具"，而是一个真正的"编程搭档"——你告诉它要做什么，它自己去搞定，中间遇到问题还会自己排查。

当然，终端Agent也有缺点。比如没有GUI的代码高亮和自动补全，写代码的时候视觉反馈不如IDE直观。但对我来说，这不是问题——我用neovim写代码，Agent负责帮我做那些重复性的工作、排查问题、重构代码。

好，废话不多说，进入正题。

三个选手介绍

Claude Code

Claude Code是Anthropic出的终端AI编程Agent，基于Claude Sonnet 4模型。它可能是目前功能最完善的终端Agent，没有之一。

安装很简单：

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

用的时候直接在项目目录下跑：

bash
1
claude

它会自动读取你的项目结构，理解代码上下文，然后你就可以用自然语言跟它对话了。比如：

  • "帮我把 src/utils 里的工具函数整理一下"
  • "这个报错怎么回事：TypeError: Cannot read property 'map' of undefined"
  • "给这个函数写个单元测试"

Claude Code的核心能力在于它的Skills系统。你可以给它配置各种技能，比如代码审查、测试驱动开发、调试流程等等。这些Skills本质上是一些markdown文件，定义了Agent在特定场景下的行为规范。

bash
1
# 查看已有技能
2
claude skills list
3
4
# 添加一个自定义技能
5
claude skills add my-skill --file ./my-skill.md

我在自己的项目里配置了十几个Skills，覆盖了从代码编写到部署的整个流程。效果非常显著——Agent不再是一个通用的助手，而是一个了解你项目规范、知道你习惯的"同事"。

价格：Claude Code用的是API计费，Sonnet 4的定价大概是输入$3/百万token，输出$15/百万token。一次普通的编程对话大概消耗$0.05-$0.15，一天高强度使用下来大概$2-$5。如果你订阅了Claude Pro（$20/月），可以解锁一些限制但API调用还是要额外付费。

OpenAI Codex CLI

Codex CLI是OpenAI在2025年5月开源的终端AI编程Agent。它基于o4-mini模型，定位是轻量级的命令行编程助手。

bash
1
npm install -g @openai/codex

使用：

bash
1
codex "帮我写一个Python脚本，读取CSV文件并统计每列的空值数量"

Codex CLI的设计理念跟Claude Code不太一样。Claude Code是一个交互式的对话Agent，你可以跟它来回聊；Codex CLI更像是一个"一次性任务执行器"——你给它一个任务描述，它执行完就结束了。

当然，你也可以用交互模式：

bash
1
codex

进入交互模式后，体验跟Claude Code类似，但功能上还是有差距。Codex CLI目前没有Skills系统，没有Claude Code那种细粒度的行为控制。它的优势在于速度——o4-mini模型的推理速度比Claude Sonnet 4快不少，对于简单的任务效率很高。

价格：Codex CLI对ChatGPT Plus用户（$20/月）免费使用，API调用的话o4-mini的价格大概是$1.1/百万输入token，$4.4/百万输出token。比Claude便宜不少。

Google Gemini CLI

Gemini CLI是Google在2025年6月推出的终端AI编程Agent，基于Gemini 2.5 Pro模型。最大的卖点？免费。没错，完全免费，不限次数。

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

等等，装错了。Gemini CLI的安装：

bash
1
npm install -g @google/gemini-cli

使用：

bash
1
gemini

Gemini CLI的界面设计很简洁，进入后就是一个交互式对话。它的代码能力说实话不如Claude Code和Codex CLI，但胜在免费，而且Google的搜索能力集成在里面，可以实时搜索技术文档和Stack Overflow。

价格：免费。这是它最大的竞争力。

额外选手：OpenCode

OpenCode是一个开源的终端AI编程Agent，支持多个LLM后端（OpenAI、Anthropic、Google、甚至本地模型）。如果你不想被某个厂商绑定，或者想用自己部署的模型，OpenCode是不错的选择。

bash
1
# 安装
2
go install github.com/opencode-ai/opencode@latest

OpenCode的界面是TUI（终端用户界面），用的是Bubble Tea框架，视觉效果在终端Agent里算好看的。它支持多文件编辑、LSP集成、Git操作等等。

不过OpenCode的生态不如Claude Code和Codex CLI成熟，社区也小一些。适合喜欢折腾的技术人员。

安装与配置踩坑实录

说起来都是泪。这三个工具的安装过程我都踩过坑。

Claude Code的坑

Claude Code需要Node.js 18+，这个倒是没啥问题。但它依赖的一些native模块在某些系统上编译会失败。我在一台Ubuntu 22.04的服务器上安装的时候，遇到了这个报错：

code
1
Error: Cannot find module '@anthropic-ai/claude-code-linux-x64'

查了半天，发现是npm的缓存问题。清缓存重装就好了：

bash
1
npm cache clean --force
2
npm install -g @anthropic-ai/claude-code

还有一个坑是API Key的配置。Claude Code支持多种认证方式，最简单的是设置环境变量：

bash
1
export ANTHROPIC_API_KEY="sk-ant-xxx"

但如果你在公司网络里，可能需要配置代理：

bash
1
export HTTPS_PROXY="http://proxy.company.com:8080"
2
claude

我第一次用的时候没配代理，结果一直报连接超时，还以为是API Key的问题，折腾了半小时才发现是网络问题。

Codex CLI的坑

Codex CLI的安装倒是很顺利，但它对Node.js版本有要求——必须是22+。我服务器上装的是20.x，直接报错：

code
1
Error: codex requires Node.js >= 22

升级Node.js就好了，但如果你用nvm管理Node版本，记得切过去：

bash
1
nvm install 22
2
nvm use 22

还有一个更坑的：Codex CLI的认证需要OpenAI的API Key，但它不直接读取OPENAI_API_KEY环境变量（至少我遇到的版本是这样）。你得通过codex auth命令登录：

bash
1
codex auth login

这个命令会打开浏览器让你登录OpenAI账户。如果你在无头服务器（headless server）上，这就有问题了——没有浏览器怎么登录？

解决办法是用API Key模式：

bash
1
export OPENAI_API_KEY="sk-xxx"
2
codex --api-key-env OPENAI_API_KEY

但这个参数在文档里不太好找，我翻了GitHub Issues才找到。

Gemini CLI的坑

Gemini CLI的安装最简单，但认证流程最烦。它需要Google Cloud的认证：

bash
1
gcloud auth application-default login

这个命令也会打开浏览器。如果你在服务器上，可以用服务账户的方式：

bash
1
export GOOGLE_APPLICATION_CREDENTIALS="/path/to/service-account.json"

但创建服务账户、下载JSON文件这一套流程本身就挺繁琐的。Google就不能学学Anthropic，直接用API Key多简单。

还有一个问题是Gemini CLI的模型选择。默认用的是Gemini 2.5 Pro，但这个模型在某些地区有访问限制。如果你在国内，可能需要配置代理或者切换到Gemini 2.0 Flash：

bash
1
gemini --model gemini-2.0-flash

实战对比：让它写个REST API

光说不练假把式。我设计了一个测试场景：让三个Agent分别帮我用Python + FastAPI写一个简单的TODO REST API，包括增删改查和数据库存储。

Claude Code的表现

我把需求丢给Claude Code：

code
1
帮我用Python + FastAPI + SQLite写一个TODO REST API，要求：
2
1. 支持CRUD操作
3
2. 使用SQLAlchemy作为ORM
4
3. 包含输入验证
5
4. 有基本的错误处理

Claude Code直接给我生成了一套完整的项目结构：

code
1
todo-api/
2
├── main.py
3
├── models.py
4
├── schemas.py
5
├── database.py
6
├── requirements.txt
7
└── tests/
8
    └── test_api.py

代码质量相当不错。它用了Pydantic做输入验证，SQLAlchemy做ORM，还贴心地加了Alembic做数据库迁移。最让我满意的是它自动生成了测试文件——不是那种敷衍的测试，而是真正覆盖了各种边界情况的测试。

python
1
# models.py
2
from sqlalchemy import Column, Integer, String, Boolean, DateTime
3
from sqlalchemy.sql import func
4
from database import Base
5
6
class Todo(Base):
7
    __tablename__ = "todos"
8
9
    id = Column(Integer, primary_key=True, index=True)
10
    title = Column(String, nullable=False)
11
    description = Column(String, nullable=True)
12
    completed = Column(Boolean, default=False)
13
    created_at = Column(DateTime(timezone=True), server_default=func.now())
14
    updated_at = Column(DateTime(timezone=True), onupdate=func.now())

整个过程大概3分钟，中间它自己跑了一遍测试确认没有报错。体验非常好。

Codex CLI的表现

同样的需求给Codex CLI：

bash
1
codex "用Python + FastAPI + SQLite写一个TODO REST API，支持CRUD，用SQLAlchemy，有输入验证和错误处理"

Codex CLI也生成了类似的结构，但有几个区别：

  1. 它没有自动生成测试文件
  2. 代码风格更简洁，但注释较少
  3. 它用的是同步版本的FastAPI（应该用async的）
python
1
# Codex 生成的 main.py（节选）
2
@app.post("/todos/", response_model=TodoResponse)
3
def create_todo(todo: TodoCreate, db: Session = Depends(get_db)):
4
    db_todo = Todo(**todo.dict())
5
    db.add(db_todo)
6
    db.commit()
7
    db.refresh(db_todo)
8
    return db_todo

我跟它说"改成async的"，它立马改了。但我觉得它应该默认就用async——FastAPI的优势就在异步，用同步等于白瞎了。

整个过程大概2分钟，比Claude Code快，但需要我额外补充一些东西（测试、async改造）。

Gemini CLI的表现

同样的需求给Gemini CLI：

bash
1
gemini
2
> 帮我用Python + FastAPI + SQLite写一个TODO REST API...

Gemini CLI生成的代码...怎么说呢，能用，但比较粗糙。它没有用SQLAlchemy，而是直接用了sqlite3标准库。输入验证也是手动做的，没有用Pydantic。

python
1
# Gemini 生成的 main.py（节选）
2
@app.post("/todos/")
3
async def create_todo(request: Request):
4
    data = await request.json()
5
    if "title" not in data:
6
        return JSONResponse(status_code=400, content={"error": "Title is required"})
7
    # ...手动验证

但Gemini CLI有一个让我惊喜的地方：它在生成代码的时候，会自动搜索FastAPI的最新文档，确保用的是最新API。比如它用了app.post的最新参数写法，这些Claude Code和Codex CLI都没有。

整个过程大概4分钟，是三个里面最慢的。代码质量也需要手动改进。

代码理解与Debug能力对比

写代码只是Agent能力的一部分，更重要的是理解现有代码和排查问题。

我测试了一个真实场景：我的项目里有一个bug，某个API接口在高并发下会返回500错误，但本地测试完全正常。

Claude Code的Debug流程

我把报错日志和相关代码文件路径丢给Claude Code：

code
1
这个接口在生产环境高并发下报500，本地正常，帮我排查：
2
错误日志：[贴日志]
3
相关文件：src/api/users.py, src/database/connection.py

Claude Code的排查流程让我印象深刻：

  1. 先读了两个文件的代码
  2. 分析了错误日志，定位到是数据库连接池耗尽
  3. 检查了数据库连接配置，发现pool_size设得太小（默认5）
  4. 给出了修复方案：增大连接池 + 添加连接回收机制
  5. 还顺便指出了一个潜在的SQL注入风险
python
1
# Claude Code 建议的修复
2
engine = create_async_engine(
3
    DATABASE_URL,
4
    pool_size=20,          # 从5改成20
5
    max_overflow=10,       # 允许额外10个连接
6
    pool_timeout=30,       # 获取连接超时30秒
7
    pool_recycle=1800,     # 30分钟回收一次连接
8
)

整个排查过程大概5分钟，非常专业。

Codex CLI的Debug流程

同样的问题给Codex CLI：

bash
1
codex "生产环境高并发下API返回500，本地正常，错误日志如下：[日志]，相关文件：src/api/users.py src/database/connection.py"

Codex CLI也找到了问题（连接池耗尽），但分析不如Claude Code深入。它没有发现SQL注入风险，也没有建议pool_recycle参数。不过它给出的修复方案是正确的，而且执行速度更快（大概2分钟）。

Gemini CLI的Debug流程

Gemini CLI在这个测试中表现最差。它找到了连接池的问题，但建议的修复方案有问题——它让我用同步连接池配合异步驱动，这在SQLAlchemy 2.0里是不对的。

我跟它说"这个方案有兼容性问题"，它又查了文档，最终给出了正确的方案。但这种需要来回纠正的情况，在实际工作中会浪费很多时间。

自动化能力：不只是写代码

终端Agent的杀手级特性是它能直接执行命令。这不是"帮你写代码"那么简单，而是"帮你完成整个工作流"。

Claude Code的自动化

Claude Code的自动化能力是最强的。它不只是执行你要求的命令，还会根据上下文自主决策。

比如我说"帮我把这个项目部署到Vercel"，Claude Code会：

  1. 检查项目结构，判断是Next.js还是其他框架
  2. 检查有没有vercel.json配置
  3. 如果没有，自动生成合适的配置
  4. 跑npm run build确认构建成功
  5. 执行vercel deploy
  6. 如果部署失败，自动排查问题并修复

整个过程我只需要说一句话，剩下全是它自己搞的。

更厉害的是，Claude Code的Skills系统可以定义复杂的自动化流程。我给自己写了一个"部署检查"技能：

markdown
1
# deploy-check
2
3
## 部署前检查清单
4
5
1. 运行所有测试：`npm test`
6
2. 类型检查：`npm run typecheck`
7
3. lint检查：`npm run lint`
8
4. 构建测试：`npm run build`
9
5. 检查环境变量是否配置完整
10
6. 检查数据库迁移是否需要执行
11
12
## 如果检查失败
13
14
- 测试失败：分析失败原因，尝试修复
15
- 类型错误：修复类型定义
16
- lint错误：自动修复（如果可以）或列出需要手动处理的

有了这个技能，每次部署前我只要说"跑一下deploy-check"，Agent就会按流程走一遍。

Codex CLI的自动化

Codex CLI的自动化更偏向"一次性任务"。比如：

bash
1
codex "把所有的console.log删掉，换成用winston logger"

它会直接扫描项目，找到所有的console.log，替换为winston的调用。速度很快，大概30秒搞定。

但Codex CLI没有Claude Code那种"多步骤自主决策"的能力。你不能跟它说"帮我优化这个项目的性能"然后让它自己去分析、测试、优化——你得一步步告诉它做什么。

Gemini CLI的自动化

Gemini CLI的自动化能力最弱，但有一个独特优势：它集成了Google搜索。

比如我说"这个库的最新API怎么用"，它会直接去搜文档，然后给你最新的答案。Claude Code和Codex CLI的训练数据有截止日期，对于新发布的库可能不了解。

但Gemini CLI的命令执行能力比较有限。它能跑命令，但不会像Claude Code那样自主决策和排查问题。

费用对比：一天下来花多少钱？

这个可能是大家最关心的问题。我做了一个粗略的统计，按照我一天的使用强度（大概20-30次对话，每次平均5轮），算一下费用。

Claude Code

  • 每次对话平均消耗：约2000输入token + 1000输出token
  • 一天30次对话：60000输入 + 30000输出
  • 费用：约$0.63/天（输入$0.18 + 输出$0.45）
  • 一个月（22个工作日）：约$14

如果你订阅Claude Pro（$20/月），API调用有折扣，一个月大概$10-$15。加上订阅费，总费用约$30-$35/月。

Codex CLI

  • o4-mini的价格比Claude便宜很多
  • 一天30次对话：约$0.15/天
  • 一个月：约$3.3

如果你有ChatGPT Plus（$20/月），Codex CLI的使用包含在订阅里（有额度限制），基本等于白嫖。

Gemini CLI

  • 免费。$0/天，$0/月。
  • 但有速率限制，高峰期可能会被限流。

总结

  • 最便宜：Gemini CLI（免费）
  • 性价比最高：Codex CLI（ChatGPT Plus用户）
  • 最贵但最强：Claude Code（约$30-$35/月）

哪个适合你？场景化推荐

说了这么多，到底该选哪个？我觉得这取决于你的使用场景和预算。

场景1：你是专业开发者，追求效率

选Claude Code。它的代码质量最高，Skills系统可以定制你的工作流，自动化能力最强。虽然贵一点，但如果你的时间值钱（大部分开发者的时间都值钱），这点投入是值得的。

场景2：你是学生或个人开发者，预算有限

选Gemini CLI。免费就是最大的优势。代码能力虽然不如前两个，但对于学习和个人项目完全够用。而且它的搜索能力可以帮你快速查找文档。

场景3：你已经是ChatGPT Plus用户

选Codex CLI。你已经付了$20/月，不用白不用。Codex CLI的速度很快，对于日常编程任务足够了。

场景4：你想要最大灵活性

选OpenCode。支持多个LLM后端，可以用自己的API Key，甚至可以用本地部署的模型。适合喜欢折腾的技术人员。

场景5：你在公司里用，有数据安全要求

这个情况比较复杂。如果你的代码不能发到外部服务器，那你需要用支持本地模型的方案。OpenCode + Ollama + CodeLlama是一个组合，但效果会打折扣。

更好的方案可能是用企业版的Claude Code或Codex CLI，它们都有数据不用于训练的承诺。但具体要看你公司的安全政策。

上下文管理：终端Agent的灵魂

用终端Agent最重要的一个概念是上下文窗口。这三个工具的上下文管理方式完全不同，直接决定了你的使用体验。

Claude Code的上下文策略

Claude Code的上下文窗口是200K token，这在三个工具里是最大的。但大不代表你可以随便丢东西进去——上下文越大，API费用越高，响应速度也越慢。

我摸索出来一个比较好的实践：

bash
1
# 在项目根目录放一个 CLAUDE.md 文件，写上项目的基本信息
2
cat > CLAUDE.md << 'EOF'
3
4
# 项目概述
5
这是一个基于Next.js 14的电商网站，使用PostgreSQL数据库。
6
7
# 技术栈
8
- 前端：Next.js 14, Tailwind CSS, Zustand
9
- 后端：Next.js API Routes, Prisma ORM
10
- 数据库：PostgreSQL 16
11
- 部署：Vercel + Supabase
12
13
# 代码规范
14
- 使用TypeScript，strict模式
15
- 组件用函数式组件 + hooks
16
- API用RESTful风格
17
- 测试用Vitest + Testing Library
18
19
# 目录结构
20
- src/app/ - Next.js App Router页面
21
- src/components/ - 可复用组件
22
- src/lib/ - 工具函数和配置
23
- prisma/ - 数据库Schema
24
EOF

有了这个文件，Claude Code每次启动都会自动读取，不需要你重复介绍项目背景。这个设计真的太聪明了。

另外，Claude Code还有.claudeignore文件，类似.gitignore，可以排除不需要Agent关注的文件：

code
1
# .claudeignore
2
node_modules/
3
.next/
4
dist/
5
* .min.js
6
* .min.css

这样Agent就不会把时间浪费在读node_modules里的代码了。

Codex CLI的上下文策略

Codex CLI的上下文窗口相对小一些，但它有一个很实用的功能：自动git感知。它会自动读取你最近的git改动，理解你当前在做什么。

bash
1
# Codex CLI会自动检测你的git状态
2
3
# 如果你在一个feature branch上，它会知道你正在开发新功能
4
codex "帮我继续完成这个功能"

但Codex CLI没有CLAUDE.md这种项目配置文件。如果你想给它项目上下文，得手动在对话里说，或者创建一个CODEX.md（它不一定读）。

Gemini CLI的上下文策略

Gemini CLI的上下文管理比较原始。它的上下文窗口虽然大（1M token），但没有自动项目感知。你每次开新对话，都得重新告诉它你的项目情况。

不过Gemini CLI有一个优势：它能实时搜索。如果它不了解你用的某个库，它会自动去搜文档。这个能力在处理新发布的库时特别有用。

bash
1
# Gemini CLI会自动搜索最新文档
2
gemini "帮我用 shadcn/ui 的最新版本写一个DataTable组件"

它会自动去查shadcn/ui的最新文档，然后给你基于最新API的代码。Claude Code和Codex CLI做不到这一点——它们的训练数据有截止日期。

插件与扩展生态

终端Agent的另一个重要维度是扩展能力。毕竟一个工具不可能内置所有功能，能不能方便地扩展，决定了它能走多远。

Claude Code的生态

Claude Code的扩展能力是三个里面最强的，主要通过Skills系统实现。Skills本质上是markdown文件，定义了Agent在特定场景下的行为规范。

社区已经有很多现成的Skills：

  • code-review：自动化的代码审查流程
  • tdd：测试驱动开发，强制先写测试再写代码
  • debug：系统化的debug流程，四步定位法
  • refactor：安全的重构流程，每步都跑测试
  • security-scan：安全扫描，检查常见的安全漏洞

我自己也写了不少Skills，比如一个"Git工作流"技能：

markdown
1
# git-workflow
2
3
## 分支命名规范
4
- feature/xxx - 新功能
5
- fix/xxx - Bug修复
6
- refactor/xxx - 重构
7
- docs/xxx - 文档更新
8
9
## Commit Message规范
10
使用Conventional Commits：
11
- feat: 新功能
12
- fix: Bug修复
13
- docs: 文档
14
- refactor: 重构
15
- test: 测试
16
- chore: 构建/工具
17
18
## PR流程
19
1. 从main分支创建feature分支
20
2. 开发完成后跑测试
21
3. 确保lint通过
22
4. 提交PR，描述改动内容
23
5. 等待review，修改反馈
24
6. 合并后删除分支

有了这个技能，Agent在帮我做Git操作时就会自动遵循这些规范。

Codex CLI的生态

Codex CLI目前没有正式的插件系统。它的扩展主要靠prompt工程——你在对话里告诉它该怎么做事。

不过Codex CLI是开源的，理论上你可以直接改代码加功能。但说实话，大部分开发者不会去改Agent的源码。

Gemini CLI的生态

Gemini CLI也没有正式的插件系统，但它支持MCP（Model Context Protocol）。通过MCP，你可以给Gemini CLI连接各种外部工具和数据源。

json
1
// gemini_config.json
2
{
3
  "mcpServers": {
4
    "github": {
5
      "command": "npx",
6
      "args": ["-y", "@modelcontextprotocol/server-github"],
7
      "env": {
8
        "GITHUB_TOKEN": "ghp_xxxx"
9
      }
10
    }
11
  }
12
}

配了MCP之后，Gemini CLI就能直接操作GitHub——创建Issue、查看PR、搜索代码等等。这个能力是Claude Code和Codex CLI没有的（它们需要自己实现GitHub集成）。

性能实测：速度到底差多少？

我做了一个简单的性能测试，用同一个prompt让三个Agent生成一个React组件（一个带搜索和分页的用户列表），记录从发送到收到完整响应的时间。

测试环境

  • 网络：100Mbps宽带，美国西海岸服务器
  • 测试时间：非高峰期（避免限流）
  • 每个工具测5次取平均值

测试结果

Claude Code

  • 平均响应时间：12.3秒
  • 首token延迟：1.2秒
  • 输出token速度：约85 token/秒
  • 生成的代码行数：约180行

Codex CLI

  • 平均响应时间：6.8秒
  • 首token延迟：0.8秒
  • 输出token速度：约150 token/秒
  • 生成的代码行数：约150行

Gemini CLI

  • 平均响应时间：9.5秒
  • 首token延迟：1.5秒
  • 输出token速度：约95 token/秒
  • 生成的代码行数：约160行

Codex CLI的速度优势很明显，主要得益于o4-mini模型的轻量级设计。Claude Code虽然慢一点，但生成的代码质量最高、最完整。Gemini CLI中规中矩。

不过要注意，这些数据会受网络、服务器负载、时段等因素影响。我的测试只是一个参考，不是绝对标准。

错误处理能力对比

开发过程中，Agent遇到错误时的处理能力非常重要。我测试了一个场景：故意给Agent一段有bug的代码，看它能不能自己发现问题并修复。

测试代码

python
1
def calculate_average(numbers):
2
    total = 0
3
    for num in numbers:
4
        total += num
5
    return total / len(numbers)  # 如果numbers是空列表会报ZeroDivisionError
6
7
# 另一个问题：这里有个off-by-one error
8
def get_fibonacci(n):
9
    if n <= 0:
10
        return []
11
    elif n == 1:
12
        return [0]
13
    fib = [0, 1]
14
    for i in range(2, n):  # 应该是range(2, n)，但如果n=2会怎样？
15
        fib.append(fib[i-1] + fib[i-2])
16
    return fib

Claude Code的表现

Claude Code直接指出了两个问题：

  1. calculate_average 没有处理空列表的情况，会抛出 ZeroDivisionError
  2. get_fibonacci 在 n=2 时返回 [0, 1] 是正确的，但代码缺少类型注解和docstring

它还给出了修复方案：

python
1
from typing import List
2
3
def calculate_average(numbers: List[float]) -> float:
4
    """计算数字列表的平均值。
5
6
    Args:
7
        numbers: 数字列表
8
9
    Returns:
10
        平均值
11
12
    Raises:
13
        ValueError: 如果列表为空
14
    """
15
    if not numbers:
16
        raise ValueError("Cannot calculate average of empty list")
17
    return sum(numbers) / len(numbers)
18
19
def get_fibonacci(n: int) -> List[int]:
20
    """生成斐波那契数列的前n个数。
21
22
    Args:
23
        n: 要生成的数字个数
24
25
    Returns:
26
        斐波那契数列
27
    """
28
    if n <= 0:
29
        return []
30
    elif n == 1:
31
        return [0]
32
    fib = [0, 1]
33
    for i in range(2, n):
34
        fib.append(fib[i-1] + fib[i-2])
35
    return fib

这个修复非常专业，不仅修了bug，还加了类型注解、docstring和异常处理。

Codex CLI的表现

Codex CLI也找到了ZeroDivisionError的问题，但没有发现第二个函数的问题（其实那个函数没问题，是我故意放的干扰项）。它只关注了真正的bug，没有提额外的代码改进建议。

这个表现其实也不差——它精准地解决了问题，没有多余的话。风格比较"务实"。

Gemini CLI的表现

Gemini CLI找到了两个问题，但它把第二个函数的逻辑也标记为bug了，说"range(2, n)在n=1时不会执行循环体"。这其实是正确的行为——当n=1时，应该返回[0]，循环不执行是正确的。

我跟它解释了这个逻辑，它才明白。说明Gemini CLI在理解代码语义方面还有提升空间。

一些使用技巧

最后分享一些我用终端Agent总结出来的技巧。

技巧1：给Agent足够的上下文

Agent不是读心术，你给它的上下文越丰富，它给你的结果越好。

bash
1
# ❌ 不好的写法
2
claude "这个函数有bug"
3
4
# ✅ 好的写法
5
claude "src/utils/parser.py 的 parse_config 函数在处理嵌套JSON时报错，错误信息是 'RecursionError: maximum recursion depth exceeded'，测试文件是 tests/test_parser.py"

技巧2：用Agent做Code Review

这是我最常用的场景之一。提交PR之前让Agent过一遍：

bash
1
claude "review一下我最近的改动，重点关注安全问题和性能问题"

Claude Code会自动读取git diff，分析你的改动，给出详细的review意见。

技巧3：让Agent帮你写Commit Message

bash
1
claude "根据我刚才的改动写一个commit message"

它会分析你的改动内容，生成一个符合conventional commits规范的commit message。比我以前自己写的好多了。

技巧4：用Agent做技术调研

在选择技术方案的时候，让Agent帮你做调研：

bash
1
claude "我想在项目里加一个消息队列，对比一下RabbitMQ、Redis Stream和Kafka，考虑我们的场景：[描述你的场景]"

它会给你一个详细的技术对比，包括优缺点、适用场景、性能特点等。

技巧5：批量操作要小心

Agent可以批量修改文件，但这个能力要慎用。我有一次让Agent"把整个项目的代码风格统一"，它改了200多个文件，结果引入了十几个bug。

教训：批量操作之前，先让它在小范围试试，确认没问题再扩大范围。

未来展望

终端AI编程Agent这个赛道才刚开始。我觉得未来会有几个趋势：

  1. 多Agent协作：不是一个Agent干活，而是多个Agent分工协作。比如一个负责写代码，一个负责测试，一个负责review。
  2. 更深的工具集成：不只是执行命令，还能直接操作CI/CD、监控系统、云平台。
  3. 个性化：Agent会学习你的编程风格和偏好，越来越像一个真正的"同事"。
  4. 本地化：随着本地模型的能力提升，越来越多的Agent会支持完全本地运行，解决数据安全问题。

现在入场终端Agent，就像2015年入场Docker一样——看起来是新玩意儿，但很快就会变成标配。

写在最后

说实话，这三个工具我都在用。Claude Code用来处理复杂的开发任务，Codex CLI用来做快速的小任务，Gemini CLI用来查文档和做技术调研。它们不是互斥的，而是互补的。

如果你还没试过终端AI编程Agent，强烈建议试试。不管选哪个，都会让你的开发效率上一个台阶。

后面打算再写一篇关于如何给Claude Code写Skills的文章，毕竟这玩意儿的定制能力真的太强了。有啥问题评论区聊。

advertisement

终端AI编程Agent大乱斗：Claude Code vs Codex CLI vs Gemini CLI 实战对比 — AI Hub