I’ve spent the last few months learning Go with an AI assistant open in the next pane, and my honest verdict is boring: it’s genuinely great at some things, useless at others, and the whole skill is knowing which is which. So I’ve been watching with interest as two open-source projects came to opposite public conclusions in the same season.
In May, Zig banned AI-assisted contributions outright — its president, Andrew Kelley, called LLM submissions “invariably garbage” and shut the door on any code created, debugged, brainstormed, or paraphrased by a model. Two months later, Bun rewrote its entire runtime from Zig into Rust: over a million lines in eleven days, roughly $165,000 of API time, some fifty AI agents running in parallel. Kelley’s verdict on that effort: “unreviewed slop.”
It’s tempting to file this as a culture war — the AI believers versus the AI refuseniks. But we’ve watched this split play out for centuries, long before software. Every disruptive technology forces a community to choose, and it tends to fracture the same way: a purist wing that refuses the new thing on principle, and a reform wing that absorbs it. In Richard Morgan’s Altered Carbon, the Neo-Catholics won’t let their digitized minds be spun back up after death — salvation doesn’t run on a hard drive, so they refuse the very technology that could resurrect them. Real faiths have done the same for ages: Orthodox and Reform, traditionalist and modernizer, the branch that walls the world out and the branch that lets it in. The Amish are the interesting case, because they aren’t the reflexive Luddites everyone assumes — they adopt a technology only after asking whether it serves the community, and refuse the ones that would corrode it. Selective, deliberate, principled.
Open source is now having its own version of that schism, and the same postures are on the table. Which is why the culture-war framing misses what’s actually being fought over.
The real question underneath#
Strip the slogans and every one of these projects is answering the same question: who is accountable for understanding this code? Not “is AI good,” not “is AI the future” — just, when this breaks at 2 a.m., is there a human who can explain why it was written the way it was? Zig, Bun, and Rust each gave a different answer, and only one of them, I think, is right.
Take Zig’s ban seriously, because the reasons are better than the soundbite. Kelley’s core problem isn’t philosophical, it’s arithmetic: a tiny core team, around two hundred open pull requests, and no bandwidth to review a flood of machine-generated ones. A model produces plausible patches faster than humans can vet them, and a patch nobody has time to understand is a liability, not a gift. Zig is also, explicitly, a teaching project — accepting code the author didn’t actually write undercuts the point. And there’s a quieter reason Kelley leans on less but that matters: Zig is young and rising fast — genuinely well-loved by the developers who use it, and climbing the popularity indexes — yet it’s still a sliver of the code in the world, well under one percent of it. That leaves it thin in the training data next to Python, JavaScript, or Rust, and models are measurably worse at it. When Kelley calls the submissions invariably garbage, he’s probably not exaggerating about his codebase — the tool really is weaker there.
Why the ban doesn’t travel#
But that’s exactly why it doesn’t generalize. “AI is bad at Zig” is true, and it’s true largely because Zig is still small in absolute terms — a fact about the training corpus, not about AI. Carry the same rule to Rust or TypeScript, where the corpus is enormous and the models are strong, and a blanket ban throws away real leverage to dodge a review problem. It’s a rational local choice wearing the costume of a universal principle.
Bun is the opposite ditch. The rewrite is a genuine marvel — a million lines, every test green across a million-plus assertions. But notice what “all tests pass” does and doesn’t buy you. The automated checks went green; no human read a million lines. Kelley’s jab lands precisely there: tests catching bugs is not the same as a person understanding the system. A codebase can pass every assertion and still be one that nobody on earth fully understands. The failure mode isn’t “AI wrote code.” It’s that AI wrote code faster than anyone could come to understand it — and shipped the gap.
The line that actually holds#
Between the two ditches, Rust is quietly drawing the honest line. Its emerging contribution policy doesn’t ban the tools; it aims them. Use an LLM to ask questions, analyze the codebase, review your own work privately, study a solution before you write your own — fine. Use it to author the contribution, to stand in for your own understanding of what you’re submitting — not fine. The rule treats the model as a thinking aid, never as the author of record. The obligation to understand what you ship stays with a human. It’s the Amish move, quietly: the question was never is the tool allowed, it’s does it serve what we’re here to protect. Even Linux, whose Torvalds recently waved off the anti-AI crowd with “Linux is not one of those anti-AI projects,” runs on a maintainer hierarchy whose entire purpose is to guarantee someone accountable read the patch. Embrace it or refuse it — the responsible projects all keep the same thing: a human who owns the result.
Where I’ve landed#
That matches how AI actually earned its place in my own work, and it isn’t complicated. I point it at the mechanical, high-repetition, machine-checkable stuff — the boilerplate, the tedious refactor, the test scaffold — where it’s fast and where go build, the tests, and CI will catch it if it’s wrong. I keep for myself the things a model has no way to know: why the system is shaped the way it is, which design choice is load-bearing, the Conway’s-law reasons the code and the org chart end up mirroring each other, the call about what’s even worth building. The AI does the mechanical; I stay accountable for the meaning. The line was never whether the model is allowed near the code — it’s what you point it at, and who owns what comes out.
So I don’t think the projects that thrive will be the ones that ban AI or the ones that turn it loose. In every one of those older schisms, the branch that endured was rarely the purest or the most permissive — it was the one that adapted without forgetting what it was for. In software, that means scaling your understanding as fast as you scale your generation — never shipping more code than a human can still answer for. Which leaves the question I keep circling: we’ve gotten very good, very fast, at making machines write code. Are we getting any better at making sure someone still understands it?
However that shakes out, one thing feels certain — we, programmers and everyone else who makes things, truly live in an unprecedented and interesting time.