What Open Source Taught Me About My Agents

My first open source pull request got merged this month, about two hours after I opened it. That felt great, so I kept going. Two weeks later I have five merged pull requests in a big Apache project, an AI agent workspace that logs everything an agent does on your machine.

Part of why I picked it: I’ve been building alone for the past year, and every rule I work under is a rule I made up, mostly for my AI agents. I wanted to see what it’s like to work under rules that aren’t mine.

I thought the hard part would be understanding the code. It wasn’t. The code was normal code. Everything around the code was the actual lesson. The rules pushed back on me all week and cost me real time, and somehow none of it annoyed me. Figuring out why took the full two weeks.

Nobody hands you the keys

The first surprise was how little I could do by myself. A CI job failed on a test I’d never touched, and I couldn’t even rerun it. I had to leave a comment explaining why I thought it was a flake, then wait for a maintainer to come press the button. Some of my pushes wouldn’t run any checks at all until a human approved them. And an approval only counts for the exact commit the reviewer saw. I force-pushed once, and the approval I already had simply expired; someone had to come review the branch again.

The work isn’t yours just because you asked first. While my second fix sat in review, another contributor showed up with a competing fix for the same issue, and the reviewer compared the two in public before picking one. Mine won that round, but the message was clear: an issue stays yours only while you keep it moving.

Main doesn’t wait for you either. My biggest pull request sat in review for three days, main kept moving underneath it, and I had to catch up and get everything green again before it could go in.

And versions. I had never once thought about old versions of my own software: at home there’s one version of everything, mine, running on my machine. Out there, older copies of the app are still talking to newer ones, so one review sent my change back until I could prove an old client would fail politely against my new code instead of crashing. My code has to stay compatible with old versions I’ll never see running.

Strangers make you write better

There are no meetings. Everything happens in writing, in public, in front of people who owe you nothing. Some review comments came in English and Chinese in the same message.

That changed how I write, fast. Getting my CI job rerun meant writing an explanation clear enough that a busy maintainer would act on it. My biggest pull request only went through after I cut it by a third and moved the rest into a separate issue, because nobody wants to review a huge diff from a stranger. Two weeks of this and my pull request descriptions are better, my commit messages are better, and honestly my thinking is a little better too. You can’t write lazy explanations for a reader who can just say no.

The rules don’t take it personally

None of the pushback actually hurt, and that’s not like me. I’ve sulked over much softer feedback than a blocked merge.

I think it’s because the rules apply to everyone the same way, visibly. The severity levels that blocked my merges block the maintainers’ merges too. The bot that expired my approval expires everyone’s. At one point a reviewer realized they’d approved something of mine too quickly, took the approval back in public, and said the mistake was theirs. The same bar catches everybody, and everybody can see it.

So when my work got blocked, there was nothing personal in it to be upset about. It just meant more work.

I’m the agent now

About halfway through, I realized I’d seen this pattern before. A new person shows up and gets small tasks. Everything they do gets reviewed by someone more senior. People check your work less as your track record builds. None of it is hidden: the trust levels are written down, and each level is granted by a vote of the people already on it.

That’s exactly how I treat my AI agents. Just last week, in The Run Outlived the Ask, I wrote about keeping them on short, supervised tasks and only giving them more room as the evidence comes in. When I wrote it, I was the one handing out the trust. Then I spent two weeks waiting for strangers to approve my checks, and felt the same policy from the other side.

In that project, I’m the agent.

That realization made me feel better, in both directions. The project watches me closely because it doesn’t know me yet, and my agents get watched closely for the same reason. That’s how you treat anyone new, human or not.

Half of it can’t be earned

One more thing about this project: it’s full of AI, openly. Every pull request has to say which AI tools touched it. Commits carry a line naming the model that generated them, the same kind of line I once wrote about finding in my own git log. Reviewers say which parts their AI checked and which parts they verified themselves. And with all of that, the place still merges dozens of pull requests a day.

I think it works because one rule is fixed: every contribution has a human name on it, and merging is always a human’s decision. An AI there can build a track record and get more freedom, same as me. But when something goes wrong, somebody has to answer for it, and answering needs a name. The AI doesn’t have one to give.

My summer rule said trust should follow the evidence. I now think that rule only covers what an agent is allowed to do. A track record doesn’t change who answers for the work. That was decided before anyone showed up.

Handing one back

My favorite moment came at the end. I’d filed a follow-up issue, fully planning to build it myself. Within a day a maintainer tagged it “help wanted”, and a stranger asked if they could take it, the same polite way I’d asked for my first issue. For a second the old reflex fired: my idea, my follow-up. Then it passed, faster than usual, and I sent them my notes that same day. When their code shows up, I’ll be one of the people reviewing it.

While writing this post I noticed the project let me in the same way. My first issue was one that somebody had claimed and then gone quiet on, and I asked to take it over. Two weeks later somebody asked to take over mine. Nobody blinked either time. Work there flows to whoever is actually moving it.

All of this is slower than working alone, and there’s no way around that. At home I merge in three minutes; over there my biggest change took three days and five people. But a three-minute merge is just me agreeing with myself. The three-day one had other people looking at it, which was the point of going.

Two weeks in, the project still doesn’t know me. It knows my five pull requests, and that’s how far it trusts me. My agents get the same deal from me, and I used to feel a little bad about that. Then I spent two weeks on the receiving end myself, and I can report back. It feels like being taken seriously.