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 ExperimentsBefore 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 PromptsplainerAlongside 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 RealHere 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 TableThe 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 RulesThis 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:
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.
Today we are launching the GNOME Foundation’s 2026 end-of-year fundraiser, and we need your donations to help build a stronger, healthier GNOME ecosystem.
GNOME is an independent computing platform enjoyed by millions of people worldwide. What if a small fraction of them helped financially sustain it? Together, we could give GNOME the resources to accomplish so much more.
GNOME and the GNOME FoundationGNOME is a Linux desktop environment and collection of apps intentionally designed to be elegant, intuitive, and privacy-respecting. It’s the default experience on many popular Linux distributions like Fedora, Ubuntu, Debian, and Zorin OS.
The GNOME Foundation is the organization working to sustain GNOME, but its resources are stretched thin. We are currently limited to a handful of paid team members, most of whom are part-time.
GNOME exists today thanks to a global community of volunteers sharing their time, talent, and passion to build software that benefits millions. They frequently juggle jobs, family, hobbies, and other commitments to accomplish this work. We see an opportunity to give some of these talented people the time, resources, and financial incentive to contribute more to GNOME.
The Fellowship is Making a DifferenceAnd thanks to your generosity in 2025, we were able to launch the GNOME Fellowship program in April 2026. The Fellowship allows us to directly support two talented members of this community, who in turn spend dedicated time enhancing the long-term sustainability and health of the GNOME project.
These Fellows are already making noticeable quality-of-life enhancements to your everyday desktop experience, and the underlying technologies that power GNOME.
In their first three months, Fellows Peter and Sophie have modernized the file previewer, made substantial improvements to image handling, and fixed many problematic bugs — some of which have existed for years. And that’s only a small sampling of what they’ve accomplished.
With your help, we can raise an additional $60,000 to sustain the fellowship program throughout 2027. Donate today, and let’s continue supporting the vital work our Fellows are doing!
Your Donation MattersGNOME isn’t just a desktop environment. It’s an alternative to a world where corporations decide how you should use your hardware, treat your personal data as a commodity, and disregard your privacy.
GNOME is a reflection of what we believe technology should be: open, empowering, and built to put the control back in your hands.
If you’re reading this, GNOME matters to you. And your donation matters to GNOME! Please give what you can today. Every single gift helps make a stronger, healthier GNOME possible.
This week's icon is for Lars Windolf's project: Liferea: "Keep up with your feeds"
Check out all weekly app icons created so far in the gallery and follow my icon creation adventures as they happen (including sketches) on the Fediverse.
Need icons?I love designing icons and am happy to contribute them free of charge when your project is Free and Open Source. Join as a community sponsor to maintain a steady supply of app icons to the Linux ecosystem (every little helps!).
I was watching a meme-heavy video there entitled “Bad Gear – BIG BRANDS have a PROBLEM!!!” which ended on the following insight:
I’ve been following the world of synthesizers and drum machines for the last decade, since the first Akai MPC with a touchscreen appeared and I thought I’d have more fun making music on that than a laptop. (Which I was wrong about, in hindsight. But it opened the door to a lot of fun exploration in the space where music intersects with technology and human interface design.)
Music technology always involved proprietary platforms and locked-down devices. Macbooks everywhere. Copy protection schemes with hardware dongles (see: iLok). Copyright sting operations against small studios (see: Waves Audio. Read Markus Schmidt of Calf Audio’s story for how wild they go). People regularly call me crazy for making music using a Linux desktop. Even in the world of “creative coding”, where making custom instruments and tools in software is part of the musicians practice, the most popular environment is Max/MSP, a proprietary product that costs 400€ and runs on Windows and Mac only.
That’s before we get to hardware devices. There has been a huge boom in the last decade, it’s been a fun time, and is much better use for semiconductors compared to making drones. There are dedicated DSP chips available. Some devices manage to build an impressive amount of functionality in the DSP chip itself… checkout how many guitar pedals use the Spin FV-1 for example. Others have an ARM chip as the brain, usually running Linux, and usually completely closed to any kind of customisation. These machines are expensive. I still think of 600€ as a cheap price point for a synth. The most expensive MPC costs over 2 grand. You’re paying a premium for custom hardware being produced at relatively small scale, and the expectation that it will be rock solid — built to the quality of any other musical instrument. A guitar doesn’t randomly reboot to install a firmware update and neither do these devices. (The level of programming skill at music tech companies is waaaay above what I’ve seen anywhere else in the tech industry… but that’s a whole other blog post).
Open, hackable devices exist but have always been pretty niche. Have you been to a gig where someone played the Monome Norns? Or maybe an Organelle concert?
The year of our Lord 2026 is the year that changed. This month I’m being bombarded with videos about the MVAVE FM-1, a synth that costs 70€, and comes with an online IDE, and an open SDK. It’s arrived at a moment when LLM coding tools are heavily subsidized by the AI bubble, and at time of writing there are two hundred and nineteen alternative firmwaves available for this thing. There’s a website hosting them all. In fact there are multiple. People are making this box into all sorts of different instruments that suit different purposes, experimenting, learning, playing and abandoning them.
To put that in comparison, I have a Korg Minilogue synth, which has had an open plugin development platform since 2019. Korgs are one of the longest established and best selling synth makers in the world. In 7 years, the official list of plugins grown to about… 200 plugins, many of which are from pro plugin makers. By comparsion, the FM-1 was released in June of this year, that is, not even 7 months have passed yet.
While a lot of the music tech video sphere is hyping the FM-1, there are some more measured takes. Jeremy Blake a.k.a Red Means Recording made a video entitled “Vibecoding in Plato’s Cave (AI, Music Tech, and Star Trek)”, which in turn links to an editorial from audionewsroom.net under “Why the open source hardware revolution is a lie”. These both make some good points, which I won’t repeat as I think everyone who reads my blog already knows that Anthropic and OpenAI are malevolent forces and today’s vibe coding apps are optimized for addiction by the same people who designed slot machines and infinite scroll. I called this back in January 2026 in a post titled “AI predictions for 2026”.
Maybe I’m in an optimistic mood, especially as we might be seeing the first signs of the AI bubble bursting, thanks to Jensen Huang accidentally having sex with a Chinese spy, but I see this sudden boom in hackable music tech as a really cool thing. Musicians who wouldn’t feel comfortable writing “Hello World” in C are suddenly designing and deploying custom device firmwares with wacky interface ideas that they dreamed up themselves. Sure, most of them probably don’t work very well and are quickly abandoned, but people are learning. You learn by doing! I didn’t get into programming because I wanted to study programming — I wanted to do cool stuff with a computer, and learning to code was a byproduct of that. My first attempts at coding were terrible and it was a long, long road to becoming good. I didn’t exactly enjoy it, more than anything it was frustrating because I could never have the time or skill to build the things I wanted. Now I find coding fun, because I did it long enough to get good, but I really see it as a lucky coincidence that I had the time and circumstances to be able to practice and fail on hundreds of projects over many years to get to where I am today.
People who have spent a long time learning to code are worrying about the effect AI coding tools will have on our world. Which is reasonable; leaders in the software industry have mostly lost their minds, almost nobody is hiring and training junior engineers, everyone is getting hacked all the time, and so on. I’m sure you know all of this.
I think the booming FM-1 firmware scenes shows that we are missing a bigger point point. What effect do AI coding tools have for people who use computers but never felt empowered to hack them before ?
The FM-1 is a perfect playground for learning to hack. There are very few security concerns — it doesn’t even have a network interface, and there’s no private data to steal (unless maybe you’ve saved a really really good song). If you brick the device — and people are doing that — you get to learn how to fix it, and you probably only make that mistake once. In the absolute worst case, you lost 70€ and you have to go back to making music on the bagpipes instead, or whatever you did before.
We need to see this as an entirely new way to interface with a computer.
The oldest computers dealt with binary numbers, one bit at a time. Modern computers do exactly the same thing! They look unrecognizably different, because we have innovated so much in how we interface with them. First we mapped the numbers to a character set, and suddenly we could communicate with them in strings of text. Programming languages emerged only once that was possible. Then we learned to map numbers to pixels on a display. From there, we could build pointing devices and touch screens and eventually get to the modern desktop interface and smartphone.
LLMs map the numbers to tokens in a heavily compressed database of basically all the text that humans ever wrote down, which gives us another new way to communicate with computers. English words map to chunks of code, which get clumsily mangled into something that the computer can and will execute. Yes, that’s a terrible way to make systems software, but that’s not the only thing you can do with this new interface. The sudden fad for making FM-1 firmwares wouldn’t have happened if the device came out 5 years ago. We are looking at the most powerful interface for hacking computers and devices that has ever existed.
I got into the open source desktop world because I wanted to see computer use democratized. Apple and Microsoft promised to lock down and control what we could do with PCs, and Google is doing the same with smartphones now. The open source movement fought against this and we are winning! The Linux desktop is more popular than ever, and operating systems are increasingly a commodity.
But when we win this round, are we clear where to go next? It feels like our only proposition is to do the same thing as before, but also be really angry about AI. I don’t think that is going to work! I’m as angry as you about OpenAI stealing all our work. I’m angry about the climate crisis and the wealth inequality crisis, too, and those both seem a lot more pressing.
It is possible to define your community around rejecting new things but it leads to stagnation. And things don’t go away just because you want them to! As Armin Ronacher put it in his post Communities of Not: “Cars shape cities even for people who cycle”. (I hate cars, too, by the way, and avoided having one for years, but they have stubbornly refused to go away).
Like many of my posts, this is partly wondering out loud about where the GNOME project could go. Fifteen years ago, we did some radical design work, and made a bet that everyone would have GPU in their computer in future. At the time I thought that was a bad call, and actually I couldn’t use GNOME Shell for 5 or so years after the GNOME 3 release because of driver issues. It works great nowadays and it’s obvious now that GNOME Shell included a lot of good decisions that have kept GNOME at the forefront of desktop Linux ever since.
I’m not very excited if our bet for the future is “do the same as before but also argue a lot about AI use.” Now is the time to make some bets about the future of hackable, ethical, open computing that includes the 99% of the population who haven’t spent decades learning to write code with the same level of proficiency and control that Khn de Poitrine has at playing guitar.
GIMP has a lot of intertwined menus, dialogs and tools. When we change a part of the interface, another may stop working and sometimes, the problem can be missed until a user reports it.
To find these problems early, a new GUI testing platform was implemented. A typical GUI test starts GIMP, clicks menus and buttons, and then checks the result. These tests run automatically each time we merge contributor changes.
Why we need themGIMP already has unit tests. A unit test checks one small part of the code, for example how GIMP reads an XCF file. But our unit tests were not opening a real window. So it coult not tell us if a dialog opens, or if a menu item did its job.
Note that GIMP already had tests of GUI code, usually interacting directly with the core code, and sometimes even simulating input devices’ events (pointer movements, clicks, drags…). But nothing can beat interacting with the real interface. Furthermore such legacy tests directly hijacking core code come with their own problems, such as breaking all too often (and not because they detected a bug), all while not being able to detect whole categories of bugs.
UI tests check the program as a whole, in the same way as you use it.
What the tests doEach test starts a real GIMP and does one small task. Then it reads the result from GIMP. If the result is not correct, the test fails and tells us what went wrong.
We have 13 tests at this time. They check that:
The tests do not need a screen. Each test starts a small, hidden desktop, runs GIMP in it, and removes it at the end. Because of this, the tests can run on our CI servers, where no screen is available.
To find a button or a menu, the tests do not look at the pixels on the screen. They use the accessibility information that GIMP gives to tools such as screen readers. This has one more good result: when we make GIMP easier to test, we also make it easier to use with a screen reader, hence improve the software accessibility.
The tests use dogtail, a Python tool for UI tests. To run GIMP on a server with no screen, dogtail needed a new feature. We contributed this feature upstream, to dogtail itself, so other projects can use it too.
At this time, the tests run only on Linux (both X11 and Wayland) since dogtail does not support Windows or macOs.
Adding even these few simple tests considerably increases confidence that the GIMP build has worked, and also shows the test infrastructure is working and useful.
CreditsYou can read the full change in merge request !2909.
How you can help13 tests is a good start, but GIMP has many more dialogs and tools. If you want to help, you can write a test for the part of GIMP that you use the most.
We wrote a guide that shows how to write a new test and how to find the cause when a test fails: UI tests on developer.gimp.org.
We hope this work will help us find bugs earlier and keep GIMP working well for everyone.