使用 Claude Code 和 Codex 编写 Rust 代码

近期我一直在试用 AI 编程工具，发现将 Rust 与 Claude Code 或 OpenAI 的 Codex 等智能体结合使用时，会产生令人着迷的效果：这种体验与使用 Python 或 JavaScript 有着根本性的不同——我认为这归结于一个简单事实：Rust 的编译器就像一位自动专家评审员，对 AI 的每次修改进行严格审核。

如果能编译，大概率就能运行；这不只是 Rust 的座右铭，更正在成为可靠 AI 辅助开发的基石。

在 Python 代码库中放任 Claude Code 或 Codex 自由发挥时，你实际上是在相信 AI 能够独立完成正确工作。虽然有代码检查工具和类型提示（如果幸运的话），但缺乏严格约束：AI 可能生成看起来合理、能通过快速审查的代码，然后因为某些未考虑到的边缘情况而在生产环境中崩溃。

而 Rust 编译器会在任何代码运行前就捕获这些问题。内存安全问题？编译时捕获。数据竞争？编译时捕获。生命周期问题？同样在编译时捕获。这创造了一个高效的反馈循环，AI 编程工具可以实时从中学习。

Rust 在 AI 编程领域的独特之处在于：编译器不只是简单报错，而是准确指出问题所在、原因分析，并经常提供修复建议。这对 Codex 或 Claude Code 等 AI 工具来说价值连城。

举例说明：假设 AI 编写了以下代码：

fn get_first_word(s: String) -> &str {
    let bytes = s.as_bytes();
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }
    &s[..]
}

Rust 编译器不会只给出晦涩的错误信息，而是提供详细指导：

error[E0106]: missing lifetime specifier
 --> src/main.rs:1:36
  |
1 | fn get_first_word(s: String) -> &str {
  |                   -             ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, 
          but there is no value for it to be borrowed from
help: consider using the `'static` lifetime
  |
1 | fn get_first_word(s: String) -> &'static str {
  |                                 ~~~~~~~~

编译器实际上是在向 AI 解释所有权模型——明确指出："试图返回引用，但引用的对象在函数结束时会被丢弃，这种做法不可行。"

对 AI 编程工具而言，这是结构化的确定性反馈。错误代码 E0106 固定明确；问题定位精确到字符；解释清晰易懂；甚至提供修复建议。

这是 AI 工具编写并发代码时经常出现的另一个例子：

use std::thread;

fn main() {
    let data = vec![1, 2, 3];

    let handle = thread::spawn(|| {
        println!("{:?}", data);
    });

    handle.join().unwrap();
}

编译器响应：

error[E0373]: closure may outlive the current function, but it borrows `data`
 --> src/main.rs:6:32
  |
6 |     let handle = thread::spawn(|| {
  |                                ^^ may outlive borrowed value `data`
7 |         println!("{:?}", data);
  |                          ---- `data` is borrowed here
  |
note: function requires argument type to outlive `'static`
 --> src/main.rs:6:18
  |
6 |     let handle = thread::spawn(|| {
  |                  ^^^^^^^^^^^^^
help: to force the closure to take ownership of `data`, use the `move` keyword
  |
6 |     let handle = thread::spawn(move || {
  |                                ++++

编译器明确指导："在此添加 move 关键字"。Claude Code 或 Codex 可以解析这个信息，应用修复并继续工作——无需猜测，不会出现导致生产系统崩溃的数据竞争问题。

这与 Python 或 JavaScript 中的情况有本质区别：当 AI 在这些语言中生成有问题的并发代码时，可能直到特定负载条件下遇到竞态条件时才会发现问题；而在 Rust 中，这类错误无法通过编译器检查。

Anthropic 的 Julian Schrittwieser 指出：

Rust 非常适合 Claude Code 在无人监督的情况下处理大型任务。强大的类型系统与严格安全检查的结合，就像专家代码评审员，自动拒绝不正确修改并防止错误。

我们在实践中也印证了这一点，使用 Rust 构建语音处理基础设施时，当 AI 工具进行代码修改，编译器会立即指出问题所在。无需等待运行时错误，无需调试会话排查崩溃原因，错误信息清晰明了，便于操作。

以下是一个典型的工作流程：

# AI 生成代码
cargo check

# 编译器输出：
error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable
 --> src/main.rs:4:5
  |
3 |     let r1 = &x;
  |              -- immutable borrow occurs here
4 |     let r2 = &mut x;
  |              ^^^^^^ mutable borrow occurs here
5 |     println!("{}, {}", r1, r2);
  |                        -- immutable borrow later used here

# AI 识别错误，理解借用冲突，重构代码
# AI 实施修改

cargo check
# 编译通过

每个错误都有唯一识别码（如 E0502）。运行 rustc --explain E0502 可获得包含示例的完整解释。AI 工具不仅能理解错误位置，还能通过编译器学习 Rust 所有权模型的原理。

编译器提供结构化、确定性的反馈，极大减少了错误发生的可能性。

与 C++ 编译器在模板出错时的输出对比：

error: no matching function for call to 'std::vector<std::basic_string<char>>::push_back(int)'
   vector<string> v; v.push_back(42);
                      ^

虽然提示类型不匹配，但如果这个错误埋没在 500 行的模板回溯中，AI 很难准确解析。

Rust 的错误信息设计为人类可读，这也使其非常适合 AI 处理：每个错误包含精确的源码位置、规则违反说明、修复建议以及详细文档链接。

当 Claude Code 或 Codex 运行 Cargo Check 时，它接收到的结构化错误信息可以直接指导修复行动。反馈循环以秒计，而非以调试会话计。

让开发工作流程显著改善的一个关键措施是创建 CLAUDE.md 文件——这是存在于代码库中的指南文档，为 AI 编程工具提供项目结构、约定和最佳实践的上下文。

对于 Rust 项目，建议包含以下内容：

1. Cargo 工作区结构 - crate 的组织方式
2. 错误处理模式 - 使用 anyhow、thiserror 还是自定义错误类型
3. 异步运行时 - 使用 tokio、async-std 或其他方案
4. 测试约定 - 集成测试位置、模拟模式
5. 内存管理指南 - 何时使用 Arc、Rc 或普通引用

Rust 严格编译器与完善项目指南的结合，创造了 AI 工具可以高效操作的环境：它们了解规则，而编译器强制执行规则。

在 WebSocket 处理、音频处理流水线、实时语音转文字/文字转语音（STT/TTS）等场景中，我们使用 Rust 处理核心逻辑。这些正是内存安全和并发保证至关重要的系统。

当 AI 重构 WebSocket 消息处理器时，不会意外引入错误；当修改音频缓冲区管理时，无法创建 use-after-free 漏洞，因为语言本身就不允许。

// 编译器确保音频缓冲区处理的安全性
pub async fn process_audio_chunk(&self, chunk: Bytes) -> Result<()> {
    let processor = self.processor.lock().await;
    processor.feed(chunk)?;

    while let Some(result) = processor.next_result().await {
        self.tx.send(result).await?;
    }

    Ok(())
}

AI 工具可能需要多次迭代才能正确处理借用和生命周期，但每次迭代都有具体的编译器错误指导：无需猜测，目标明确。

OpenAI 最近使用 Rust 完全重写了其 Codex CLI。这不只是性能考虑——他们明确提到 Rust 在编译时消除了整类错误。这预示着技术发展的方向。

安全影响也很显著：结合 Rust 安全保证与操作系统隔离，当 AI 生成代码在沙盒环境中运行时，编译时安全保证成为必要条件。

Rust 的所有权模型需要时间掌握，生命周期概念初学时可能令人困惑——但 AI 编程工具实际上擅长处理这些难点。

一个实用技巧是指导 Claude Code"修复生命周期"，让它找出正确的引用组合，而开发者可以专注于业务逻辑和架构。

// 修复前：存在生命周期问题
fn process(&self, data: Vec<String>) -> &str {
    &data[0]  // 无法编译 - 返回局部数据的引用
}

// 修复后：正确的借用方案
fn process(&self, data: &[String]) -> &str {
    &data[0]  // 正常工作 - 从输入参数借用
}

这实际上是比独自面对编译器错误更有效的学习方式：通过观察模式，理解方法原理，AI 还能在询问时解释推理过程。

如果考虑使用 Claude Code 或 Codex 进行 Rust 开发，建议：

1. 完善 CLAUDE.md - 记录项目模式、约定和架构决策
2. 积极使用 cargo clippy - 启用所有 lint 检查，更多反馈提升 AI 输出质量
3. 严格 CI 检查 - 确保每次更改都运行 Cargo test、Cargo clippy 和 Cargo fmt
4. 从明确定义的任务开始 - 边界清晰时，Rust 的类型系统优势最能体现
5. 保持代码审查 - 编译器能捕获很多问题，但逻辑错误仍需人工审查

我们正处在有趣的技术转折点：Rust 在系统编程领域快速发展，AI 编程工具日益成熟。两者的结合产生了协同效应。

语音处理基础设施需要处理实时音频流、多提供商集成和复杂状态管理，使用 Rust 构建并辅以 AI 辅助，可以在保证内存安全和并发稳定的前提下加速开发进程。

如果你曾因学习曲线而放弃 Rust，不妨尝试以 Claude Code 或 Codex 作为编程伙伴。当 AI 处理所有权和借用模式时，你可以专注于功能实现，体验将完全不同。

工具的能力正在赶上语言的潜力。