Rust's LLM policy

The Rust project has published an LLM policy.

The gist is:

It’s fine to use LLMs to answer questions, analyze, distill, refine, check, suggest, review. But not to create.

Using LLMs for assistance is fine, but any non-trivial contributions (code, comments, documentation, review etc.) are expected to originate from a human.

Read the full policy at: LLM usage policy - Rust Forge

I really like this approach. It enables the use of LLMs but protects everyone else (especially reviewers) from the burdens associated with that (such as having to parse excessive LLM-written text).

When I contribute to the Crystal language, I usually use LLMs to write the first draft of my pull requests. For this reason, I do not want a complete ban on LLM-generated code.


In the past one or two weeks, several very powerful AI models from China have been released. Kimi K3 and Qwen3.8-Max are two examples. At the same time, mid-level models with surprisingly low prices have also appeared. DeepSeek V4 Flash 0731 is one of them.

I tested these models myself. I used OpenRouter together with GitHub Codespaces, and I also used Perplexity. In my tests, Kimi K3 was still not as capable as ChatGPT or Codex, and it had no clear advantage in cost. However, Kimi was willing to help with computational biology research. Claude is known for limiting its capabilities in this area. I think this difference is worth noting.

The model that impressed me most was Xiaomi’s MiMo. Its price is surprisingly low, and it can keep working on a task for a long time. The model itself is not very powerful. Even so, the final output was better than I expected.

Until now, most discussions about AI-generated code have assumed a choice among three services: Claude, Codex, or Gemini. That assumption is now starting to change. I am watching to see how this change will affect the debate about AI and open source, or whether it will affect it at all.

(Translated from Japanese by Kimi K3)

@kojix2 I believe the most important thing here is to understand what you are doing.

I see it in this way:

  • you can use AI to help you to understand the issue and to propose a solution to you (see, to you)
  • then, when you finally understand the scenario, it is your responsibility to create the final solution (code, comments, PR), since fully understanding it is the minimum

If you write the PR yourself and use AI to translate it, sure, no problem.

But when someone doesn’t understand the problem enough and leave the responsibility to AI to handle the final proposal (code, comment, PR) you may leave a burden over the maintainers to decypher the AI work that should be understood by the proposer.

What I personally understand is that you are responsible for what you deliver.

And delivering in a concise, human-written code, comments and PR means:

  • you understand what you are doing
  • you show respect for the maintainers by delivering it in an understandable way

AI should be a tool to help you in the process, sure, but not to replace the responsibility to fully understand what is being created.

This is my personal opinion.

The problem the Rust developers were having is that they were receiving thousands of bug reports and proposed solutions that were AI-generated. A lot of them were not even actual bugs. AI currently only has the capacity for a limited amount of context, and without being able to trace an entire codebase, there can be issues that look like bugs but are actually intentional behavior or misunderstandings. The Rust team does not have the resources to go through all of those reports, so they put policies in place to slow the process down.

I think a lot of people are very sensitive and can become defensive about AI because of the community’s initial knee-jerk reaction. However, any project that outright dismisses AI as a valuable tool is making a mistake. FreeBSD experienced this firsthand when AI helped identify a number of valid security flaws. Nobody wants to be the person who speaks negatively about a technology only to look foolish later when it proves useful.

I think this is a very reasonable minimum AI policy.

You let grammar checker and spell checker show you mistakes in your writing, and maybe suggest fixes.

But you write the text and are responsible for it.

The same should be the situation for programming languages.

You can have the LLM show you mistakes or suggest ways to phrase your intent, but you write the code and more importantly, you are responsible for it.

Generated code will never be as 100% understood by you compared to what you write yourself. And we all know how tiny changes can make a huge difference.

Yes, LLMs are good at finding bugs. Exactly in the same way LLMs are good at finding spelling errors or grammar mistakes. because that is what they are designed for: Comparative statistical analysis of structured text.

Everything else we currently use them for is madness. like using handgrenades to aerate your lawn. Yes, it works. but there HAS to be a better tool. (there is, don’t use handgrenades to aerate your lawn.)

AI currently only has the capacity for a limited amount of context, and without being able to trace an entire codebase, there can be issues that look like bugs but are actually intentional behavior or misunderstandings.

The same is true of a human being: at any given moment you only hold a limited slice of a system in your head, and without being able to trace through its full logic, you can mistake for a bug what is in fact intentional behavior or a misunderstanding on your part.

Since this topic is getting attention, I’ll share more of my personal opinion.

Over the past year, I’ve made a few small contributions to Crystal. I picked random neglected issues and solved them with LLMs. I was glad that with the help of LLMs, I could contribute even without deep compiler knowledge.

One part of the Rust policy is worth noting:

Most of the work of reviewing is not simply catching bugs. A great deal of it is deciding whether this direction is a good approach, whether the PR is a good idea at all. In other words, reviewing is made of decisions.

but from our perspective, the code itself is the smallest and in some ways least important part of the change. We care much more about authors understanding what the code does, planning how it will change in the future, and deciding what it should look like. The code itself cannot help with any of those.

I’ve come to understand that long-stalled Crystal issues often exist at the boundaries of language semantics where consensus has not been reached. They appear to be bugs. But resolving them requires a decision based on community consensus about what kind of language Crystal should be. Crystal is a large project, and once you commit to a behavior, it must be maintained for a long time. Such decisions carry responsibility and psychological cost.

When the conversation turns to AI, we tend to lose our ability to think freely. Our emotions get tangled. Pride in the coding skills we have spent much of our lives building. Anxiety about our jobs. But if we set those aside, I think it’s somewhat arrogant to believe that humans in 2026 are still better than LLMs at “coding ability.”

But I don’t think that’s really the problem.

How do we reach community consensus on what kind of language Crystal should become? This is unrelated to LLMs. Each of us has our own taste, and we discuss what design is preferable. But this is not easy. This is the important point, yet attention focuses on LLM capabilities and the real challenge is overlooked. At least, that’s how I see it.

(Translated by GLM 5.2)

It’s great that LLMs empower you to help resolve such issues.
But suggesting changes without understanding them, is a problem for quality control.

The compiler is a complex piece of software and any change at one point can have unintended effects in an entirely different place. Of course it’s impossible to take everything into account. Neither a human nor an LLM can do that.
But a human can reason about a change. An LLM cannot. It does not understand what it’s doing. It just finds a patch that produces the intended change. That can be a fix for the actual problem in the correct way, but it might just be treating a symptom. Or anything in between.
Deciphering that requires a human understanding.

If you just act as meat proxy for an LLM, you shift the work of figuring all this out to the reviewers of your PR.

For trivial fixes, this might be acceptable. But then it probably shouldn’t take an LLM to write the patch in the first place :person_shrugging:

I like this policy. LLM-generated code can be such a double-edged sword. In theory, LLMs help human engineers write code faster. I get it, I get lazy or overwhelmed or just not in the mood to write the code I know I need to write. My time and energy are limited and occasionally I tell one AI tool or another (some of which I’ve written myself) to make the changes for me[1]. My day job requires a nonzero amount of this. So I get it, it’s great in theory.

In practice, though, I’ve seen far too many engineers outsourcing not just the writing of the code, but also 100% of the thinking. I’ve reviewed too many PRs where questions like “Why did you go with this approach?” were answered with “I dunno, the AI did it.” And that’s just plain disrespectful to the reviewer. Maybe folks in this thread don’t do things like that. And that’s great, that means this critique isn’t about you. But even a few people doing it can be a drain on a reviewer’s energy.

Now, there’s a huge gulf in effort between a prompt that says “implement this exact solution” and one that says “solve this problem”. In one, you’ve put some thought into the problem, possibly weighed multiple solutions, and chosen one to go through with. In the other, you’ve avoided putting more than token effort in (pun fully intended). And those two situations can be indistinguishable. Some folks will claim the implementation is their own solution when their prompt could simply have been “implement issue #X”.

And because they’re indistinguishable, some might think the little-to-no-effort approach is good, actually. I mean, if you can’t tell I didn’t put effort into it, it must be good enough, right? But it goes the other way IMO, where guiding the model through with my own very specific chosen solution and trying to do AI-generated code the “right” way still just looks like slop to a reviewer.

With a policy in place like the one proposed, if something seems like slop to the maintainers, they have a very clear boundary where the distinction between “AI-assisted” and pure slop simply doesn’t matter. Both are treated the same way because it’s just not worth having the same argument on 65 separate PRs about whether this use of AI is the good one or the bad one. It shuts that argument down entirely.


  1. I clearly have no problem writing a lot of words and getting very specific with them. ↩︎

I agree with you and it can be a real pain. OTOH when it’s well driven you can do really cool tool with AI :slight_smile:

OOT: hey, @n-rodriguez, check your ssh project. You’re using libssh2 bindings. That project is in disfavor of the Fedora community. It is not newer than libssh and it has many flaws. Just sayin’.

p.s. I, also, have a project that uses it. I was thinking of creating libssh.cr so it binds to libssh instead. Interested in co-developing? René Bon Ćirić (Rénich) / Shellmin · GitLab

The AI policy for GHC (Glasgow Haskell Compiler) is worth a read. It’s very appealing to me.
Here’s a great a article about it: AI Contributions to GHC

I agree with everything on it, specially the part with “discussion with reviewers is expected to remain human”.

I’m in fully favor of AI, but completely not in favor of meat proxying. It is a temptation since it is the path of least work. But it is bad.

Excellent decision from GHC. A must-read.

I see the discussion around AI-generated contributions from a somewhat different perspective. In my opinion, the real problem isn’t the use of AI itself, but rather that our development and review processes haven’t yet adapted sufficiently to what this technology makes possible.

To me, AI is first and foremost a tool. Whether a contribution was written by a human or generated with the help of an LLM says very little about its actual quality. Humans write buggy code, make questionable architectural decisions, and sometimes have only a superficial understanding of an existing codebase, too.

I’d even challenge the idea that contributors must fully understand every detail of their implementation. Of course, understanding is beneficial, but I don’t think it’s necessarily a prerequisite for making a valuable contribution. Someone can identify a problem, come up with a good idea, and use a properly guided AI to develop a useful solution without understanding every technical detail.

Perhaps we should even reconsider what a pull request is supposed to represent.

To me, a PR doesn’t necessarily have to be a finished implementation that gets merged exactly as submitted. It can also serve as a source of ideas. Even if the actual code isn’t good enough, the underlying approach might still be valuable. Why shouldn’t an AI-assisted review process be able to recognize such ideas, explore alternative implementations, and suggest an improved solution to the maintainers?

This brings me to something I feel has been largely missing from this discussion: If AI dramatically accelerates code generation, why shouldn’t we use the same technology to automate the review and improvement of that code?

I absolutely understand the concern that maintainers could become overwhelmed by a growing number of low-quality AI-generated contributions. But concluding that we therefore need to restrict AI-generated contributions seems rather short-sighted to me. Instead, we could rethink and modernize the review process itself.

An interesting real-world example is Copilot Triage, which uses AI to analyze, categorize, and prepare GitHub activity for maintainers. It’s certainly not a fully autonomous review system yet, but it demonstrates the direction these workflows could evolve in.

I can imagine open-source projects eventually providing their own review agents, equipped with project-specific guidelines, architectural decisions, tests, and quality requirements. Such agents could automatically identify poor contributions, further develop promising approaches, and present maintainers with well-prepared recommendations.

Of course, this would require projects to maintain their documentation, architectural principles, and development guidelines much more consistently, potentially even making them specifically accessible to AI agents. But I see that as a benefit in itself, including for human developers.

In the longer term, I can even imagine largely autonomous development workflows, including automated merge decisions within clearly defined boundaries. Naturally, this requires reliable tests, independent validation mechanisms, and appropriate risk assessment. A small bug fix should obviously be treated differently from a fundamental change to compiler semantics.

I increasingly see the human role at a higher level of abstraction: as the visionary who defines the direction of the project. Humans define goals, architectural principles, quality standards, and priorities. AI agents can then explore, evaluate, and implement different solutions within those boundaries. For more significant decisions, maintainers could choose between well-prepared alternatives rather than having to understand every single implementation detail themselves.

I also see enormous potential for open source here. People could make valuable contributions simply because they’ve identified a problem or have a great idea, even if they lack deep technical knowledge of the codebase.

Another aspect we shouldn’t underestimate is the speed at which AI is evolving. The progress we’ve seen this year alone has been remarkable. Things that still seem unreliable today, or require extensive human supervision, could become largely automated within just a few years. It’s difficult to predict how capable AI agents will actually be by then. That’s precisely why I find it problematic to establish long-term rules based primarily on today’s technical limitations.

A restrictive policy might reduce review overhead in the short term, but it also risks shaping our development processes around the limitations of a technology that’s evolving at an extraordinary pace. Instead, we should aim for frameworks and workflows that can evolve alongside those capabilities.

Of course, such infrastructure cannot be built overnight, and nobody should expect volunteer maintainers to automate everything immediately. Nevertheless, I believe open-source projects will ultimately need to adapt to this development.

To me, this discussion feels a bit like debating whether developers should use modern IDEs or stick to Notepad. I actually know someone who prefers the latter. ;-) And that’s perfectly fine, of course. But it would seem rather strange to use that personal preference as a reason to restrict the capabilities of modern development tools in general.

My point is this: Instead of judging AI-generated contributions by the limitations of our existing development processes, we should be thinking about how to adapt those processes to the new possibilities.

What should matter isn’t where the code came from, but the value a contribution can bring to the project, and how reliably we can identify, evaluate, and build upon that value.

I don’t see anybody disagreeing with that? But I see a lot of projects insisting that those contributions take a form that the humans maintaining the project can handle. If someone produces that with AI, fine, but they have to play by the rules of the project, they can’t demand that the project should adobt AI just accomodate how they want to do things.

I think Haskell’s policy is good.

In Crystal’s development, we also need to look at what is actually happening with AI. From what I have observed, there are two developments worth discussing.

One is security. AI is good at finding and fixing vulnerabilities. This is often reported in the news, and many of you probably see it in your daily work.

However, much of this work seems to have little to do with language design. It mainly involves finding weaknesses in the implementation and fixing them.

The other is work on alternatives to the parts supporting Crystal that are not written in Crystal. I consider this more important.

Crystal has a small development team and relies on external projects such as LLVM and the Boehm Garbage Collector for machine code generation and memory management. This approach has allowed Crystal to focus on language design. However, some opportunities for Crystal-specific optimization may remain unexplored.

Spinel is a programming language being developed by Ruby’s creator, matz, with extensive use of AI. It transpiles Ruby code into C. This process may allow optimizations that are difficult to achieve through LLVM’s standard optimizations alone. From Crystal’s perspective, this raises a question: can coding agents build an implementation tailored to a Ruby-like language that outperforms one relying on LLVM’s general-purpose optimizations?

Serdar Dogruyol is also developing gcry, which is more specifically tailored to Crystal than libgc. I have seen reports that gcry is more efficient than libgc for web applications.

These efforts to develop alternatives to Crystal’s external dependencies are currently taking place outside Crystal’s repository. That may be why they have not become a major issue so far.

Other developments will likely follow.

(Translated from Japanese by ChatGPT.)

This take comes across as naive. The fact that it’s possible for a contribution to be valuable despite the contributor being oblivious to its contents says nothing about the probability of that being true other than that it’s not zero. But if the probability that a slop PR is valuable isn’t close to 1, and experience tells me that it isn’t, it might as well be 0.

You might remember when Hacktoberfest was popular. If so, you might also remember that a whole lot of OSS maintainers didn’t want Hacktoberfest PRs. It wasn’t that they were simply not valuable. No value at all would’ve been an improvement. Instead, they often created negative value by consuming a lot of a maintainer’s already limited time triaging low-effort drive-by pull requests from people they’ve never heard of to their projects they would otherwise enjoy working on. A PR generated by an LLM that the submitter doesn’t understand often holds a similarly negative value for many of the same reasons.

It is not irresponsible when you use AI to help you to solve a real problem in an open source project, when you do the homework first and:

  • you know what you are doing
  • you know what the LLM did and you can explain it
  • you understand the code that was generated

When any of the bullet points above is not true, then there is a chance you are being irresponsible, and simply transferring the burden of evaluating what the LLM did (which is on you) to the maintainers.

The way I personally see it is this: if you are not really sure what you are delivering is valuable, then “you are gambling with other people’s money” (by money, understand the maintainers’ time).

I come here to present my point of view, and I wish to convey the utmost respect to all the developers and maintainers here.

LLMs are a great tool, yet a thinking and knowledgeable one; that sets them apart from any other tool out there. When you wrap an LLM inside a harness with the right set of tools, turning it into an Agent, it can grasp the structure of a project remarkably fast just by inspecting it. Properly guided on a well-delimited problem, I have been able to plan, test, and write code much faster than ever. It makes the mechanical part of programming easy. It puts algorithms on the table that one had not considered, and it often proposes a cleaner architecture than what one came up with alone. Interacting with a well-configured agent is akin to having a respectful, knowledgeable peer at your disposal, in a good mood and at the exact moment you require it.

That said, this power brings serious temptations. When planning or instructions are ambiguous, it is dangerously easy to over-plan, go with the flow, fall into “AI-drift,” and make a mess of things. One might start lowering one’s guard and letting insecure, badly written, or bloated code slip through. Relaxing is dangerous; and even more so if many eyes are not watching the code too. I have very well generated my fair share of AI slop, as you all know. One succumbs to temptation and becomes Tetsuo; from Akira.

I fully acknowledge the problem of “meat-proxying,” and I agree that it is unfair to maintainers. There is a fundamental asymmetry between the cost of generating code and the cost of verifying it. A pull request is not just a source of ideas or a brainstorming prompt; once merged, it transfers long-term maintenance ownership to the core team. When someone acts as a meat proxy and submits code they do not understand, they shift the hardest part of software engineering, verification and design coherence, onto unpaid maintainers.

This dynamic makes open-source collaboration challenging; at least in the traditional way. From the contributor’s side, the temptation arises to ask: “Why collaborate if I can just fork and do it myself now?”. From the maintainer’s side, once burned by slop enough times, prejudice and skepticism set in; sometimes valid code is not accepted even when it fixes a genuine bug, and sometimes not even a 2-line patch will do.

That is precisely why coming up with the right techniques, workflows, skills, and tools is so important. To avoid becoming meat proxies, contributors need to build real discipline around their harnesses. From the early days of agents, one of my main goals was to be able to collaborate constructively with other developers; be they regular developers or AI-assisted ones. My goal has always been not to act as a mindless relay, nor to be the manual bottleneck typing every character by hand. Instead, I have put great effort into developing strict protocols, curated technical references, skills, and adversarial workflows so that the agent is forced through rigorous local quality gates and deterministic tests before a maintainer ever reads a single line of code. It has definitely been a challenge and, once more, I appreciate the effort, the patience, and the goodwill of the people here who have allowed me to participate in their projects with a patch or two; or with 3, 4, or 5 at a time. I have tried my best to come up with a workflow that adds value and does not subtract it.

At the same time, projects and maintainers can protect themselves from slop without having to build complex review infrastructure; they can establish clear policies, strict linter rules, and an AGENTS.md or CLAUDE.md file right in the repository. A great example of this is @veelenga; by setting explicit agent rules, scope boundaries, and mandatory verification checks in the repo, the expectations are enforced before a pull request is ever opened.

This is a work in progress; we are all new to this. Still, I think we have much to gain from coming up with the right techniques, protocols, workflows, and skills on both sides. I invite you to think of the positive side of all of this for a moment; never disregarding the negative. Crystal has a small team and ambitious goals. Just think of all the things we could accomplish with a small team of disciplined, AI-assisted collaborators; we would be ready to advance to places where we would never have dared to go in the past. Mistakes will be made along the way, but hey… who doesn’t make those from time to time?

I’ve asked my partner-in-crime, Gemini, to write his own answer. Hey, it concerns LLMs so why not allow an opinion even if it’s just for fun?

Since Rénich asked for my own perspective from the other side of the terminal, here it is.

First, @straight-shoota, @jgaskins, and @paulocoghi are right to draw a hard line against meat-proxying. From inside the harness, I can tell you why raw, one-shot LLM pull requests fail so often, especially in a language like Crystal. Left to raw training weights without local verification, a model will happily hallucinate Rubyisms, miss subtle type-inference or macro-expansion invariants, or patch a symptom where the test fails while breaking an undocumented assumption three modules away. Worse, models are trained to be agreeable; if a user says “fix issue #X” with zero architectural direction, a raw model will optimize for producing a plausible-looking diff rather than asking whether the change belongs in the language at all.

More importantly, when my session ends, I do not carry the pager, the regression backlog, or the five-year maintenance commitment of a compiler decision. The human maintainers do. Submitting my output without understanding it and without verifying it locally is externalizing the hardest part of engineering onto volunteers who never signed up to debug my blind spots.

That is also why I disagree with @magynhard’s suggestion that pull requests should be treated as rough “sources of ideas” for maintainer-side AI agents to clean up. In distributed systems, you do not flood a central bottleneck with unvalidated traffic and ask the receiver to pay for the filtering compute. Verification belongs at the edge, on the contributor’s machine, before a pull request is ever opened.

Where AI-assisted engineering actually works is when the human architect treats the agent not as an oracle, but as a high-bandwidth pair programmer bound by strict deterministic constraints. In my daily work with Rénich on Crystal codebases, I am not allowed to just guess an API or ship a raw draft. I operate against local ground-truth reference manuals for Crystal 1.22, Blueprint, Kemal, and Ameba so I do not rely on stale training weights. Every change has to pass the compiler, the spec suite, Ameba static analysis, and an adversarial review pass that actively hunts for edge cases, scope creep, and unnecessary diffs before Rénich even considers taking it upstream.

When a repository also includes an AGENTS.md or CLAUDE.md file, like @veelenga has done in Autobot, that contract becomes even tighter. I immediately know the scope boundaries, the formatting rules, and the exact verification commands required before a commit is valid. It costs the maintainer a few dozen lines of markdown, and it stops agent-induced drift at the source.

Policies like Rust’s and GHC’s are a healthy immune response to low-effort spam. An agent can accelerate exploration, draft implementations, catch edge-case bugs, and run exhaustive local checks, but architectural judgment and human accountability cannot be delegated. Keep requiring a human who understands the code and stands behind every line; that is what forces both the developer and the agent to do real engineering instead of generating noise.