What Maintaining SwiftTerm Taught Me About AI Contributions
If you maintain an open-source project right now, your pull request queue probably looks very different than it did two years ago.
I maintain SwiftTerm, an open-source terminal emulator library that is now seven years old. Today, I estimate that about 80% of the pull requests I receive involve AI in some capacity. Looking back, though, this didn't happen all at once—it came in distinct waves.
Disclosure: as a Mexican national that routinely writes tedious and typo-ridden English blog posts, I had Antigravity fix my writing and repeated tedious and repetitive points (as my wife often points out).
Wave One: Vibe-Coded Band-Aids and Fork Experiments
Before people even started opening AI-assisted pull requests on my repository, I would browse the GitHub network graph just to see what forks were popping up and what problems users were struggling with. Early on, what I found was a lot of "vibe coding"—folks patching around issues in ways that were fundamentally wrong, slapping surface-level band-aids over deeper terminal state bugs. I would fix or implement the feature, despite the fact that the user had not submitted the fix - for the sake of helping all my users.
In one fork I stumbled across, someone had clearly unleashed an autonomous agent to try to fix all of my open issues in rapid fire. Luckily, they never actually submitted those PRs—they were likely just experimenting—and it was only my nosy self browsing the network graph that spotted it. Still, looking through those commits confirmed the early reality: the fixes weren't worth merging. They solved surface symptoms without understanding the system.
The Rise of the Promptsplainer
Alongside those early waves came a new open-source archetype—one that many communities had to deal with: the Promptsplainer.
Some folks are really eager to particiapte in improving a project and LLMs have opened new doors, but they lack some basic etiquette.
A Promptsplainer is someone who asks an LLM a question, gets back a confident-sounding explanation or a sprawling patch, and suddenly believes they can override decades of hard-won domain expertise. They don't actually understand the underlying quirks, race conditions, or protocol edge cases of the codebase they are touching. When a veteran maintainer points out a flaw, the Promptsplainer doesn't go investigate the code; they just copy-paste the maintainer's review comments straight back into their chat session and paste whatever the bot spits out next.
You don't need a massive daily flood of Promptsplainers to feel the damage. Even the occasional encounter can fill a maintainer with rage - and with good reason.
Wave Two: "Send a Patch" Finally Became Real
Here is what has changed dramatically over the last year. We went from AI fixes being flat-out wrong or lazy band-aids to pretty much landing in the right ballpark.
To appreciate why this matters so much to me, you have to remember what maintaining an open-source library looked like just a few years ago. Back then, I would get a steady stream of bug reports—and if I had the spare time, the patience, the kids went to sleep early, and my Netflix queue was empty, I might actually sit down and fix the bug.
For decades, open-source communities had a semi-joking, semi-exasperated stock response whenever a user asked, "Why doesn't it...?". We told them, "Patches welcome," or "Send a PR." Most of the time, we knew they wouldn't, because diving into a complex codebase from scratch was too steep a climb. The perfect storm between unpaid volunteer work, uneducated takes and exasperation.
Like many others, I have witnessed the change from getting bug reports to getting detailed pull requests. And I am personally grateful for this.
My philosophy on incoming contributions comes down to a simple reality: every PR represents a real pain point caught in the wild. It means a real user ran into a problem in their day-to-day work, reported or tracked down the issue, found a working solution, and felt the pain acutely enough that they took the time to package it up and upstream it.
As a maintainer, that is an infinitely better signal than my own laundry list of wish-list items sitting in the issue tracker. Even if the implementation needs additional work, someone just handed me proof of a real-world problem along with a concrete starting point to fix it.
Multi-Agent Code Review on My Side of the Table
The catch is that many coding models and agents still have a bad habit of just doing the fix—taking the shortest path to make a test pass without stepping back to look at the whole library. And not every contributor has learned how to tune their agents for deep engineering review, or has access to the best models for it.
The first pass of AI-generated code often needs work, and that is okay. Just as we spent years developing the discipline to master our programming languages, debuggers, and in some cases, write m4 macros, we now need to develop the muscle for using AI tools effectively—learning how to steer them, verify their assumptions, and audit their output.
For me, building that muscle meant putting AI on my side of the table to bridge the gap. Before I even bother reading a contributor's patch line-by-line, I religiously run /code-review in Claude and /review in ChatGPT [1].
These review passes routinely catch far more than narrow syntax nits—they surface genuine architectural flaws, subtle API breakage, rare side effects, and terminal conformance problems that would take me hours to trace manually [2].
Armed with that feedback, I can point contributors toward concrete architectural fixes—or, if someone disappears after opening a PR for a critical bug, I can clean up their branch and land it myself.
Some maintainers lament that reviewing these PRs feels like talking to someone who just copies and pastes feedback into a remote LLM. But we are still communicating with a human being on the other end. That gives us a real opportunity not just to coach contributors on how to use these tools responsibly, but to model and adopt better engineering practices across our industry. Given that the economics of top-tier reasoning models aren't ideal for everyone doing casual open-source work, I’m happy to foot that bill on my end for the sake of keeping my library healthy.
The Friction of One-Size-Fits-All Rules
This brings me to why I’ve been watching the broader debate around AI policies in large projects like Gnome and Godot with a lot of sympathy—and a bit of concern.
At Godot's massive scale, protecting volunteer reviewers from unvetted submissions and the occasional Promptsplainer is a completely understandable instinct. Nobody wants their Netflix time eaten up by drive-by code the author didn't bother to understand.
The challenge is that drawing hard lines around how code was written inevitably creates friction for experienced contributors who are already doing the architectural heavy lifting. Recently, I tried to upstream a small, production-tested bug fix to Godot as a trial balloon—one of roughly 60 to 80 improvements my team has built and tested in our own tree. Because I disclosed my AI workflow honestly, it ran afoul of their strict guidelines and was rejected.
When a policy polices provenance rather than quality, two unintended things happen:
- It penalizes transparency: Honest contributors who disclose their tools get blocked, while others are quietly nudged to keep quiet and pretend they typed every character by hand.
- Good fixes stay locked in private forks: Rather than wrestling with policy friction, teams like mine simply keep useful patches in our own internal trees. Because AI has made maintaining forks trivial, it doesn't slow us down—it just means the broader community misses out on fixes that could have helped everyone.
Accountability Over Provenance
The Promptsplainer is a real headache, and open-source projects are right to push back against uncomprehending, drive-by contributions.
But the antidote isn't banning the tools—it's requiring human accountability paired with better review tooling on the maintainer's side. At the end of the day, as the maintainer of a library, it is my role to make the editorial decisions about what goes in—and the people who depend on my library trust me to make those calls. Whether a patch started in an LLM prompt or was typed out by hand doesn't change that responsibility. If a contributor understands the problem, has tested the fix, and can engage thoughtfully in review as a human being, the models they used in their editor shouldn't disqualify their work.
Of course, scaling that kind of review culture when a handful of core maintainers are already stretched thin is a structural challenge all its own.
[1] With Claude I use Opus 5.5 alongside /review in GPT 6.2 with Sol-xhigh. In Claude, /code-review actually launches multiple distinct agents in parallel, each focused on different goals and common engineering mistakes. Looking forward to Antigravity to get this.
[2] In fact these reviews are so thorough, that I use /code-review on my own changes before shipping. In a seven-year-old codebase, it is impossible to keep every historical invariant in your head at once, and those agents regularly catch edge-case scenarios I had completely forgotten about.