Using AI Agents to Optimize Rust Code: A New Approach to Performance Engineering

Writing Faster Rust Code with AI Agents

Performance optimization has always been central to systems programming, and Rust — with its zero-cost abstractions and memory safety guarantees — has become a go-to choice for high-performance workloads. A thought-provoking discussion recently surfaced on Hacker News, proposing an intriguing approach: instead of manually tuning code line by line, simply let an AI Agent iterate repeatedly by "asking it to make the code faster."

The core idea is to transform performance optimization from a one-time manual effort into an iterative, automated process. Developers supply a benchmark and a clear performance target, then let the AI Agent close in on better solutions through a measure–modify–measure loop.

A quick caveat: the original source has limited information (the Hacker News post only has a title, 4 upvotes, and no comments). The analysis below is an extended exploration of this idea's feasibility and boundaries, offered for the reader's reference.

Why This Approach Might Actually Work

Rust performance optimization often involves a staggering number of details: memory allocation strategies, the trade-offs between iterators and raw loops, unnecessary clone calls, eliminating bounds checks, SIMD vectorization, and more. The sheer volume of these considerations makes manual auditing time-consuming and error-prone.

The value of an AI Agent here isn't that it's "smarter than humans" — it's that it "never gets tired of trial and error." When a quantifiable feedback signal exists (i.e., benchmark results), an Agent can:

• Rapidly enumerate common optimization patterns and validate them one by one
• Use profiling data to identify hot functions
• Refactor critical paths while preserving correctness

The critical prerequisite is reliable measurement. "Making it faster" without a benchmark is just guessing. With a framework like criterion, every change the Agent makes produces clear positive or negative feedback, enabling an effective optimization feedback loop.

SIMD (Single Instruction, Multiple Data) vectorization in Rust is a perfect example of a "high-reward but tedious" optimization that's well-suited for AI Agents to handle. SIMD lets a CPU process multiple data elements in a single instruction (e.g., adding 8 f32 values simultaneously), delivering several-fold speedups in numerical computation and byte-sequence processing. Rust exposes platform-specific SIMD intrinsics via std::arch, or offers portable abstractions through libraries like packed_simd and wide. Writing SIMD code by hand demands deep knowledge of target architectures (AVX2 on x86-64, NEON on ARM, etc.) and is error-prone. While the compiler's auto-vectorization handles simple loops, it often falls short on complex cases. An AI Agent can attempt to rewrite hot loops into forms that are more amenable to vectorization, or introduce SIMD libraries directly, then use benchmarks to verify real-world gains — a quintessential use case for its "tireless trial-and-error" advantage.

Key Considerations for Practice

Establish Trustworthy Benchmarks

Before bringing an Agent into the picture, stable benchmarks are the foundation of everything. The criterion library in the Rust ecosystem provides statistically meaningful performance comparisons, guarding against false conclusions caused by measurement noise. Every "speedup" from the Agent must be verified through benchmarks, not subjective judgment.

criterion is the most widely used micro-benchmarking framework in the Rust ecosystem. Its core strength lies in applying statistical methods to eliminate measurement noise: it takes multiple samples of the same code, computes mean, standard deviation, and confidence intervals, and thereby distinguishes genuine performance changes from system jitter. Unlike the rudimentary timing methods in the standard library, criterion can tell you whether an optimization delivered a definitive 5% improvement or just fell within the margin of measurement error. It's typically used alongside the cargo bench command, with benchmarks defined as separate test targets. Worth noting: there's still a gap between microbenchmarks and real-world workloads. criterion excels at measuring isolated functions but can't capture cache effects, concurrency contention, or other system-level behaviors. In an AI Agent optimization loop, criterion works great as a rapid feedback signal — but final validation should still happen under conditions that closely mirror production.

Correctness Comes Before Speed

The biggest risk in performance optimization is introducing bugs. Comprehensive unit and integration tests serve as a safety net — the Agent can refactor aggressively, but any change that breaks tests must be rejected. A speed gain that comes at the cost of correctness is worthless.

Human Review of the Final Output

AI-generated optimization code may employ obscure or overly aggressive techniques (such as heavy use of unsafe), sacrificing maintainability. Developers need to review the final code and weigh the performance gains against long-term maintenance costs.

Potential Limitations and Risks

This approach is not a silver bullet. First, Agents can easily get stuck in local optima — an Agent might repeatedly tweak a single function while missing architectural improvements that are often the real performance bottlenecks.

Second, over-relying on automated optimization can lead to a codebase accumulating incomprehensible "magic code." When an Agent introduces unsafe blocks or platform-specific tricks just to pass a benchmark, the code's portability and safety may both be compromised.

Finally, the quality of the benchmark design directly determines the effectiveness of optimization. If the benchmark doesn't represent the real workload, the "speed" the Agent optimizes for may only hold in the test scenario, with negligible gains in actual deployment.

The "local optima trap" has a solid technical foundation in optimization theory: most performance problems follow Amdahl's Law — a program's maximum speedup is limited by the fraction that cannot be parallelized or optimized. AI Agents tend to spin their wheels on visible, locally quantifiable code, while overlooking decisive factors like algorithmic complexity, data structure choices, or I/O patterns. For example, an Agent might spend many iterations squeezing a 30% constant-factor improvement out of an O(n) inner loop, while completely missing that converting an O(n²) outer scheduling step to a hash table lookup (O(1)) would be the real breakthrough. This kind of architectural insight requires a holistic understanding of business logic and data distribution — still a blind spot for current AI Agents. In practice, it's advisable to have an experienced engineer first do a round of profiling to identify the level of the bottleneck, then hand off the well-scoped local optimization tasks to the Agent, rather than delegating everything from the start.

Broader Implications for AI-Assisted Programming

Setting aside the specific context of Rust, this idea reveals a more general principle of AI-assisted programming: when a task has clear, quantifiable feedback signals, the value of an AI Agent is significantly amplified.

Performance optimization is precisely such a domain — targets are measurable, results are verifiable, and iteration costs are low. By contrast, tasks with high subjectivity, such as code readability or architectural design, remain difficult for AI to handle independently.

For developers, rather than agonizing over whether "AI will replace programmers," it's more productive to think about how to decompose engineering problems into "measurable optimization loops" that let AI act as a force multiplier on well-defined sub-problems. That may be the most pragmatic direction in AI-assisted programming today.