Skip to main content

AI made open source fun again

11 min read

Summary: AI agents took over the toil on my 15-year-old WordPress plugin, and maintaining it got fun again. Point agents at the work you’ve been dreading, read every diff, and keep the decisions for yourself.

Table of contents

In 2023, I made seven commits to WP Document Revisions, the WordPress plugin I started in 2011. In 2024, four. In 2026, the plugin passed 200,000 downloads and had its busiest year ever: 756 commits, 478 of them made by AI agents working for me. I didn’t type that code, but I carefully read every diff.

Stacked bar chart of commits per year to WP Document Revisions, 2011 to 2026. My handwritten commits spike in 2011 to 2012, 2017, and 2021, then nearly vanish in 2023 and 2024 while Neil James carries the plugin, and stop entirely after that. From 2025, AI agents take over. 2026 is the tallest bar by far, with 756 commits: 478 from AI agents, 138 from Neil, and 140 from everyone else, including dependency bots. The previous high was 467 in 2021.

I didn’t find more free time, and nobody started paying me to maintain it. Open source projects don’t die because maintainers quit. They die when catching up costs more than ignoring them. For years, that math kept me away from my own project, my first “real” open source project. This year, AI agents flipped it, and once the toil was gone, maintaining it was fun again.

If there’s a repository you feel a little guilty about every time it crosses your mind, it can be fun again for you, too.

Nobody decides to abandon an open source project

The maintainer’s attention goes somewhere else, and the issue queue gets longer every month. If that’s your project, you still care. You’re a volunteer, and the shift stopped being fun, because every visit cost an evening of catching up before you got to the part you liked. That’s what happened to mine.

It worked too well

In 2011, I was a law and business student1 trying to set up SharePoint for my law journal’s publishing workflow, and losing. WordPress already had revisions, permissions, and permalinks. All it was missing was documents, so I pitched bolting them on as a Google Summer of Code project, and WordPress picked it. My entire public reaction was “W00t I can haz Google Summer of Code.”2

WP Document Revisions launched that August,3 and then it did something side projects rarely do: it worked. Sites installed it and kept running it, and nothing broke badly enough to drag me back. Every few years, something would pull me in for a burst of work, and then I’d drift off again.

The closest the plugin came to forcing my hand was an email in April 2019 from a student editor at my old law journal. I hadn’t heard from the journal since I graduated, nearly six years earlier, and I’d assumed they’d moved on to something better. They hadn’t. Eight years after I’d built it, the journal still ran its publishing workflow on it.

Someone’s well-intentioned changes had broken it, and I was still the person they emailed. I was surprised, flattered, and a little humbled. Assume whatever you ship will still be running in ten years, long after anyone remembers why it works the way it does.4

A stranger kept it alive

While I was drifting,5 the plugin got lucky. In 2017, a stranger named Neil James filed a bug about its sidebar widget, and then he never left. (In the best way possible. Thank you, Neil.) He went from bug reports to features that became major releases, and he’s essentially co-maintained the plugin ever since, with more than a thousand contributions to show for it.6 From 2019 through 2024, he’s most of the chart above in every year but one. If you’ve used the plugin in the last few years, thank him.

One volunteer can only do so much. By 2023, I’d nearly stopped committing, and the plugin went 14 months without a release.

The cost of ignoring the plugin went up

WordPress.org says the plugin runs on more than 2,000 sites. One of them is the UK Ministry of Justice, whose intranet and WordPress hosting platform both build on it.

The plugin shipped two releases in 2024. Each went out the day Davey, a developer on the Ministry’s intranet, politely opened an issue asking for one, in March and again in June. Those requests were how I found out a government department depended on a plugin I wrote as a law student.

AI agents brought the cost of catching up down

Four failed attempts taught me how to work with an agent

Most old projects have a rewrite nobody wants to do. Mine was CoffeeScript, a language that compiles to JavaScript and was briefly the cool way to write it.7 I adopted it in 2013, opened an issue to get rid of it a decade later, and then didn’t touch that issue for a year and a half.

I handed it to an AI agent,8 and it failed. So did the next three. I closed all four without merging them. They left me four rules.

  • Check the work, not the summary. An agent will say it’s finished when it isn’t. The first attempt added a “modern” copy beside the old code instead of replacing it. The fourth converted one file and told me the rest were “already written in modern ES6+.” They weren’t.
  • Ask for changes small enough to read. The second attempt ballooned into 96 files and 21,000 lines. If you can’t review it, you can’t merge it.
  • Ask for evidence. When I asked the third attempt how I could be confident nothing would break, it replied, “You can be confident there are no breaking changes.” I asked for tests instead, which the plugin’s JavaScript had never had, and got 181 of them that night.
  • Give the agent a way to check itself. With those tests to check its work against, the fifth attempt converted all five files and passed every test.9

Eleven months after the first try, the last .coffee file was gone.

Review takes minutes, not evenings

The expensive part of maintaining an old project is catching up. You have to remember how the upload path works, rebuild the test environment, and read a three-year-old issue to figure out what the reporter meant. On a side project you touch twice a year, catching up eats the whole evening before you change a line.

Agents do the catching up. I point one at an issue and come back to a pull request with a fix and a failing test that now passes. My job is to read it and decide whether it’s right.

That’s a short job when the pull requests are small and the tests are real. Half of the 180 pull requests I merged this year landed within 10 minutes of opening. Those had a median of about 60 changed lines, and none could merge until every required check passed.10 Write down how the project works, too, because an agent is only as good as the docs you feed it.

Quick reviews turn into quick releases. One morning in September, Davey reported two bugs from the Ministry of Justice, a slow Media Library and a missing revision log. Both fixes merged that night and shipped the next day.11

The plugin shipped 33 releases this year, 23 of them small patches. The previous record was 11, set the year it launched.

Bar chart of releases per year of WP Document Revisions, 2011 to 2026. 11 in 2011 and 9 in 2012, then between zero and five a year from 2013 through 2025. 2026 has 33.

Agents do the chores maintainers skip

The work you rationally skip as a solo maintainer gets done now. Changelogs are written for humans. The 5.8.3 changelog explains what broke, who saw it, and what to do about it, instead of “misc fixes.” Weird edge cases get handled. One recent fix replaced a blank error page with a message that says what’s wrong.12

That work isn’t glamorous, and it doesn’t happen when each item costs you an evening.

The math flipped on my other projects, too

I maintain seven Jekyll plugins, and GitHub Pages turns five of them on by default for every site it builds. Across all seven, I made five commits from 2022 through 2024. This year, they’ve had 274 commits and 29 releases.13 word2md, my twelve-year-old Word-to-Markdown converter, has had 449 commits this year.

Moving fast made the plugin safer, mostly

The plugin published 11 security advisories this year, each explaining in plain language who was affected and what to do. That sounds like bad news. Most of it isn’t. Seven fixed holes, some of them years old, that otherwise wouldn’t have been found.

The other four are also on me. They covered code the agents wrote this year. In one, private documents uploaded through the new block editor panel were saved to an unprotected folder. The agent wrote that bug, but I’m the one who merged it. Humans still make mistakes, too. With more than 2,000 sites running this code, reading every diff is on me. I take responsibility for everything I ship.

What’s left is the fun part

The fun part of maintaining a project is adding new features, and going from an idea to a release, safely.

One evening in April, I decided the plugin’s WordPress.org page should have a Live Preview, so anyone can try it in their browser without installing anything.14 It shipped that night, and so did the fix for the file path the agent got wrong. For most of the plugin’s life, an idea like that would have stayed in my head until some free weekend that never came.

Every pull request arrives with its own tests, so I don’t have to write them. Aaron Jorbin, one of my Summer of Code mentors, taught me what a unit test was, and I’ve loathed writing them ever since. (Sorry, Aaron.)

The decisions are still yours. Even when the work is cheap, someone has to decide what the project is for, which feature requests to turn down, when a fix is risky enough to hold for a minor release, and what to tell users when something went wrong.

In 2024, the plugin shipped two releases, and a government department had to ask for both. This year, it shipped 33, and nobody had to ask.

Since my role at GitHub ended in July, open source has been a hobby again, the way it was in 2011. Contributing to open source has always been a kind of volunteering. It’s a lot easier to keep showing up when the shift is fun.

How to revive your own open source project with AI agents

If you’ve got a project where catching up looks more expensive than ignoring it, here’s where I’d start.

  1. Get CI green before anything else. Agents need a test suite to check their work against. If yours is broken, the first pull request you ask for is the one that fixes it.
  2. Turn on automated dependency updates. Dependabot or Renovate turns a year of drift into a stream of small pull requests you can merge between meetings.
  3. Write down how the project works. A short AGENTS.md (or CLAUDE.md) with the build, test, and lint commands saves every future session from rediscovering them. Good documentation makes AI tools better, and it helps the next human contributor, too.
  4. Start with the issue queue. Work it oldest first, one bug at a time. Each fix is a small, reviewable pull request, and the queue shrinks visibly.
  5. Review everything, merge nothing blind. Read the diff. Run it. If you wouldn’t merge it from a stranger, don’t merge it from an agent.
  6. Thank the people who kept it alive. If someone held the project together while you were gone, say so publicly. Mine is Neil, along with more than 50 other people.

Open the oldest issue in your side project’s queue tonight and ask an agent to take a pass at it. If the pull request it opens takes less time to review than the issue took to ignore, you’ve got your answer.

Footnotes

Footnotes 14
  1. Like Nathan Fielder, who opens every episode of his Comedy Central show Nathan for You with the line, I graduated from one of Canada’s Washington, DC’s top business schools with “really good grades.” ↩︎

  2. For the record, I’d like to think the few social media posts I still write have improved since then. ↩︎

  3. I spent that summer writing PHP with three WordPress developers looking over my shoulder: Mitcho Erlewine, Aaron Jorbin, and Jon Cave. Andrew Nacin, then one of WordPress’s lead developers, kept a close eye on it too. ↩︎

  4. A student journal replaces its whole board every year or two, so anything you build for one is built for strangers who’ll inherit it without you. Whoever inherits it won’t know who to email. Or worse, they will. ↩︎

  5. Mostly toward Ruby. In 2012, I moved this site from WordPress to Jekyll, a static site generator written in Ruby, and for the next decade, I wrote Jekyll plugins instead of WordPress ones. ↩︎

  6. When a user needed the plugin to work with WPML, a closed-source translation plugin, Neil talked WPML into giving him a sandbox and spent six months building an integration. That’s the kind of maintainer he is. ↩︎

  7. CoffeeScript had classes, arrow functions, and a cleaner syntax years before JavaScript did. JavaScript caught up in 2015, which took away the reason to use it. ↩︎

  8. Until my role at GitHub ended in July 2026, my agent was GitHub Copilot. Since then, I’ve used Claude Code. The workflow is the same either way: the agent opens a pull request, and I review it. ↩︎

  9. All 181 tests passed, and the fifth attempt added 113 more. It then added end-to-end tests that drive a real WordPress install in a browser, and they caught breakage the unit tests had missed. ↩︎

  10. The repository’s branch rules require the unit tests, the end-to-end tests, the WordPress.org Plugin Check, and a few build checks to pass before anything merges, including Renovate’s automatic merges. ↩︎

  11. Then he and Neil spent two weeks benchmarking queries against his database, to see if the Media Library could load faster. ↩︎

  12. That one covers a PHP upgrade that changes which account PHP runs as, so the server can’t read a document’s file anymore. ↩︎

  13. GitHub Pages pins its own versions of these plugins and updates them on its own schedule, so for now, most of those fixes only help sites that build with Jekyll directly, for example through GitHub Actions. Pages picked up a security fix for one of them in November 2026. ↩︎

  14. WordPress.org can launch any plugin in WordPress Playground, a full WordPress that runs entirely in the browser, if the plugin ships a small configuration file describing how to set it up. ↩︎

Keep reading

Ben Balter

I'm Ben Balter, and I write here about developer platforms, product and engineering leadership, open source, and showing your work. I spent over a decade building developer platforms at GitHub. For five years I was a product manager for trust and safety, shipping 500+ features and the API endpoints behind them to 50M+ developers. I also led a bottom-up rewrite of GitHub Pages and wrote the open source library behind GitHub's license detection, and my open source projects have hundreds of millions of downloads. I wrote Open and Async, the playbook for remote and distributed teams, and shipped a Model Context Protocol (MCP) server alongside it so agents can query it directly. More about the author

Follow along: Bluesky LinkedIn

Originally published November 15, 2026 View revision history

This page is open source Help improve this article on GitHub

Keyboard shortcuts

Search

  • / or ⌘ K Open search
  • ↓ or j ↑ or k Move through results
  • Enter Open the selected result
  • Esc Close search

Go to

  • g then h Home
  • g then p All posts

This page

  • y Copy link to this page
  • ? Show this list

Turn off if you use voice control or keep triggering them by accident. ⌘ K still opens search, and this list stays under "Keyboard shortcuts" in the footer.