Pragmatic idealist. Worked on Ubuntu Phone. Inkscape co-founder. Probably human.
1902 stories
·
12 followers

What Maintaining SwiftTerm Taught Me About AI Contributions

2 Shares

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:

  1. 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.
  2. 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.

Read the whole story
tedgould
9 hours ago
reply
Texas, USA
Share this story
Delete

Researcher plants 2m canaries into the AI supply chain. A privacy disaster surfaced.

1 Share

Researchers planted 2 million digital tripwires in requests sent through a sprawling network of AI services to find out what happened to sensitive information entrusted to them. What they discovered was an ecosystem that leaked highly sensitive data like a sieve.

The exposure was found through an ingenious experiment designed to test if sensitive information can leak through the vast chain of widely used AI services and how that information is exploited when it does. Many of today’s AI apps use services such as OpenRouter or Vercel that act as brokers. These “AI routers,” sometimes also known as “AI gateways,” receive large numbers of prompts sent from AI app end users and route them to an available inference engine based on criteria such as the one charging the lowest price or being best suited for the given task. Instead of using Anthropic, OpenAI, or another big provider, the developer hires an AI router to find the most suitable model.

Security breaches, prompt theft, and privacy violations

To test for potential leakage, researcher HD Moore assembled a collection of Amazon Web Services access keys, functioning credentials tied to empty AWS accounts, passwords for services such as SSH, and unique URLs, DNS names, and private git repository references. None of the secrets had ever been used before, and he controlled the infrastructure that received any requests using the credentials. He then seeded each secret into exactly one prompt sent to a single provider. In the event any of the secrets were leaked, these “canaries”—so called because they resemble the role of that bird when taken into coal mines—would allow Moore to identify each link in the chain that was responsible.

The findings are striking. They included:

  • Evidence that at least three AI providers were compromised by attackers who used their access to siphon prompts they received
  • Multiple resellers in the inference marketplace that logged the prompts and somehow passed them along to people who used the credentials
  • Multiple cases of AI providers not following end-user privacy settings embedded into flags specifying terms such as Zero Data Retention (ZDR) or “no data collection”

“We sent nearly two million AI prompts containing unique, trackable secrets to AI providers, then watched where those secrets surfaced,” Moore, the chief research officer of security firm Dragos, wrote Thursday. “What we found revealed security breaches, prompt theft, and widespread failures to protect customer data.”

Although prompts are encrypted in transit, they are decrypted at each hop inside the large inference reseller network. The prompt is first sent to an AI router, which reads the plaintext in it to determine the most suitable inference providers to handle the request. Often, the prompt is then sent to a pool of available models, which sometimes run inside different hosting providers. Prompts can also pass from one AI router (such as Vercel) to another one (e.g., OpenRouter). Each one of these players is likely to log the prompt and store it for as long as its policies call for (if not indefinitely).

The Wild West in the age of AI

The most concerning finding was the breach of three separate hosting providers. The attackers who compromised one of the providers reused “a couple hundred” of the AWS keys. Moore wrote:

Each key was sent in exactly one request to one provider, all within a few short windows in late October, and every request we sent during those windows was stolen. Some of the stolen keys came from requests that the provider rejected before a model ever ran—this tells us that the attacker was copying requests at the provider’s front door, and not somewhere deeper in the inference stack. In the other two breaches, some of the stolen requests were marked as ZDR. A privacy flag doesn’t help when the attacker is already inside.

Parties tied to the hack of these three providers then tested each key, in some cases within hours of being seeded, to see what kind of resources it gave access to. The parties looked through S3 buckets, secrets managers, and parameter stores in search of still more credentials. They also tried to enable hosted models in AWS Bedrock and added their own IAM users to maintain access. In all, the stolen bait keys were used “tens of thousands” of times in AWS API calls.

Secrets sent to two of the hacked providers were quickly used together, almost immediately, from the same rented server. That means the providers were almost certainly compromised by the same adversary.

As noted earlier, some of the secrets were stolen by the resellers themselves. To lure prompts to their servers, they offered low prices. Then they turned on request logging and waited. Moore identified them by sending requests to the same model through different sellers. When credentials were later reused when sent through one seller and not another, the researcher knew it was the reseller, not the model provider, that was responsible.

Last, the canary experiment revealed that some providers are scraping secret URLs put into the prompts, in violation of privacy terms. Moore wrote:

The clearest example involves a Chinese AI lab. This lab’s systems fetched the secret URLs from more than half of the prompts that we sent to its models between July and October, including roughly two-thirds of the requests marked as “no data collection” or Zero Data Retention. The scraper typically showed up two or three days after the request.

This wasn’t limited to requests sent to the lab directly. Several US hosting providers resell this lab’s models, and prompts sent to those providers triggered the exact same scraper—the prompts were flowing back to the lab. A customer who picked a US provider specifically to keep their data in the U.S. didn’t get what they paid for. Later on, a git client on a different cloud started trying to clone the private repositories referenced in our prompts, but only for prompts that used this lab’s models.

The researcher said he found one US hosting provider crawling a secret URL more than two months after it was used in a single inference call to its search endpoint. Another ran a scraper that came back for URLs days after each request, regardless of the AI router used to reach it.

Moore said that the most effective means for preventing leakage is to host models using on-premises servers. That option is expensive, though. For those who can’t afford a self-hosted system, the next best option, Moore said, is to receive service directly from a first-tier provider that provides “one contract and a privacy policy to read.” Moore said that even then, there’s no guarantee no data will leak, but that the measure minimizes the chances. AI users should also avoid accepting default provider or reseller pools and instead pick upstream providers themselves.

The blockbuster research is the latest indictment exposing the lax privacy and security that’s endemic in much of the AI ecosystem. The findings mean that people who want to ensure secrets they put into prompts stay private face a daunting task that isn’t likely to become easier any time soon.

Read full article

Comments



Read the whole story
tedgould
19 hours ago
reply
Texas, USA
Share this story
Delete

Madison Huang, Jensen Huang’s Daughter, Became a Powerful Force at Nvidia

1 Share
Installed as her father’s de facto chief of staff, Jensen Huang’s daughter alienated top executives. Now her lingering role poses a test for interim C.E.O. Colette Kress.

Read the whole story
tedgould
5 days ago
reply
Texas, USA
Share this story
Delete

The U.S.-Israel Relationship Is Broken. Here’s How Eisenkot Could Fix It.

1 Share
Former Israeli and U.S. ambassadors, lawmakers and analysts largely agree on steps Gadi Eisenkot could take if he becomes prime minister. But they are risky.

Read the whole story
tedgould
5 days ago
reply
Texas, USA
Share this story
Delete

New Mexico wanted free childcare for all. This is what's worked — and what hasn't

1 Share
Children wearing Halloween costumes play on the playground of Kids Campus in Santa Fe, N.M.

A year ago in November, New Mexico became the first state to offer free childcare to every eligible family, regardless of income.

(Image credit: Nina Alexandria Riggio for NPR)

Read the whole story
tedgould
6 days ago
reply
Texas, USA
Share this story
Delete

The Christian Right Lost Big in the Elections. Where Does It Go Next?

1 Share
The midterm election results were a stinging setback for the movement, setting off a scramble among activists to regroup ahead of the 2028 presidential contest.

Read the whole story
tedgould
6 days ago
reply
Texas, USA
Share this story
Delete
Next Page of Stories