Pause fixing each mess in isolation, building process that composts mess into more useful paths

This #blocking conversation on the #oxfordboaters chat is a intolerant conflict between trying to manage the immediate problem and building the collective process needed to stop the same problems recurring. Lets look through a needed #KISS lens at the cludge between reactive (stupid)individualism and the harder work of building community structures.

The immediate conflict is a symptom, not the underlying problem

The conversation is filled with suspicion and frustration about people, conduct, and the proposed response to HT. There is a concern, and a #blocking that the group is accommodating behaviour that should be challenged. This is a two sided mess we need to compost as these conflicts become more damaging because the group lacks the processes and structures needed to deal with any collective working path.

Politeness and niceness become tools of control

The articles smiling-faced vileness and WhatsApp plebiscites reveal the wider mess we need to compost. That enforced niceness discourage the needed confrontation, that composting is about. Our focus on informal #dotcons chat platforms encourage reactive opinions and shallow consensus rather than sustaining any working collective decision-making. People trying to challenge dysfunctional paths are framed as the problem because they make the people blocking and obscuring uncomfortable.

In this self creating mess, the pressure to remain agreeable prevents a working group empowered culture from developing the capacity to act effectively. This is not an argument against kindness, it is an argument against using politeness as a weapon of control to substitute for accountability, political clarity and collective action we need.

The current flipping of #WhatsApp groups is this same problem because it shapes the process. This is a part of the blinded objection to setting up the #opencollective page, its unthinking #blocking, not merely technological. The group had an opportunity to move away from the limitations of the #dotcons but instead blindly reproduced the same failed patterns and paths that are shaping the current mess.

The underlying argument here is simple that the tools we use shape what we can collectively do. When the group stays locked into a reactive chat environment, where decisions emerge through fragmented discussion and informal fear based influence, it becomes harder to maintain any shared direction, to challenge obstruction or organize sustained work we need. The medium is helping to reproduce the dysfunction we already suffer from.

The group needs basic, half step, working activism infrastructure, like moving to Signal chat from WhatsApp, not just more noise, and blind reaction inside the #dotcons. Then we have #OpenCollective role in cutting through and composting this crap, to establish a clearer organizational and resource base. then the simple process of Working Groups give people defined areas of responsibility and #KISS accountability, with out this the is ZERO trust that we can deal with conflict without repeatedly returning to the same informal blocking arguments and paths.

The purpose for this change is not bureaucracy for its own sake, it is to make collective action possible without relying entirely on personal relationships, goodwill or whoever happens to be most active in the chat.

Working groups are not a magic solution

Yes, working groups often disappear, and the same people end up doing all the work. That is a genuine challenge to any horizontal path. Composting is not just adding more material to the pile, it requires active work to turn the material into something useful. A working group without responsibility, follow-through and a shared direction is just another layer of organizational clutter. What it dose give us, and what we need, is transparency and focus, it can be used as a path to organically work round the nasty-ness of smiling passive blocking.

We need to focus, on taking responsibility for growing the path out of our group’s own dysfunction. The difficulty is not an external force that the group can do nothing about, the group is reproducing its own problems through its current practices. Instead of treating every dispute as a fresh crisis caused by particular people, the group needs to examine the conditions that allow the same patterns to recur. That means moving past blame to structure, from reaction to process, and from informal influence to shared responsibility.

The immediate HT response is distracting from the work

The disagreement is not necessarily about whether NBTA proposed response is factually or tactically sound. It is about whether solving the immediate problem is being allowed to substitute for fixing the conditions that keep producing these problems. The group needs an active pause, to examine the wider issues and decide whether it is willing to pursue a more functional collective path.

What is not working or sustainable is the current messy flow of immediate conflict, suspicion, frustration, disagreement. We need to compost the mess of enforced niceness, reactive chat, informal power and avoidance of any difficult questions. Its been a year and we still have no reliable shared process, clear responsibilities or sustained collective organization. OpenCollective, working groups, #KISS structures and accountable processes. So the question that matters is can we do the difficult work of changing our practices, or just continue reacting to each new crisis?

Lets look at these flows – first, #stupidindividualism is strong, treating each incident as a problem of individual behaviour rather than examining the social structures that reproduce it. Even when people recognize that something is wrong, they remain trapped in personal reactions, competing opinions and informal status games. The answer to this kinda mess is not to build an elaborate governance system, it is to establish the minimum viable structure that allows our group of disparate boaters to make decisions, share responsibility, resolve disagreements and get things done. Simple does not mean structure-less.

We need to focus on social composting of the existing conflict, frustration and failed attempts are the raw material for building something better. But they do not transform themselves, the current people (or a smaller subset of them) has to do the work of turning experience into shared learning, practical process and renewed collective capacity. The important distinction is that a working group, an OpenCollective account or a new chat platform is not, by itself, an alternative. These are tools, the alternative is the commons practice that makes them useful. There is still to wide a gap between identifying the problem and making the solution work in practice.

Peoples objection exposes this – how do working groups avoid becoming inactive, and how do they stop the same few people carrying all the work? The next step needs to have solid moorings, what is each working group’s purpose? Who has committed to take responsibility for this work? The is core here, how are decisions made and communicated? What happens when commitments are not met? How does the group review progress and change direction? Yes, without answers to these questions, calls for structure risk becoming another round of mess created discussion. With them, #KISS becomes a practical path rather than just a principle to stand on.

The Oxford boaters’ problem is not simply a difficult dispute with #HT, it is that the group is trying to act collectively through bad, reactive and conflict-avoidant practices that repeatedly undermine our ability to act. Rather than building the simple, accountable structures needed to turn shared frustration into collective power we need to keep our moorings. That is the central #OMN point – stop trying to fix each new mess in isolation, and start building the community process that compost our mess into something useful.

#Oxfordboaters need to do better.

What software do social justice activists need?

First we need to look at the core problem for the last 20 years has been that most activists were locked into #dotcons (corporate social media silos) because open alternatives were either too difficult to use, lack network effects, or fail to meet their practical needs. With the current reboot of the #openweb with the #fedivers based on #ActivityPub we have already taken a step away from this mess.

From my experience, here’s what’s needed from a software development perspective to break out of this mess. Open & accessible publishing networks. Activists need easy ways to publish and share information outside corporate-controlled platforms. Right now, #Fediverse is a first step, tools like #Mastodon and #PeerTube exist, but they are still largely copies of centralized platforms rather than native alternatives that work for any working grassroots media.

To take the second step in alt tech we need a native decentralized, trust-based publishing network (#OMN is the example I am working on) Bridging tools to syndicate content between #dotcons and open platforms. Better “unbranded” discovery tools for surfacing trusted grassroots content (think of a federated search engine that’s not controlled by Google)

The third step of secure yet open communication, is already mostly in place. Activists do need to secure yet transparent communication tools that balance privacy with accessibility. Right now, many are stuck using encrypted corporate platforms like #WhatsApp and #Telegram, which create spy silos and exclude people who purposely don’t have the apps. Projects like #Signal and XMPP chat kinda work in this space, so this is not a strong social tech focus, but is a social issue to work on getting people to use the tools.

Finally, the type of project we do need #indymediaback, #makeinghistory, #OGB and the base #OMN coding. There is a continuing need for resilient infrastructure, hosting and sysadmin alongside sustainable funding tools for activists’ websites, blogs, and tools. Currently, these tools often get taken down due to coordinated attacks and lack of resources. On the more dev side of this path, hybrid peer-to-peer hosting solutions (so sites can stay online even under attack) could be useful to bridge current client server tools.

There’s a roadmap, but the problem is developer focus and funding. If you’re serious about helping, check out the stalled dev work on https://unite.openworlds.info and see how it can be set in motion, please. If you’re a dev who wants to make a real impact, this is a good place to look.

The issue, we need to work more on, with #FOSS tech development, the failure of many #FOSS projects, is a failure to move from theory to practice. The issue is that developers work in isolation, disconnected from grassroots needs, and get lost in perfectionism rather than delivering functional prototypes.

The #geekproblem dominates, with coders prioritize control, abstract debates, and self-contained experiments over practical, usable tools for real-world communities. This is why projects stall: they are not built with activists in mind. Meanwhile, centralized platforms continue to consolidate power, because they offer simple, accessible, and functional solutions, despite their deep and nasty flaws.

To break this cycle, we need:

  • Practical iteration, build rough, working solutions rather than endless theorizing.
  • culture, embrace open process, standards, and real collaboration.
  • Bridging solutions, tech that activists can actually use, not just developer-driven experiments.
  • Funding models beyond #NGO traps, so projects remain independent and sustainable.

The fight for the #openweb is not only about resisting #dotcons but creating alternatives people can and will use. Can we move beyond abstraction and actually make history?

Please.

The #GeekProblem is why so much open development is stuck in a dead end

It’s not sin to have to submit to the #dotcons overlords – we all do it, whether we like it or not. Just recently, I found myself installing that vile spyware known as #Whatsapp because this was the only way to talk to the people I needed to talk to. That bitter swipe to hide the app from view brought a momentary sense of agency, but the reality remains: we are still failing at building out the #openweb that normal people find useful and really use in everyday life.

The needed question is: why? It’s too easy blaming users, after all, if they just cared more, if they just tried harder to use open tools, we wouldn’t be in this mess. But let’s be honest: this isn’t on them, the fault lies with the so-called “open developers” who have spent the last 20 years failing to make open tools actually work in usefull ways for normal people. And before anyone objects, yes, I’ve been in the trenches, I’ve been building, testing, promoting, and using these tools for decades, i’ve seen what works, and more often, what doesn’t.

The truth is stark: “open development” is too often a dead end and few of the current paths are going anywhere useful. There are way to meany dysfunctional ecosystems of half-built projects, overcomplicated interfaces, and insular communities that gatekeep instead of welcoming. Meanwhile, the #dotcons corporate silos grow stronger, locking out alternatives at every turn. And what do the open devs do? They tinker endlessly on the backend, build for themselves rather than for real people, and when questioned they retreat into identity purity rather than engaging in practical bridge-building. The #geekproblem is not just one of incompetence, it’s one of misplaced priorities and an aversion to social reality.

Control vs. Trust is the divide, at the heart of the #geekproblem lies a misunderstanding of social dynamics. Where the #OMN sees the solution as building bridges, the dominant geek mindset sees it as erecting gates. A gate is about control: who gets in, who stays out, who holds the keys. A bridge is about trust: connecting communities, facilitating movement, and breaking down barriers. Yet, the geek worldview, is deeply shaped by corporate structures, #neoliberal ideology, and a toxic engineering mindset, defaults to control every time.

This is why open projects fail, they mimic the structures of the #dotcons without the resources to sustain them. They chase security and rigidity at the expense of usability and social flow. Then see failure as an inevitable technical problem, rather than a failure of community engagement and human-centred design. And worst of all, they refuse to recognize that openness isn’t just about code, it’s about social process. So what needs to change:

  • Stop only building for yourself, the #openweb won’t be rebooted by developers coding for their own niche needs and narrow interests. For grow, the open path needs to serve real people, communities in real contexts.
  • Embrace messiness, if it’s not messy, it’s very likely not worth doing. The corporate mindset is about tidiness and control, the #openweb must be about adaptability and flexibility.
  • Then there is leaky by design – data and communication should leak in ways that benefit social needs, but yes, not in ways that only serve the surveillance economy. We have to focus, locking everything down means locking serendipity out.
  • Bridge, don’t block: Instead of obsessing over identity purity, we need to build pragmatic solutions that work alongside existing tools while providing clear alternatives.
  • Trust as the foundation: The default state of open networks should be trust, not fear. We have seen where the obsession with security leads, it builds walls instead of communities.

#KISS is the paths, a good place to start is with the principles of the #OMN and . These aren’t abstract theories; they’re rooted in decades of radical tech and media movements that worked, before they were systematically ignored and buried by the rising tide of centralized control.

It’s time to stop pretending the current model will somehow fix itself, it won’t. We need to look back, dig up the roots, and start again, not with another doomed attempt at technical perfection, but with a renewed commitment to social usability, community-first development, and a radical rejection of the failed control-based mindset.

The alternative is simple: keep failing, keep watching the #openweb erode, and keep making excuses while we all install the next piece of #dotcons spyware just to stay connected. The choice is ours, and the time to act is now.

Our #geekproblem needs to think about this “It is not the consciousness of men that determines their being, but, on the contrary, their social being that determines their consciousness.”

This applies to code too, the social structures developers work inside shape the problems they see, the solutions they build, and the assumptions buried in the code.

You don’t escape politics by writing software. You often just hide the politics inside the software.