AI Coding with Rust

AI Tool Ecosystem for Rust

Rust's AI coding tool ecosystem is strong but requires more developer oversight than Python or TypeScript. Claude Code stands out for Rust -- it handles ownership, borrowing, and trait bounds more accurately than most competitors. GitHub Copilot produces reasonable Rust but frequently triggers borrow checker errors on first attempt. Cursor's codebase-aware completions help significantly with Rust because the type context from surrounding files reduces lifetime ambiguity. Aider works well for Rust refactoring tasks. rust-analyzer integration means AI tools get real-time compiler feedback, and the Rust compiler's error messages are detailed enough that AI tools can iteratively fix issues. The ecosystem lacks Rust-specific AI tooling, but the language's strong conventions and compiler strictness act as a natural quality gate on AI output.

What AI Does Well with Rust

• Generating derive macro annotations and trait implementations (Display, From, Into, Serialize/Deserialize) with correct syntax
• Writing exhaustive match arms for complex enums, including nested destructuring patterns
• Explaining and fixing borrow checker errors with actionable suggestions for restructuring ownership
• Scaffolding CLI tools with clap derive macros, including subcommands and argument validation

Tips for AI-Assisted Rust Development

• Let AI handle boilerplate like From/Into trait implementations and Display formatting
• AI is excellent at generating pattern matching blocks for enums
• Use AI to write unit tests - it understands Rust's testing conventions well
• Ask AI to explain borrow checker errors - it often suggests the right fix
• AI tools handle serde serialization/deserialization derive macros and custom implementations well

Prompting Tips for Rust

Where AI Struggles with Rust

• AI frequently generates Rust code that fails to compile due to incorrect lifetime annotations, especially with structs holding references across async boundaries
• AI tools often default to .clone() and .unwrap() instead of proper ownership transfer and error handling, producing code that compiles but is not idiomatic or production-ready
• Complex trait bound combinations (where clauses with multiple bounds, associated types, and HRTBs) are often generated incorrectly
• AI struggles with unsafe Rust blocks, frequently producing code with undefined behavior that passes compilation but violates memory safety invariants

Axum handler with typed extractors

A web API handler demonstrating typed extractors, custom error handling with thiserror, and proper async patterns -- a workflow where AI significantly accelerates Rust development.

use axum::{extract::{Path, State}, Json, http::StatusCode};
use serde::{Deserialize, Serialize};
use sqlx::PgPool;
use thiserror::Error;

#[derive(Error, Debug)]
pub enum AppError {
    #[error("not found: {0}")]
    NotFound(String),
    #[error("database error")]
    Db(#[from] sqlx::Error),
}

impl axum::response::IntoResponse for AppError {
    fn into_response(self) -> axum::response::Response {
        let status = match &self {
            AppError::NotFound(_) => StatusCode::NOT_FOUND,
            AppError::Db(_) => StatusCode::INTERNAL_SERVER_ERROR,
        };
        (status, self.to_string()).into_response()
    }
}

pub async fn get_user(
    State(pool): State<PgPool>,
    Path(user_id): Path<i64>,
) -> Result<Json<User>, AppError> {
    let user = sqlx::query_as!(User, "SELECT * FROM users WHERE id = $1", user_id)
        .fetch_optional(&pool)
        .await?
        .ok_or_else(|| AppError::NotFound(format!("User {user_id}")))?;
    Ok(Json(user))
}

Common Use Cases

• Systems programming and CLI tools
• WebAssembly modules
• High-performance web services with Actix/Axum
• Embedded systems and game engines

Popular Rust Libraries AI Handles Well

Best Practices

AI tools work best with Rust when you provide clear type signatures and document your intent with comments. Complex lifetime scenarios may need manual adjustment. Use clippy lints to catch issues in AI-generated code. Start with simple ownership patterns and let AI help refactor toward more complex ones.

Recommended Tools for Rust

The following AI coding tools offer the best support for Rust development:

• Cursor - AI-first code editor built as a fork of VS Code with deep AI integration for code generation, editing, and chat.
• Claude Code - Anthropic's agentic CLI coding tool that operates directly in your terminal, capable of editing files, running commands, and managing entire coding workflows.
• GitHub Copilot - AI pair programmer by GitHub and Microsoft that provides code suggestions, chat, and autonomous coding agents directly in your editor.
• Aider - Open-source AI pair programming tool that runs in your terminal and makes coordinated edits across multiple files with automatic git commits.

FAQ