I Maintained a Popular Open Source Project for 3 Years—Here’s What Actually Kills Them (And It’s Not What You Think)
I ran a 12,000-star GitHub repo for three years. A Python microframework for building event-driven APIs. It was my baby. I poured nights, weekends, and more than a few vacation days into it.
And then I walked away.
How We Built a Multi-Agent Customer Support System in 4 Weeks — A Real Vietnam Offshore Case Study
How We Built a Multi-Agent Customer Support System in 4 Weeks — A Real Vietnam Offshore Case Study… ...
Not because the code was bad. Not because the community didn’t care. Actually, the opposite. The community cared *too much* — in all the wrong ways.
Here’s the real story of what kills open source projects. And it’s probably not what you’re expecting.
Cursor vs Windsurf vs Claude Code: Which AI IDE is Best for Your Team?
We tested the three most popular AI-powered IDEs with our development team over 3 months. Here’s what we… ...
The Myth: “Bad Code Kills Projects”
Everyone assumes open source projects die because the code is messy, unmaintained, or technically obsolete.
That’s wrong.
I’ve seen projects with spaghetti codebases thrive for years. I’ve seen beautifully architected repos go dark in six months. The code quality is rarely the deciding factor.
What actually kills them? The invisible tax of being a maintainer.
Let me break down the three real killers.
Killer #1: The PR Graveyard
You know what I spent most of my time on? Not writing features. Not fixing bugs.
Reviewing PRs.
In my final year, I received 847 pull requests. I merged 89 of them. That’s a 10.5% acceptance rate.
Why so low? Most PRs were:
- One-line formatting changes that violated the project’s style guide
- “Fixes” that introduced three new bugs per line changed
- Feature additions that solved a problem only the submitter had
- PRs that didn’t bother reading the CONTRIBUTING.md file (which I spent 12 hours writing)
Here’s the math: Each PR took me an average of 15 minutes to review and respond to. That’s 127 hours per year. Just on *rejecting* contributions.
I could have built three major features in that time.
The real cost of “community contributions”
People love to say “open source is free labor.” It’s not. It’s labor you’re subsidizing with your own time. Every contributor who opens a low-quality PR is stealing from your development budget.
I started tracking it. 73% of first-time contributors to my repo never submitted a second PR. They’d fire off a half-baked change, get rejected, and disappear. I’d waste 20 minutes explaining why their PR didn’t pass CI, and they’d never even read the response.
Solution? I eventually automated 90% of my PR triage with a GitHub Actions workflow that ran linting, type checking, and test coverage before I even looked at it. It dropped my review time by 60%. But that took two weeks to build.
Killer #2: The Emotional Drain
This is the one nobody talks about.
Open source maintainers are support staff. For free.
I got:
- 15-20 GitHub Issues per week
- 30-40 emails from people asking “how do I install this?”
- DMs on Twitter, LinkedIn, and even my personal blog
- One guy who found my phone number and called me at 11 PM to ask why his deployment failed
The worst part? The entitlement.
I had someone file a bug report that was literally “your library sucks, fix it.” No reproduction steps. No logs. Just a demand.
Another user opened an issue titled “This is broken” with a screenshot of a 500 error from their own code. When I asked for details, they replied, “You wrote it, you fix it.”
That’s when I started questioning my life choices.
The loneliness factor
You’re the only person who understands the entire codebase. Every architectural decision, every edge case, every workaround. There’s nobody to delegate to. Nobody to share the load.
I spent 18 months as the sole maintainer. In that time, I had:
- 2,347 commits
- 1,892 closed issues
- 847 PRs reviewed
- 0 co-maintainers who stuck around for more than 3 months
The turnover was brutal. People would volunteer, contribute for a few weeks, then disappear. I’d spend a month onboarding someone, only to have them vanish. Each time, I lost a piece of my motivation.
Killer #3: The “Feature Creep” Death Spiral
Here’s a pattern I see everywhere: a project starts lean. It does one thing well. Users love it.
Then the requests pour in.
“Can you add WebSocket support?” “What about a CLI?” “Why doesn’t it integrate with Kubernetes?”
You say yes to a few. Then a few more. Suddenly, your 2,000-line codebase is 50,000 lines. Your documentation is a mess. Your test suite takes 45 minutes to run.
You’ve lost the plot.
Your project now does everything poorly instead of one thing well. New users are confused. Old users are angry about the bloat. You’re maintaining features you don’t care about.
I did this. I added a plugin system, a CLI tool, and three database adapters. All because people asked. All because I wanted to be “responsive to the community.”
It nearly killed the project.
The escape hatch
I eventually did a hard reset. I deprecated 60% of the features, moved them to separate repos, and went back to the core library. It was painful. I lost 40% of my user base. But the project survived.
Here’s the lesson: Saying no is a feature, not a bug. The most successful open source projects are the ones with a clear, narrow vision. They’re opinionated. They reject more than they accept.
The Real Fix: What I’d Do Differently
If I could go back, here’s what I’d change.
1. Automate everything early. Don’t wait until you’re drowning. Set up CI/CD on day one. Use Dependabot. Write a CONTRIBUTING.md that’s brutally specific. I now use a GitHub Action that auto-closes PRs that don’t pass linting, with a template explaining why.
2. Recruit co-maintainers from your users, not your contributors. The best maintainers I found were people who had used the library for months and understood the pain points. They weren’t the ones submitting PRs. They were the ones filing detailed bug reports with reproduction steps.
3. Set boundaries. I now have a “no support via DM” policy. All questions go to GitHub Discussions or Stack Overflow. It sounds harsh, but it saved my sanity. People respect boundaries if you enforce them consistently.
4. Embrace the “benevolent dictator” model. Democracy doesn’t work in open source. Someone needs to make the hard calls. That someone is you. Stop trying to make everyone happy. You can’t.
Why This Matters for Your Team
At ECOA AI, we work with a lot of teams in Vietnam — in Ho Chi Minh City and Can Tho — who contribute to open source as part of their development workflow. I’ve seen firsthand how the right team culture can make or break an open source project.
The best contributors we’ve hired from Vietnam share one trait: they read the documentation before asking questions. They understand that open source is a relationship, not a transaction. They write clean, testable PRs that respect the maintainer’s time.
That’s rare. And it’s valuable.
If you’re building an open source project, or contributing to one, remember: the code is the easy part. The hard part is the people.
Frequently Asked Questions
Q: How do I get started contributing to open source without annoying the maintainer?
Start small. Read the CONTRIBUTING.md file. Look for issues tagged “good first issue” or “help wanted.” Submit a documentation fix or a test improvement before touching any core code. And always, *always* ask before starting work on a feature — nothing frustrates a maintainer more than a 500-line PR for something they never wanted.
Q: What’s the best way to increase my PR acceptance rate?
Follow the existing code style exactly. Run the linter before pushing. Write tests for your changes. Keep PRs small — under 200 lines if possible. And include a clear description of what you changed and why. PRs that require no back-and-forth get merged 3x faster.
Q: Should I start my own open source project?
Only if you’re prepared for the maintenance burden. Start with a single, focused feature. Don’t accept feature requests for the first six months. Build a small, happy user base before scaling. And find at least one co-maintainer before you hit 1,000 stars — that’s when the noise really starts.
Q: How do I handle toxic users without burning out?
Block them. Seriously. You’re not a public utility. If someone is abusive, disrespectful, or wasting your time, close the issue and ban them. The 99% of reasonable users will thank you for it. A healthy community requires active moderation.
Related: affordable software outsourcing — Learn more about how ECOA AI can help your team.
Related: outsource software development — Learn more about how ECOA AI can help your team.
Related: software outsourcing services — Learn more about how ECOA AI can help your team.
Related reading: Vietnam Outsourcing: Why It’s the Smartest Move for Software Development in 2025
