This week, I received two feature requests.
Both technically feasible. Both framed as small. Both designed entirely around one person’s workflow.
And both would have made the codebase worse in the long run.
In the first case, the requested feature would have fundamentally changed how the plugin behaves. On the surface it looked minor, but architecturally it meant shifting the design philosophy. I declined. The response was predictable: “It’s actually very simple.”
Maybe it is simple in terms of lines of code. That is not the point.
So I sent the repository link and said: feel free to submit a PR.
The reply was not a PR. It was a long explanation about why the plugin “does not work at all currently,” why alternatives are overpriced, why S3 is obviously superior, why shared hosting is terrible, and how it is ultimately my decision anyway.
Ironically, that last sentence was the only accurate one.
It is my decision, because I am the one who has to maintain it.
In the second case, someone suggested a feature that might benefit one out of a thousand users at best. If I implement it, one person is happy. The codebase gets heavier. The mental load increases. Every future change becomes slightly harder. From the outside, it looks harmless. Just another option.
This is where most people misunderstand open source.
Adding a feature is cheap. Maintaining it is expensive.
Every new branch in the logic tree becomes something you carry for years. It interacts with other plugins. It creates new edge cases. It requires documentation. It generates support emails. It complicates refactors. It increases cognitive load in ways that are invisible at first.
The person requesting the feature rarely stays around for that part.
The maintainer does.
I am not some legendary FOSS gatekeeper running a massive foundation project. I maintain a few plugins. Even in a completely normal week, I still deal with the same pattern: a small request, framed as simple, but architecturally expensive.
Open source is not a custom software service. It does not mean every workflow becomes first-class. It does not mean the roadmap is crowdsourced. It means the code is open. You can fork it. You can modify it. You can build exactly what you need.
What you cannot do is shift your long-term maintenance cost onto someone else and call it a small improvement.
Maintainers are gatekeepers because they have to be. Without that boundary, you do not get a coherent product. You get an accumulation of preferences.
Sometimes the most honest answer is blunt.
Fork it!
Not as hostility. As clarity.
If the feature truly belongs in the core, implement it and make a solid case. If it only serves your unique workflow, own that uniqueness.
FOSS is not just about the code. It is about deciding which code you are willing to carry forward. Now that generating code has never been easier, that decision matters even more. Lowering the barrier to contribution is a good thing. Lowering the barrier to responsibility is not. When code can be written in seconds, the ability to say no matters more than ever.
Saying no is not ego. It is maintenance.
Leave a Reply