Linux advocates talk about how “open” their software is.
The truth is that it’s open to people who code. Everyone else can fuck off.
A designer can’t contribute without learning Git workflows and terminal commands. A copywriter can’t improve docs without understanding repository structures. A marketer can’t shape messaging without passing through the developer approval gauntlet.
You say you want mainstream adoption. You say you need designers and marketers. But when they show up, you hand them a CLI and wonder why they leave.
Then you complain that your project looks like 2006.
The GitHub Moat
The entire OSS ecosystem runs on developer tools. GitHub, GitLab, Git workflows—excellent tools for developers. Useless moat for everyone else.
Here’s what happens when a designer tries to contribute:
Designer spends six hours on UI mockups. Real research. Real work. They figure out enough GitHub to submit an issue. Then they wait for a backend dev with zero design training to review it. Feedback comes back: “doesn’t align with our architecture” or “not technical enough.” Issue sits untouched for months.
Designer gives up.
They had expertise. They had value. The contribution model filtered them out before any of it mattered.
Technical writers who could make your docs readable? Bounced. Marketers who could explain what your product does without jargon? Bounced. Product managers who prioritize based on user needs instead of technical novelty? Bounced.
All hitting the same GitHub wall.
The Benevolent Dictator Problem
Even when non-devs navigate the technical barriers, they hit something worse. No real power.
OSS projects love the “benevolent dictator” model. One person (always a developer) makes final decisions. Contributors suggest. Dictator decides. Prevents design-by-committee paralysis, sure. Also means developers control everything—including shit they don’t understand.
Designer submits a complete UI overhaul backed by user research. Developer who last studied design in 2003 (maybe) rejects it because it “doesn’t feel right.”
Marketer proposes messaging that normal humans can understand. Developer rewrites it to be more “technically accurate,” adding back all the jargon.
User researcher shows that your workflow confuses everyone. Developer dismisses it because “power users don’t have that problem.”
This isn’t collaboration. It’s a suggestion box.
Non-devs can suggest. Developers decide. And developers pick technical elegance over market viability every time, because that’s what they understand and that’s what gets GitHub stars.
What Real Openness Looks Like
If you’re serious about building a market competitor—not a hobby project with delusions—here’s what changes:
Accessible contribution channels. Not GitHub Projects. Not another dev tool repurposed for non-devs. Something built for cross-discipline collaboration. LeanTime. Open source Kanban. Notion’s free for OSS projects and more accessible than anything in the Git ecosystem. Pick one. Use it.
Separate decision-making authority. Design decisions approved by designers. Marketing approved by marketers. Code approved by developers. Stop filtering everything through a developer-dictator who thinks they’re qualified to rule all domains.
This isn’t developers giving up control. It’s developers admitting they’re not qualified to make every decision. You wouldn’t let a designer dictate database architecture. Stop dictating their UI choices.
Clear governance. Who has authority over what? How are decisions made? What happens when domains overlap? Document it. If designers don’t have actual power over design, you don’t have designers. You have unpaid consultants you ignore.
The Examples
PayloadCMS gets it. Building a real WordPress competitor. Created great dev experience AND great UI for marketers. The admin interface doesn’t look like it was designed by someone who thinks “user-friendly” means adding tooltips. Actually intuitive. Actually polished. Actually competitive.
Not there yet on full market ecosystem. But the foundation works because they recognized developers alone can’t build products for non-developers.
Redmine is the counter-example. Powerful tool. Flexible. Enterprise-ready (Siemens uses it). Looks like 2006. The UI is a usability disaster. Works if you’re a dev willing to climb the learning curve. Turns off everyone else.
Solid market ecosystem around Redmine because it solved technical problems. Could’ve been so much bigger if anyone with design sense had decision-making power over the interface.
Hobby or Market Competitor—Pick One
Every OSS project needs a declaration in the README:
“Hobby project. Contributions welcome, no roadmap, no commitments. Use at your own risk.”
Or:
“We’re building a market competitor to [proprietary alternative]. We need designers, marketers, users—not just developers. Here’s how to contribute. Here’s who has authority in each domain.”
Both valid. You can’t claim the latter while operating like the former.
Hobby project? Fine. Build what you want, how you want. No shame in that.
Building a serious Adobe/Microsoft alternative? Then act like it. Give non-devs the tools and authority to contribute in their domains. Admit you don’t know everything. Play the game competitive products play.
The Ask
Project maintainers: Set up accessible contribution channels this month. Define governance. Give designers authority over design, marketers over marketing. Or admit you’re a hobby project and stop complaining about adoption.
Developers: Stop gatekeeping. Backend expertise doesn’t make you a design expert. When a designer with actual training gives feedback, listen. When a marketer says your messaging is incomprehensible, believe them. Defend technical decisions. Get out of the way on everything else.
Designers and marketers: Stop waiting for permission. Find projects claiming they want help and test if they mean it. If they make you jump through dev hoops with no power at the end, leave. Find projects that give you authority or build your own.
OSS has a market problem. Starts with a contribution problem.
You can’t compete with Adobe’s polish using developer-only contributions. You can’t steal marketshare from proprietary alternatives while locking out people who know how to communicate with non-developers.
Linux has a window. Denmark switching. Gamers switching. Windows shitting the bed.
Window closes if the community keeps doing the same insular developer-only bullshit.
Real openness means more than open code. Open contribution. Open decision-making. Open acknowledgment that developers don’t have all the answers.
Prove it or stop talking about mainstream adoption.