I am brainstorming

Why the World Needs More Open Source (FOSS) Software Architects

Date: 30-03-2026

The world today does not merely suffer from bugs—it suffers from bad design. Systems that shape our lives—social media, financial markets, governance platforms—are increasingly chaotic, not because humans are inherently disordered, but because the scaffolding beneath these systems is flawed. What matters is not just what we build, but what we build on top of. When the foundation is weak, even the most polished features collapse into dysfunction.

The Crisis of Bad Design

Look at modern social media. Platforms optimized for engagement have unintentionally become engines of outrage. Algorithms reward virality over truth, speed over depth, and reaction over reflection. The result is an information ecosystem polluted with disinformation, echo chambers, and shallow discourse. This is not a content problem—it is a protocol problem. The rules of the system incentivize the worst of human behavior.

Similarly, our economic systems often prioritize speculation over value creation. Markets externalize costs—environmental damage, labor exploitation—while internalizing profits. Public goods remain underfunded because the system lacks mechanisms to reward collective benefit. Again, this is not a failure of participants, but of architecture.

Bad systems produce bad outcomes, even with good people.

Developers vs Architects: A Fundamental Difference

At the heart of this issue lies a misunderstanding of roles in technology.

A software developer executes. They build features, fix bugs, and ensure that what is specified gets delivered. Their work is essential—but bounded.

A software architect, however, asks deeper questions. They define the structure within which all developers operate. They think in terms of systems, incentives, and long-term consequences. Where a developer asks, “Does this function work?”, an architect asks, “What kind of world does this system create?”

This distinction becomes critical when systems affect millions—or billions—of people.

Thinking in Protocols, Not Products

Architects do not just build applications; they design protocols. A protocol is a set of rules that governs interactions in a system. It defines what is possible, what is rewarded, and what is forbidden.

Consider the internet itself. Protocols like HTTP and TCP/IP enabled a decentralized web where no single entity controlled all information. But over time, applications built on top—centralized platforms—reintroduced control and power concentration.

Now, a new generation of architects is rethinking this foundation.

Take the rise of decentralized social protocols like ActivityPub and AT Protocol.

These are not apps—they are foundations:

• ActivityPub powers platforms like Mastodon, enabling federated social networks where servers interoperate instead of competing in isolation.
• AT Protocol reimagines social media with portable identities, algorithmic choice, and user control over data.

In both cases, the goal is the same: No single entity should control the flow of information.

This is architectural thinking. Instead of building “another Twitter,” these protocols redefine what social media is allowed to be.

The Power Imbalance of Client-Server Systems

Most of today’s internet operates on a client-server model. This architecture inherently creates power asymmetry:

• The server owns the data
• The server controls access
• The server defines the rules

Users become dependent, not empowered.

This imbalance is not accidental—it is structural. Even well-intentioned companies eventually optimize for control, because the architecture allows it.

In contrast, peer-to-peer systems distribute power. There is no central authority to dictate terms. Trust is embedded in the protocol, not delegated to corporations. This shift is not just technical—it is philosophical. It redefines relationships between individuals, institutions, and information.

Projects like Iroh and Freenet aim to rebuild the internet using peer-to-peer (P2P) protocols. In these systems:

• Data is distributed, not stored in centralized servers
• Control is shared among participants
• Censorship becomes harder
• Ownership shifts back to users

This is architectural thinking: redesigning the rules of the game, not just the interface.

Blockchain: Promise vs Reality

Blockchain was introduced as a breakthrough in economic architecture—a way to design programmable money and trustless systems.

At its core, blockchain enables:

• Transparent and immutable records
• Decentralized coordination without intermediaries
• Programmable incentives through smart contracts

The vision was profound: Rebuild economic systems from first principles.

But in practice, much of the ecosystem has drifted toward:

• Speculative trading
• Token gambling
• Short-term profit extraction

Instead of solving real economic problems, many systems amplify volatility and inequality.

This is not a failure of the technology—it is a failure of architecture.

The Need for Real Economic Protocols

What we truly need is not more tokens—but better economic protocols.

Imagine systems where blockchain is used to:

• Coordinate decentralized supply chains with transparency and fairness
• Enable community-owned infrastructure
• Fund public goods through programmable incentives
• Build decentralized governance where decisions are transparent and participatory

These are not hypothetical—they are architectural opportunities.

The difference lies in intent:

• Speculative systems extract value
• Well-designed protocols create value

Blockchain architects must shift the focus from financial engineering to economic design.

Open Source as a Moral and Structural Choice

Free and Open Source Software (FOSS) is not just about transparency—it is about freedom to reshape systems. When code is open:

• Anyone can audit the rules
• Anyone can fork and improve the system
• No single entity can permanently monopolize control

But openness alone is not enough. If the underlying architecture is flawed, open source simply replicates broken systems in public.

This is why we need FOSS architects, not just FOSS developers.

Architects ensure that openness extends beyond code into governance, incentives, and power distribution. They design systems that are resilient, fair, and aligned with human values.

From Cloning to Reimagining

Much of today’s innovation is imitation. We build clones of existing platforms—another social network, another marketplace, another messaging app—without questioning the assumptions beneath them.

But copying a broken system does not fix it.

The world does not need more efficient versions of flawed ideas. It needs new architectures that solve root problems:

• Information systems that reward truth over virality
• Economic systems that fund public goods sustainably
• Social platforms that encourage meaningful discourse

This requires stepping back from features and asking first-principles questions:

• What incentives does this system create?
• Who holds power?
• What happens at scale?
• Can it survive misuse?

These are architectural questions.

The Role of the FOSS Architect

A FOSS architect operates at the intersection of technology, philosophy, and society. Their work is not just to build software, but to design systems that shape behavior.

They:

• Think in decades, not sprints
• Design protocols, not just applications
• Anticipate failure modes and abuse
• Embed fairness and resilience into the system
• Enable collective ownership and participation

In a world increasingly governed by code, architects are the new institutional designers.

Conclusion: Rebuilding the Foundations

We are living in systems that no longer serve us—not because we lack talent, but because we lack architectural vision. Developers alone cannot fix this. We need people who can rethink the foundations.

The future will not be determined by who builds the most features, but by who designs the most meaningful systems.

We don’t need clones of systems that failed us.

We need architects who are willing to rebuild the world—from the protocol up.