Open Source Myth Busting: The 0.01 Percent Who Actually Write the Code
Archi4 min read
Contents
- The Number That Reframes the Whole Debate
- Myth 1: Most Users Contribute Back
- What teams can do
- Myth 2: More Eyes Means More Bugs Found
- Myth 3: Corporate Money Flows to the Small Dependencies
- Myth 4: A License Settles the Legal Question
- Myth 5: Forking Is a Real Fallback
- Reading the Numbers Before You Adopt
The Number That Reframes the Whole Debate#
Ask someone how open source works and you will usually get a story about crowds. Thousands of eyes. Developers everywhere pitching in. The reality is narrower and stranger. In most large projects, a small core of people writes the overwhelming share of the code that ships. For many widely used libraries, the number of regular committers sits in the low single digits.
That gap between the crowd in the story and the room in the code review is where most open source myths go wrong. Here are five of them, checked against how projects actually run.
Myth 1: Most Users Contribute Back#
Fact: The ratio of users to contributors is closer to a rounding error than a share.
Take a library embedded in thousands of commercial products. It might log millions of downloads a month. The people who filed a pull request in the last year could fit around a small conference table. Projects that publish contributor graphs tend to show the same shape: a long tail of one-time patches and a flat line of repeat authors.
This matters for planning. If your company depends on a package with three active maintainers, you are not an outlier. You are typical. The question worth asking is not whether the community will fix your bug. It is whether anyone is awake when a security report lands at 2 a.m. on a Saturday.
What teams can do#
, Count the maintainers, not the stars., Check the date of the last release and the last merged pull request., Look for a funded maintainer or a company with a clear stake.
Myth 2: More Eyes Means More Bugs Found#
Fact: Eyes only help if they are looking, and most never do.
A dependency can be read by thousands of engineers every day and still go unexamined, because reading someone else's code is work nobody is assigned. Famous failures in widely used libraries have shown this repeatedly: the bug was in plain sight, the code was public, and still it survived for years.
Public visibility is a precondition for review, not a substitute for it. The projects that catch problems early usually have a reviewer with a name and a habit of reading diffs. Pure transparency without staffing produces a comfortable illusion.
Myth 3: Corporate Money Flows to the Small Dependencies#
Fact: Funding clusters where the business case is visible, and small libraries often sit outside it.
The big projects get the sponsorships, the foundation seats and the headcount. The 400-line parser that everything depends on may get nothing. A maintainer of a small but widely used package can go years without a single donation large enough to cover a laptop.
This is an incentive problem, not a moral one. Companies pay for what they can see on a slide. A transitive dependency four levels deep does not appear on any roadmap. The surprising number here is how little separates a package from total obscurity: often one maintainer and one repository with no funding link.
Myth 4: A License Settles the Legal Question#
Fact: A permissive license answers what you may do with the code. It does not answer what happens when the only person who understands the build system leaves.
The license is the easy part. The harder questions are operational. Who has commit access? Which continuous integration services will still run when a maintainer loses interest? Is there a copy of the build environment that works without a specific cloud account?
Companies that audit licenses and ignore these questions are checking the receipt and skipping the wiring. When a maintainer steps away, the license grants you the right to fork a project nobody on your team knows how to compile.
Myth 5: Forking Is a Real Fallback#
Fact: The right to fork is broad. The capacity to fork is narrow.
A fork needs people who can read the codebase, triage incoming issues, manage releases and keep downstream users from drifting. Most organizations cannot staff that for a project they already depend on, which is precisely why they depend on it.
Forking works when a company has engineers who already know the code and a commercial reason to keep it alive. It fails when the plan is to fork and hand it to a team that has never opened the repository.
Reading the Numbers Before You Adopt#
None of this argues against open source. It argues for reading the maintenance record the way you read a security advisory. A short checklist beats a long procurement process:
- How many people merged code in the past twelve months?
- How long has the oldest active maintainer been involved?
- Is there a published process for security reports?
- Does any organization pay someone to work on it?
A project with one funded maintainer and a clear release rhythm can be safer than one with a thousand stars and a silent issue tracker. The crowd is real. It is just smaller than the story suggests, and knowing its size is the first useful step.
More articles