It’s good to see more people turning their focus back to the #openweb. For the past five years of the #reboot we’ve been distracted in a signal-to-noise mess from the #fashionistas. That time needs to be over, we need to start looking clearly at both internal rot and the external threats.
A good first step is in balancing the realisation that we actually have far more direct power to deal with the internal mess than we do over the eternal #dotcons and their #closedweb “common sense”. That’s why we need to put activism into composting the internal #blocking (see: https://hamishcampbell.com/?s=compost). Composting isn’t just a metaphor – it’s a way to recycle the piles of #techshit we’ve built up into soil that can grow new #openweb seeds. #KISS
I understand the focus on the external #dotcons, yes, we also need to keep pushing back against the external enclosures. But inside our own spaces, it’s clear that possessiveness, in code, in reputation, in control over projects, undermines cooperation. It destroys trust, it wastes resources, it corrodes integrity. People often destroy what they love, not out of hate, but out of possession.
Drafting blog posts, polemics, and rallying calls to sharpen the #OMN narrative. Use the compost metaphors (#techshit, seeds, soil) into accessible messaging that sticks. Editing to transform the long posts into shareable, short-form content for Mastodon, Fediverse, and allied networks.
Curating and organizing existing #OMN writings into a structured wiki-style knowledge base. Building summaries, FAQs, and primers for newcomers who hit the projects cold. Draft “composting guides” – how to deal with #blocking, #fashionistas, and #geekproblem inside communities.
Writing simple documentation for the Unite Forge and other #OMN tools. Helping draft roadmaps that explain what’s built, what’s missing, and what needs contributors. Produce explainers on why #OMN is different from #dotcons and #NGO capture, grounded in #4opens.
Write out templates for horizontal decision-making (#OGB style) that projects can adapt. Suggest practical ways to “compost” blockers while keeping the wider network fertile. Help draft neticate rooted in #KISS + #4opens rather than #NGO-speak.
Each of these can be grown into living resources: wiki pages, blog posts, shareable guides, or activist toolkits – depending on where you want the energy to flow.
The geek answer (bad faith or blindness): “If only everyone learned to code, then society would be fairer.”
The activist answer: Code is part of the landscape, but culture, governance, and lived practice matter more. We don’t escape domination by teaching more people to type commands, we escape by changing what we do together with the tools.
Why “teach everyone to code” has become a dead-end slogan – it’s been tried, it’s been funded, and yet it hasn’t shifted power one bit. If anything, it’s reinforced the tech priesthood instead of breaking it.
The #geekproblem is exactly this blindness: geeks mistake tools for culture, skill for power, and training for change. They can’t see that the last 20 years of “learn to code” projects have failed precisely because they sidestep politics, trust, and social fabric. It’s comfortable, because it keeps power where it already is.
So, coding literacy might be useful, but it’s not transformative without social literacy – trust, collective governance, open processes. The real activist social tech path is to compost geek mess-making and build alt-cultures where tools serve the collective, not the priesthood.
Otherwise, “coding for all” is another flavour of #blocking – keeping us stuck, distracted, and blind. This is a useful example of the blinded #geekproblem. I use the word blinded to illustrate that people can’t see the sense in front of their faces. And I use the hashtag #blocking to show the outcome of this common “sense” blindness #KISS
Coding is not automatically social power, but in some contexts it does act as power, and understanding when/why helps unpack the #geekproblem.
When coding is not power
Most coding done in industry is low-level labour: writing scripts, fixing bugs, maintaining old systems. These programmers aren’t powerful; they’re workers. Their code serves capital.
Teaching kids to code (“everyone can make an app!”) rarely translates to actual power, because the infrastructure, distribution, and governance of platforms remain controlled by corporations.
Coding on its own doesn’t equal voice. A line of code in a corporate repo is no more socially powerful than a line in a personal diary if the person coding has no agency over how it’s used.
When coding is power
Coding becomes power when it bridges infrastructure + governance + culture.
Building #openweb infrastructure: If you can write the protocols or standards (e.g. ActivityPub, TCP/IP), you shape the possibilities for everyone downstream. That’s a kind of structural power.
Gatekeeping: If you control the codebase of a popular project, you can decide what features exist, whose contributions get merged, and which voices are excluded. This is soft but real power.
Automation and scale: Writing code that automates tasks (e.g. bots, algorithms, moderation tools) gives leverage over many people’s experience, especially when hidden in the background.
Narrative + legitimacy: In activist or grassroots spaces, coders too often get treated as “high priests” because they appear to have magical abilities others lack. This cultural framing inflates their social weight.
Coders confuse technical power with social change. They think: “If I can write the tool, I can fix the politics.” But tools reflect cultures. Without collective governance, tools just reproduce existing hierarchies.
The illusion of inevitability: because software underpins modern life, geeks assume society must organize around them. That blindness is what we’re pointing to.
When geeks push “everyone must code” as the path, they miss that most people don’t need to code to have power, they need agency in decision-making and trust networks.
How it really works (coding + social power)
Coding has power when embedded in movements that control their infrastructure. Example: early #Indymedia coders had real social power because their code directly enabled publishing outside corporate media – and at the start they were accountable to activist collectives.
Coding has power when it’s used to mediate flows of attention, trust, and resources. For example, algorithms that boost or bury voices. In grassroots hands, that can be liberatory; in corporate hands, it’s oppressive.
Coding becomes shared power when it is paired with open process (#4opens), shared governance (#OGB), and cultural literacy. Otherwise, it’s generally more priesthood, likely for the #deatcult in the end.
So: coding is like fire. On its own, it’s just heat and light. In the hands of a few, it’s a weapon or a fortress. In the commons, with shared tending, it’s the hearth – collective power.
To recap, coding as social power: Myth vs Reality
Myth 1: Coding = empowerment We’ve been told that “if everyone learns to code, everyone will have power.” Twenty years of coding bootcamps, “learn to code” initiatives, and school programs prove otherwise. Most of this simply trains people to slot into corporate pipelines. The power stays where it always was.
Reality: Coding on its own is labour, not empowerment. The infrastructure, governance, and distribution layers decide where the power flows. Without culture and collective governance, coding is just fuel for someone else’s engine.
Myth 2: Coding makes you special Coders often act like priests, holding secret knowledge. In activist spaces, this creates the illusion that coders alone can “save” or “lead.” That’s the #geekproblem in action.
Reality: Tools are only as powerful as the cultures and processes around them. A coder without collective accountability is just another gatekeeper. A coder inside a collective, with open governance (#4opens, #OGB), can help shift power outward.
Myth 3: Coding will fix politics The geek fantasy: “If I build the right app, the politics will fix itself.” We’ve seen this with countless “alternative platforms” that end up reproducing the same hierarchies.
Reality: Politics is culture, trust, and process. Code can mediate, amplify, or automate, but it cannot replace politics. Tools without culture are empty shells; culture without tools is still possible.
The compost view is the task isn’t to make everyone a coder, but to compost the priesthood and grow cultures where coding is a part of the collective. That’s the #KISS answer: code can support social power, but it is not social power.
Build cultures, not just tools: Stop pretending apps fix politics. Tools only matter if they grow inside strong cultures. Put people first, tech second.
Open the process (#4opens): Keep everything open: code, data, governance, strategy. Power hides in shadows; openness dissolves the priesthood. If it’s not open, it’s not our path.
Practice collective governance (#OGB): It helps when decisions about infrastructure are made more horizontally. Coders are part of the collective, not above it. Shared governance turns coding from priesthood into common fire.
The path out of the #geekproblem is in composting geek blindness and building living cultures where coding is a part of growing the commons.
For an example, this post is relevant to the degeneration of the #SocialHub project, which for meany years was the place for #ActivityPub and #Fediverse#openweb reboot, but now what’s left of the social side is the few remaining active unthinking “problem” people.
This is a normal path and outcome, that we need to compost to keep growing seeds #KISS
It happens every time. A fresh grassroots project kicks off, chaotic, joyful, full of promise. The code is rough, the conversations messy, but the energy is real. People come together not for money or prestige, but because something needs doing and no one else will do it.
Then, they arrive, the careerists, the chancers, the opportunists who talk a good game of “community” and “values” while quietly positioning themselves for influence, funding, reputation. You know these people, they start “facilitating” things, pushing for “professionalism,” organising pointless panels, and – without fail – introduce hierarchical management logic dressed in pseudo-horizontal language.
Soon, the messy collective space becomes an application form, organic conversations shift to curated “working groups”, governance becomes gatekeeping, code becomes control.
Careerism is a cultural virus, OK, these people aren’t evil villains, they’re simply products of their environment, trained to extract value, shape narratives, and build CVs. But their impact is destructive, even if unintentional. What they bring with them is the #mainstreaming mindset, a default toward #NGO logic, safe liberalism, risk-aversion, and the slow suffocation of wild experimentation.
They start to block with niceness., they silence with process, they smother with “inclusivity” until there’s no air left to breathe. When people question this, then they start to become nasty, trolling, blocking and finally ignoring runs its predictable course…
Examples? Let’s name some very formiler patterns:
The Self-Appointed Spokesperson – Shows up late, speaks the loudest, builds a personal brand on the back of others’ labour.
The Grant-Whisperer – Always chasing the next funder, reshaping the project to fit what’s "deliverable" instead of what’s needed.
The Gatekeeping Ally – Claims to represent the marginalised, while shutting down dissent and complexity with soft authoritarianism.
The #NGO Zombie – Thinks every grassroots space needs a board, a charter, and a code of conduct before it needs trust or purpose.
The Pivot Junkie – Tries to steer the project toward startup land “just to be sustainable,” and ends up reinventing capitalism in #FOSS clothes.
These types thrive when horizontality lacks grounding. On the path we need to take, “cancel culture” is a cul-de-sac. Blocking them just makes them martyrs. Ignoring them lets them take over. The alternative? Compost them, let their bullshit rot in the open, call things what they are. Tech is political, values are not neutral. What to do? Compost, don’t cancel.
To reboot the #openweb and keep it rooted in the #4opens: Open Code, Open Data, Open Standards, Open Process. Rebooting needs resistance, we have to build spaces that are both porous and protected, we need, paths and spaces with membranes, not walls. Trust-based collectives with clear boundaries. If someone’s treating your community like a stepping stone, show them the compost bin. If someone’s building with care, humility, and rootedness, then share our tools with them.
This is not a purity test, it’s composting as culture, if something smells off, trust your nose. Because if we don’t get serious about this, the chancers will take over. They always do. Unless we make the path too muddy for them to walk it.
A core problem is that too many “open” tech projects try to model social relations after code workflows rather than shaping code to reflect healthy social processes. Ersatz writing, ersatz governance and the slow death of the #openweb. We’re living through a wave of fakery. The #AI hype machine spews endless streams of ersatz writing – grammatically perfect, stylistically smooth, and hollow. It feels like content but carries no lived experience, no rooted context, no risk. Unedited, it’s a shadow play of culture.
The same hollowness infects too many horizontal tech spaces. Here, we find ersatz governance – systems that borrow the forms of openness and collaboration, but replace the substance with tech bureaucracy. Instead of starting from lived social practice, they mimic software workflows: people reduced to issue tickets, trust replaced by “process,” culture swapped for sprint planning. The result is the same as with AI: the outputs are technically competent but socially dead.
When governance is reduced to process, the door swings open for the chancers, the careerists, and the #NGO climbers. They’re fluent in the language of inclusivity and consensus, but they’re not here to build, these people thrive in systems where nothing is anchored in lived trust or collective history. In such environments, appearances are reality, and they control the appearance.
The mirror needs to flip, healthy social production can inspire healthy code production, but trying to run human interaction like a Git repo produces brittle, alienating cultures. We see it in the #Fediverse right now: meetings full of procedure but no warmth; #PRs merged while communities fracture; polished governance documents for projects this pointlessness.
The #openweb was never meant to be safe for professional managers of openness. It was meant to be a living commons, messy, unpredictable, full of disagreements and breakthroughs. If we can root our governance in actual relationships rather than corporate abstractions, we can build tech that reflects community rather than forcing community to reflect tech. Otherwise, we’ll just have two hollow empires – AI’s Ersatz Writing on one side, and our own Ersatz Governance on the other – both looking open, both feeling dead.
The #OGB (Open Governance Body) isn’t built around the smooth, efficient ideals of platform logic or institutional control. It’s messy by design, because it’s rooted in real-world activist practice. It draws from the hard-won experience of protest camp organising, where consensus, affinity, and trust are the foundations of action.
The #OMN governance app we’re working with doesn’t come from corporate boards or #NGO playbooks. It comes from the mud, the rain, the late-night meetings under tarps and tents, where people work through differences because they have to – because they’re doing something together that matters. This is people-to-people trust, built over time, grounded in shared struggle. We’re not designing for online autocracy. We’re designing for affinity groups.
So yes, the #OGB is trying to do what many others won’t. Not because it’s easier (it’s not), but because it’s necessary.
We already know this kind of organising works, not in theory, but in practice. Sometimes badly, sometimes slowly, but it works. People come together, they make decisions, they take action, and they build power without needing top-down control. But we also know it doesn’t scale well – that’s always been the limit of these methods. Consensus is powerful at small scales, but it breaks under weight if there’s no structure to hold it.
The #OGB is built on the idea that the horizontal protocols of the Fediverse can scale this kind of messy, native governance, not by centralising it, but by networking it. Federation isn’t just a technical model; it’s a political one. It mirrors the way affinity groups operate: autonomous, loosely coordinated, sharing enough common ground to work together without collapsing into uniformity.
This is what we mean when we say the #OGB is native. It’s growing from within the world we’re already in – not imposed from outside. It respects mess, embraces friction, understands that governance isn’t something you tack on later, it’s something you live through, build with, and struggle over, together.
If we’re going to have a real #openweb, we can’t keep mimicking the logic of #dotcons, or #NGO platforms and empires. We have to build our own paths, grounded, imperfect, resilient.
A community is only viable if enough people care enough to keep it relevant. In this era of #stupidindividualism, most people don’t lift a finger to make that happen.
This is the norm across many #4opens spaces: a near-total lack of interest in building or maintaining shared paths. It’s a textbook case of right-wing Tragedy of the Commons. Developers show up when it suits them, use the space for their narrow needs, then drift off without contributing to the upkeep. They treat community like free infrastructure – something passive they can extract from – rather than a living, tended path.
This same pattern plays out across the grassroots and #FOSS world. Devs focus on their code, their projects, their timelines. Rarely do they look up and engage with the broader ecology that their work depends on. In the #Fediverse especially, most developers ignore shared infrastructure, governance, and the standards they rely on, until something breaks. Then they complain.
Same social dynamics, same outcome: a mess that keeps repeating itself. And until we break that pattern, we’re stuck.
On the alt path, it’s fair to ask for clarity. When we talk about “#openweb projects,” we mean efforts grounded in the values of the early web commons: transparency, decentralization, collective ownership. This includes things like the rebooted #Indymedia, the #OMN (Open Media Network), and the #OGB (Open Governance Body). These aren’t about building shiny platforms, they’re about building the structures and relationships that allow real alternatives to survive and grow outside the #mainstreaming mess.
This isn’t just evangelism, it’s hands-on work: shaping frameworks for local and federated publishing (like the original Indymedia), and now modelling governance and trust systems that resist hierarchy and #NGO capture.
As for government institutions joining the #Fediverse – What we pushed was a bottom-up, native process rooted in people and practice, not imposed solutions. But as is often the case, after we laid the groundwork, the institutional #PR and #NGO crowd moved in and took over.
The “community” we speak of does exist, even if it’s fragmented, marginal, and ignored. You’ll find it in squats, permaculture collectives, activist media spaces, messy corners of the #Fediverse, and in the hands of people still building trust and tools outside the #dotcons. It’s not centralized or funded, so it’s not visible like capitalist platforms are. But it’s real. I’ve lived inside it for decades.
You’re right that real code is needed. But it’s not about one perfect tool. It’s about the network of trust and shared values that can hold many tools and projects together. That’s slower to build, less flashy to show off, but far more resilient and necessary.
The #Fediverse is a good first step. But let’s be honest: we’ve lost the thread when it comes to building tech that walks off the beaten path. Most #mainstreaming energy, and much of the #NGO outreach, still flows into reinforcing the same old ruts: centralization, enclosure, obedience to capital. Anything that doesn’t follow those routes is starved of support and often treated as a threat, a curiosity, or a waste of time.
But it’s exactly that off-path infrastructure we need, not just to resist the current system, but to outlast it. To still be standing when the old ways collapse. That means supporting tools and systems that aren’t profitable, aren’t convenient, and aren’t slick. They’re harder to fund, harder to maintain, but they’re what let us keep moving forward through the coming storm of #climatechaos.
If we don’t build and sustain these alternative tracks, the dominant ones will keep absorbing or destroying everything new. It’s a recursive trap: we need better systems to make better tools, but we can’t build those tools without some of those better systems already in place.
So we need to hold space – with care, mess, and trust – for that in-between.
That’s where projects like #OMN, the rebooted #Indymedia, and the #4opens live. Not trying to escape friction, but embracing it. Mediating it. Letting it guide us toward what’s honest, what’s native, what lasts.
The new litmus test isn’t “Does it scale?” It’s: “Does it spread? Does it take root? Can it compost and regrow?”
It’s important to recognise that friction – the mess, the slowness, the need for constant negotiation – is not a flaw in native paths, it’s a virtue. It’s how trust, mutuality, and accountability are sustained over time. These are not bugs to be eliminated with slick #UX and #VC-funded convenience – they’re part of what keeps a community honest and rooted.
The problem arises when less-native, often externally imposed systems (driven by capitalist or institutional agendas) treat these messy, friction-full spaces as broken or backwards. This is the classic dynamic of imperialism and settler colonialism: imposing order, “fixing” things, extracting value, and in doing so erasing the lived, relational logic of native systems.
If you look through the lens of native/western histories – indigenous struggles vs colonial modernity, the same pattern plays out again and again: the native path is degraded, disrespected, overwritten. In tech, it’s no different. You see it when horizontal, trust-based networks get steamrolled by #NGO capture, institutional gatekeeping, or #VC-funded platforms that sell convenience and control.
So the real work is mediation. Not purity, not retreat, but balancing these tensions in practice: holding space where native paths can grow without being co-opted or crushed, while still reaching out to shift the wider terrain.
We need to stop seeing native approaches as “immature” or “inefficient.” They’re often the only thing holding the line against complete enclosure. The question isn’t “How do we fix the mess?”, it’s “How do we stay with it, tend it, and let it teach us how to do this differently?”
It’s an old but urgent problem: how do we support tech that walks outside the dominant paths long enough to clear new ones? Infrastructure that can challenge the mainstream only survives if we build support systems that reflect different values — trust, openness, and care over control, profit, and scale. Right now, we’ve stopped thinking seriously about this. If we don’t return to this work, building the path as we walk it, we’ll be stuck cycling through the same traps, watching each alternative collapse back into the old defaults.
Let’s look at this from a prospective, both the W3C statement and the #OMN recognize that the early web was built with open sharing, decentralization, and public good in mind. The #W3C calls for a web “respectful of all participants,” which aligns with the #OMN goal of building an open media infrastructure based on the #4opens: open data, open source, open standards, and open process.
Where this W3C #mainstreamin alt path falls short (and why #OMN matters). The W3C vision speaks of “taking responsibility” and “addressing the impact of our work” through technical standards, but in reality, the current web’s architecture has been co-opted by centralized, profit-driven platforms (#dotcons) that dominate communication and content flow.
In reaction to this, the #OMN is grounded in the reality that technical fixes alone won’t solve these social problems, we need working activist cultures, grassroots governance, and federated media networks to actively challenge #mainstreaming and #deathcult values.
What #OMN brings is a social layer: W3C focuses on technology and ethics at the standards level. The #OMN focuses on the cultural and organizational infrastructure needed to build, sustain, and govern alternative media networks.
Scaling what worked: The W3C admits we’ve lost the “openness” to misinformation and data abuse. The #OMN is about bringing back what worked (e.g., early Indymedia, radical tech collectives) and scaling it using tools like #ActivityPub and the #fediverse.
Compost and regenerate: The W3C wants reform from within. The #OMN recognizes the need to compost the #techshit, grow anew, and create autonomous, federated spaces where community processes are native, not retrofitted.
A positive reboot (from within the #openweb), where the W3C gives us a narrative frame. The #OMN gives us a path to act. We can reclaim the web not only through better standards, but through working, lived alternatives – composting what failed, and growing based on what we know works.
We need bridging, if the W3C and groups like them are serious about rebuilding a humane web, then the #OMN path as much to offer:
A bridge to activist governance.
A working example of the Ethical Web Principles being practiced socially, not just technically.
A push for native, grassroots agency, not just safeguards built by the same #NGO centralizers who failed the first time.
Let’s do better, yes, but let’s also be native, that’s what the #OMN is about.
A thread on a different project on the same subject, “Open Source and Open Standards nerds like me ought to know by now that the protocol is the least compelling thing about a service. Who cares if your home is built using only Stallman-blessed tools, when the walls are full of rats?” https://shkspr.mobi/blog/2025/07/im-never-going-back-to-matrix
This post is talking in the sense of structure rather than individual experience. Let’s be honest, much of the so-called “alternative” tech scene is still stuck. Yes, we fled the #dotcons for something better, but ended up with copies of the same broken models. The #Fediverse, with all its potential, is still as often dominated by “mainstreaming meta” chat (“Twitter refugees incoming!”) or conspiracy-laden, #fashionista rabbit holes. It’s little wonder that even the nerdy privacy crowd struggles to find meaningful content or community. And no, shouting “fuck the system!” isn’t enough.
If we’re serious about systemic change, we need to do much more. The question is not if people will come, some always will, the real challenge is what they’ll find when they get here. Right now? It’s messy, insular, and missing the tools people need to use for change and challenge, let alone feel at home. We must move beyond building clones of corporate platforms and start composting the path that got us here.
This is why we need a reboot, not from scratch, but from memory. Projects like #indymediaback aim to reclaim 20+ years of working grassroots media practice. With tools like #ActivityPub we now have scalable tech that can bring those old social processes – based on #4opens (open code, open data, open governance, open standards) – into the present. The #OMN (Open Media Network) is such a path: combining the solid tech foundations with the radical social methods that we know worked (but didn’t scale).
To move at all, we must change and challenge the toxic norms of the #mainstreaming#deathcult, and yes, this means building real alternative identities and spaces that don’t live in the shadow of big tech. Being “alternative” used to mean something, and it can again, if we stop ONLY copying the mainstream and instead focus on nurturing something more strongly rooted and real.
This isn’t about being purist, #FOSS and Open Source already works in this way, the #OMN just brings this path to media and community infrastructure. It’s not utopian, it’s compost. And yes, that means dealing with hard questions, including our own funding. Let’s stop pretending we’re neutral when we’re not. Let’s build from honesty. It’s time to dig, plant, grow, and repeat.
NOTE: the comments below are a useful example of #stupidindividualism, and remember this hashtag is about social groups and their #blocking of social thinking. The history matters, flaming is not a useful response.
These people have a role in the balance of the #openweb reboot, the middle class, careerists, petty capitalist, “privileged” #NGO and co-op crew. But they need pushing themselves, when they push over this balance role… and they do become, when they don’t have any idea or understanding for the need for the balance. This is a very common problem that we need to compost.
Let’s take a step back. In an old thread about online governance, I found it revealing – and a bit frustrating – that almost nobody actually engaged with what the thread was about: building a lightweight, federated, working governance layer. The project in question is the OpenWeb Governance Body (#OGB): https://unite.openworlds.info/Open-Media-Network/openwebgovernancebody/
We were writing a funding proposal to take a simple, well-tested social workflow (which we already know doesn’t scale in its current form), and federate it, to scale through distribution, not centralization. Think of it like this, we already have a proof-of-concept that this can work. It’s called the #Fediverse. Yes, there will be a lot of “smoke”, confusion, distraction, bureaucratic inertia. But we’ve got practice cutting through it, and could use the funding to bring in more people who see clearly and act with purpose.
What we are working on is a cultural problem, not just a technical one. This isn’t about personal attacks, it’s about recognizing a systemic cultural issue. Many people (often, but not exclusively, middle-aged white men) simply can’t see that some projects have value despite being outside their frameworks or institutional comfort zones. It’s a kind of intellectual and emotional poverty endemic to the late capitalist #deathcult era.
“Distilled, grassroots, radical governance is a good fit for the fediverse.”
And that’s what we’re doing. This work comes from decades of experience, 30+ years of distilled practice from social change spaces:
Squats and protest camps
Climate camps and Reclaim the Streets
Indymedia, XR, and even Occupy
And Rainbow Gatherings — still running on consensus-based governance born from the Vietnam-era anti-war movement (not “hippy dippy” utopias, as some imagine)
What we’re doing is embedding this lived practice into the tools and frameworks of the #openweb, creating digital tools that reflect real-world collective experience. These are bottom-up, permissionless, and rooted in doing and trust built through doing. This is not about technical fixes. It’s about using tech to open spaces for people to get messy and find their own path to cooperation.
Why we don’t use #processgeek paths like “Sociocracy”? The “problem people we touch on at the start of this article suggest alternatives like sociocracy. And sure, if that works for your group, go for it. But from the native grassroots side, sociocracy is often the equivalent of a well-meaning hippy round the campfire saying “can’t we all just get along?” while someone pisses on the garden they planted and another person ignores the washing-up rota they just taped up. It’s a structure that presumes goodwill and compliance, and that’s not enough. We’re building for mess, for people who don’t agree, for trust that emerges through doing, not rules imposed from the enlightened #blocking crew from above.
Multi-stakeholder Co-ops? Yes, but not from your typical bureaucratic blueprint. What we’re proposing looks like a multi-stakeholder co-op at times, but it’s far more grounded in anarchist and community-based models. It’s not about creating legalistic enclosures or hierarchical enforcement, we deliberately ignore that mostly irrelevant logic.
About centralization, Yes, Mastodon’s >90% of instances are in five countries. Yes, some instances hold way more users than others. And yes, that’s an issue. But we address this differently, we recognize centralization as a problem and create space for alternatives by encouraging small, local, resilient hosting.
If you run an instance in the #Fediverse, you already understand, It’s your voice, there’s a positive feedback loop here, the more care you give to your space, the more your voice matters. No need for complicated representation schemes. This is the natural governance of federation. You don’t get a vote unless you actually show up, that’s fair, if you want influence, spin up an instance, participate in the culture, do the work.
Governance isn’t something you build from scratch. It’s something you distill from lived experience.
We don’t want complexity. We want clarity, action, and real tools that reflect how people already cooperate.
#KISS wins — every time.
The project matters more for what it refuses to do, than for what it builds.
The #OGB native path is not #mainstreming, it’s a #KISS counter current, about building shared governance for the #openweb, grounded in the #4opens and real-world collective experience. Want to help? Step out of your institutional box, get your hands dirty, help make governance useful again.
A few recent conversations remind me: we’ve already done the work of building alternatives. Twenty years of grassroots tech, radical process, and messy social organizing. The trouble is, that soil has been hollowed out, scattered, exhausted, and feed into the #dotcons
Our current mission isn’t to “start from scratch,” but to rebuild bridges, spread compost, and replenish the soil. That’s why I keep coming back to this moment, the bridging of the #openweb back into #mainstream via #ActivityPub. This is a rare window, let’s not waste it.
The #SocialWebFoundation (#SWF) and others organizing around this space need to think hard about where the bridges land. If we build only toward control, influence, and safety, we miss the point. The #Fediverse wasn’t meant to become a “cleaned-up Twitter clone.” That path leads us back to enclosure.
We need to keep the messy stuff alive, the radical roots, the collective compost piles, the experiments. Because if our worlds keep shrinking, if we make everything tidy and branded, we lose the alternatives that might save us in an age of #climatechaos and hard-right acceleration.
And yes, some of them do understand, the #nastyfew they ran the numbers, and concluded they don’t have to care. In their calculus, the collapse is survivable (for them). The rest of us? We’re disposable. We need different maths, rooted in care, commons, and continuity.
Personally, I’m tired, I no longer have the energy to push these projects alone. So, the next step? Abstract the flows, share the compost, and hand the maps to the next generation. I’m still here to mentor. Still sailing, thinking of writing a book to document the 40+ years of practice that shaped this works
If you want to help build something that actually matters, not just another platform, but commons, the tools are here. The ideas are ripe. The soil can be restored. Let’s keep building, linking, and #makinghistory.
Funding the #openweb is a political act, yet most funding decisions today are framed in technical terms only, dominated by what we call the #geekproblem – a worldview where infrastructure is king, user needs are secondary, and social context is largely ignored.
Let’s unpack this with real-world examples and look at how we keep falling into this trap, and what we could do to climb out. The call-out for funding is phrased in social language, to build privacy-preserving tools, improve the commons, empower communities, decentralize infrastructure. But the funded projects rarely reach or empower actual communities. This is the disconnect, a cultural blind spot that stems from the #geekproblem.
We need to fund the social layer, as a strong backend is necessary, nobody is saying otherwise. But it’s not sufficient, the #openweb is not failing because of lack of backends. It’s failing because almost nobody knows they exist, cares, or knows how to use them. Take ActivityPub, the protocol behind Mastodon and the #fediverse. It had existed in various forms for years, but it only took off because:
Mastodon made it social.
It had good UX for regular people.
There was media buzz and community-building.
It offered emotional utility — a real alternative to Twitter at the moment people needed it.
Without this social glue, ActivityPub would have been another elegant-but-abandoned standard. A backend sitting on a shelf, this is the lesson:
To have an #openweb because we need to fund the people and projects who do social UX, onboarding, design, documentation, evangelism, and community organizing.
We currently keep building plumbing and call it a house, we then blame people for not living in it, feeding the #dotcons. Here’s a bitter irony:
Funding backend tools with no regard for adoption pathways just helps #dotcons.
The corporate world happily scoops up open source backend work (including ActivityPub) and wraps it in slick UX, marketing, and control. That’s how:
Meta is building Threads with ActivityPub.
Google funds protocol work to feed proprietary services.
Microsoft contributes to open source, then wraps it in Azure services.
They have the social layer, #PR, onboarding, monetization, network effects, and we hand them the backend work for free. We build the roads, they put up the toll booths.
The Fediverse is not a collection of protocols, it’s not a stack of servers, it’s a culture – or it was. And that culture is in crisis:
Burnout among developers.
Fractured community governance.
Rising influence of #NGOs and foundations pushing vertical, institutional models.
Selling out to mainstreaming partnerships (ex: EU outreach, Threads integration).
Social stagnation as microblogging dominates over creativity, curation, and real collaboration.
There is still potential, a web of relationships, tools, and practices built on trust rather than control, but we are not funding that potential. We are, instead, funding more tools, more protocols, more #techchurn.
What’s the pat out of this mess? We need to rebalance, right now funding overwhelmingly goes toward:
Code (especially backend)
Security and cryptography
Infrastructure-level "innovation"
We need to start funding:
Onboarding, documentation, UX
Social features, not just tech protocols
Network-building between grassroots media and communities
Outreach that isn’t just evangelism, but relationship-building
Public education, not just developer conferences
Human infrastructure — the people doing the messy, unglamorous work of care and connection
Think about projects like: The Open Media Network (OMN) – which builds out real linking between alt-media producers using existing standards like RSS and ActivityPub. It’s boring tech, but socially radical. This project aren’t shiny, but it matters.
We cannot build future paths by pretending the problem is just technical. The #geekproblem is a cultural blindness, the belief that the social will magically emerge once the tech is “good enough.” It won’t.
If you want a flourishing #openweb, you need to fund the people with shovels — the ones doing the care work, building bridges, and holding space for non-geek communities.
Until we do that, the #openweb will remain a ghost town of beautiful ruins – and a free R&D lab for the next generation of #dotcons.
Capitalism, especially in its late-stage #neoliberal form, has always had significant structural problems. In recent decades, these problems have been amplified and globalized through our society, I look here at the path of the digital platforms, what we call the #dotcons. These companies are not in any way a break from capitalism, they are its most refined, efficient, and extractive version to date.
Income Inequality
Traditional critique: Capitalism concentrates wealth in the hands of those who own capital (factories, land, assets), while workers receive only a small slice of wages.
#Dotcons example: Big Tech CEOs and early investors have become some of the richest people in human history – Elon Musk, Jeff Bezos, Mark Zuckerberg – while gig workers and content creators struggle to survive.
Amazon workers are underpaid and overworked, with high injury rates in warehouses. Meanwhile, Bezos took a vanity trip to space.
Uber/Lyft drivers bear the cost of vehicles and insurance, receive no job security, and can be "deactivated" (fired) algorithmically with no recourse.
Exploitation
Traditional critique: The wage labour system is inherently exploitative, profits come from paying workers less than the value they produce.
#Dotcons example: Digital platforms exploit user-generated content while paying creators next to nothing.
YouTube demonetizes videos arbitrarily. Creators build platforms that YouTube controls and profits from.
Facebook/Meta builds its empire off unpaid emotional labour — your social life, your attention, your photos — monetized through surveillance and advertising.
TikTok algorithms suck in youth creativity, reward a few, and discard the rest. The work is free, the profit is centralised.
We’ve all become digital piece-workers, feeding the machine with likes, posts, and swipes, and we’re not even getting wages any more.
Environmental Degradation
Traditional critique: Capitalism’s drive for infinite growth in a finite world results in ecosystem destruction.
#Dotcons example: The cloud isn’t light and airy, it’s made of data centres that consume vast amounts of energy and water.
Bitcoin mining (driven by capitalist speculation) consumes more electricity annually than Argentina.
AI training for LLMs (like ChatGPT) has a massive carbon footprint, often hidden behind “green” branding.
Amazon delivery and consumption cycles have increased packaging waste and pushed unsustainable shipping logistics into overdrive.
Digital capitalism gives us the illusion of “clean” convenience, but its ecological impact is catastrophic and accelerating.
Short-Term Thinking
Traditional critique: Shareholder capitalism focuses on quarterly profits, not long-term well-being.
#Dotcons example: The platforms build attention economies, short-term dopamine hits over sustained engagement, destroying social connectivity and democratic culture.
Twitter/X encourages outrage over insight. Algorithmic virality means trolls win.
Facebook actively promoted divisive content because it increased “engagement.”
Startups "move fast and break things" without repairing the damage. Few are held accountable.
Product design is driven by venture capital exits, not by usefulness or ethics. Tech isn’t solving problems; it’s creating new ones, faster and faster.
Lack of Access to Essential Goods and Services
Traditional critique: In capitalism, basic needs like healthcare, housing, and education are commodified, your access depends on your income.
#Dotcons example: Digital access is the new essential, but it’s increasingly paywalled and monopolized.
Google Classroom became a default education tool during COVID — but it’s ad-funded, tracks users, and lacks any transparency.
Zoom and other platforms required for remote work/schooling are corporate-run silos, with data surveillance baked in.
People in the Global South are increasingly pushed into “zero-rated” Facebook and WhatsApp ecosystems — giving up any path to digital autonomy for basic closed access.
The digital divide isn’t just about cables or bandwidth, it’s about who owns and controls the networks we rely on to build a future.
From Capitalism to #dotcons to #deathcult, the digital platforms didn’t disrupt capitalism, they turbocharged it. What we’re living through and witnessing now isn’t Big Tech behaving badly, it’s the logical endpoint of capitalism in a networked world. The #dotcons replicate and intensify the worst features of capitalism:
More control with less accountability
More labour with less compensation
More growth with more destruction
They’re efficient machines of extraction, cloaked in the language of innovation and empowerment. What’s the Alternative? We need to stop asking how to “fix” the #dotcons and start building outside of them. That means:
Supporting the #fediverse and #ActivityPub as protocols of freedom and decentralization
Backing grassroots media and alternative tech through projects like the #OMN (Open Media Network)
Embracing the #4opens
Fighting back against #mainstreaming capture by NGOs and foundations that reproduce te normal power hierarchies
Prioritizing trust over control, cooperation over extraction, and commons over private for profit platforms
We need to name the problem for what it is: Capitalism – digital or otherwise – is incompatible with the future of people and planet. It’s past time to compost it and grow something better. As a first very basic step, let’s build tech that reflects our #KISS values, not just our fears.
And what would that actually look like? Let’s be honest about what the #Fediverse is, despite all the code and standards talk, the heart of the Fediverse is anarchism – not in the chaos sense, but in the older meaning:
The letter A for anarkhia (‘without ruler’), circled by an O that stands for order or organization.
We have plenty of the A with decentralization, voluntary cooperation and resistance to imposed authority. But where’s the O? Of clear coordination, transparent process and federated trust and mediation?
Right now, we’re herding cats – each server, dev group, and community running off on their own, building tools and protocols, often without clear ways to connect, share governance, or defend against capture. This worked when we were small, it will not work now the big boys have arrived.
Warning from experience: The #EU outreach failure, we had a direct taste of this during the 2023–24 EU outreach process. It worked, but was quickly transitioned to the infrastructure of the #Fediverse without its soul. This isn’t theoretical, it is what happened to #FOSS transitioning to #opensource in the 2010s. This is what happens if we keep doing nothing? If we don’t act:
The foundation model is imposed — not built.
The fig leaf of “community governance” will be ignored.
A self-selecting oligarchy will form — friendly faces, perhaps, but still an eliteist power cleqe.
The Fediverse will be co-opted — just like we watched Google and Microsoft do to open source over the last 20 years.
Yes, #ActivityPub is “open” but openness alone doesn’t stop capture. Ask the #FSF, or look at meany #NGO paths in tech.
What would “native” governance look like? Built from our values, not imported from the institutions we’re resisting.
Soft Structure – Not no structure. The #OGB (Open Governance Body) project is one possible model: https://unite.openworlds.info/Open-Media-Network/openwebgovernancebody It’s based on the #4opens and rooted in the real history of grassroots organising, not rigid control, but visible, participatory trust-based structure.
Real federation of trust -Imagine something like “trust instances”, each instance or org can choose to endorse certain process and values (e.g., 4opens, PGA hallmarks), creating a visible network of aligned projects. Not a central body, but a web of consent, the #OMN is an example of this.
Self-accountability + Diversity of tactics. Everyone agrees to transparency and openness. Everyone chooses their own path. Nobody is forced, but the community can see what you’re doing. This is essential for resisting #NGO co-option without creating more gatekeeping elitists
Are Platform Co-ops the Answer? Maybe, but… proceed with caution. Many tech co-op projects I’ve seen:
Become ossified in bureaucratic process
Elevate process geeks over users and communities
Reproduce #NGO behaviours under a different name
We’ve seen this in the #techcoop movement, especially in the UK, where platform co-ops often start with radical aims and drift into “doing B2B consulting for ethical startups.” Fine, but not the revolution we worked for. The stakes are real, we’re not just talking about tech here, we’re talking about:
Climate collapse
Social fragmentation
The rise of digital authoritarianism
We need an #openweb that reflects our values, #fediverse governance that protects the commons, and to move from just the A to the full A inside the O – the anarchist circle of voluntary structure. Let’s not wait for another hijacking, we need to build something native to the Fediverse before it’s too late.
The signal-to-noise problem of our #geekproblem in the #fediverse and the wider #openweb. Let’s be clear: platforms like #Mastodon and the #Fediverse are native openweb projects. They embody the values of the #4opens — open data, open source, open process, and open standards.
The value here is not in hardening and securing these systems to the teeth. People who are pushing for hyper-“security” are missing the point entirely. This isn’t about “common sense” dev practice. It’s about use-case. Public media content should be open — and that’s what the Fediverse is good at. It’s media. It’s conversation. It’s public dialogue. That’s what #ActivityPub is designed for. For private communication, we already have mature and well-tested encrypted tools: #Matrix, #Briar, #Signal, etc. Use those for whistleblowing, direct action, or anything sensitive.
Trying to bolt high-security models onto public communication tools breaks the value of the #Fediverse – its simplicity, accessibility, and low barrier to entry. Right now, the #Fediverse is a functional part of the #OMN – it’s a mesh of many small pieces, loosely joined, low-barrier, easy to host, easy to adapt, easy to grow. This is a fragile ecosystem, not a fortress. By pushing unnecessary “security” requirements, this #geekproblem are:
Scaring away potential users and admins
Raising technical barriers
Spreading #FUD
And most dangerously — undermining real-world activists who rely on open visibility and reach, not secrecy.
The #geekproblem, pushing complexity, abstraction, and fear over usability and trust, has been blocking the alt-tech world for over 20 years, it’s happening again. Let’s not let them smother this moment, the open web works when it’s messy, simple, and human.
