Is contributing to FOSS worth it?
I used to contribute to quite a few FOSS projects. Lately I have stepped back from several, especially the ones where the attention required started to feel out of proportion to what I got back.
Take packaging work for GNU Guix, where I was briefly involved. This
PR updated a package I maintain, emacs-jabber. Writing the recipe
took roughly five minutes. After an initial positive review, the
thread expanded into a longer discussion about dependency handling,
recursive checkouts, and vendored cryptographic code. There was no
clear owner of the review and no obvious stopping point. The total
attention cost ended up being many times higher than the original
contribution.
I am not singling Guix out. Plenty of projects have the same structural problem: review processes that can turn small patches into open-ended attention sinks. When I can point an agent at the same task and iterate quickly, or just maintain the package outside the main distribution, the old calculation stops making sense.
The question is no longer “can I do this?” It becomes: Is my limited attention better spent here than somewhere else?
This does not make all FOSS contribution pointless. It just raises the bar. A contribution is worth my attention when it teaches me something new, meaningfully improves a tool I actually use, or connects me with people whose judgment I value. That thread did none of those things.
Nobody becomes a better Schemer by writing yet another package recipe and reading build logs. An agent running a decent model could have handled most of that loop and caught the obvious review points. Without clear policy and explicit review expectations, even a checklist-driven agent can be more useful than unstructured human review.
This applies to any contribution where the work itself is now cheap enough that a model can do it for a few cents, but the human coordination around it has stayed expensive. At that point, doing it by hand is no longer obviously worth your attention.
Code has become cheap
ESR recently wrote that the age of hand-coding is mostly over. I think he is mostly right. The real shift is not that humans stop writing code. It is that code has become cheap enough to meaningfully increase individual autonomy.
When I already know what I want a tool to do, what stack it should use, and how it should fit into my workflow, I no longer need to hunt for an existing project, evaluate its abstractions, adapt my process to it, or inherit its maintenance burden. A local model can just generate a focused implementation for me.
This changes the dependency relationship. Instead of relying on third-party developers I do not know, whose priorities, judgment, and long-term commitment are always uncertain, I can produce exactly what I need. The result is often higher quality for personal use, because it contains only the behavior I want and none of the assumptions or baggage I do not want.
Cheap code does not just make development faster. It reduces the need to outsource small but important parts of my computing environment to strangers.