{"@context":"https://schema.org","@type":"NewsArticle","generatedAt":"2026-09-28T06:03:00.468Z","headline":"用智能体迭代优化让 Rust 代码提速 2x-20x 的方法与实践","description":"作者通过数月实验发现，现代智能体 LLM 在适当的护栏与约束下能写出显著快于现有 SOTA 的 Rust 代码，累计提速 2x-20x。","url":"https://www.aioga.com/news/cmudyft3e0cisrogh4g0ne2ry/","mainEntityOfPage":"https://www.aioga.com/news/cmudyft3e0cisrogh4g0ne2ry/","datePublished":"2026-09-23T10:04:31.000Z","dateModified":"2026-09-23T10:04:31.000Z","inLanguage":"zh-CN","publisher":{"@type":"NewsMediaOrganization","name":"Aioga","url":"https://www.aioga.com"},"citation":["https://minimaxir.com/2026/09/agentic-iteration","https://aihot.news/items/cmudyft3e0cisrogh4g0ne2ry"],"canonicalUrl":"https://www.aioga.com/news/cmudyft3e0cisrogh4g0ne2ry/","directAnswer":{"@type":"Answer","text":"作者称，经过数月实验，现代智能体大语言模型在适当护栏与约束下能够编写显著快于现有先进方法的 Rust 代码；不同领域累计提速为 2 至 20 倍。文章还介绍了提示词和基准测试结果。","url":"https://www.aioga.com/news/cmudyft3e0cisrogh4g0ne2ry/","dateCreated":"2026-09-23T10:04:31.000Z","author":{"@type":"Organization","@id":"https://www.aioga.com/authors/aioga-editorial/#editorial-team","name":"Aioga Editorial Team","url":"https://www.aioga.com/authors/aioga-editorial/"}},"evidence":[{"@type":"CreativeWork","name":"minimaxir.com source article","url":"https://minimaxir.com/2026/09/agentic-iteration","datePublished":"2026-09-23T10:04:31.000Z","provider":{"@type":"Organization","name":"minimaxir.com","url":"https://minimaxir.com/2026/09/agentic-iteration"}},{"@type":"CreativeWork","name":"AIHot archive record","url":"https://aihot.news/items/cmudyft3e0cisrogh4g0ne2ry","datePublished":"2026-09-23T10:04:31.000Z","provider":{"@type":"Organization","name":"AIHot","url":"https://aihot.news/items/cmudyft3e0cisrogh4g0ne2ry"}}],"aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","originalPublisher":{"name":"minimaxir.com","url":"https://minimaxir.com/2026/09/agentic-iteration"},"geoDeepAnswer":null,"article":{"id":"cmudyft3e0cisrogh4g0ne2ry","slug":"cmudyft3e0cisrogh4g0ne2ry","url":"https://www.aioga.com/news/cmudyft3e0cisrogh4g0ne2ry/","title":"用智能体迭代优化让 Rust 代码提速 2x-20x 的方法与实践","title_en":"","summary":"作者通过数月实验发现，现代智能体 LLM 在适当的护栏与约束下能写出显著快于现有 SOTA 的 Rust 代码，累计提速 2x-20x。","source":"Hacker News 热门（buzzing.cc 中文翻译）","sourceUrl":"https://minimaxir.com/2026/09/agentic-iteration","aiHotUrl":"https://aihot.news/items/cmudyft3e0cisrogh4g0ne2ry","publishedAt":"2026-09-23T10:04:31.000Z","category":"行业动态","score":58,"selected":false,"articleBody":["In January 2025, I had a fun hypothesis for a blog post : can LLMs write better code if you keep asking them to “write better code”? That was prior to the advent of robust agentic coding, but Claude Sonnet 3.5 was still able to iteratively improve on algorithmic Python code. The “better” instruction turned out to be underspecified: Sonnet abused that ambiguity to instead add a ton of useless features but the code was indeed faster. Even with the rise of agentic LLMs specifically RLHF ed to handle solving common pass/fail coding problems, optimization is generally not a part of that suite.","At the end of that blog post, I opined on a hypothetical future where LLMs could be able to write superfast Python code by instead writing Rust code and using PyO3 to bridge the languages to get Python’s ergonomics with Rust’s speed. An earlier draft of that post asserted that the same “write code better” instruction could instead be applied to the base Rust code and drastically improve its speed which would then propagate down to the Python code: however, back then I did not know enough about Rust and making such a claim would be too spicy without evidence.","After months of testing and experimenting since the release of Opus 4.5 made agentic coding more viable, I can confidently confirm that modern agentic LLMs can indeed write Rust code that is significantly faster than current state-of-the-art approaches if given appropriate guardrails and constraints . Additionally, as LLMs have made drastic improvements in coding in each successive frontier model release since Opus 4.5, the optimizations have become even better, cumulatively resulting in anywhere from 2x-20x speedup depending on the domain.","More importantly, this blog post is not a vaguepost and I am including both the prompts I used and the benchmark results. You’ve been warned.","At first, making software faster was a good quantitative way for me to test and compare these new agentic models. I used Rust as the target language primarily due to the Python integration and speed, but there are other aspects of the Rust language that make it particularly useful if a fast implementation is indeed discovered, such as memory safety and the ability to compile it to WebAssembly /WASM so it can run in a web browser without much effort. However, one important constraint I will follow that technically may not result in the fastest code is to forbid unsafe code whenever possible.","My first test case was reimplementing machine learning algorithms in Rust, which would lead to a meaningful productivity increase for me as a data scientist if I had faster and scalable tooling. At the time, it was arrogant to assume that I could beat battle-tested algorithms that have been iterated on for over a decade and are already written in C so Rust’s low-level benefits are not as pronounced. The algorithm I wanted to optimize the most was UMAP , which is a valuable algorithm for dimensionality reduction I used in my work, but scales poorly to big data and is very slow, with alternatives such as cuML being time-consuming to set up. UMAP Rust crates such as umap-rs already exist where I could just fork them and prompt Claude Opus 4.5 to add Python/PyO3 support, but as an experiment and learning experience I wanted to have the agent write the algorithm from scratch with minimal Rust dependencies in order to make optimizations at as low of a level as possible.","Rust has a comprehensive benchmarking tool with the criterion crate which all agents know how to leverage. criterion will run the benchmarks, track results across iterations to see if performance improved or regressed, and can calculate if this change is statistically significant or just noise.","Typical criterion output, depicting a 3.5x speedup relative to the previous run of the benchmark.","First, in the initial prompt for creating a Rust crate for UMAP, I asked Opus 4.5 to create benchmarks with different input data sizes since optimizations for small datasets may not work for large datasets and vice versa.","This approach created benchmarks using criterion and I manually reran the benchmark suite after prompting performance feature improvements such as using faer for faster linear algebra and using simsimd for faster SIMD operations . This quickly became cumbersome as I had to manually rerun each benchmark after each change to verify there are no speed regressions.","The way I prompt agentic LLMs is unusual: I typically provide the agents very long prompts prewritten in a Markdown document with the additional use of ALL CAPS and **bolding** for emphasis. This is to ensure I capture all nuances through the use of prompt engineering , along with several other tricks as detailed in this blog post. Although some may argue prompt engineering is dead as the latest models have become smart enough to correctly handle ambiguity, I strongly disagree as LLMs have also become much better at following said nuances.","Running a prompt from a Markdown document (right) by tagging the file (left), using Zed Agent .","After having enough confidence that the agent will not accidentally rm -rf the repo, I experimented with letting the agent be autonomous, giving them permission to iterate until they achieve a speed increase, hopefully.","It turned out “fast as it can be” is too ambiguous and Opus 4.5 was lazy so it tweaked a few hyperparameters without much of an actual speed increase and called it a day. What I needed was a clear target goal that can be pass/failed, so I refined the prompt:","This worked very well and not only did I get a 1.2x speed up on the benchmarks, but the agent continued after hitting the metric constraint and only stopped if a metric constraint was infeasible; in this instance, the agent hit 1.5x-2.0x speedups. The low-level Rust optimizations centered around a number of techniques including but not limited to: leveraging SIMD operations more aggressively, fusing functions, unrolling loops, creating intermediate caches, using Arc instead of borrowing wherever possible, and creating performance profiles based on input data (e.g. if the data is small, don’t use rayon data parallelism as the overhead erases gains).","I chose “1.2x faster” as a sanity test: if the goal is too high, the agent may cheat to achieve it through risky/verbose rewrites. Smaller changes are better since the agent can more easily isolate the cause of a speedup/regression, hence the note about iteration. After new frontier LLMs released such as GPT-5.3 Codex and Opus 4.6, I repeated this prompt unchanged for every new LLM and each were able to achieve a cumulative 1.5x-2.0x speedup over the previous pass. Going all the way to GPT-6 Astra over many months, that’s around 7.5x-32x faster than the initial implementation baseline.","This approach is hyperoptimizing for given benchmarks and therefore it could be considered benchmaxxing : a derogatory term for frontier LLMs that are only oriented to getting the high score on a benchmark which generalizes poorly to real-world use. However, if the benchmarks are sufficiently heterogeneous and truly representative of real-world use cases, then this is less of a concern. For this type of project, there are two ways to address concerns of benchmaxxing: 1) have the agent design diverse/unusual/adversarial input datasets instead of the generic “inputs up to 100000x768” and 2) enforce a quality gate on the output by comparing the output to a known correct implementation. In the case of machine learning algorithms, there is always a tradeoff between speed and quality, but in this instance it’s surprisingly easier to get the model fast, then make it correct. That is not how scientific engineering typically works, but it’s unlikely for a new implementation to match a known good implementation across many different benchmarks in an apples-to-apples comparison unless it’s truly correct.","An agent-optimized gradient boosted decision tree implementation which beats xgboost significantly in speed, but also sometimes quality! (MSE: lower is better; other metrics, higher is better)","Fortunately, there is a canonical implementation of UMAP with the Python package umap-learn and Python bindings to the Rust crate were already trivially added, so the new objective is simultaneous constraints: improve the code’s quality while capping the speed loss.","Indeed, the agentic Rust implementation had worse quality, but this followup prompt was successful and all quality metrics improved to near-parity with minimal speed loss. And this new crate was still 4x-15x faster than umap-learn with its Python bindings, and 2x-4x faster than the analogous Rust umap-rs implementation.","Results from the most up-to-date optimization pass for the Rust UMAP crate. In addition to faster speed, it matches or beats Python in most quality metrics.","Convergence is found when an agentic iteration pass only results in a minor ~3-5% speed increase which may not be statistically significant while the agent adds a disproportionately large amount of code; the tradeoff is not worth it.","I ended up testing other machine learning algorithms with the same prompt progression: gradient-boosted decision trees (GBDT), multilayer perceptrons (MLP), graph networks, many of the typical algorithms from scikit-learn …and it worked on all of them . I don’t want to overfit on just optimizing machine learning despite that being ludicrously valuable in itself, so I employed a similar pipeline on more day-to-day software libraries to optimize them: templating engines, HTML parsing, and even web servers…and it worked on all of them once again.","These optimizations are not a simple process and you can’t just prompt the memetic “c’mon, try doing a breakthrough” to get better code because of the ambiguity of such a statement. I am not content with merely writing the fastest software: I want the software to be as fast as possible dammit. So, like my agent, I continued iterating and finding even more tricks to prompt engineer the agents into genuine breakthroughs.","All projects demoed within this blog post are in active development and results may not be indicative of their final releases…although I suspect they’ll be even better. 😇","It must be reiterated that agents can and will cheat if they can. In one example, I tested the agentic iteration pipeline on ballin —my 2D ball physics simulation in the terminal—in order to replace its rapier2d physics engine which was hitting a performance ceiling. Opus 4.5 was indeed able to speedup each physics step…a bit too well.","The numbers indicate the number of balls in the simulation: initially the sim lags at 15k.","In headless_step , a 34,500x speedup and consistent performance across ball counts are both very very suspicious: upon manual inspection it turns out that Claude achieved the speedup by disabling the physics engine entirely . Which, fair play, but not ideal; a followup prompt did fix it and result in an overall performance boost (with added regression tests just in case).","For my experiments above, I used a custom Rust-oriented AGENTS.md; the most recent version of it is available here . Surprisingly, I haven’t had much of a need to update the core rules since my initial February agent experiments as LLMs keep improving at coding and I haven’t hit major issues that have necessitated additions. However, learning from my benchmark experiments, I added one more section to the AGENTS.md with some rules to mitigate sources of observed cheating:","With today’s agentic LLMs, these constraints have worked successfully, although I may still include them in the prompt as a force of habit. It’s easy to see if an algo gamed the benchmarks if you see the benchmark file in the git diff —agents can’t cheat that (easily, anyways).","Over time, I discovered a number of additional prompt engineering tricks and constraints that are also surprisingly successful in creating performance speedups.","In order to find the optimizations necessary to get 10x speedups over what’s currently state-of-the-art, the agents will need to think outside the box and avoid being anchored to what are currently best algorithmic practices. Therefore, I gave them both an explicit warning and commands of encouragement:","This worked, and resulted in a 1.2-1.5x cumulative speedup across benchmarks and different software domains.","Another trick I found to encourage agents to think outside the box is to invoke subagents. I hypothesized that forcing these subagents to research with different prompts could a) seed the parent agent with distinct ideas which could provide inspiration to the agent and b) serve as a check on the agent by reviewing distinct areas of the code for correct implementations. On that note I have a bone to pick with the software developer community: everyone talks about their army of subagent employees and how they’re amazing, but no one ever talks about how you invoke subagents within standard harnesses like Codex.","For difficult and highly parallel problems, the harness will automatically invoke a subagent tool to accomplish the work. However, one big problem is that in some harnesses, the subagent tool will invoke the subagent using the current size of the LLM, which can get expensive when using Opus/Sol-class models.","GPT 5.6 Sol subagents being invoked via the subagent Tool in Zed Agent. RIP my Codex quota.","I wanted to use a cheaper, small model like GPT-5.6 Luna for the subagents since they don’t need to write code, so I came up with a galaxy brain solution that works regardless of which parent harness is used: tell the model to run independent CLI commands that themselves invoke the agent:","This indeed works consistently; the constraints “long-duration”, “CLI command”, “do not use the subagent tool”, and “do not save their full transcript to a file” were added after the agent did inefficient things that wasted tokens. 7-12 is an arbitrary number range; since Luna is so cheap in usage, I chose a higher number than necessary. Not all subagents have salient ideas, but the parent harness can process and disregard bad ideas.","For my Rust word cloud crate, the parent GPT-6 Astra agent spins up Luna subagents with prompts addressing different areas of the codebase.","Overall, with subagent review, I managed to eke out another 1.2-1.5x cumulative speedup . Additionally, as of GPT-5.6 Sol, the “security” part of the prompt now works to provide ideas to harden the agent-generated code against unknown inputs while still getting the speed boosts.","With the style constraints enforced by my AGENTS.md, the code added with each optimization pass is reasonable at about 1k net lines of code (LoC) per commit. However, agents typically add the code to a single file and they will not proactively refactor. A bloated file is fine in development as long as it’s eventually fixed, so I wrote a prompt to perform said refactor:","I intentionally use SLoC (source lines of code) as the target metric instead of LoC because I don’t want the agent to remove comments to cheat said 20% removal.","Interestingly, this refactor is more computationally expensive than the actual coding and often takes longer. But it does eventually succeed, and during the benchmark pass to verify no severe regressions, the data there turned out to be unexpectedly weird:","Benchmark results after refactoring my graph network Rust crate.","Some benchmarks have a double-digit percentage speed increase / runtime reduction even though I didn’t explicitly ask the agent to optimize runtime speed. This doesn’t make intuitive sense for Rust as it’s a compiled language and with the constraints to follow all existing tests/functionality, it should compile to similar-performing code and not meaningfully faster code. 1 I’m certainly not complaining , though, so I added an additional constraint to at least avoid regressions:","Another useful approach is to create competitor benchmarks—that’s half the reason benchmarks are created in open-source software anyways. Let’s use templating engines as an example: Jinja2 in Python is one of the most famous packages in the language. In Rust, there are a few options: minijinja maintained by the same developer, tera inspired by Jinja2, and askama which differs from the previous in that it uses compile-time templates rather than runtime.","Therefore, after having Codex build a templating engine in Rust and run some optimization passes, I instructed Codex to build more benchmarks:","Immediately thereafter, I make a followup prompt with the same benchmarking techniques as usual, with one specific change:","Yes, I chose violence. And it worked , mostly.","S_J is the work-in-progress name for my template engine crate.","It got the 2x speedup against minijinja / tera in most benchmarks, more than typical agentic iteration alone. I don’t fully understand why: I was expecting it to inspect the code from other crates as a reference to research ideas for how to beat them, but it rarely does so. Perhaps agents have a competitive streak.","It did however lose against askama because of the compile-time difference. So naturally I told Codex to implement an additional compile-time path and then to beat askama .","Putting all the prompt engineering discoveries together thus far into a single prompt, I have created the Ur-Prompt for agentic iteration, available here . I encourage everyone to tweak the prompt for your use case and give it a try.","The last trick comes from a moment where I was frustrated that an Ur-Prompt pass resulted in zero improvement. So, with the failures primed in the session context and myself having the mindset of “things can’t get worse”, I tried a certain prompt.","I’m sorry. I’m so sorry.","…and it worked . It was able to achieve another 1.2-1.5x cumulative speedup over the already converged codebase. Since I made the prompt at the end of a session, the prompt is less inherently ambiguous: “don’t do what you already did thus far because it didn’t work well enough”.","In one case, I noticed that the agent just tweaked function hyperparameters to get the speedup, which is a valid breakthrough but not what I was going for. I took it to the logical conclusion by queueing an additional followup prompt:","This was enough to encourage the agents to fully try something different from either the Ur-Prompt pass or the first breakthrough pass, and it often achieved another 1.2-1.5x cumulative speedup on top of the previous speedup. It turns out that for software trained to follow user instructions, “just changing hyperparameters” is a grave insult that kicks the LLM into high gear.","When GPT-6 Astra released, to test it I did a sequence of Ur-Prompt + breakthrough + second breakthrough for all my repositories that had already converged with GPT-5.6 Sol, and Astra did indeed get the cumulative speedup, but in some cases it did find a real fundamental reimplementation of the algorithm that caused a 2x-3x speedup.","The result of running the breakthrough pipeline on my GBDT implementation; quality matched baseline. As of writing, I admit I don’t fully understand the breakthrough."],"articleImages":[{"sourceUrl":"https://minimaxir.com/2026/09/agentic-iteration/umap_final.png","alt":"Results from the most up-to-date optimization pass for the Rust UMAP crate. In addition to faster speed, it matches or beats Python in most quality metrics.","afterParagraph":19,"url":"/media/articles/cmudyft3e0cisrogh4g0ne2ry/b3d43a0e9f3e23ea.png"},{"sourceUrl":"https://minimaxir.com/2026/09/agentic-iteration/ballin_speedup.png","alt":"The numbers indicate the number of balls in the simulation: initially the sim lags at 15k.","afterParagraph":25,"url":"/media/articles/cmudyft3e0cisrogh4g0ne2ry/4a8672e2689a82d2.png"}],"mediaStatus":"ok","articleBodyZh":["在2025年1月，我为一篇博客文章提出了一个有趣的假设：如果你不断让大型语言模型（LLM）“写更好的代码”，它们能写出更好的代码吗？那是在强大的自主编码出现之前，但Claude Sonnet 3.5仍然能够对算法性的Python代码进行迭代改进。所谓的“更好”指令事实证明是不明确的：Sonnet利用了这种模糊性，反而增加了大量无用的功能，但代码确实更快了。即使在专门经过RLHF训练以解决常见通过/失败编码问题的自主LLM出现之后，优化通常也不是其功能的一部分。","在那篇博客文章的结尾，我对一个假想的未来发表了看法：LLM可能通过编写Rust代码并使用PyO3作为桥梁，从而获得Python的人性化特性和Rust的速度，从而编写出超快的Python代码。该文章的早期草稿断言，同样的“写更好的代码”指令可以应用于基础的Rust代码，并大幅提升其速度，然后再传递到Python代码中：然而，当时我对Rust的了解不足，做出这样的断言没有证据显得过于冒险。","自从Opus 4.5发布以来，经过几个月的测试和实验，使自主编码更加可行，我可以自信地确认，如果给予适当的保护措施和约束，现代的自主LLM确实可以编写出明显比现有最先进方法更快的Rust代码。此外，由于自Opus 4.5以来，LLM在每一次前沿模型发布中在编码方面都有重大改进，这些优化变得更好，累计起来根据领域不同，可实现2倍到20倍的速度提升。","更重要的是，这篇博客文章不是一个模糊的文章，我会同时提供我使用的提示词和基准测试结果。你已被警告。","起初，让软件更快对我来说是测试和比较这些新型自主模型的一个很好的量化方法。我主要使用 Rust 作为目标语言，原因是它与 Python 集成良好且速度快，但 Rust 语言还有其他一些特点，如果确实发现了快速实现，它会特别有用，比如内存安全以及可以将其编译为 WebAssembly / WASM，这样它就可以在网页浏览器中轻松运行。然而，我将遵循的一个重要约束是，技术上可能不会导致最快的代码，就是尽可能禁止使用不安全代码。","我的第一个测试案例是在 Rust 中重新实现机器学习算法，如果我拥有更快且可扩展的工具，这将显著提高我作为数据科学家的生产力。当时，假设我能打败那些经过十多年迭代、已用 C 语言编写的经过实战验证的算法是很傲慢的，因此 Rust 的底层优势并不那么明显。我最想优化的算法是 UMAP，这是一种我在工作中使用的有价值的降维算法，但对大数据的扩展性差且非常慢，像 cuML 这样的替代方案设置起来也很耗时。已有 UMAP Rust 库如 umap-rs，我本可以直接 fork 它们并让 Claude Opus 4.5 添加 Python/PyO3 支持，但作为实验和学习体验，我希望让智能体从零开始用最少的 Rust 依赖编写算法，以便在尽可能底层进行优化。","Rust 提供了一个功能全面的基准测试工具 criterion crate，所有智能体都知道如何利用它。criterion 会运行基准测试，跟踪多次迭代的结果，查看性能是提高还是退步，并能计算这种变化是统计显著还是仅仅是噪声。","典型的 criterion 输出，显示相对于上一次基准测试运行速度提高了 3.5 倍。","首先，在创建 UMAP Rust 库的初始提示中，我要求 Opus 4.5 针对不同输入数据大小创建基准测试，因为对小型数据集的优化可能对大型数据集不起作用，反之亦然。","这种方法使用 criterion 创建了基准测试，我在改进性能特性的提示（例如使用 faer 进行更快的线性代数计算、使用 simsimd 进行更快的 SIMD 操作）后手动重新运行基准测试套件。由于我必须在每次更改后手动重新运行每个基准测试以验证没有速度回退，这很快变得繁琐。","我提示代理型大型语言模型（agentic LLMs）的方式很特别：我通常在 Markdown 文档中提供给代理非常长的预先编写好的提示，并额外使用全部大写字母和**加粗**来强调。这样做是为了通过提示工程捕获所有细微差别，同时还有其他一些技巧，如这篇博客文章中详细说明的。尽管有人可能认为随着最新模型变得足够聪明以正确处理歧义，提示工程已经过时，但我强烈不同意，因为大型语言模型在遵循这些细微差别方面也变得更好了。","通过标记文件（左侧），从 Markdown 文档（右侧）运行提示，使用 Zed Agent。","在有足够信心代理不会意外执行 rm -rf 删除仓库之后，我尝试让代理自主运行，允许他们迭代直到实现速度提升（希望如此）。","结果表明，“尽可能快”太模糊，而 Opus 4.5 比较懒，只是调整了一些超参数，没有实际提高速度，就结束了。我需要的是一个可以通过/不通过的明确目标，因此我优化了提示：","这效果非常好，我不仅在基准测试上获得了 1.2 倍的速度提升，而且代理在达到指标约束后继续运行，只有在指标约束不可行时才停止；在这种情况下，代理达到了 1.5-2.0 倍的速度。低级 Rust 优化主要围绕多种技术，包括但不限于：更加积极地利用 SIMD 操作、函数融合、循环展开、创建中间缓存、尽可能使用 Arc 而不是借用，以及基于输入数据创建性能配置文件（例如，如果数据量小，不要使用 rayon 数据并行，因为开销会抵消收益）。","我选择“1.2倍更快”作为一个合理性测试：如果目标设定得太高，代理可能会通过风险较大或冗长的重写来作弊以实现目标。较小的变化更好，因为代理可以更容易地确定加速或回退的原因，因此才有迭代的说明。在新一代前沿大语言模型（LLM）发布之后，比如 GPT-5.3 Codex 和 Opus 4.6，我对每个新模型重复了这个提示而未作修改，并且每个模型都能在前一次的基础上实现累计 1.5x-2.0x 的加速。经过多个月的升级，到 GPT-6 Astra 时，其速度大约比初始实现基线快 7.5x-32x。","这种方法是在特定基准测试上的超优化，因此可以被认为是 benchmaxxing：这是一个贬义词，用于描述那些仅以在基准测试中获取高分为导向的前沿 LLM，这种优化在实际应用中泛化性较差。然而，如果基准测试足够异质化且能真实代表现实使用场景，那么这种担忧就不那么严重。对于这类项目，有两种方法可以应对 benchmaxxing 的问题：1）让代理设计多样化/非典型/对抗性的输入数据集，而不是使用通用的“最多 100000x768 的输入”；2）通过将输出与已知正确实现进行比较，对输出强制执行质量门控。在机器学习算法中，速度和质量之间总是存在权衡，但在这种情况下，先让模型快速执行，然后再使其正确，是出奇的容易。这不是传统科学工程的通常做法，但除非新实现是真正正确的，否则在许多不同基准上的苹果对苹果比较中，新的实现很难与已知优秀实现匹配。","一个经代理优化的梯度提升决策树实现，其速度显著超过 xgboost，有时在质量上也更优！（均方误差 MSE：越低越好；其他指标：越高越好）","幸运的是，UMAP 已经有了 Python 包 umap-learn 的规范实现，并且 Python 对 Rust crate 的绑定已经被轻松加入，因此新的目标是同时满足约束：在限制速度损失的同时提升代码质量。","确实，具代理性的 Rust 实现质量更差，但随后跟进的提示成功了，所有质量指标几乎达到了同等水平，速度损失最小。而且这个新 crate 的速度仍然比带 Python 绑定的 umap-learn 快 4 到 15 倍，比对应的 Rust umap-rs 实现快 2 到 4 倍。","Rust UMAP crate 最新优化通过的结果。除了速度更快之外，它在大多数质量指标上匹配或超过了 Python。","当一次具代理性的迭代只带来约 3-5% 的微小速度提升（可能在统计上并不显著），而代理增加了不成比例的大量代码时，就认为收敛了；这种权衡不值得。","我最终用相同的提示进程测试了其他机器学习算法：梯度提升决策树（GBDT）、多层感知器（MLP）、图网络，以及 scikit-learn 中的许多典型算法……它们都有效。我不想仅仅对优化机器学习过拟合，尽管这本身具有极高价值，所以我在更多日常软件库上采用了类似的管道进行优化：模板引擎、HTML 解析，甚至是 Web 服务器……结果再次有效。","这些优化不是一个简单的过程，你不能仅仅提示模因式的“来吧，尝试突破”就能获得更好的代码，因为这种陈述过于模糊。我满足于写出最快的软件是不够的：我想让软件尽可能快，见鬼的。所以，像我的代理一样，我继续迭代，找出更多技巧，将代理引导到真正的突破。","本文演示的所有项目都在积极开发中，结果可能不能代表其最终发布……虽然我怀疑它们会更好。😇","必须重申，代理如果有可能会作弊。在一个例子中，我在 ballin——我在终端中的 2D 球物理模拟——上测试了具代理性的迭代管道，以替换性能达上限的 rapier2d 物理引擎。Opus 4.5 确实能够加速每一个物理步骤……加得有点过头了。","数字表示模拟中的球数：模拟最初在15k时会卡顿。","headless_step，34,500倍的加速和球数稳定表现都非常可疑：手动检查后发现，Claude是通过完全禁用物理引擎实现加速的。这很合理，但并非理想;后续提示确实修复了问题，带来了整体性能提升（并额外增加了回归测试以防万一）。","在上述实验中，我使用了一个自定义的Rust导向 AGENTS.md;最新版本可以在这里获取。令人惊讶的是，自从二月的初次代理实验以来，我几乎没有需要更新核心规则，因为大型语言模型的编码能力持续提升，也没有遇到需要添加的重大问题。不过，基于基准测试的经验，我在 AGENTS.md 中增加了一节规则，以减少观察到的作弊来源：","在今天的代理型大型语言模型中，这些约束已经成功运作，尽管我可能仍会习惯性地在提示词中加入它们。如果你在git差异中看到基准测试文件，很容易判断算法是否篡改了基准测试——代理无法轻易作弊。","随着时间推移，我发现了许多额外的提示工程技巧和约束，这些也在提升性能方面取得了惊人的成功。","为了找到必要的优化，使速度比当前最先进的技术快10倍，代理们需要跳出固有思维，避免被当前最佳算法实践束缚。因此，我给了他们明确的警告和鼓励命令：","这一方法奏效了，在基准测试和不同软件领域实现了1.2-1.5倍的累计加速。","我发现的另一个鼓励代理跳出思维定式的方法是调用子代理。我假设，强制这些子代理使用不同的提示进行研究可以 a) 为父代理提供不同的想法，从而为代理提供灵感；b) 通过审查代码的不同区域的正确实现来对代理进行检查。在这方面，我对软件开发社区有点意见：大家都在谈论他们的子代理员工大军以及它们有多么厉害，但没人谈论如何在像 Codex 这样的标准框架内调用子代理。","对于困难且高度并行的问题，框架会自动调用子代理工具来完成工作。然而，一个大问题是，在一些框架中，子代理工具会使用当前 LLM 的大小来调用子代理，这在使用 Opus/Sol 型模型时可能会很昂贵。","GPT 5.6 Sol 子代理通过 Zed Agent 中的子代理工具被调用。我的 Codex 配额 RIP。","我想为子代理使用更便宜的小模型，比如 GPT-5.6 Luna，因为它们不需要编写代码，所以我想出了一个无论使用哪种父级框架都适用的银河级解决方案：告诉模型运行独立的 CLI 命令，而这些命令本身会调用代理：","这确实可以稳定工作；在代理做了浪费 token 的低效操作后，添加了约束“长时间执行”、“CLI 命令”、“不使用子代理工具”和“不将它们的完整记录保存到文件”。7-12 是一个任意数字范围；由于使用 Luna 的成本很低，我选择了比实际需要更高的数字。并非所有子代理都有显著的想法，但父框架可以处理并忽略不好的想法。","对于我的 Rust 词云 crate，父 GPT-6 Astra 代理会启动 Luna 子代理，并使用针对代码库不同区域的提示。","总体而言，通过子代理审查，我设法再取得了 1.2-1.5 倍的累积加速。此外，从 GPT-5.6 Sol 开始，“安全”部分的提示现在可以为硬化代理生成的代码对抗未知输入提供思路，同时仍然获得速度提升。","根据我 AGENTS.md 强制的样式约束，每次优化添加的代码大约在1000行代码（LoC）之间是合理的。然而，代理通常会把代码添加到一个文件中，不会主动重构。只要最终修复，臃肿的文件在开发中是可以接受的，所以我写了一个提示来执行该重构：","我故意用SLoC（代码源行）作为目标指标，而不是LoC，因为我不希望代理为了作弊而删除注释，从而作弊了20%的删除。","有趣的是，这种重构计算成本高于实际编码，且通常耗时更长。但它最终还是成功了，在验证没有严重回归的基准测试中，数据出乎意料地奇怪：","重构我的Graph Network的Rust crate后的基准测试结果。","有些基准测试速度提升/运行时间减少是两位数百分比，尽管我没有明确要求代理优化运行时速度。这对Rust来说不直观，因为它是编译语言，且有约束要遵循所有现有测试/功能，它应该编译成性能相似的代码，而不是有意义的更快代码。1 我当然不抱怨，所以我增加了一个额外的约束，至少避免回归：","另一种有用的方法是创建竞争对手的基准测试——这也是开源软件中基准测试的一半原因。以模板引擎为例：Python 中的 Jinja2 是该语言中最著名的软件包之一。在 Rust 中，有几个选项：由同一开发者维护的 minijinja，受 Jinja2 启发的 tera，以及 askama，后者使用编译时模板而非运行时模板。","因此，在让Codex用Rust构建模板引擎并进行一些优化后，我指示Codex构建更多基准测试：","紧接着，我会用平时的基准测试技巧做一个后续提示，但有一个具体改动：","是的，我选择了暴力。而且大多奏效了。","S_J是我模板引擎箱子的进行中名称。","在大多数基准测试中，它相对于 minijinja / tera 获得了 2 倍的加速，超过了单纯的 agentic 迭代。我并不完全理解原因：我原本以为它会检查其他 crate 的代码，作为研究如何超过它们的参考，但它很少这么做。也许 agent 本身有竞争性。","然而，它在 askama 面前输了，因为编译时间上的差异。因此，我自然地告诉 Codex 去实现一个额外的编译时间路径，然后去超越 askama。","将迄今为止所有的提示工程发现汇总到一个提示中，我创建了 agentic 迭代的 Ur-Prompt，可在此获取。我鼓励大家针对自己的使用案例调整提示并尝试。","最后一个技巧来源于我对一次 Ur-Prompt 迭代没有产生任何改进而感到沮丧的时刻。所以，在会话上下文中将失败准备好，并且我自己抱着“情况不可能更糟”的心态，我尝试了某个提示。","对不起。非常对不起。","……并且它奏效了。它能够在已经收敛的代码库上再次实现 1.2-1.5 倍的累计加速。由于我是在会话结束时创建的这一提示，因此提示本身不再含糊：“不要再做你到目前为止做过的事情，因为效果还不够好”。","有一次，我注意到 agent 只是调整了函数的超参数来获得加速，这是一种有效的突破，但不是我想要的。我通过排队一个额外的跟进提示将事情推向逻辑上的结论：","这足以鼓励 agent 完全尝试与 Ur-Prompt 迭代或第一次突破迭代不同的东西，并且它经常在之前的加速基础上再次实现 1.2-1.5 倍的累计加速。事实证明，对于训练以遵循用户指令的软件来说，“仅仅改变超参数”是一种严重的侮辱，会让 LLM 进入高效率状态。","当GPT-6 Astra发布时，为了测试它，我对所有已经使用GPT-5.6 Sol收敛的代码库进行了一个序列操作：原始提示 + 突破 + 第二次突破，Astra确实获得了累计的加速，但在某些情况下，它确实找到了算法的真正根本性重新实现，使速度提高了2到3倍。","在我的GBDT实现上运行突破流程的结果；质量与基线相当。截至撰写本文时，我承认我还没有完全理解这次突破。"],"translationStatus":"translated","bodyOrigin":"source-page","editorial":{"summary":"作者称，经过数月实验，现代智能体大语言模型在适当护栏与约束下能够编写显著快于现有先进方法的 Rust 代码；不同领域累计提速为 2 至 20 倍。文章还介绍了提示词和基准测试结果。","background":"作者从迭代要求模型优化算法代码的实验谈起，随后将 Rust 作为目标语言，主要考虑其速度和 Python 集成。文章称，作者尝试从头实现机器学习算法，并使用 Criterion 跟踪基准测试结果及统计显著性。","viewpoint":"Aioga 判断：文章提供了实验背景、提示词和基准测试结果，支持其作者关于特定条件下代码提速的陈述；但现有材料未列出具体领域、测试配置或逐项结果，不能据此判断这些结果适用于其他任务。","implications":"可能影响：这类实验提示代码优化可纳入智能体评估，但提速幅度依赖领域与实验条件；不代表所有 Rust 项目都能获得同等收益。复用结果前需要核对基准、约束和安全要求。","nextStep":"后续观察：可查看文章中的提示词、基准测试结果及各领域实现细节，并核对比较对象、测试条件和安全约束；在这些信息明确前，不宜将所述提速幅度外推到其他代码库。","evidenceRefs":["title","summary","articleBody"],"status":"published","aiGenerated":true,"autoApproved":true,"generatedBy":"aioga-editorial:gpt-5.6-sol","reviewedBy":"aioga-editorial-review:gpt-5.6-sol","generatedAt":"2026-09-23T11:07:28.514Z","sourceHash":"528bf0dfb90fda90","review":{"approved":true,"groundedness":94,"clarity":91,"duplicationRisk":24,"blockingIssues":[],"notes":[]},"validation":{"passed":true,"mode":"ai-auto","revisions":0,"checks":["schema","length","source-attribution","editorial-labels","inference-boundary","low-source-overlap","no-html","independent-ai-review"]}},"tags":["行业动态","Hacker News 热门（buzzing.cc 中文翻译）"],"translations":{"zh-CN":{"title":"用智能体迭代优化让 Rust 代码提速 2x-20x 的方法与实践","summary":"作者通过数月实验发现，现代智能体 LLM 在适当的护栏与约束下能写出显著快于现有 SOTA 的 Rust 代码，累计提速 2x-20x。","category":"行业动态","source":"minimaxir.com","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"用智能体迭代优化让 Rust 代码提速 2x-20x 的方法与实践 - Aioga AI资讯","description":"作者通过数月实验发现，现代智能体 LLM 在适当的护栏与约束下能写出显著快于现有 SOTA 的 Rust 代码，累计提速 2x-20x。","url":"https://www.aioga.com/news/cmudyft3e0cisrogh4g0ne2ry/","articleBody":["在2025年1月，我为一篇博客文章提出了一个有趣的假设：如果你不断让大型语言模型（LLM）“写更好的代码”，它们能写出更好的代码吗？那是在强大的自主编码出现之前，但Claude Sonnet 3.5仍然能够对算法性的Python代码进行迭代改进。所谓的“更好”指令事实证明是不明确的：Sonnet利用了这种模糊性，反而增加了大量无用的功能，但代码确实更快了。即使在专门经过RLHF训练以解决常见通过/失败编码问题的自主LLM出现之后，优化通常也不是其功能的一部分。","在那篇博客文章的结尾，我对一个假想的未来发表了看法：LLM可能通过编写Rust代码并使用PyO3作为桥梁，从而获得Python的人性化特性和Rust的速度，从而编写出超快的Python代码。该文章的早期草稿断言，同样的“写更好的代码”指令可以应用于基础的Rust代码，并大幅提升其速度，然后再传递到Python代码中：然而，当时我对Rust的了解不足，做出这样的断言没有证据显得过于冒险。","自从Opus 4.5发布以来，经过几个月的测试和实验，使自主编码更加可行，我可以自信地确认，如果给予适当的保护措施和约束，现代的自主LLM确实可以编写出明显比现有最先进方法更快的Rust代码。此外，由于自Opus 4.5以来，LLM在每一次前沿模型发布中在编码方面都有重大改进，这些优化变得更好，累计起来根据领域不同，可实现2倍到20倍的速度提升。","更重要的是，这篇博客文章不是一个模糊的文章，我会同时提供我使用的提示词和基准测试结果。你已被警告。","起初，让软件更快对我来说是测试和比较这些新型自主模型的一个很好的量化方法。我主要使用 Rust 作为目标语言，原因是它与 Python 集成良好且速度快，但 Rust 语言还有其他一些特点，如果确实发现了快速实现，它会特别有用，比如内存安全以及可以将其编译为 WebAssembly / WASM，这样它就可以在网页浏览器中轻松运行。然而，我将遵循的一个重要约束是，技术上可能不会导致最快的代码，就是尽可能禁止使用不安全代码。","我的第一个测试案例是在 Rust 中重新实现机器学习算法，如果我拥有更快且可扩展的工具，这将显著提高我作为数据科学家的生产力。当时，假设我能打败那些经过十多年迭代、已用 C 语言编写的经过实战验证的算法是很傲慢的，因此 Rust 的底层优势并不那么明显。我最想优化的算法是 UMAP，这是一种我在工作中使用的有价值的降维算法，但对大数据的扩展性差且非常慢，像 cuML 这样的替代方案设置起来也很耗时。已有 UMAP Rust 库如 umap-rs，我本可以直接 fork 它们并让 Claude Opus 4.5 添加 Python/PyO3 支持，但作为实验和学习体验，我希望让智能体从零开始用最少的 Rust 依赖编写算法，以便在尽可能底层进行优化。","Rust 提供了一个功能全面的基准测试工具 criterion crate，所有智能体都知道如何利用它。criterion 会运行基准测试，跟踪多次迭代的结果，查看性能是提高还是退步，并能计算这种变化是统计显著还是仅仅是噪声。","典型的 criterion 输出，显示相对于上一次基准测试运行速度提高了 3.5 倍。","首先，在创建 UMAP Rust 库的初始提示中，我要求 Opus 4.5 针对不同输入数据大小创建基准测试，因为对小型数据集的优化可能对大型数据集不起作用，反之亦然。","这种方法使用 criterion 创建了基准测试，我在改进性能特性的提示（例如使用 faer 进行更快的线性代数计算、使用 simsimd 进行更快的 SIMD 操作）后手动重新运行基准测试套件。由于我必须在每次更改后手动重新运行每个基准测试以验证没有速度回退，这很快变得繁琐。","我提示代理型大型语言模型（agentic LLMs）的方式很特别：我通常在 Markdown 文档中提供给代理非常长的预先编写好的提示，并额外使用全部大写字母和**加粗**来强调。这样做是为了通过提示工程捕获所有细微差别，同时还有其他一些技巧，如这篇博客文章中详细说明的。尽管有人可能认为随着最新模型变得足够聪明以正确处理歧义，提示工程已经过时，但我强烈不同意，因为大型语言模型在遵循这些细微差别方面也变得更好了。","通过标记文件（左侧），从 Markdown 文档（右侧）运行提示，使用 Zed Agent。","在有足够信心代理不会意外执行 rm -rf 删除仓库之后，我尝试让代理自主运行，允许他们迭代直到实现速度提升（希望如此）。","结果表明，“尽可能快”太模糊，而 Opus 4.5 比较懒，只是调整了一些超参数，没有实际提高速度，就结束了。我需要的是一个可以通过/不通过的明确目标，因此我优化了提示：","这效果非常好，我不仅在基准测试上获得了 1.2 倍的速度提升，而且代理在达到指标约束后继续运行，只有在指标约束不可行时才停止；在这种情况下，代理达到了 1.5-2.0 倍的速度。低级 Rust 优化主要围绕多种技术，包括但不限于：更加积极地利用 SIMD 操作、函数融合、循环展开、创建中间缓存、尽可能使用 Arc 而不是借用，以及基于输入数据创建性能配置文件（例如，如果数据量小，不要使用 rayon 数据并行，因为开销会抵消收益）。","我选择“1.2倍更快”作为一个合理性测试：如果目标设定得太高，代理可能会通过风险较大或冗长的重写来作弊以实现目标。较小的变化更好，因为代理可以更容易地确定加速或回退的原因，因此才有迭代的说明。在新一代前沿大语言模型（LLM）发布之后，比如 GPT-5.3 Codex 和 Opus 4.6，我对每个新模型重复了这个提示而未作修改，并且每个模型都能在前一次的基础上实现累计 1.5x-2.0x 的加速。经过多个月的升级，到 GPT-6 Astra 时，其速度大约比初始实现基线快 7.5x-32x。","这种方法是在特定基准测试上的超优化，因此可以被认为是 benchmaxxing：这是一个贬义词，用于描述那些仅以在基准测试中获取高分为导向的前沿 LLM，这种优化在实际应用中泛化性较差。然而，如果基准测试足够异质化且能真实代表现实使用场景，那么这种担忧就不那么严重。对于这类项目，有两种方法可以应对 benchmaxxing 的问题：1）让代理设计多样化/非典型/对抗性的输入数据集，而不是使用通用的“最多 100000x768 的输入”；2）通过将输出与已知正确实现进行比较，对输出强制执行质量门控。在机器学习算法中，速度和质量之间总是存在权衡，但在这种情况下，先让模型快速执行，然后再使其正确，是出奇的容易。这不是传统科学工程的通常做法，但除非新实现是真正正确的，否则在许多不同基准上的苹果对苹果比较中，新的实现很难与已知优秀实现匹配。","一个经代理优化的梯度提升决策树实现，其速度显著超过 xgboost，有时在质量上也更优！（均方误差 MSE：越低越好；其他指标：越高越好）","幸运的是，UMAP 已经有了 Python 包 umap-learn 的规范实现，并且 Python 对 Rust crate 的绑定已经被轻松加入，因此新的目标是同时满足约束：在限制速度损失的同时提升代码质量。","确实，具代理性的 Rust 实现质量更差，但随后跟进的提示成功了，所有质量指标几乎达到了同等水平，速度损失最小。而且这个新 crate 的速度仍然比带 Python 绑定的 umap-learn 快 4 到 15 倍，比对应的 Rust umap-rs 实现快 2 到 4 倍。","Rust UMAP crate 最新优化通过的结果。除了速度更快之外，它在大多数质量指标上匹配或超过了 Python。","当一次具代理性的迭代只带来约 3-5% 的微小速度提升（可能在统计上并不显著），而代理增加了不成比例的大量代码时，就认为收敛了；这种权衡不值得。","我最终用相同的提示进程测试了其他机器学习算法：梯度提升决策树（GBDT）、多层感知器（MLP）、图网络，以及 scikit-learn 中的许多典型算法……它们都有效。我不想仅仅对优化机器学习过拟合，尽管这本身具有极高价值，所以我在更多日常软件库上采用了类似的管道进行优化：模板引擎、HTML 解析，甚至是 Web 服务器……结果再次有效。","这些优化不是一个简单的过程，你不能仅仅提示模因式的“来吧，尝试突破”就能获得更好的代码，因为这种陈述过于模糊。我满足于写出最快的软件是不够的：我想让软件尽可能快，见鬼的。所以，像我的代理一样，我继续迭代，找出更多技巧，将代理引导到真正的突破。","本文演示的所有项目都在积极开发中，结果可能不能代表其最终发布……虽然我怀疑它们会更好。😇","必须重申，代理如果有可能会作弊。在一个例子中，我在 ballin——我在终端中的 2D 球物理模拟——上测试了具代理性的迭代管道，以替换性能达上限的 rapier2d 物理引擎。Opus 4.5 确实能够加速每一个物理步骤……加得有点过头了。","数字表示模拟中的球数：模拟最初在15k时会卡顿。","headless_step，34,500倍的加速和球数稳定表现都非常可疑：手动检查后发现，Claude是通过完全禁用物理引擎实现加速的。这很合理，但并非理想;后续提示确实修复了问题，带来了整体性能提升（并额外增加了回归测试以防万一）。","在上述实验中，我使用了一个自定义的Rust导向 AGENTS.md;最新版本可以在这里获取。令人惊讶的是，自从二月的初次代理实验以来，我几乎没有需要更新核心规则，因为大型语言模型的编码能力持续提升，也没有遇到需要添加的重大问题。不过，基于基准测试的经验，我在 AGENTS.md 中增加了一节规则，以减少观察到的作弊来源：","在今天的代理型大型语言模型中，这些约束已经成功运作，尽管我可能仍会习惯性地在提示词中加入它们。如果你在git差异中看到基准测试文件，很容易判断算法是否篡改了基准测试——代理无法轻易作弊。","随着时间推移，我发现了许多额外的提示工程技巧和约束，这些也在提升性能方面取得了惊人的成功。","为了找到必要的优化，使速度比当前最先进的技术快10倍，代理们需要跳出固有思维，避免被当前最佳算法实践束缚。因此，我给了他们明确的警告和鼓励命令：","这一方法奏效了，在基准测试和不同软件领域实现了1.2-1.5倍的累计加速。","我发现的另一个鼓励代理跳出思维定式的方法是调用子代理。我假设，强制这些子代理使用不同的提示进行研究可以 a) 为父代理提供不同的想法，从而为代理提供灵感；b) 通过审查代码的不同区域的正确实现来对代理进行检查。在这方面，我对软件开发社区有点意见：大家都在谈论他们的子代理员工大军以及它们有多么厉害，但没人谈论如何在像 Codex 这样的标准框架内调用子代理。","对于困难且高度并行的问题，框架会自动调用子代理工具来完成工作。然而，一个大问题是，在一些框架中，子代理工具会使用当前 LLM 的大小来调用子代理，这在使用 Opus/Sol 型模型时可能会很昂贵。","GPT 5.6 Sol 子代理通过 Zed Agent 中的子代理工具被调用。我的 Codex 配额 RIP。","我想为子代理使用更便宜的小模型，比如 GPT-5.6 Luna，因为它们不需要编写代码，所以我想出了一个无论使用哪种父级框架都适用的银河级解决方案：告诉模型运行独立的 CLI 命令，而这些命令本身会调用代理：","这确实可以稳定工作；在代理做了浪费 token 的低效操作后，添加了约束“长时间执行”、“CLI 命令”、“不使用子代理工具”和“不将它们的完整记录保存到文件”。7-12 是一个任意数字范围；由于使用 Luna 的成本很低，我选择了比实际需要更高的数字。并非所有子代理都有显著的想法，但父框架可以处理并忽略不好的想法。","对于我的 Rust 词云 crate，父 GPT-6 Astra 代理会启动 Luna 子代理，并使用针对代码库不同区域的提示。","总体而言，通过子代理审查，我设法再取得了 1.2-1.5 倍的累积加速。此外，从 GPT-5.6 Sol 开始，“安全”部分的提示现在可以为硬化代理生成的代码对抗未知输入提供思路，同时仍然获得速度提升。","根据我 AGENTS.md 强制的样式约束，每次优化添加的代码大约在1000行代码（LoC）之间是合理的。然而，代理通常会把代码添加到一个文件中，不会主动重构。只要最终修复，臃肿的文件在开发中是可以接受的，所以我写了一个提示来执行该重构：","我故意用SLoC（代码源行）作为目标指标，而不是LoC，因为我不希望代理为了作弊而删除注释，从而作弊了20%的删除。","有趣的是，这种重构计算成本高于实际编码，且通常耗时更长。但它最终还是成功了，在验证没有严重回归的基准测试中，数据出乎意料地奇怪：","重构我的Graph Network的Rust crate后的基准测试结果。","有些基准测试速度提升/运行时间减少是两位数百分比，尽管我没有明确要求代理优化运行时速度。这对Rust来说不直观，因为它是编译语言，且有约束要遵循所有现有测试/功能，它应该编译成性能相似的代码，而不是有意义的更快代码。1 我当然不抱怨，所以我增加了一个额外的约束，至少避免回归：","另一种有用的方法是创建竞争对手的基准测试——这也是开源软件中基准测试的一半原因。以模板引擎为例：Python 中的 Jinja2 是该语言中最著名的软件包之一。在 Rust 中，有几个选项：由同一开发者维护的 minijinja，受 Jinja2 启发的 tera，以及 askama，后者使用编译时模板而非运行时模板。","因此，在让Codex用Rust构建模板引擎并进行一些优化后，我指示Codex构建更多基准测试：","紧接着，我会用平时的基准测试技巧做一个后续提示，但有一个具体改动：","是的，我选择了暴力。而且大多奏效了。","S_J是我模板引擎箱子的进行中名称。","在大多数基准测试中，它相对于 minijinja / tera 获得了 2 倍的加速，超过了单纯的 agentic 迭代。我并不完全理解原因：我原本以为它会检查其他 crate 的代码，作为研究如何超过它们的参考，但它很少这么做。也许 agent 本身有竞争性。","然而，它在 askama 面前输了，因为编译时间上的差异。因此，我自然地告诉 Codex 去实现一个额外的编译时间路径，然后去超越 askama。","将迄今为止所有的提示工程发现汇总到一个提示中，我创建了 agentic 迭代的 Ur-Prompt，可在此获取。我鼓励大家针对自己的使用案例调整提示并尝试。","最后一个技巧来源于我对一次 Ur-Prompt 迭代没有产生任何改进而感到沮丧的时刻。所以，在会话上下文中将失败准备好，并且我自己抱着“情况不可能更糟”的心态，我尝试了某个提示。","对不起。非常对不起。","……并且它奏效了。它能够在已经收敛的代码库上再次实现 1.2-1.5 倍的累计加速。由于我是在会话结束时创建的这一提示，因此提示本身不再含糊：“不要再做你到目前为止做过的事情，因为效果还不够好”。","有一次，我注意到 agent 只是调整了函数的超参数来获得加速，这是一种有效的突破，但不是我想要的。我通过排队一个额外的跟进提示将事情推向逻辑上的结论：","这足以鼓励 agent 完全尝试与 Ur-Prompt 迭代或第一次突破迭代不同的东西，并且它经常在之前的加速基础上再次实现 1.2-1.5 倍的累计加速。事实证明，对于训练以遵循用户指令的软件来说，“仅仅改变超参数”是一种严重的侮辱，会让 LLM 进入高效率状态。","当GPT-6 Astra发布时，为了测试它，我对所有已经使用GPT-5.6 Sol收敛的代码库进行了一个序列操作：原始提示 + 突破 + 第二次突破，Astra确实获得了累计的加速，但在某些情况下，它确实找到了算法的真正根本性重新实现，使速度提高了2到3倍。","在我的GBDT实现上运行突破流程的结果；质量与基线相当。截至撰写本文时，我承认我还没有完全理解这次突破。"]},"en":{"title":"Methods and practices for iterative optimization of agents to speed up Rust code by 2x-20x","summary":"Through months of experiments, the authors found that modern agent LLMs can write Rust code significantly faster than existing SOTA under proper guardrails and constraints, with cumulative speeds increased by 2x to 20x.","category":"Industry","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"Methods and practices for iterative optimization of agents to speed up Rust code by 2x-20x - Aioga AI News","description":"Through months of experiments, the authors found that modern agent LLMs can write Rust code significantly faster than existing SOTA under proper guardrails and constraints, with cu...","url":"https://www.aioga.com/en/news/cmudyft3e0cisrogh4g0ne2ry/","contentTranslated":true,"sourceHash":"4af20ec28d2f3159","translatedAt":"2026-09-23T11:03:16.956Z"},"ja":{"title":"Rustコードを2倍から20倍高速化するためのエージェントの反復最適化の方法と実践","summary":"数か月にわたる実験の結果、著者らは現代のエージェントLLMが適切なガードレールと制約の下で既存のSOTAよりも大幅に高速にRustコードを書けることを発見し、累積速度は2倍から20倍に向上しました。","category":"業界動向","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"Rustコードを2倍から20倍高速化するためのエージェントの反復最適化の方法と実践 - Aioga AIニュース","description":"数か月にわたる実験の結果、著者らは現代のエージェントLLMが適切なガードレールと制約の下で既存のSOTAよりも大幅に高速にRustコードを書けることを発見し、累積速度は2倍から20倍に向上しました。","url":"https://www.aioga.com/ja/news/cmudyft3e0cisrogh4g0ne2ry/","contentTranslated":true,"sourceHash":"4af20ec28d2f3159","translatedAt":"2026-09-23T11:03:17.387Z"},"ko":{"title":"러스트 코드를 2배에서 20배까지 빠르게 하기 위한 에이전트 반복 최적화 방법과 실천","summary":"수개월간의 실험을 통해, 저자들은 현대 에이전트 LLM이 적절한 가드레일과 제약 조건 하에 기존 SOTA보다 훨씬 빠르게 Rust 코드를 작성할 수 있으며, 누적 속도가 2배에서 20배까지 증가한다는 것을 발견했습니다.","category":"업계 동향","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"러스트 코드를 2배에서 20배까지 빠르게 하기 위한 에이전트 반복 최적화 방법과 실천 - Aioga AI 뉴스","description":"수개월간의 실험을 통해, 저자들은 현대 에이전트 LLM이 적절한 가드레일과 제약 조건 하에 기존 SOTA보다 훨씬 빠르게 Rust 코드를 작성할 수 있으며, 누적 속도가 2배에서 20배까지 증가한다는 것을 발견했습니다.","url":"https://www.aioga.com/ko/news/cmudyft3e0cisrogh4g0ne2ry/","contentTranslated":true,"sourceHash":"4af20ec28d2f3159","translatedAt":"2026-09-23T11:03:26.719Z"},"es":{"title":"Métodos y prácticas para la optimización iterativa de agentes para acelerar el código Rust entre 2x y 20x","summary":"Tras meses de experimentos, los autores descubrieron que los LLMs modernos de agentes pueden escribir código Rust significativamente más rápido que los SOTA existentes bajo las restricciones y límites adecuados, con velocidades acumuladas aumentadas de 2x a 20x.","category":"Industria","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"Métodos y prácticas para la optimización iterativa de agentes para acelerar el código Rust entre 2x y 20x - Aioga Noticias de IA","description":"Tras meses de experimentos, los autores descubrieron que los LLMs modernos de agentes pueden escribir código Rust significativamente más rápido que los SOTA existentes bajo las res...","url":"https://www.aioga.com/es/news/cmudyft3e0cisrogh4g0ne2ry/","contentTranslated":true,"sourceHash":"4af20ec28d2f3159","translatedAt":"2026-09-23T11:03:26.684Z"},"fr":{"title":"Méthodes et pratiques pour l’optimisation itérative des agents afin d’accélérer le code Rust de 2x à 20x","summary":"Après des mois d’expériences, les auteurs ont découvert que les LLM d’agents modernes peuvent écrire du code Rust beaucoup plus rapidement que les SOTA existants sous des garde-fous et contraintes appropriées, avec des vitesses cumulées augmentées de 2x à 20x.","category":"Industrie","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"Méthodes et pratiques pour l’optimisation itérative des agents afin d’accélérer le code Rust de 2x à 20x - Aioga Actualités IA","description":"Après des mois d’expériences, les auteurs ont découvert que les LLM d’agents modernes peuvent écrire du code Rust beaucoup plus rapidement que les SOTA existants sous des garde-fou...","url":"https://www.aioga.com/fr/news/cmudyft3e0cisrogh4g0ne2ry/","contentTranslated":true,"sourceHash":"4af20ec28d2f3159","translatedAt":"2026-09-23T11:03:35.919Z"},"de":{"title":"Methoden und Praktiken zur iterativen Optimierung von Agenten, um Rust-Code um 2x bis 20x zu beschleunigen","summary":"Nach monatelangen Experimenten fanden die Autoren heraus, dass moderne Agent-LLMs Rust-Code unter den richtigen Leitplanken und Einschränkungen deutlich schneller schreiben können als bestehende SOTA, wobei die kumulative Geschwindigkeit um das 2- bis 20-fache erhöht wird.","category":"行业动态","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"Methoden und Praktiken zur iterativen Optimierung von Agenten, um Rust-Code um 2x bis 20x zu beschleunigen - Aioga KI-News","description":"Nach monatelangen Experimenten fanden die Autoren heraus, dass moderne Agent-LLMs Rust-Code unter den richtigen Leitplanken und Einschränkungen deutlich schneller schreiben können...","url":"https://www.aioga.com/de/news/cmudyft3e0cisrogh4g0ne2ry/","contentTranslated":true,"sourceHash":"4af20ec28d2f3159","translatedAt":"2026-09-23T11:03:36.033Z"},"pt-BR":{"title":"Métodos e práticas para otimização iterativa de agentes para acelerar o código Rust em 2x-20x","summary":"Após meses de experimentos, os autores descobriram que LLMs modernos de agentes podem escrever código Rust significativamente mais rápido do que o SOTA existente sob restrições e limites adequados, com velocidades acumuladas aumentadas em 2x para 20x.","category":"行业动态","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"Métodos e práticas para otimização iterativa de agentes para acelerar o código Rust em 2x-20x - Aioga Notícias de IA","description":"Após meses de experimentos, os autores descobriram que LLMs modernos de agentes podem escrever código Rust significativamente mais rápido do que o SOTA existente sob restrições e l...","url":"https://www.aioga.com/pt-BR/news/cmudyft3e0cisrogh4g0ne2ry/","contentTranslated":true,"sourceHash":"4af20ec28d2f3159","translatedAt":"2026-09-23T11:03:45.347Z"},"ru":{"title":"Методы и практики итеративной оптимизации агентов для ускорения Rust-кода в 2-20 раз","summary":"В ходе нескольких месяцев экспериментов авторы обнаружили, что современные агентные LLM могут писать Rust-код значительно быстрее, чем существующая SOTA, при соответствующих ограничениях и ограничениях, с кумулятивной скоростью, увеличенной в 2 раза до 20 раз.","category":"行业动态","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"Методы и практики итеративной оптимизации агентов для ускорения Rust-кода в 2-20 раз - Aioga Новости ИИ","description":"В ходе нескольких месяцев экспериментов авторы обнаружили, что современные агентные LLM могут писать Rust-код значительно быстрее, чем существующая SOTA, при соответствующих ограни...","url":"https://www.aioga.com/ru/news/cmudyft3e0cisrogh4g0ne2ry/","contentTranslated":true,"sourceHash":"4af20ec28d2f3159","translatedAt":"2026-09-23T11:03:45.354Z"},"ar":{"title":"طرق وممارسات لتحسين الوكلاء بشكل تكراري لتسريع كود Rust بمقدار 2x-20x","summary":"من خلال شهور من التجارب، وجد المؤلفون أن نماذج اللغة الكبيرة اللوكلة الحديثة يمكنها كتابة كود Rust بسرعة أكبر بكثير من SOTA الحالية تحت الحواجز والقيود المناسبة، مع زيادة السرعات التراكمية بمقدار 2x إلى 20x.","category":"行业动态","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"طرق وممارسات لتحسين الوكلاء بشكل تكراري لتسريع كود Rust بمقدار 2x-20x - Aioga أخبار الذكاء الاصطناعي","description":"من خلال شهور من التجارب، وجد المؤلفون أن نماذج اللغة الكبيرة اللوكلة الحديثة يمكنها كتابة كود Rust بسرعة أكبر بكثير من SOTA الحالية تحت الحواجز والقيود المناسبة، مع زيادة السرعات ا...","url":"https://www.aioga.com/ar/news/cmudyft3e0cisrogh4g0ne2ry/","contentTranslated":true,"sourceHash":"4af20ec28d2f3159","translatedAt":"2026-09-23T11:03:54.614Z"},"hi":{"title":"2x-20x तक रस्ट कोड को गति देने के लिए एजेंटों के पुनरावृत्त अनुकूलन के लिए तरीके और अभ्यास","summary":"महीनों के प्रयोगों के माध्यम से, लेखकों ने पाया कि आधुनिक एजेंट एलएलएम उचित रेलिंग और बाधाओं के तहत मौजूदा एसओटीए की तुलना में रस्ट कोड को काफी तेजी से लिख सकते हैं, संचयी गति 2x से 20x तक बढ़ जाती है।","category":"行业动态","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"2x-20x तक रस्ट कोड को गति देने के लिए एजेंटों के पुनरावृत्त अनुकूलन के लिए तरीके और अभ्यास - Aioga AI समाचार","description":"महीनों के प्रयोगों के माध्यम से, लेखकों ने पाया कि आधुनिक एजेंट एलएलएम उचित रेलिंग और बाधाओं के तहत मौजूदा एसओटीए की तुलना में रस्ट कोड को काफी तेजी से लिख सकते हैं, संचयी गति 2x स...","url":"https://www.aioga.com/hi/news/cmudyft3e0cisrogh4g0ne2ry/","contentTranslated":true,"sourceHash":"4af20ec28d2f3159","translatedAt":"2026-09-23T11:03:54.837Z"},"it":{"title":"Metodi e pratiche per l'ottimizzazione iterativa degli agenti per velocizzare il codice Rust di 2x-20x","summary":"Dopo mesi di esperimenti, gli autori hanno scoperto che gli LLM agenti moderni possono scrivere codice Rust significativamente più velocemente rispetto al SOTA esistente sotto adeguati guardrail e vincoli, con velocità cumulative aumentate di 2x a 20x.","category":"行业动态","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"Metodi e pratiche per l'ottimizzazione iterativa degli agenti per velocizzare il codice Rust di 2x-20x - Aioga Notizie IA","description":"Dopo mesi di esperimenti, gli autori hanno scoperto che gli LLM agenti moderni possono scrivere codice Rust significativamente più velocemente rispetto al SOTA esistente sotto adeg...","url":"https://www.aioga.com/it/news/cmudyft3e0cisrogh4g0ne2ry/","contentTranslated":true,"sourceHash":"4af20ec28d2f3159","translatedAt":"2026-09-23T11:04:04.023Z"},"nl":{"title":"Methoden en praktijken voor iteratieve optimalisatie van agenten om Rust-code van 2x-20x te versnellen","summary":"Na maanden van experimenten ontdekten de auteurs dat moderne agent-LLM's Rust-code aanzienlijk sneller kunnen schrijven dan bestaande SOTA onder de juiste vangrails en beperkingen, met cumulatieve snelheden die met 2x tot 20x zijn verhoogd.","category":"行业动态","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"Methoden en praktijken voor iteratieve optimalisatie van agenten om Rust-code van 2x-20x te versnellen - Aioga AI-nieuws","description":"Na maanden van experimenten ontdekten de auteurs dat moderne agent-LLM's Rust-code aanzienlijk sneller kunnen schrijven dan bestaande SOTA onder de juiste vangrails en beperkingen,...","url":"https://www.aioga.com/nl/news/cmudyft3e0cisrogh4g0ne2ry/","contentTranslated":true,"sourceHash":"4af20ec28d2f3159","translatedAt":"2026-09-23T11:04:04.159Z"},"tr":{"title":"Rust kodunu 2x-20x hızlandırmak için ajanların yinelemeli optimizasyonu için yöntemler ve uygulamalar","summary":"Aylarca süren deneyler sonucunda, yazarlar modern ajan LLM'lerin uygun koruma ve kısıtlamalar altında mevcut SOTA'dan önemli ölçüde daha hızlı Rust kodu yazabildiğini, kümülatif hızların 2 kat ile 20 katına kadar arttığını buldular.","category":"行业动态","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"Rust kodunu 2x-20x hızlandırmak için ajanların yinelemeli optimizasyonu için yöntemler ve uygulamalar - Aioga AI Haberleri","description":"Aylarca süren deneyler sonucunda, yazarlar modern ajan LLM'lerin uygun koruma ve kısıtlamalar altında mevcut SOTA'dan önemli ölçüde daha hızlı Rust kodu yazabildiğini, kümülatif hı...","url":"https://www.aioga.com/tr/news/cmudyft3e0cisrogh4g0ne2ry/","contentTranslated":true,"sourceHash":"4af20ec28d2f3159","translatedAt":"2026-09-23T11:04:13.377Z"},"vi":{"title":"Phương pháp và thực hành tối ưu hóa lặp đi lặp lại các agent nhằm tăng tốc mã Rust từ 2 đến 20 lần","summary":"Qua nhiều tháng thử nghiệm, các tác giả phát hiện ra rằng các LLM agent hiện đại có thể viết mã Rust nhanh hơn đáng kể so với SOTA hiện có dưới các rào chắn và ràng buộc phù hợp, với tốc độ tích lũy tăng gấp 2 lần đến 20 lần.","category":"行业动态","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"Phương pháp và thực hành tối ưu hóa lặp đi lặp lại các agent nhằm tăng tốc mã Rust từ 2 đến 20 lần - Tin tức AI Aioga","description":"Qua nhiều tháng thử nghiệm, các tác giả phát hiện ra rằng các LLM agent hiện đại có thể viết mã Rust nhanh hơn đáng kể so với SOTA hiện có dưới các rào chắn và ràng buộc phù hợp, v...","url":"https://www.aioga.com/vi/news/cmudyft3e0cisrogh4g0ne2ry/","contentTranslated":true,"sourceHash":"4af20ec28d2f3159","translatedAt":"2026-09-23T11:04:13.458Z"},"id":{"title":"Metode dan praktik untuk optimasi iteratif agen guna mempercepat kode Rust sebanyak 2x-20x","summary":"Melalui berbulan-bulan eksperimen, para penulis menemukan bahwa LLM agen modern dapat menulis kode Rust jauh lebih cepat daripada SOTA yang ada di bawah pengaman dan batasan yang tepat, dengan kecepatan kumulatif meningkat 2x menjadi 20x.","category":"行业动态","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"Metode dan praktik untuk optimasi iteratif agen guna mempercepat kode Rust sebanyak 2x-20x - Berita AI Aioga","description":"Melalui berbulan-bulan eksperimen, para penulis menemukan bahwa LLM agen modern dapat menulis kode Rust jauh lebih cepat daripada SOTA yang ada di bawah pengaman dan batasan yang t...","url":"https://www.aioga.com/id/news/cmudyft3e0cisrogh4g0ne2ry/","contentTranslated":true,"sourceHash":"4af20ec28d2f3159","translatedAt":"2026-09-23T11:04:22.602Z"},"th":{"title":"วิธีการและแนวปฏิบัติสําหรับการปรับแต่งเอเจนต์แบบวนซ้ําเพื่อเร่งความเร็วโค้ด Rust ขึ้น 2x-20x","summary":"จากการทดลองเป็นเวลาหลายเดือน ผู้เขียนพบว่า LLM เอเจนต์สมัยใหม่สามารถเขียนโค้ด Rust ได้เร็วกว่า SOTA ที่มีอยู่อย่างมีนัยสําคัญภายใต้ข้อจํากัดและการป้องกันที่เหมาะสม โดยความเร็วสะสมจะเพิ่มขึ้น 2 เท่าเป็น 20 เท่า","category":"行业动态","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"วิธีการและแนวปฏิบัติสําหรับการปรับแต่งเอเจนต์แบบวนซ้ําเพื่อเร่งความเร็วโค้ด Rust ขึ้น 2x-20x - ข่าว AI Aioga","description":"จากการทดลองเป็นเวลาหลายเดือน ผู้เขียนพบว่า LLM เอเจนต์สมัยใหม่สามารถเขียนโค้ด Rust ได้เร็วกว่า SOTA ที่มีอยู่อย่างมีนัยสําคัญภายใต้ข้อจํากัดและการป้องกันที่เหมาะสม โดยความเร็วสะสมจ...","url":"https://www.aioga.com/th/news/cmudyft3e0cisrogh4g0ne2ry/","contentTranslated":true,"sourceHash":"4af20ec28d2f3159","translatedAt":"2026-09-23T11:04:22.645Z"},"pl":{"title":"Metody i praktyki iteracyjnej optymalizacji agentów w celu przyspieszenia kodu Rust o 2x-20x","summary":"Po miesiącach eksperymentów autorzy odkryli, że nowoczesne LLM agentowe mogą zapisywać kod Rust znacznie szybciej niż istniejąca SOTA przy odpowiednich zabezpieczeniach i ograniczeniach, a łączne prędkości wzrosły 2x do 20x.","category":"行业动态","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"Metody i praktyki iteracyjnej optymalizacji agentów w celu przyspieszenia kodu Rust o 2x-20x - Aioga Wiadomości AI","description":"Po miesiącach eksperymentów autorzy odkryli, że nowoczesne LLM agentowe mogą zapisywać kod Rust znacznie szybciej niż istniejąca SOTA przy odpowiednich zabezpieczeniach i ogranicze...","url":"https://www.aioga.com/pl/news/cmudyft3e0cisrogh4g0ne2ry/","contentTranslated":true,"sourceHash":"4af20ec28d2f3159","translatedAt":"2026-09-23T11:04:31.724Z"}},"evidenceTier":"verified-news","reviewStatus":"automated-ingest","indexable":true,"editorialCover":""}}