You’ve probably noticed the quiet shame spreading through developer circles. We’re all using AI to write, refactor, and debug code, but we talk about it in hushed tones, terrified that the purist down the hall will judge us for not typing every semicolon by hand.
We built an industry designed to make humans more powerful, yet we hide the tools that actually make us powerful like they’re a dirty secret.
Enter the Rust project. They just dropped a new LLM policy that everyone is dissecting for the wrong reasons. The headline is simple: you can use AI to answer questions, analyze, distill, refine, check, suggest, and review. But you cannot use it to create. It’s a neat little boundary drawn in the sand.
Except, that boundary is a complete illusion. If you use an LLM to refactor 500 lines of legacy code, is that analysis or creation? The LLM is generating new syntax, new structure. The Rust policy calls it refinement. The reality is far messier. The line between ‘assisting’ and ‘creating’ is so blurry that enforcing it will likely cause more headaches than it cures.
But that’s not the real story here. The actual power move isn’t the rule about creation. It’s the anti-harassment clause buried in the text.
The Rust policy explicitly states: Harassment is not allowed. You may not harass people for using an LLM, regardless of whether or not their use is banned by the policy.
Banning AI from writing code is easy. Banning humans from bullying each other because their code looks too perfect—that’s a power move.
Think about how open source actually works. It’s a high-stress, high-ego environment. Contributors get ripped apart in pull request reviews for minor syntax errors. Now, introduce a tool that allows a junior dev to produce senior-level architecture in seconds. The natural human reaction from the old guard isn’t admiration; it’s resentment. It’s the moral panic of, ‘You didn’t earn this.’
Rust sees this coming. They know that the greatest threat to a project’s health isn’t an AI hallucinating a bad function; it’s a toxic community tearing itself apart over who is ‘really’ writing the code. By dropping the hammer on harassment, they are preempting the moral panic. They are normalizing AI assistance.
We spend so much time worrying about machines replacing us that we forget humans are the ones who are best at driving each other out.
If you contribute to open source, this is the precedent that matters. It means your workflow can evolve. It means you can leverage LLMs to parse dense documentation or spot security vulnerabilities without painting a target on your back. The community is contractually obligated to attack the code, not the contributor’s choice of tools.
The anxiety that AI will replace developers is a distraction. The real battle is between those who adapt their workflow to include AI and those who demand the world stay frozen in 2015. Rust just picked a side. They chose the future, but more importantly, they chose to protect the humans stepping into it.
AI isn’t going to replace you. But a peer who refuses to use AI, while reviewing your PR, absolutely will try to.
Stop hiding your tools. The code doesn’t care who wrote it, and soon, neither will the rules.
FAQ
Q: How can they realistically enforce the line between AI 'analysis' and 'creation'?
A: They really can't. The line is inherently blurry and mostly relies on the honor system. The policy acknowledges this by focusing on the output's quality and human accountability, rather than playing an impossible game of forensic code detection.
Q: What does this mean for my day-to-day open source contributions?
A: You can freely use LLMs to parse documentation, review code, and suggest improvements without fear of being bullied by community purists. It protects your reputation while allowing you to work smarter.
Q: Is the 'no AI creation' rule just performative gatekeeping?
A: Partially, yes. It's a compromise to appease traditionalists. But by pairing it with a strict anti-harassment clause, Rust neutralizes the gatekeepers, making the creation rule largely toothless in practice.