浩子的小站

Mac 上的 AI 编码利器：打造高效命令行工作流

AI 开发工具 命令行 Mac
字数统计: 4.9k阅读时长: 20 min
2026/03/22

这篇是命令行工具系列里的工具总览版。

如果你更关心“为什么我后来决定彻底迁出 oh-my-zsh、以及迁移里到底踩了哪些坑”，可以继续看：

如果你只想先回答一个问题：

AI 编码场景下，哪些工具真的值得先装，分别解决什么问题？

那这篇就是给这个问题准备的。

如果你想再往下看“为什么现代 AI coding agent 最终会把体验问题做成 runtime 问题”，也可以继续读：

这篇文章更适合做第一入口：先帮你建立一张工具地图，知道每种工具到底解决的是文件定位、会话管理、历史搜索，还是运行时接管。

在 AI 辅助编程时代，选对工具能让你的开发效率翻倍。作为一名长期使用 Mac 进行 AI 编码的开发者，我发现命令行工具的选择对工作流的影响远超想象。今天分享几个我每天都在用的神器，它们让我的 AI 编码体验提升了一个档次。

AI 编码命令行分层图

为什么命令行工具对 AI 编码如此重要？

在使用 Claude Code、Cursor 等 AI 编程助手时，你会发现：

  • 频繁的文件切换：AI 可能同时修改多个文件，需要快速定位
  • 大量的终端操作：运行测试、查看日志、管理进程
  • 复杂的项目导航：在大型代码库中快速找到目标文件
  • 多任务并行：同时运行开发服务器、测试、构建等

传统的 GUI 工具在这些场景下显得力不从心，而精心选择的命令行工具能让你如鱼得水。

这里的关键不是“命令行一定比 GUI 高级”，而是 AI 编码会把很多原本零散的小动作放大成一条高频链路：定位文件、切目录、查历史命令、打开日志、看测试输出、切会话。如果这条链路里每一步都慢一点、卡一点、绕一点，最后你对 AI 的整体体感也会变差。

AI 编码任务在终端里的流动

工具职责矩阵

一个真实案例：AI 给出下一步之后，真正拖慢你的往往不是模型

举个非常具体的案例。

当 Claude Code 或 Cursor 告诉你：

  • 去看某个文件
  • 切到某个目录
  • 跑一条测试命令
  • 盯一会儿日志

这件事表面上像“模型在给建议”，但真正决定体感的，其实是后面的执行链路是不是够短。

如果文件定位要翻目录，日志要切窗口，测试要重开 session，Node/Ruby 还可能被不同 runtime 抢所有权，那你的体验问题本质上就不是“AI 不够聪明”，而是终端工作流的调度链太长。

这也是我越来越在意这几类工具的原因：

  • fzf 和 Yazi 解决的是定位问题
  • Tmux 解决的是 session 和日志观察问题
  • mise 解决的是 runtime 所有权问题
  • Ghostty 解决的是终端本身的交互成本问题

换句话说，这篇文章想解决的不是“推荐几个命令行玩具”，而是给 AI 编码场景补一条更顺的执行链。

1. fzf：模糊搜索的艺术

为什么选择 fzf？

fzf 是一个通用的命令行模糊查找器，它能让你在海量文件中秒速定位目标。当 AI 告诉你”请检查 src/components/UserProfile.tsx“时，你不需要手动 cd 进多层目录，一个快捷键就能直达。

安装与配置

1
2
3
4
5
# 使用 Homebrew 安装
brew install fzf

# 安装 shell 集成（快捷键绑定）
$(brew --prefix)/opt/fzf/install

实战技巧

1. 快速打开文件（Ctrl+T）

在任何目录下按 Ctrl+T，输入文件名的几个字母，fzf 会实时过滤匹配的文件。选中后直接插入到命令行，配合 vim 或 code 使用：

1
2
# 按 Ctrl+T，输入 "user"，选择文件
vim <Ctrl+T>UserProfile.tsx

2. 历史命令搜索（Ctrl+R）

当 AI 建议你运行某个之前执行过的复杂命令时，不用翻找历史记录：

1
2
# 按 Ctrl+R，输入关键词如 "docker"
# 立即找到之前的 docker compose 命令

3. 目录跳转（Alt+C）

快速切换到项目的任何子目录：

1
2
# 按 Alt+C，输入 "comp"
# 直接跳转到 src/components/

进阶配置

在 ~/.zshrc 中添加以下配置，让 fzf 更强大：

1
2
3
4
5
6
7
8
9
# 使用 fd 替代 find（更快，自动忽略 .git）
export FZF_DEFAULT_COMMAND='fd --type f --hidden --follow --exclude .git'
export FZF_CTRL_T_COMMAND="$FZF_DEFAULT_COMMAND"

# 预览文件内容
export FZF_CTRL_T_OPTS="--preview 'bat --color=always --line-range :500 {}'"

# 更好的配色
export FZF_DEFAULT_OPTS='--height 40% --layout=reverse --border'

2. Ghostty：为 AI 编码而生的终端

为什么不用 iTerm2？

Ghostty 是一个用 Zig 编写的现代终端模拟器，专为性能和开发者体验设计。在 AI 编码场景下，它的优势明显：

  • 极致性能：渲染速度比 iTerm2 快 3-5 倍，处理大量日志输出不卡顿
  • GPU 加速：利用 Metal 渲染，滚动和动画丝滑流畅
  • 原生 macOS 体验：完美支持 macOS 的手势和快捷键
  • 配置简单：TOML 配置文件，清晰易懂

安装与配置

1
2
# 使用 Homebrew 安装
brew install ghostty

创建配置文件 ~/.config/ghostty/config：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 字体配置
font-family = "JetBrains Mono"
font-size = 14

# 主题
theme = "catppuccin-mocha"

# 性能优化
window-vsync = true
macos-option-as-alt = true

# 快捷键
keybind = cmd+t=new_tab
keybind = cmd+w=close_surface
keybind = cmd+shift+[=previous_tab
keybind = cmd+shift+]=next_tab

AI 编码场景优化

1. 分屏布局

当 AI 同时修改多个文件时，使用 Ghostty 的原生分屏：

1
2
3
# Cmd+D 垂直分屏
# Cmd+Shift+D 水平分屏
# Cmd+[ / Cmd+] 切换面板

2. 快速复制 AI 输出

Ghostty 支持智能选择，双击选中单词，三击选中整行，非常适合快速复制 AI 生成的代码片段。

3. Yazi：现代化的文件管理器

为什么需要 Yazi？

在 AI 编码时，你经常需要：

  • 快速浏览项目结构
  • 批量重命名文件
  • 预览图片、PDF 等非文本文件
  • 在多个目录间移动文件

Yazi 是一个用 Rust 编写的终端文件管理器，速度快、功能强、颜值高。

安装与配置

1
2
3
4
5
# 安装 Yazi
brew install yazi

# 安装依赖（用于预览）
brew install ffmpegthumbnailer unar jq poppler fd ripgrep fzf zoxide

核心功能

1. 可视化文件浏览

1
2
3
4
5
6
7
8
9
10
# 启动 Yazi
yazi

# 基本操作
# j/k - 上下移动
# h/l - 进入/退出目录
# Space - 选中文件
# y - 复制
# p - 粘贴
# d - 删除

2. 文件预览

Yazi 自动识别文件类型并显示预览：

  • 代码文件：语法高亮
  • 图片：缩略图
  • PDF：首页预览
  • 视频：帧预览

3. 批量操作

当 AI 建议重构文件结构时，Yazi 的批量操作非常高效：

1
2
3
4
# 选中多个文件（Space）
# 按 r 批量重命名
# 按 d 批量删除
# 按 y 批量复制

与 AI 工具集成

在 ~/.config/yazi/yazi.toml 中配置快捷键：

1
2
3
4
5
6
7
8
9
10
[opener]
edit = [
  { exec = 'code "$@"', block = true },
]

[open]
rules = [
  { mime = "text/*", use = "edit" },
  { mime = "application/json", use = "edit" },
]

现在在 Yazi 中按 Enter 就能用 VS Code 打开文件。

4. Tmux：终端复用的王者

为什么 AI 编码需要 Tmux？

使用 Claude Code 或 Cursor 时，你经常需要：

  • 同时运行开发服务器、测试、构建
  • 保持会话，即使终端关闭
  • 在多个项目间快速切换
  • 远程开发时保持连接

Tmux 是终端复用器，让你在一个终端窗口中管理多个会话。

安装与配置

1
2
3
4
5
# 安装 Tmux
brew install tmux

# 安装 TPM（Tmux 插件管理器）
git clone https://github.com/tmux-plugins/tpm ~/.tmux/plugins/tpm

创建配置文件 ~/.tmux.conf：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
# 改变前缀键为 Ctrl+a（更顺手）
unbind C-b
set -g prefix C-a
bind C-a send-prefix

# 启用鼠标支持
set -g mouse on

# 从 1 开始编号（0 太远）
set -g base-index 1
setw -g pane-base-index 1

# 更好的分屏快捷键
bind | split-window -h -c "#{pane_current_path}"
bind - split-window -v -c "#{pane_current_path}"

# Vim 风格的面板切换
bind h select-pane -L
bind j select-pane -D
bind k select-pane -U
bind l select-pane -R

# 插件
set -g @plugin 'tmux-plugins/tpm'
set -g @plugin 'tmux-plugins/tmux-sensible'
set -g @plugin 'tmux-plugins/tmux-resurrect'
set -g @plugin 'tmux-plugins/tmux-continuum'

# 自动保存会话
set -g @continuum-restore 'on'

# 初始化 TPM
run '~/.tmux/plugins/tpm/tpm'

AI 编码工作流

典型的 Tmux 布局：

1
2
3
4
5
6
7
8
9
10
┌─────────────────────────────────────┐
│ Window 1: 开发                       │
├──────────────┬──────────────────────┤
│              │                      │
│  编辑器      │   开发服务器         │
│  (Pane 1)    │   (Pane 2)           │
│              │                      │
├──────────────┴──────────────────────┤
│  测试输出 (Pane 3)                  │
└─────────────────────────────────────┘

创建这个布局：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 创建新会话
tmux new -s ai-coding

# 垂直分屏
Ctrl+a |

# 水平分屏
Ctrl+a -

# 在右上面板运行开发服务器
npm run dev

# 在底部面板运行测试监听
npm run test:watch

会话管理：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 创建新会话
tmux new -s project-name

# 列出所有会话
tmux ls

# 附加到会话
tmux attach -t project-name

# 分离会话（保持运行）
Ctrl+a d

# 切换会话
Ctrl+a s

进阶技巧

1. 会话持久化

使用 tmux-resurrect 插件，即使重启电脑也能恢复会话：

1
2
3
4
5
# 保存会话
Ctrl+a Ctrl+s

# 恢复会话
Ctrl+a Ctrl+r

2. 与 AI 工具集成

在 Claude Code 中运行长时间任务时，使用 Tmux 后台运行：

1
2
3
4
5
# 创建后台会话运行构建
tmux new -d -s build 'npm run build'

# 查看构建输出
tmux attach -t build

5. 组合拳：打造完整工作流

场景 1：启动新项目

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 1. 使用 fzf 快速找到项目目录
cd $(fd --type d --max-depth 3 | fzf)

# 2. 创建 Tmux 会话
tmux new -s $(basename $(pwd))

# 3. 查看项目结构（eza + 树形视图）
lt

# 4. 分屏布局
# 左侧：编辑器
# 右上：开发服务器
# 右下：测试

# 5. 使用 Yazi 浏览项目结构
yazi

场景 2：AI 建议的多文件修改

1
2
3
4
5
6
7
8
9
10
11
12
13
# 1. AI 说："我修改了 3 个文件，请检查"

# 2. 使用 eza 快速查看哪些文件被修改
ll  # 会显示 Git 状态标记

# 3. 使用 Lazygit 可视化查看所有变更
lazygit

# 4. 使用 fzf 快速打开每个文件
vim $(fzf)

# 5. 在 Tmux 的另一个面板运行测试
npm test

场景 3：调试复杂问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 1. 在 Tmux 中创建调试布局
# 面板 1：运行应用
# 面板 2：查看日志
# 面板 3：运行测试
# 面板 4：编辑代码

# 2. 使用 Atuin 智能搜索之前的调试命令
Ctrl+R -> 输入关键词 -> 按目录过滤

# 3. 使用 Lazygit 查看代码变更历史
lazygit -> 按 l 查看文件历史

# 4. 使用 Yazi 快速定位相关文件
yazi

场景 4：提交 AI 修改的代码

1
2
3
4
5
6
7
8
9
10
11
# 1. 使用 Lazygit 可视化查看所有变更
lazygit

# 2. 在 Lazygit 中：
#    - 按 Space 选择性暂存文件
#    - 按 c 提交
#    - 按 P 推送

# 3. Starship 提示符实时显示 Git 状态
# 提交前：🌱 feature/auth ✅3 📝2
# 提交后：🌱 feature/auth ⬆️1

6. 进阶工具：让 AI 编码更上一层楼

在掌握了前面的基础工具后，这些进阶工具能让你的 AI 编码效率再提升一个档次。它们都是 GitHub 上的热门项目，经过了大量开发者的实战检验。

Atuin：智能命令历史搜索 (⭐ 27.5K)

为什么需要 Atuin？

传统的 Ctrl+R 历史搜索有很多局限：

  • 只能搜索当前机器的历史
  • 无法按目录、时间过滤
  • 搜索结果不够智能

当 AI 建议你运行一个复杂的命令时，你可能几天前在另一个项目中执行过类似的命令。Atuin 将所有命令历史存储在 SQLite 数据库中，支持跨设备同步，让你永远不会丢失有用的命令。

安装与配置

1
2
3
4
5
6
7
8
9
# 安装 Atuin
brew install atuin

# 初始化（会自动导入现有历史）
atuin init zsh >> ~/.zshrc
source ~/.zshrc

# 导入现有历史
atuin import auto

AI 编码场景

场景 1：找回 AI 建议的复杂命令

1
2
3
4
5
6
7
8
9
10
11
12
# 按 Ctrl+R，输入关键词
# Atuin 会显示：
# - 命令执行时间
# - 执行目录
# - 命令是否成功
# - 执行时长

# 例如搜索 "docker"，立即找到：
# docker compose -f docker-compose.dev.yml up -d
# 📁 ~/projects/api-service
# ✅ 成功 (2s)
# 🕐 2 天前

场景 2：跨项目复用命令

AI 在项目 A 中建议的测试命令，在项目 B 中也能快速找到并复用：

1
2
3
4
5
# 在项目 A 中执行过：
npm test -- --coverage --watchAll=false

# 在项目 B 中按 Ctrl+R 搜索 "coverage"
# 立即找到并复用

进阶配置

在 ~/.config/atuin/config.toml 中配置：

1
2
3
4
5
6
7
8
9
10
11
# 按目录过滤
filter_mode = "directory"

# 智能排序（常用命令优先）
search_mode = "fuzzy"

# 显示更多上下文
show_preview = true

# 同步到云端（可选）
sync_address = "https://api.atuin.sh"

Lazygit：Git 操作的可视化革命 (⭐ 55K)

为什么 AI 编码需要 Lazygit？

当 AI 同时修改 10 个文件时，传统的 git status 和 git diff 显得力不从心：

  • 无法快速预览每个文件的变更
  • 暂存/取消暂存操作繁琐
  • 解决冲突时缺乏可视化
  • 交互式 rebase 难以操作

Lazygit 提供了一个强大的终端 UI，让所有 Git 操作都变得直观和高效。

安装与配置

1
2
3
4
5
# 安装 Lazygit
brew install lazygit

# 创建配置文件
mkdir -p ~/.config/lazygit

创建 ~/.config/lazygit/config.yml：

1
2
3
4
5
6
7
8
9
10
11
12
gui:
  theme:
    activeBorderColor:
      - green
      - bold
  showFileTree: true
  showRandomTip: false

git:
  paging:
    colorArg: always
    pager: delta --dark --paging=never

AI 编码工作流

场景 1：快速查看 AI 的多文件修改

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 启动 Lazygit
lazygit

# 界面布局：
# ┌─────────────┬──────────────────┐
# │ 文件列表    │  Diff 预览       │
# │ ✓ auth.ts   │  - old code      │
# │ ✓ user.ts   │  + new code      │
# │   api.ts    │                  │
# └─────────────┴──────────────────┘

# 快捷键：
# j/k - 上下移动
# Space - 暂存/取消暂存
# c - 提交
# P - 推送
# Enter - 查看完整 diff

场景 2：交互式暂存

AI 修改了一个文件的多个部分，但你只想提交其中一部分：

1
2
3
4
5
# 在 Lazygit 中：
# 1. 选中文件，按 Enter 查看 diff
# 2. 移动到想要暂存的代码块
# 3. 按 Space 只暂存这个代码块
# 4. 按 c 提交

场景 3：解决合并冲突

1
2
3
4
# Lazygit 会高亮显示冲突文件
# 按 Enter 进入冲突解决模式
# 使用方向键选择保留哪一方的代码
# 或按 e 在编辑器中手动解决

实用技巧

1
2
3
4
5
6
7
8
9
10
11
# 快速修改上一次提交
# 在 Lazygit 中按 A（amend）

# 交互式 rebase
# 选中提交，按 e（edit）、s（squash）、d（drop）

# 查看文件历史
# 选中文件，按 l（log）

# 快速切换分支
# 按 b（branches），输入分支名

Starship：智能提示符 (⭐ 53.7K)

为什么 AI 编码需要 Starship？

在 AI 编码时，你需要快速了解当前环境的上下文：

  • 当前 Git 分支和状态
  • Node/Python/Go 版本
  • 是否在虚拟环境中
  • 上一个命令是否成功

Starship 是一个跨 shell 的智能提示符，用 Rust 编写，速度极快，能实时显示所有关键信息。

安装与配置

1
2
3
4
5
6
# 安装 Starship
brew install starship

# 添加到 ~/.zshrc
echo 'eval "$(starship init zsh)"' >> ~/.zshrc
source ~/.zshrc

创建配置文件 ~/.config/starship.toml：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
# 简洁模式
format = """
[┌─](bold green)$directory$git_branch$git_status
[└─](bold green)$character"""

# 目录显示
[directory]
truncation_length = 3
truncate_to_repo = true
style = "bold cyan"

# Git 分支
[git_branch]
symbol = "🌱 "
style = "bold purple"

# Git 状态
[git_status]
conflicted = "⚔️ "
ahead = "⬆️ 

        
Mac 上的 AI 编码利器：打造高效命令行工作流
这篇是命令行工具系列里的工具总览版。


如果你更关心“为什么我后来决定彻底迁出 oh-my-zsh、以及迁移里到底踩了哪些坑”，可以继续看：



如果你只想先回答一个问题：


AI 编码场景下，哪些工具真的值得先装，分别解决什么问题？


那这篇就是给这个问题准备的。


如果你想再往下看“为什么现代 AI coding agent 最终会把体验问题做成 runtime 问题”，也可以继续读：



这篇文章更适合做第一入口：先帮你建立一张工具地图，知道每种工具到底解决的是文件定位、会话管理、历史搜索，还是运行时接管。




在 AI 辅助编程时代，选对工具能让你的开发效率翻倍。作为一名长期使用 Mac 进行 AI 编码的开发者，我发现命令行工具的选择对工作流的影响远超想象。今天分享几个我每天都在用的神器，它们让我的 AI 编码体验提升了一个档次。


AI 编码命令行分层图


为什么命令行工具对 AI 编码如此重要？
在使用 Claude Code、Cursor 等 AI 编程助手时，你会发现：


    

  • 频繁的文件切换：AI 可能同时修改多个文件，需要快速定位
    • 

  • 大量的终端操作：运行测试、查看日志、管理进程
    • 

  • 复杂的项目导航：在大型代码库中快速找到目标文件
    • 

  • 多任务并行：同时运行开发服务器、测试、构建等
    • 



传统的 GUI 工具在这些场景下显得力不从心，而精心选择的命令行工具能让你如鱼得水。


这里的关键不是“命令行一定比 GUI 高级”，而是 AI 编码会把很多原本零散的小动作放大成一条高频链路：定位文件、切目录、查历史命令、打开日志、看测试输出、切会话。如果这条链路里每一步都慢一点、卡一点、绕一点，最后你对 AI 的整体体感也会变差。


AI 编码任务在终端里的流动


工具职责矩阵


一个真实案例：AI 给出下一步之后，真正拖慢你的往往不是模型
举个非常具体的案例。


当 Claude Code 或 Cursor 告诉你：


    

  • 去看某个文件
    • 

  • 切到某个目录
    • 

  • 跑一条测试命令
    • 

  • 盯一会儿日志
    • 



这件事表面上像“模型在给建议”，但真正决定体感的，其实是后面的执行链路是不是够短。


如果文件定位要翻目录，日志要切窗口，测试要重开 session，Node/Ruby 还可能被不同 runtime 抢所有权，那你的体验问题本质上就不是“AI 不够聪明”，而是终端工作流的调度链太长。


这也是我越来越在意这几类工具的原因：


    

  • fzf 和 Yazi 解决的是定位问题
    • 

  • Tmux 解决的是 session 和日志观察问题
    • 

  • mise 解决的是 runtime 所有权问题
    • 

  • Ghostty 解决的是终端本身的交互成本问题
    • 



换句话说，这篇文章想解决的不是“推荐几个命令行玩具”，而是给 AI 编码场景补一条更顺的执行链。


1. fzf：模糊搜索的艺术
为什么选择 fzf？
fzf 是一个通用的命令行模糊查找器，它能让你在海量文件中秒速定位目标。当 AI 告诉你”请检查 src/components/UserProfile.tsx“时，你不需要手动 cd 进多层目录，一个快捷键就能直达。


安装与配置
1
2
3
4
5
# 使用 Homebrew 安装
brew install fzf

# 安装 shell 集成（快捷键绑定）
$(brew --prefix)/opt/fzf/install



实战技巧
1. 快速打开文件（Ctrl+T）


在任何目录下按 Ctrl+T，输入文件名的几个字母，fzf 会实时过滤匹配的文件。选中后直接插入到命令行，配合 vim 或 code 使用：


1
2
# 按 Ctrl+T，输入 "user"，选择文件
vim <Ctrl+T>UserProfile.tsx



2. 历史命令搜索（Ctrl+R）


当 AI 建议你运行某个之前执行过的复杂命令时，不用翻找历史记录：


1
2
# 按 Ctrl+R，输入关键词如 "docker"
# 立即找到之前的 docker compose 命令



3. 目录跳转（Alt+C）


快速切换到项目的任何子目录：


1
2
# 按 Alt+C，输入 "comp"
# 直接跳转到 src/components/



进阶配置
在 ~/.zshrc 中添加以下配置，让 fzf 更强大：


1
2
3
4
5
6
7
8
9
# 使用 fd 替代 find（更快，自动忽略 .git）
export FZF_DEFAULT_COMMAND='fd --type f --hidden --follow --exclude .git'
export FZF_CTRL_T_COMMAND="$FZF_DEFAULT_COMMAND"

# 预览文件内容
export FZF_CTRL_T_OPTS="--preview 'bat --color=always --line-range :500 {}'"

# 更好的配色
export FZF_DEFAULT_OPTS='--height 40% --layout=reverse --border'



2. Ghostty：为 AI 编码而生的终端
为什么不用 iTerm2？
Ghostty 是一个用 Zig 编写的现代终端模拟器，专为性能和开发者体验设计。在 AI 编码场景下，它的优势明显：


    

  • 极致性能：渲染速度比 iTerm2 快 3-5 倍，处理大量日志输出不卡顿
    • 

  • GPU 加速：利用 Metal 渲染，滚动和动画丝滑流畅
    • 

  • 原生 macOS 体验：完美支持 macOS 的手势和快捷键
    • 

  • 配置简单：TOML 配置文件，清晰易懂
    • 



安装与配置
1
2
# 使用 Homebrew 安装
brew install ghostty



创建配置文件 ~/.config/ghostty/config：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 字体配置
font-family = "JetBrains Mono"
font-size = 14

# 主题
theme = "catppuccin-mocha"

# 性能优化
window-vsync = true
macos-option-as-alt = true

# 快捷键
keybind = cmd+t=new_tab
keybind = cmd+w=close_surface
keybind = cmd+shift+[=previous_tab
keybind = cmd+shift+]=next_tab



AI 编码场景优化
1. 分屏布局


当 AI 同时修改多个文件时，使用 Ghostty 的原生分屏：


1
2
3
# Cmd+D 垂直分屏
# Cmd+Shift+D 水平分屏
# Cmd+[ / Cmd+] 切换面板



2. 快速复制 AI 输出


Ghostty 支持智能选择，双击选中单词，三击选中整行，非常适合快速复制 AI 生成的代码片段。


3. Yazi：现代化的文件管理器
为什么需要 Yazi？
在 AI 编码时，你经常需要：


    

  • 快速浏览项目结构
    • 

  • 批量重命名文件
    • 

  • 预览图片、PDF 等非文本文件
    • 

  • 在多个目录间移动文件
    • 



Yazi 是一个用 Rust 编写的终端文件管理器，速度快、功能强、颜值高。


安装与配置
1
2
3
4
5
# 安装 Yazi
brew install yazi

# 安装依赖（用于预览）
brew install ffmpegthumbnailer unar jq poppler fd ripgrep fzf zoxide



核心功能
1. 可视化文件浏览


1
2
3
4
5
6
7
8
9
10
# 启动 Yazi
yazi

# 基本操作
# j/k - 上下移动
# h/l - 进入/退出目录
# Space - 选中文件
# y - 复制
# p - 粘贴
# d - 删除



2. 文件预览


Yazi 自动识别文件类型并显示预览：


    

  • 代码文件：语法高亮
    • 

  • 图片：缩略图
    • 

  • PDF：首页预览
    • 

  • 视频：帧预览
    • 



3. 批量操作


当 AI 建议重构文件结构时，Yazi 的批量操作非常高效：


1
2
3
4
# 选中多个文件（Space）
# 按 r 批量重命名
# 按 d 批量删除
# 按 y 批量复制



与 AI 工具集成
在 ~/.config/yazi/yazi.toml 中配置快捷键：


1
2
3
4
5
6
7
8
9
10
[opener]
edit = [
  { exec = 'code "$@"', block = true },
]

[open]
rules = [
  { mime = "text/*", use = "edit" },
  { mime = "application/json", use = "edit" },
]



现在在 Yazi 中按 Enter 就能用 VS Code 打开文件。


4. Tmux：终端复用的王者
为什么 AI 编码需要 Tmux？
使用 Claude Code 或 Cursor 时，你经常需要：


    

  • 同时运行开发服务器、测试、构建
    • 

  • 保持会话，即使终端关闭
    • 

  • 在多个项目间快速切换
    • 

  • 远程开发时保持连接
    • 



Tmux 是终端复用器，让你在一个终端窗口中管理多个会话。


安装与配置
1
2
3
4
5
# 安装 Tmux
brew install tmux

# 安装 TPM（Tmux 插件管理器）
git clone https://github.com/tmux-plugins/tpm ~/.tmux/plugins/tpm



创建配置文件 ~/.tmux.conf：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
# 改变前缀键为 Ctrl+a（更顺手）
unbind C-b
set -g prefix C-a
bind C-a send-prefix

# 启用鼠标支持
set -g mouse on

# 从 1 开始编号（0 太远）
set -g base-index 1
setw -g pane-base-index 1

# 更好的分屏快捷键
bind | split-window -h -c "#{pane_current_path}"
bind - split-window -v -c "#{pane_current_path}"

# Vim 风格的面板切换
bind h select-pane -L
bind j select-pane -D
bind k select-pane -U
bind l select-pane -R

# 插件
set -g @plugin 'tmux-plugins/tpm'
set -g @plugin 'tmux-plugins/tmux-sensible'
set -g @plugin 'tmux-plugins/tmux-resurrect'
set -g @plugin 'tmux-plugins/tmux-continuum'

# 自动保存会话
set -g @continuum-restore 'on'

# 初始化 TPM
run '~/.tmux/plugins/tpm/tpm'



AI 编码工作流
典型的 Tmux 布局：


1
2
3
4
5
6
7
8
9
10
┌─────────────────────────────────────┐
│ Window 1: 开发                       │
├──────────────┬──────────────────────┤
│              │                      │
│  编辑器      │   开发服务器         │
│  (Pane 1)    │   (Pane 2)           │
│              │                      │
├──────────────┴──────────────────────┤
│  测试输出 (Pane 3)                  │
└─────────────────────────────────────┘



创建这个布局：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 创建新会话
tmux new -s ai-coding

# 垂直分屏
Ctrl+a |

# 水平分屏
Ctrl+a -

# 在右上面板运行开发服务器
npm run dev

# 在底部面板运行测试监听
npm run test:watch



会话管理：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 创建新会话
tmux new -s project-name

# 列出所有会话
tmux ls

# 附加到会话
tmux attach -t project-name

# 分离会话（保持运行）
Ctrl+a d

# 切换会话
Ctrl+a s



进阶技巧
1. 会话持久化


使用 tmux-resurrect 插件，即使重启电脑也能恢复会话：


1
2
3
4
5
# 保存会话
Ctrl+a Ctrl+s

# 恢复会话
Ctrl+a Ctrl+r



2. 与 AI 工具集成


在 Claude Code 中运行长时间任务时，使用 Tmux 后台运行：


1
2
3
4
5
# 创建后台会话运行构建
tmux new -d -s build 'npm run build'

# 查看构建输出
tmux attach -t build



5. 组合拳：打造完整工作流
场景 1：启动新项目
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 1. 使用 fzf 快速找到项目目录
cd $(fd --type d --max-depth 3 | fzf)

# 2. 创建 Tmux 会话
tmux new -s $(basename $(pwd))

# 3. 查看项目结构（eza + 树形视图）
lt

# 4. 分屏布局
# 左侧：编辑器
# 右上：开发服务器
# 右下：测试

# 5. 使用 Yazi 浏览项目结构
yazi



场景 2：AI 建议的多文件修改
1
2
3
4
5
6
7
8
9
10
11
12
13
# 1. AI 说："我修改了 3 个文件，请检查"

# 2. 使用 eza 快速查看哪些文件被修改
ll  # 会显示 Git 状态标记

# 3. 使用 Lazygit 可视化查看所有变更
lazygit

# 4. 使用 fzf 快速打开每个文件
vim $(fzf)

# 5. 在 Tmux 的另一个面板运行测试
npm test



场景 3：调试复杂问题
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 1. 在 Tmux 中创建调试布局
# 面板 1：运行应用
# 面板 2：查看日志
# 面板 3：运行测试
# 面板 4：编辑代码

# 2. 使用 Atuin 智能搜索之前的调试命令
Ctrl+R -> 输入关键词 -> 按目录过滤

# 3. 使用 Lazygit 查看代码变更历史
lazygit -> 按 l 查看文件历史

# 4. 使用 Yazi 快速定位相关文件
yazi



场景 4：提交 AI 修改的代码
1
2
3
4
5
6
7
8
9
10
11
# 1. 使用 Lazygit 可视化查看所有变更
lazygit

# 2. 在 Lazygit 中：
#    - 按 Space 选择性暂存文件
#    - 按 c 提交
#    - 按 P 推送

# 3. Starship 提示符实时显示 Git 状态
# 提交前：🌱 feature/auth ✅3 📝2
# 提交后：🌱 feature/auth ⬆️1



6. 进阶工具：让 AI 编码更上一层楼
在掌握了前面的基础工具后，这些进阶工具能让你的 AI 编码效率再提升一个档次。它们都是 GitHub 上的热门项目，经过了大量开发者的实战检验。


Atuin：智能命令历史搜索 (⭐ 27.5K)
为什么需要 Atuin？
传统的 Ctrl+R 历史搜索有很多局限：


    

  • 只能搜索当前机器的历史
    • 

  • 无法按目录、时间过滤
    • 

  • 搜索结果不够智能
    • 



当 AI 建议你运行一个复杂的命令时，你可能几天前在另一个项目中执行过类似的命令。Atuin 将所有命令历史存储在 SQLite 数据库中，支持跨设备同步，让你永远不会丢失有用的命令。


安装与配置
1
2
3
4
5
6
7
8
9
# 安装 Atuin
brew install atuin

# 初始化（会自动导入现有历史）
atuin init zsh >> ~/.zshrc
source ~/.zshrc

# 导入现有历史
atuin import auto



AI 编码场景
场景 1：找回 AI 建议的复杂命令


1
2
3
4
5
6
7
8
9
10
11
12
# 按 Ctrl+R，输入关键词
# Atuin 会显示：
# - 命令执行时间
# - 执行目录
# - 命令是否成功
# - 执行时长

# 例如搜索 "docker"，立即找到：
# docker compose -f docker-compose.dev.yml up -d
# 📁 ~/projects/api-service
# ✅ 成功 (2s)
# 🕐 2 天前



场景 2：跨项目复用命令


AI 在项目 A 中建议的测试命令，在项目 B 中也能快速找到并复用：


1
2
3
4
5
# 在项目 A 中执行过：
npm test -- --coverage --watchAll=false

# 在项目 B 中按 Ctrl+R 搜索 "coverage"
# 立即找到并复用



进阶配置
在 ~/.config/atuin/config.toml 中配置：


1
2
3
4
5
6
7
8
9
10
11
# 按目录过滤
filter_mode = "directory"

# 智能排序（常用命令优先）
search_mode = "fuzzy"

# 显示更多上下文
show_preview = true

# 同步到云端（可选）
sync_address = "https://api.atuin.sh"



Lazygit：Git 操作的可视化革命 (⭐ 55K)
为什么 AI 编码需要 Lazygit？
当 AI 同时修改 10 个文件时，传统的 git status 和 git diff 显得力不从心：


    

  • 无法快速预览每个文件的变更
    • 

  • 暂存/取消暂存操作繁琐
    • 

  • 解决冲突时缺乏可视化
    • 

  • 交互式 rebase 难以操作
    • 



Lazygit 提供了一个强大的终端 UI，让所有 Git 操作都变得直观和高效。


安装与配置
1
2
3
4
5
# 安装 Lazygit
brew install lazygit

# 创建配置文件
mkdir -p ~/.config/lazygit



创建 ~/.config/lazygit/config.yml：


1
2
3
4
5
6
7
8
9
10
11
12
gui:
  theme:
    activeBorderColor:
      - green
      - bold
  showFileTree: true
  showRandomTip: false

git:
  paging:
    colorArg: always
    pager: delta --dark --paging=never



AI 编码工作流
场景 1：快速查看 AI 的多文件修改


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 启动 Lazygit
lazygit

# 界面布局：
# ┌─────────────┬──────────────────┐
# │ 文件列表    │  Diff 预览       │
# │ ✓ auth.ts   │  - old code      │
# │ ✓ user.ts   │  + new code      │
# │   api.ts    │                  │
# └─────────────┴──────────────────┘

# 快捷键：
# j/k - 上下移动
# Space - 暂存/取消暂存
# c - 提交
# P - 推送
# Enter - 查看完整 diff



场景 2：交互式暂存


AI 修改了一个文件的多个部分，但你只想提交其中一部分：


1
2
3
4
5
# 在 Lazygit 中：
# 1. 选中文件，按 Enter 查看 diff
# 2. 移动到想要暂存的代码块
# 3. 按 Space 只暂存这个代码块
# 4. 按 c 提交



场景 3：解决合并冲突


1
2
3
4
# Lazygit 会高亮显示冲突文件
# 按 Enter 进入冲突解决模式
# 使用方向键选择保留哪一方的代码
# 或按 e 在编辑器中手动解决



实用技巧
1
2
3
4
5
6
7
8
9
10
11
# 快速修改上一次提交
# 在 Lazygit 中按 A（amend）

# 交互式 rebase
# 选中提交，按 e（edit）、s（squash）、d（drop）

# 查看文件历史
# 选中文件，按 l（log）

# 快速切换分支
# 按 b（branches），输入分支名



Starship：智能提示符 (⭐ 53.7K)
为什么 AI 编码需要 Starship？
在 AI 编码时，你需要快速了解当前环境的上下文：


    

  • 当前 Git 分支和状态
    • 

  • Node/Python/Go 版本
    • 

  • 是否在虚拟环境中
    • 

  • 上一个命令是否成功
    • 



Starship 是一个跨 shell 的智能提示符，用 Rust 编写，速度极快，能实时显示所有关键信息。


安装与配置
1
2
3
4
5
6
# 安装 Starship
brew install starship

# 添加到 ~/.zshrc
echo 'eval "$(starship init zsh)"' >> ~/.zshrc
source ~/.zshrc



创建配置文件 ~/.config/starship.toml：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
# 简洁模式
format = """
[┌─](bold green)$directory$git_branch$git_status
[└─](bold green)$character"""

# 目录显示
[directory]
truncation_length = 3
truncate_to_repo = true
style = "bold cyan"

# Git 分支
[git_branch]
symbol = "🌱 "
style = "bold purple"

# Git 状态
[git_status]
conflicted = "⚔️ "
ahead = "⬆️ ${count}"
behind = "⬇️ ${count}"
diverged = "🔀"
untracked = "🤷"
stashed = "📦"
modified = "📝"
staged = "✅"
renamed = "👅"
deleted = "🗑️ "

# 语言版本
[nodejs]
symbol = "⬢ "
style = "bold green"

[python]
symbol = "🐍 "
style = "bold yellow"

[rust]
symbol = "🦀 "
style = "bold red"

# 命令执行时间
[cmd_duration]
min_time = 500
format = "took [$duration](bold yellow)"



AI 编码场景
提示符显示示例：


1
2
3
4
5
6
7
8
┌─ ~/projects/ai-app 🌱 feature/auth ✅3 📝2
└─ ❯

# 解读：
# ~/projects/ai-app - 当前目录
# 🌱 feature/auth - Git 分支
# ✅3 - 3 个文件已暂存
# 📝2 - 2 个文件已修改



当 AI 修改文件后，提示符会实时更新，让你一眼看出项目状态。


eza：现代化的 ls (⭐ 20.4K)
为什么需要 eza？
传统的 ls 命令输出单调，缺乏关键信息。eza 是 exa 的继任者，提供：


    

  • 彩色输出和图标
    • 

  • Git 状态集成
    • 

  • 树形视图
    • 

  • 更好的排序和过滤
    • 



在 AI 编码时，快速浏览项目结构和文件状态至关重要。


安装与配置
1
2
3
4
5
6
7
8
# 安装 eza
brew install eza

# 添加别名到 ~/.zshrc
alias ls="eza --icons --group-directories-first"
alias ll="eza -l --icons --group-directories-first --git"
alias la="eza -la --icons --group-directories-first --git"
alias lt="eza --tree --level=2 --icons"



AI 编码场景
场景 1：快速查看项目结构


1
2
3
4
5
6
7
8
9
10
11
# 使用 lt（tree）查看项目结构
lt

# 输出：
# 📁 src
# ├── 📁 components
# │   ├── 📄 Button.tsx
# │   └── 📄 Input.tsx
# ├── 📁 utils
# │   └── 📄 helpers.ts
# └── 📄 index.ts



场景 2：查看 Git 状态


1
2
3
4
5
6
7
8
9
10
11
12
# 使用 ll 查看文件详情和 Git 状态
ll

# 输出：
# .rw-r--r-- 1.2k user 22 Mar 10:30 -M auth.ts
# .rw-r--r-- 856  user 22 Mar 09:15 N- user.ts
# .rw-r--r-- 2.1k user 21 Mar 14:20 -- api.ts

# 解读：
# -M - 已修改（Modified）
# N- - 新文件（New）
# -- - 未修改



场景 3：按时间排序查看最近修改


1
2
3
4
# 查看最近修改的文件（AI 刚修改的）
eza -l --sort=modified --reverse

# 最新修改的文件会显示在最下面



进阶用法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 只显示目录
eza -D

# 显示隐藏文件
eza -a

# 按大小排序
eza -l --sort=size

# 显示文件树（3 层）
eza --tree --level=3

# 显示 Git 忽略的文件
eza --git-ignore



7. 额外推荐工具
bat：更好的 cat
1
2
3
4
5
6
7
brew install bat

# 语法高亮的文件查看
bat src/main.ts

# 与 fzf 集成预览
fzf --preview 'bat --color=always {}'



fd：更快的 find
1
2
3
4
5
6
7
brew install fd

# 查找所有 TypeScript 文件
fd -e ts -e tsx

# 忽略 node_modules
fd --exclude node_modules



ripgrep：更快的 grep
1
2
3
4
5
6
7
brew install ripgrep

# 在所有文件中搜索
rg "function.*User"

# 只搜索 TypeScript 文件
rg -t ts "interface"



zoxide：智能目录跳转
1
2
3
4
5
6
7
brew install zoxide

# 添加到 ~/.zshrc
eval "$(zoxide init zsh)"

# 使用
z project  # 跳转到最常访问的包含 "project" 的目录



总结
这些工具的组合让我的 AI 编码效率提升了至少 50%：


核心工具（必装）
    

  1. fzf - 秒速定位文件和命令
    2. 

  2. Ghostty - 流畅的终端体验
    3. 

  3. Yazi - 可视化文件管理
    4. 

  4. Tmux - 强大的会话管理
    5. 



进阶工具（强烈推荐）
    

  1. Atuin (⭐ 27.5K) - 智能命令历史，跨设备同步
    2. 

  2. Lazygit (⭐ 55K) - Git 可视化操作，告别复杂命令
    3. 

  3. Starship (⭐ 53.7K) - 智能提示符，实时显示上下文
    4. 

  4. eza (⭐ 20.4K) - 现代化文件列表，Git 状态集成
    5. 



辅助工具（锦上添花）
    

  1. bat - 语法高亮的文件查看
    2. 

  2. fd - 更快的文件搜索
    3. 

  3. ripgrep - 更快的内容搜索
    4. 

  4. zoxide - 智能目录跳转
    5. 



关键是要形成肌肉记忆。刚开始可能觉得学习曲线陡峭，但坚持使用 2-3 周后，这些操作会变得自然而然。


完整工作流示例
当 AI 助手建议你修改 10 个文件时，你的操作流程是：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 1. 查看修改了哪些文件
ll  # eza 显示 Git 状态

# 2. 可视化查看所有变更
lazygit

# 3. 快速打开文件
vim $(fzf)  # Ctrl+T

# 4. 在 Tmux 分屏中运行测试
Ctrl+a | && npm test

# 5. 找回之前的复杂命令
Ctrl+R  # Atuin 智能搜索

# 6. 提交代码
lazygit  # 可视化暂存和提交



你的提示符会实时显示：


1
2
┌─ ~/projects/ai-app 🌱 feature/auth ✅3 📝2 ⬢ v20.11.0
└─ ❯



这就是现代 AI 编码的正确打开方式。




你在用什么命令行工具提升 AI 编码效率？欢迎在评论区分享！


参考资源




本文由 Claude Opus 4.6 辅助创作，工具链：Ghostty + Tmux + fzf + Yazi + Lazygit + Atuin + Starship + eza




    
#123;count}"
behind = "⬇️ 

        
Mac 上的 AI 编码利器：打造高效命令行工作流
这篇是命令行工具系列里的工具总览版。


如果你更关心“为什么我后来决定彻底迁出 oh-my-zsh、以及迁移里到底踩了哪些坑”，可以继续看：



如果你只想先回答一个问题：


AI 编码场景下，哪些工具真的值得先装，分别解决什么问题？


那这篇就是给这个问题准备的。


如果你想再往下看“为什么现代 AI coding agent 最终会把体验问题做成 runtime 问题”，也可以继续读：



这篇文章更适合做第一入口：先帮你建立一张工具地图，知道每种工具到底解决的是文件定位、会话管理、历史搜索，还是运行时接管。




在 AI 辅助编程时代，选对工具能让你的开发效率翻倍。作为一名长期使用 Mac 进行 AI 编码的开发者，我发现命令行工具的选择对工作流的影响远超想象。今天分享几个我每天都在用的神器，它们让我的 AI 编码体验提升了一个档次。


AI 编码命令行分层图


为什么命令行工具对 AI 编码如此重要？
在使用 Claude Code、Cursor 等 AI 编程助手时，你会发现：


    

  • 频繁的文件切换：AI 可能同时修改多个文件，需要快速定位
    • 

  • 大量的终端操作：运行测试、查看日志、管理进程
    • 

  • 复杂的项目导航：在大型代码库中快速找到目标文件
    • 

  • 多任务并行：同时运行开发服务器、测试、构建等
    • 



传统的 GUI 工具在这些场景下显得力不从心，而精心选择的命令行工具能让你如鱼得水。


这里的关键不是“命令行一定比 GUI 高级”，而是 AI 编码会把很多原本零散的小动作放大成一条高频链路：定位文件、切目录、查历史命令、打开日志、看测试输出、切会话。如果这条链路里每一步都慢一点、卡一点、绕一点，最后你对 AI 的整体体感也会变差。


AI 编码任务在终端里的流动


工具职责矩阵


一个真实案例：AI 给出下一步之后，真正拖慢你的往往不是模型
举个非常具体的案例。


当 Claude Code 或 Cursor 告诉你：


    

  • 去看某个文件
    • 

  • 切到某个目录
    • 

  • 跑一条测试命令
    • 

  • 盯一会儿日志
    • 



这件事表面上像“模型在给建议”，但真正决定体感的，其实是后面的执行链路是不是够短。


如果文件定位要翻目录，日志要切窗口，测试要重开 session，Node/Ruby 还可能被不同 runtime 抢所有权，那你的体验问题本质上就不是“AI 不够聪明”，而是终端工作流的调度链太长。


这也是我越来越在意这几类工具的原因：


    

  • fzf 和 Yazi 解决的是定位问题
    • 

  • Tmux 解决的是 session 和日志观察问题
    • 

  • mise 解决的是 runtime 所有权问题
    • 

  • Ghostty 解决的是终端本身的交互成本问题
    • 



换句话说，这篇文章想解决的不是“推荐几个命令行玩具”，而是给 AI 编码场景补一条更顺的执行链。


1. fzf：模糊搜索的艺术
为什么选择 fzf？
fzf 是一个通用的命令行模糊查找器，它能让你在海量文件中秒速定位目标。当 AI 告诉你”请检查 src/components/UserProfile.tsx“时，你不需要手动 cd 进多层目录，一个快捷键就能直达。


安装与配置
1
2
3
4
5
# 使用 Homebrew 安装
brew install fzf

# 安装 shell 集成（快捷键绑定）
$(brew --prefix)/opt/fzf/install



实战技巧
1. 快速打开文件（Ctrl+T）


在任何目录下按 Ctrl+T，输入文件名的几个字母，fzf 会实时过滤匹配的文件。选中后直接插入到命令行，配合 vim 或 code 使用：


1
2
# 按 Ctrl+T，输入 "user"，选择文件
vim <Ctrl+T>UserProfile.tsx



2. 历史命令搜索（Ctrl+R）


当 AI 建议你运行某个之前执行过的复杂命令时，不用翻找历史记录：


1
2
# 按 Ctrl+R，输入关键词如 "docker"
# 立即找到之前的 docker compose 命令



3. 目录跳转（Alt+C）


快速切换到项目的任何子目录：


1
2
# 按 Alt+C，输入 "comp"
# 直接跳转到 src/components/



进阶配置
在 ~/.zshrc 中添加以下配置，让 fzf 更强大：


1
2
3
4
5
6
7
8
9
# 使用 fd 替代 find（更快，自动忽略 .git）
export FZF_DEFAULT_COMMAND='fd --type f --hidden --follow --exclude .git'
export FZF_CTRL_T_COMMAND="$FZF_DEFAULT_COMMAND"

# 预览文件内容
export FZF_CTRL_T_OPTS="--preview 'bat --color=always --line-range :500 {}'"

# 更好的配色
export FZF_DEFAULT_OPTS='--height 40% --layout=reverse --border'



2. Ghostty：为 AI 编码而生的终端
为什么不用 iTerm2？
Ghostty 是一个用 Zig 编写的现代终端模拟器，专为性能和开发者体验设计。在 AI 编码场景下，它的优势明显：


    

  • 极致性能：渲染速度比 iTerm2 快 3-5 倍，处理大量日志输出不卡顿
    • 

  • GPU 加速：利用 Metal 渲染，滚动和动画丝滑流畅
    • 

  • 原生 macOS 体验：完美支持 macOS 的手势和快捷键
    • 

  • 配置简单：TOML 配置文件，清晰易懂
    • 



安装与配置
1
2
# 使用 Homebrew 安装
brew install ghostty



创建配置文件 ~/.config/ghostty/config：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 字体配置
font-family = "JetBrains Mono"
font-size = 14

# 主题
theme = "catppuccin-mocha"

# 性能优化
window-vsync = true
macos-option-as-alt = true

# 快捷键
keybind = cmd+t=new_tab
keybind = cmd+w=close_surface
keybind = cmd+shift+[=previous_tab
keybind = cmd+shift+]=next_tab



AI 编码场景优化
1. 分屏布局


当 AI 同时修改多个文件时，使用 Ghostty 的原生分屏：


1
2
3
# Cmd+D 垂直分屏
# Cmd+Shift+D 水平分屏
# Cmd+[ / Cmd+] 切换面板



2. 快速复制 AI 输出


Ghostty 支持智能选择，双击选中单词，三击选中整行，非常适合快速复制 AI 生成的代码片段。


3. Yazi：现代化的文件管理器
为什么需要 Yazi？
在 AI 编码时，你经常需要：


    

  • 快速浏览项目结构
    • 

  • 批量重命名文件
    • 

  • 预览图片、PDF 等非文本文件
    • 

  • 在多个目录间移动文件
    • 



Yazi 是一个用 Rust 编写的终端文件管理器，速度快、功能强、颜值高。


安装与配置
1
2
3
4
5
# 安装 Yazi
brew install yazi

# 安装依赖（用于预览）
brew install ffmpegthumbnailer unar jq poppler fd ripgrep fzf zoxide



核心功能
1. 可视化文件浏览


1
2
3
4
5
6
7
8
9
10
# 启动 Yazi
yazi

# 基本操作
# j/k - 上下移动
# h/l - 进入/退出目录
# Space - 选中文件
# y - 复制
# p - 粘贴
# d - 删除



2. 文件预览


Yazi 自动识别文件类型并显示预览：


    

  • 代码文件：语法高亮
    • 

  • 图片：缩略图
    • 

  • PDF：首页预览
    • 

  • 视频：帧预览
    • 



3. 批量操作


当 AI 建议重构文件结构时，Yazi 的批量操作非常高效：


1
2
3
4
# 选中多个文件（Space）
# 按 r 批量重命名
# 按 d 批量删除
# 按 y 批量复制



与 AI 工具集成
在 ~/.config/yazi/yazi.toml 中配置快捷键：


1
2
3
4
5
6
7
8
9
10
[opener]
edit = [
  { exec = 'code "$@"', block = true },
]

[open]
rules = [
  { mime = "text/*", use = "edit" },
  { mime = "application/json", use = "edit" },
]



现在在 Yazi 中按 Enter 就能用 VS Code 打开文件。


4. Tmux：终端复用的王者
为什么 AI 编码需要 Tmux？
使用 Claude Code 或 Cursor 时，你经常需要：


    

  • 同时运行开发服务器、测试、构建
    • 

  • 保持会话，即使终端关闭
    • 

  • 在多个项目间快速切换
    • 

  • 远程开发时保持连接
    • 



Tmux 是终端复用器，让你在一个终端窗口中管理多个会话。


安装与配置
1
2
3
4
5
# 安装 Tmux
brew install tmux

# 安装 TPM（Tmux 插件管理器）
git clone https://github.com/tmux-plugins/tpm ~/.tmux/plugins/tpm



创建配置文件 ~/.tmux.conf：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
# 改变前缀键为 Ctrl+a（更顺手）
unbind C-b
set -g prefix C-a
bind C-a send-prefix

# 启用鼠标支持
set -g mouse on

# 从 1 开始编号（0 太远）
set -g base-index 1
setw -g pane-base-index 1

# 更好的分屏快捷键
bind | split-window -h -c "#{pane_current_path}"
bind - split-window -v -c "#{pane_current_path}"

# Vim 风格的面板切换
bind h select-pane -L
bind j select-pane -D
bind k select-pane -U
bind l select-pane -R

# 插件
set -g @plugin 'tmux-plugins/tpm'
set -g @plugin 'tmux-plugins/tmux-sensible'
set -g @plugin 'tmux-plugins/tmux-resurrect'
set -g @plugin 'tmux-plugins/tmux-continuum'

# 自动保存会话
set -g @continuum-restore 'on'

# 初始化 TPM
run '~/.tmux/plugins/tpm/tpm'



AI 编码工作流
典型的 Tmux 布局：


1
2
3
4
5
6
7
8
9
10
┌─────────────────────────────────────┐
│ Window 1: 开发                       │
├──────────────┬──────────────────────┤
│              │                      │
│  编辑器      │   开发服务器         │
│  (Pane 1)    │   (Pane 2)           │
│              │                      │
├──────────────┴──────────────────────┤
│  测试输出 (Pane 3)                  │
└─────────────────────────────────────┘



创建这个布局：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 创建新会话
tmux new -s ai-coding

# 垂直分屏
Ctrl+a |

# 水平分屏
Ctrl+a -

# 在右上面板运行开发服务器
npm run dev

# 在底部面板运行测试监听
npm run test:watch



会话管理：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 创建新会话
tmux new -s project-name

# 列出所有会话
tmux ls

# 附加到会话
tmux attach -t project-name

# 分离会话（保持运行）
Ctrl+a d

# 切换会话
Ctrl+a s



进阶技巧
1. 会话持久化


使用 tmux-resurrect 插件，即使重启电脑也能恢复会话：


1
2
3
4
5
# 保存会话
Ctrl+a Ctrl+s

# 恢复会话
Ctrl+a Ctrl+r



2. 与 AI 工具集成


在 Claude Code 中运行长时间任务时，使用 Tmux 后台运行：


1
2
3
4
5
# 创建后台会话运行构建
tmux new -d -s build 'npm run build'

# 查看构建输出
tmux attach -t build



5. 组合拳：打造完整工作流
场景 1：启动新项目
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 1. 使用 fzf 快速找到项目目录
cd $(fd --type d --max-depth 3 | fzf)

# 2. 创建 Tmux 会话
tmux new -s $(basename $(pwd))

# 3. 查看项目结构（eza + 树形视图）
lt

# 4. 分屏布局
# 左侧：编辑器
# 右上：开发服务器
# 右下：测试

# 5. 使用 Yazi 浏览项目结构
yazi



场景 2：AI 建议的多文件修改
1
2
3
4
5
6
7
8
9
10
11
12
13
# 1. AI 说："我修改了 3 个文件，请检查"

# 2. 使用 eza 快速查看哪些文件被修改
ll  # 会显示 Git 状态标记

# 3. 使用 Lazygit 可视化查看所有变更
lazygit

# 4. 使用 fzf 快速打开每个文件
vim $(fzf)

# 5. 在 Tmux 的另一个面板运行测试
npm test



场景 3：调试复杂问题
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 1. 在 Tmux 中创建调试布局
# 面板 1：运行应用
# 面板 2：查看日志
# 面板 3：运行测试
# 面板 4：编辑代码

# 2. 使用 Atuin 智能搜索之前的调试命令
Ctrl+R -> 输入关键词 -> 按目录过滤

# 3. 使用 Lazygit 查看代码变更历史
lazygit -> 按 l 查看文件历史

# 4. 使用 Yazi 快速定位相关文件
yazi



场景 4：提交 AI 修改的代码
1
2
3
4
5
6
7
8
9
10
11
# 1. 使用 Lazygit 可视化查看所有变更
lazygit

# 2. 在 Lazygit 中：
#    - 按 Space 选择性暂存文件
#    - 按 c 提交
#    - 按 P 推送

# 3. Starship 提示符实时显示 Git 状态
# 提交前：🌱 feature/auth ✅3 📝2
# 提交后：🌱 feature/auth ⬆️1



6. 进阶工具：让 AI 编码更上一层楼
在掌握了前面的基础工具后，这些进阶工具能让你的 AI 编码效率再提升一个档次。它们都是 GitHub 上的热门项目，经过了大量开发者的实战检验。


Atuin：智能命令历史搜索 (⭐ 27.5K)
为什么需要 Atuin？
传统的 Ctrl+R 历史搜索有很多局限：


    

  • 只能搜索当前机器的历史
    • 

  • 无法按目录、时间过滤
    • 

  • 搜索结果不够智能
    • 



当 AI 建议你运行一个复杂的命令时，你可能几天前在另一个项目中执行过类似的命令。Atuin 将所有命令历史存储在 SQLite 数据库中，支持跨设备同步，让你永远不会丢失有用的命令。


安装与配置
1
2
3
4
5
6
7
8
9
# 安装 Atuin
brew install atuin

# 初始化（会自动导入现有历史）
atuin init zsh >> ~/.zshrc
source ~/.zshrc

# 导入现有历史
atuin import auto



AI 编码场景
场景 1：找回 AI 建议的复杂命令


1
2
3
4
5
6
7
8
9
10
11
12
# 按 Ctrl+R，输入关键词
# Atuin 会显示：
# - 命令执行时间
# - 执行目录
# - 命令是否成功
# - 执行时长

# 例如搜索 "docker"，立即找到：
# docker compose -f docker-compose.dev.yml up -d
# 📁 ~/projects/api-service
# ✅ 成功 (2s)
# 🕐 2 天前



场景 2：跨项目复用命令


AI 在项目 A 中建议的测试命令，在项目 B 中也能快速找到并复用：


1
2
3
4
5
# 在项目 A 中执行过：
npm test -- --coverage --watchAll=false

# 在项目 B 中按 Ctrl+R 搜索 "coverage"
# 立即找到并复用



进阶配置
在 ~/.config/atuin/config.toml 中配置：


1
2
3
4
5
6
7
8
9
10
11
# 按目录过滤
filter_mode = "directory"

# 智能排序（常用命令优先）
search_mode = "fuzzy"

# 显示更多上下文
show_preview = true

# 同步到云端（可选）
sync_address = "https://api.atuin.sh"



Lazygit：Git 操作的可视化革命 (⭐ 55K)
为什么 AI 编码需要 Lazygit？
当 AI 同时修改 10 个文件时，传统的 git status 和 git diff 显得力不从心：


    

  • 无法快速预览每个文件的变更
    • 

  • 暂存/取消暂存操作繁琐
    • 

  • 解决冲突时缺乏可视化
    • 

  • 交互式 rebase 难以操作
    • 



Lazygit 提供了一个强大的终端 UI，让所有 Git 操作都变得直观和高效。


安装与配置
1
2
3
4
5
# 安装 Lazygit
brew install lazygit

# 创建配置文件
mkdir -p ~/.config/lazygit



创建 ~/.config/lazygit/config.yml：


1
2
3
4
5
6
7
8
9
10
11
12
gui:
  theme:
    activeBorderColor:
      - green
      - bold
  showFileTree: true
  showRandomTip: false

git:
  paging:
    colorArg: always
    pager: delta --dark --paging=never



AI 编码工作流
场景 1：快速查看 AI 的多文件修改


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 启动 Lazygit
lazygit

# 界面布局：
# ┌─────────────┬──────────────────┐
# │ 文件列表    │  Diff 预览       │
# │ ✓ auth.ts   │  - old code      │
# │ ✓ user.ts   │  + new code      │
# │   api.ts    │                  │
# └─────────────┴──────────────────┘

# 快捷键：
# j/k - 上下移动
# Space - 暂存/取消暂存
# c - 提交
# P - 推送
# Enter - 查看完整 diff



场景 2：交互式暂存


AI 修改了一个文件的多个部分，但你只想提交其中一部分：


1
2
3
4
5
# 在 Lazygit 中：
# 1. 选中文件，按 Enter 查看 diff
# 2. 移动到想要暂存的代码块
# 3. 按 Space 只暂存这个代码块
# 4. 按 c 提交



场景 3：解决合并冲突


1
2
3
4
# Lazygit 会高亮显示冲突文件
# 按 Enter 进入冲突解决模式
# 使用方向键选择保留哪一方的代码
# 或按 e 在编辑器中手动解决



实用技巧
1
2
3
4
5
6
7
8
9
10
11
# 快速修改上一次提交
# 在 Lazygit 中按 A（amend）

# 交互式 rebase
# 选中提交，按 e（edit）、s（squash）、d（drop）

# 查看文件历史
# 选中文件，按 l（log）

# 快速切换分支
# 按 b（branches），输入分支名



Starship：智能提示符 (⭐ 53.7K)
为什么 AI 编码需要 Starship？
在 AI 编码时，你需要快速了解当前环境的上下文：


    

  • 当前 Git 分支和状态
    • 

  • Node/Python/Go 版本
    • 

  • 是否在虚拟环境中
    • 

  • 上一个命令是否成功
    • 



Starship 是一个跨 shell 的智能提示符，用 Rust 编写，速度极快，能实时显示所有关键信息。


安装与配置
1
2
3
4
5
6
# 安装 Starship
brew install starship

# 添加到 ~/.zshrc
echo 'eval "$(starship init zsh)"' >> ~/.zshrc
source ~/.zshrc



创建配置文件 ~/.config/starship.toml：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
# 简洁模式
format = """
[┌─](bold green)$directory$git_branch$git_status
[└─](bold green)$character"""

# 目录显示
[directory]
truncation_length = 3
truncate_to_repo = true
style = "bold cyan"

# Git 分支
[git_branch]
symbol = "🌱 "
style = "bold purple"

# Git 状态
[git_status]
conflicted = "⚔️ "
ahead = "⬆️ ${count}"
behind = "⬇️ ${count}"
diverged = "🔀"
untracked = "🤷"
stashed = "📦"
modified = "📝"
staged = "✅"
renamed = "👅"
deleted = "🗑️ "

# 语言版本
[nodejs]
symbol = "⬢ "
style = "bold green"

[python]
symbol = "🐍 "
style = "bold yellow"

[rust]
symbol = "🦀 "
style = "bold red"

# 命令执行时间
[cmd_duration]
min_time = 500
format = "took [$duration](bold yellow)"



AI 编码场景
提示符显示示例：


1
2
3
4
5
6
7
8
┌─ ~/projects/ai-app 🌱 feature/auth ✅3 📝2
└─ ❯

# 解读：
# ~/projects/ai-app - 当前目录
# 🌱 feature/auth - Git 分支
# ✅3 - 3 个文件已暂存
# 📝2 - 2 个文件已修改



当 AI 修改文件后，提示符会实时更新，让你一眼看出项目状态。


eza：现代化的 ls (⭐ 20.4K)
为什么需要 eza？
传统的 ls 命令输出单调，缺乏关键信息。eza 是 exa 的继任者，提供：


    

  • 彩色输出和图标
    • 

  • Git 状态集成
    • 

  • 树形视图
    • 

  • 更好的排序和过滤
    • 



在 AI 编码时，快速浏览项目结构和文件状态至关重要。


安装与配置
1
2
3
4
5
6
7
8
# 安装 eza
brew install eza

# 添加别名到 ~/.zshrc
alias ls="eza --icons --group-directories-first"
alias ll="eza -l --icons --group-directories-first --git"
alias la="eza -la --icons --group-directories-first --git"
alias lt="eza --tree --level=2 --icons"



AI 编码场景
场景 1：快速查看项目结构


1
2
3
4
5
6
7
8
9
10
11
# 使用 lt（tree）查看项目结构
lt

# 输出：
# 📁 src
# ├── 📁 components
# │   ├── 📄 Button.tsx
# │   └── 📄 Input.tsx
# ├── 📁 utils
# │   └── 📄 helpers.ts
# └── 📄 index.ts



场景 2：查看 Git 状态


1
2
3
4
5
6
7
8
9
10
11
12
# 使用 ll 查看文件详情和 Git 状态
ll

# 输出：
# .rw-r--r-- 1.2k user 22 Mar 10:30 -M auth.ts
# .rw-r--r-- 856  user 22 Mar 09:15 N- user.ts
# .rw-r--r-- 2.1k user 21 Mar 14:20 -- api.ts

# 解读：
# -M - 已修改（Modified）
# N- - 新文件（New）
# -- - 未修改



场景 3：按时间排序查看最近修改


1
2
3
4
# 查看最近修改的文件（AI 刚修改的）
eza -l --sort=modified --reverse

# 最新修改的文件会显示在最下面



进阶用法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 只显示目录
eza -D

# 显示隐藏文件
eza -a

# 按大小排序
eza -l --sort=size

# 显示文件树（3 层）
eza --tree --level=3

# 显示 Git 忽略的文件
eza --git-ignore



7. 额外推荐工具
bat：更好的 cat
1
2
3
4
5
6
7
brew install bat

# 语法高亮的文件查看
bat src/main.ts

# 与 fzf 集成预览
fzf --preview 'bat --color=always {}'



fd：更快的 find
1
2
3
4
5
6
7
brew install fd

# 查找所有 TypeScript 文件
fd -e ts -e tsx

# 忽略 node_modules
fd --exclude node_modules



ripgrep：更快的 grep
1
2
3
4
5
6
7
brew install ripgrep

# 在所有文件中搜索
rg "function.*User"

# 只搜索 TypeScript 文件
rg -t ts "interface"



zoxide：智能目录跳转
1
2
3
4
5
6
7
brew install zoxide

# 添加到 ~/.zshrc
eval "$(zoxide init zsh)"

# 使用
z project  # 跳转到最常访问的包含 "project" 的目录



总结
这些工具的组合让我的 AI 编码效率提升了至少 50%：


核心工具（必装）
    

  1. fzf - 秒速定位文件和命令
    2. 

  2. Ghostty - 流畅的终端体验
    3. 

  3. Yazi - 可视化文件管理
    4. 

  4. Tmux - 强大的会话管理
    5. 



进阶工具（强烈推荐）
    

  1. Atuin (⭐ 27.5K) - 智能命令历史，跨设备同步
    2. 

  2. Lazygit (⭐ 55K) - Git 可视化操作，告别复杂命令
    3. 

  3. Starship (⭐ 53.7K) - 智能提示符，实时显示上下文
    4. 

  4. eza (⭐ 20.4K) - 现代化文件列表，Git 状态集成
    5. 



辅助工具（锦上添花）
    

  1. bat - 语法高亮的文件查看
    2. 

  2. fd - 更快的文件搜索
    3. 

  3. ripgrep - 更快的内容搜索
    4. 

  4. zoxide - 智能目录跳转
    5. 



关键是要形成肌肉记忆。刚开始可能觉得学习曲线陡峭，但坚持使用 2-3 周后，这些操作会变得自然而然。


完整工作流示例
当 AI 助手建议你修改 10 个文件时，你的操作流程是：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 1. 查看修改了哪些文件
ll  # eza 显示 Git 状态

# 2. 可视化查看所有变更
lazygit

# 3. 快速打开文件
vim $(fzf)  # Ctrl+T

# 4. 在 Tmux 分屏中运行测试
Ctrl+a | && npm test

# 5. 找回之前的复杂命令
Ctrl+R  # Atuin 智能搜索

# 6. 提交代码
lazygit  # 可视化暂存和提交



你的提示符会实时显示：


1
2
┌─ ~/projects/ai-app 🌱 feature/auth ✅3 📝2 ⬢ v20.11.0
└─ ❯



这就是现代 AI 编码的正确打开方式。




你在用什么命令行工具提升 AI 编码效率？欢迎在评论区分享！


参考资源




本文由 Claude Opus 4.6 辅助创作，工具链：Ghostty + Tmux + fzf + Yazi + Lazygit + Atuin + Starship + eza




    
#123;count}"
diverged = "🔀"
untracked = "🤷"
stashed = "📦"
modified = "📝"
staged = "✅"
renamed = "👅"
deleted = "🗑️ "

# 语言版本
[nodejs]
symbol = "⬢ "
style = "bold green"

[python]
symbol = "🐍 "
style = "bold yellow"

[rust]
symbol = "🦀 "
style = "bold red"

# 命令执行时间
[cmd_duration]
min_time = 500
format = "took [$duration](bold yellow)"

AI 编码场景

提示符显示示例：

1
2
3
4
5
6
7
8
┌─ ~/projects/ai-app 🌱 feature/auth ✅3 📝2
└─ ❯

# 解读：
# ~/projects/ai-app - 当前目录
# 🌱 feature/auth - Git 分支
# ✅3 - 3 个文件已暂存
# 📝2 - 2 个文件已修改

当 AI 修改文件后，提示符会实时更新，让你一眼看出项目状态。

eza：现代化的 ls (⭐ 20.4K)

为什么需要 eza？

传统的 ls 命令输出单调，缺乏关键信息。eza 是 exa 的继任者，提供：

  • 彩色输出和图标
  • Git 状态集成
  • 树形视图
  • 更好的排序和过滤

在 AI 编码时，快速浏览项目结构和文件状态至关重要。

安装与配置

1
2
3
4
5
6
7
8
# 安装 eza
brew install eza

# 添加别名到 ~/.zshrc
alias ls="eza --icons --group-directories-first"
alias ll="eza -l --icons --group-directories-first --git"
alias la="eza -la --icons --group-directories-first --git"
alias lt="eza --tree --level=2 --icons"

AI 编码场景

场景 1：快速查看项目结构

1
2
3
4
5
6
7
8
9
10
11
# 使用 lt（tree）查看项目结构
lt

# 输出：
# 📁 src
# ├── 📁 components
# │   ├── 📄 Button.tsx
# │   └── 📄 Input.tsx
# ├── 📁 utils
# │   └── 📄 helpers.ts
# └── 📄 index.ts

场景 2：查看 Git 状态

1
2
3
4
5
6
7
8
9
10
11
12
# 使用 ll 查看文件详情和 Git 状态
ll

# 输出：
# .rw-r--r-- 1.2k user 22 Mar 10:30 -M auth.ts
# .rw-r--r-- 856  user 22 Mar 09:15 N- user.ts
# .rw-r--r-- 2.1k user 21 Mar 14:20 -- api.ts

# 解读：
# -M - 已修改（Modified）
# N- - 新文件（New）
# -- - 未修改

场景 3：按时间排序查看最近修改

1
2
3
4
# 查看最近修改的文件（AI 刚修改的）
eza -l --sort=modified --reverse

# 最新修改的文件会显示在最下面

进阶用法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 只显示目录
eza -D

# 显示隐藏文件
eza -a

# 按大小排序
eza -l --sort=size

# 显示文件树（3 层）
eza --tree --level=3

# 显示 Git 忽略的文件
eza --git-ignore

7. 额外推荐工具

bat：更好的 cat

1
2
3
4
5
6
7
brew install bat

# 语法高亮的文件查看
bat src/main.ts

# 与 fzf 集成预览
fzf --preview 'bat --color=always {}'

fd：更快的 find

1
2
3
4
5
6
7
brew install fd

# 查找所有 TypeScript 文件
fd -e ts -e tsx

# 忽略 node_modules
fd --exclude node_modules

ripgrep：更快的 grep

1
2
3
4
5
6
7
brew install ripgrep

# 在所有文件中搜索
rg "function.*User"

# 只搜索 TypeScript 文件
rg -t ts "interface"

zoxide：智能目录跳转

1
2
3
4
5
6
7
brew install zoxide

# 添加到 ~/.zshrc
eval "$(zoxide init zsh)"

# 使用
z project  # 跳转到最常访问的包含 "project" 的目录

总结

这些工具的组合让我的 AI 编码效率提升了至少 50%：

核心工具（必装）

  1. fzf - 秒速定位文件和命令
  2. Ghostty - 流畅的终端体验
  3. Yazi - 可视化文件管理
  4. Tmux - 强大的会话管理

进阶工具（强烈推荐）

  1. Atuin (⭐ 27.5K) - 智能命令历史，跨设备同步
  2. Lazygit (⭐ 55K) - Git 可视化操作，告别复杂命令
  3. Starship (⭐ 53.7K) - 智能提示符，实时显示上下文
  4. eza (⭐ 20.4K) - 现代化文件列表，Git 状态集成

辅助工具（锦上添花）

  1. bat - 语法高亮的文件查看
  2. fd - 更快的文件搜索
  3. ripgrep - 更快的内容搜索
  4. zoxide - 智能目录跳转

关键是要形成肌肉记忆。刚开始可能觉得学习曲线陡峭，但坚持使用 2-3 周后，这些操作会变得自然而然。

完整工作流示例

当 AI 助手建议你修改 10 个文件时，你的操作流程是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 1. 查看修改了哪些文件
ll  # eza 显示 Git 状态

# 2. 可视化查看所有变更
lazygit

# 3. 快速打开文件
vim $(fzf)  # Ctrl+T

# 4. 在 Tmux 分屏中运行测试
Ctrl+a | && npm test

# 5. 找回之前的复杂命令
Ctrl+R  # Atuin 智能搜索

# 6. 提交代码
lazygit  # 可视化暂存和提交

你的提示符会实时显示：

1
2
┌─ ~/projects/ai-app 🌱 feature/auth ✅3 📝2 ⬢ v20.11.0
└─ ❯

这就是现代 AI 编码的正确打开方式。

你在用什么命令行工具提升 AI 编码效率？欢迎在评论区分享！

参考资源

本文由 Claude Opus 4.6 辅助创作，工具链：Ghostty + Tmux + fzf + Yazi + Lazygit + Atuin + Starship + eza

原文作者：zenghao0708

原文链接：https://coolzeng.com/posts/mac-ai-coding-tools/

发表日期：March 22nd 2026, 12:00:00 am

更新日期：April 5th 2026, 1:59:15 pm

版权声明：本文采用知识共享署名-非商业性使用 4.0 国际许可协议进行许可

CATALOG
  1. 1. Mac 上的 AI 编码利器：打造高效命令行工作流
    1. 1.1. 为什么命令行工具对 AI 编码如此重要？
    2. 1.2. 一个真实案例：AI 给出下一步之后，真正拖慢你的往往不是模型
    3. 1.3. 1. fzf：模糊搜索的艺术
      1. 1.3.1. 为什么选择 fzf？
      2. 1.3.2. 安装与配置
      3. 1.3.3. 实战技巧
      4. 1.3.4. 进阶配置
    4. 1.4. 2. Ghostty：为 AI 编码而生的终端
      1. 1.4.1. 为什么不用 iTerm2？
      2. 1.4.2. 安装与配置
      3. 1.4.3. AI 编码场景优化
    5. 1.5. 3. Yazi：现代化的文件管理器
      1. 1.5.1. 为什么需要 Yazi？
      2. 1.5.2. 安装与配置
      3. 1.5.3. 核心功能
      4. 1.5.4. 与 AI 工具集成
    6. 1.6. 4. Tmux：终端复用的王者
      1. 1.6.1. 为什么 AI 编码需要 Tmux？
      2. 1.6.2. 安装与配置
      3. 1.6.3. AI 编码工作流
      4. 1.6.4. 进阶技巧
    7. 1.7. 5. 组合拳：打造完整工作流
      1. 1.7.1. 场景 1：启动新项目
      2. 1.7.2. 场景 2：AI 建议的多文件修改
      3. 1.7.3. 场景 3：调试复杂问题
      4. 1.7.4. 场景 4：提交 AI 修改的代码
    8. 1.8. 6. 进阶工具：让 AI 编码更上一层楼
      1. 1.8.1. Atuin：智能命令历史搜索 (⭐ 27.5K)
        1. 1.8.1.1. 为什么需要 Atuin？
        2. 1.8.1.2. 安装与配置
        3. 1.8.1.3. AI 编码场景
        4. 1.8.1.4. 进阶配置
      2. 1.8.2. Lazygit：Git 操作的可视化革命 (⭐ 55K)
        1. 1.8.2.1. 为什么 AI 编码需要 Lazygit？
        2. 1.8.2.2. 安装与配置
        3. 1.8.2.3. AI 编码工作流
        4. 1.8.2.4. 实用技巧
      3. 1.8.3. Starship：智能提示符 (⭐ 53.7K)
        1. 1.8.3.1. 为什么 AI 编码需要 Starship？
        2. 1.8.3.2. 安装与配置
        3. 1.8.3.3. AI 编码场景
      4. 1.8.4. eza：现代化的 ls (⭐ 20.4K)
        1. 1.8.4.1. 为什么需要 eza？
        2. 1.8.4.2. 安装与配置
        3. 1.8.4.3. AI 编码场景
        4. 1.8.4.4. 进阶用法
    9. 1.9. 7. 额外推荐工具
      1. 1.9.1. bat：更好的 cat
      2. 1.9.2. fd：更快的 find
      3. 1.9.3. ripgrep：更快的 grep
      4. 1.9.4. zoxide：智能目录跳转
    10. 1.10. 总结
      1. 1.10.1. 核心工具（必装）
      2. 1.10.2. 进阶工具（强烈推荐）
      3. 1.10.3. 辅助工具（锦上添花）
      4. 1.10.4. 完整工作流示例
    11. 1.11. 参考资源
Total : 17
2026
2024
2022
2018
2017
2016
Claude Code AI 编程 源码分析 OpenClaw LLM GPT iOS cocoapods AI Agent ReactNative git 多线程 开发工具 命令行 Mac 分享 hexo 网络编程 zsh Ghostty
AI 工具 AI 开发 ReactNative 技术分享 分享