Elgg's 2007 Pitch: A Platform With No Features

Elgg’s 2007 Announcement: “The Next Version Has No Features”

AI coding tools have made it much easier to build small features yourself. A community organizer, for instance, can now put together a message board or a sign-up form for their own group. So could you go further and build an entire platform to run your community? A piece by Ben Werdmuller, co-founder of Elgg, takes on exactly this question.

In an essay from April 2026, he looks back on a talk he gave at the University of Brighton in September 2007. He was there to introduce the next version of Elgg, an open-source social network. In the audience were people running social networks with anywhere from tens of thousands to hundreds of thousands of users. He put up a blank slide and said something like this:

“Nothing. The next version has no features.”

According to Werdmuller, the audience was stunned. What he meant was this: instead of shipping the same set of features to every community, let operators pick and configure whatever they actually need. It was a proposal to hand the choice to the people who understood their community’s needs best.

Now, roughly 19 years later, in 2026, he thinks agentic coding¹ and open protocols² could finally make that vision easy to pull off. One helps you build the software; the other gives you the rules for connecting services that were built separately.

When Big Platforms Miss Local Needs

Large platforms like Facebook, Twitter, Instagram, and TikTok serve many countries on the basis of shared products and operating policies. There’s some regional tuning of features and policies, but small communities can’t easily reshape the product to work the way they need it to.

Content moderation and reporting, in particular, require people who understand local language and social context. The mere fact that a company’s headquarters is far away doesn’t fully explain the problem, but when there aren’t enough people on the ground to understand and respond to local conditions, dangerous posts can slip through.

The spread of hatred and incitement to violence against the Rohingya on Facebook in Myanmar shows how serious this can get. A 2018 United Nations fact-finding mission singled out the role of social media—Facebook in particular—in this process. The human rights impact assessment Facebook itself published that same year also acknowledged that its platform hadn’t done enough to prevent its use in stoking division and inciting violence.

This case shouldn’t be read as proof that uniform design is the root cause of every problem. But it does make clear how much it matters to have systems in place that can recognize and act on local risks—since the dangers of exposing someone’s identity, the forms harassment takes, and the context in which speech is made can all differ from one community to the next.

What AI Coding Makes Easier Now

Changing an existing platform’s features or building your own service still requires development skills for a community. AI coding tools can help with part of that work.

Vermeulen points to Jesse Vincent and Simon Willison—both developers with long track records—actively using LLMs. Vincent led Perl development, and Willison built Datasette. Their examples show that AI tools can be useful even for experienced developers. Still, two cases alone aren’t enough to conclude that productivity rises across all development work.

For communities, what’s appealing is that the barrier to a first attempt gets lower. Work that once required hiring a developer to modify WordPress or Elgg can now be attempted by the operator directly. But there’s still a gap between building a prototype and reliably running features like member data, payments, and reporting.

I think this is where two kinds of roles will need to work together.

One is the on-the-ground person who defines what’s actually needed. When someone who isn’t a professional developer builds a tool for their own work, it’s called “citizen development.” The concept comes from low-code/no-code³ tools, and AI coding can support this kind of attempt too. A community operator can draft a feature, show it to members, and gather feedback.

The other is the developer who reviews the implementation and takes responsibility for operations. Someone has to check whether the generated code properly protects member data, whether access permissions are correct, and whether recovery is possible when errors occur. Even if AI writes the code, that judgment and accountability don’t get resolved automatically.

Collaboration is possible where the operator explains member needs and tests drafts, while the developer reviews the design and the security/operational requirements. The roles don’t necessarily have to be split between two different people, but it should be clear who is responsible for checking what.

Building services separately also creates a connection problem. If people have to sign up and post separately everywhere, exchange between communities becomes cumbersome. Different services need to agree on how accounts and posts will be shared with one another.

An Open Standard That Connects Different Services

An open protocol is a public specification for how software communicates. Even when each service implements things differently under the hood, they can still agree on the format of the messages they exchange and how those messages get handled.

On the web, transport protocols like HTTP and document formats like HTML play this role. In social services, ActivityPub and ATProto are the leading open standards. The two differ in design and scope.

ActivityPub is a protocol that the W3C adopted as a recommended standard in 2018. It defines functions like exchanging posts and following users across different servers. Mastodon, Ghost, and Threads all use it, but the features each service supports and the conditions for interconnecting vary.

ATProto is the open protocol used by Bluesky. It’s designed so that an account’s identity and data aren’t locked into a single hosting provider. Even if you move your account to a different server, your identity and connections are meant to carry over. Still, that doesn’t mean the features and data of different apps automatically become interchangeable.

Anyone can build a new service on top of these specifications. But simply referencing a spec doesn’t make a service instantly, fully compatible with existing ones. You still have to align supported features, data formats, and authentication/authorization handling, then actually test the connection between live services. And since ActivityPub and ATProto are themselves different standards, bridging the two requires a separate implementation.

Vermeulen believes that as custom-built apps proliferate, these shared standards will only grow more important. Even today, they connect many kinds of apps — and going forward, he expects an even wider range of community-built apps to adopt the same standards. For that to happen, the tools and documentation that make implementation easy need to be in place alongside them.

Who Decides the Rules for Reporting, Blocking, and Data Use

Just because a platform runs doesn’t mean it’s safe to operate. Operators especially need to prepare for situations where members harm each other or expose personal information.

Content moderation, reporting and blocking, and abuse prevention are things operators must handle on an ongoing basis. Knowing a community’s context helps, but even small communities may lack the staff or experience for this. Simply building your own platform doesn’t solve the operational problems that come with running a large one.

Vermeulen proposes connecting safety tools to open standards as well. Under this approach, operators could use external reporting and review tools, or several communities could pool staff and costs to run moderation jointly. This is a possible design direction — not a finished system every community can adopt right away.

Even when AI builds features for you, you still need to precisely describe what members require and verify the results.

AI can reflect the biases embedded in its training data and development process in its output. For instance, you need to check whether default settings — like mandatory identity disclosure or blanket bans on certain expressions — actually fit your community. These are decisions for operators and members to make, and the generated code needs to be checked against those decisions.

There’s also AI research focused on reflecting the needs of local languages and communities. Examples include efforts to adapt small language models (SLMs)⁴ for specific languages, and projects like Mila’s FLAIR project, which develops speech recognition technology together with Indigenous communities. Speech recognition and code generation are different tasks, but it’s worth noting that in both, the people who actually use the technology participate in deciding the data and the purpose.

The Mozilla Data Collective, which officially launched in November 2025, is also designed so that data providers set the terms of use. Its launch materials introduced more than 300 datasets across 286 languages. Having this kind of participatory structure doesn’t automatically eliminate model bias, but it does expand the room communities that contribute data have to decide how that data gets used.

Oswarld’s Lens

As a GTM strategy consultant, what interests me here is the growing number of features communities can build for themselves. When the cost of building drops, you can test small needs that existing platforms never bothered to support. But existing platforms already have users and operating infrastructure concentrated in one place. That advantage doesn’t disappear just because writing code got easier.

Channel strategy gains options too. If a community can set its own features and operating rules, and interoperate with other services through open standards, it becomes easier to respond when a given platform changes its policies. In exchange, someone has to decide who handles hosting costs, incident response, and member support.

Working on strategy for companies of various sizes, I’ve seen new tools expand the range of people who can directly do the work. I’ve also designed processes that separate drafting from verification in practice. I think the same approach applies to community features built with AI coding: operators test quickly, but before rolling anything out to actual members, they review permissions and personal data handling.

Using an open standard doesn’t automatically decentralize control over how a service is run, either. If many communities end up depending on the same hosting, search, and authentication providers, influence can simply re-concentrate around those providers. You still have to check whether members’ input actually shapes the rules, and whether they can move to a different operator at all.

Closing

If a community is considering building its own platform, it needs to work through the following together.

Decide on the needed features first. Only by identifying what existing services fail to address can a community judge the cost and operational burden of building something in-house.

Test both the build and the integration. Even if AI-assisted coding makes it possible to build a feature, the community still needs to review the code’s safety and confirm that it actually interoperates with other services as required.

Someone must own operations, and there must be a process. Who responds to reports, how rules get amended, and how the community handles outages or data breaches all need to be spelled out in advance.

What I took away from Vermeulen’s essay is this: now that building has gotten so much easier, we should have a more concrete conversation about what we’re building and for whom. If community members can take part in that decision, I think the purpose of adopting a new tool becomes a lot clearer too.

References & Further Reading

Primary sources

• Ben Werdmüller, “One size fits none: let communities build for themselves”, werd.io, 2026. 4. 14. This is the source article for today’s newsletter — a piece from a pioneer of open-source social networks unpacking the possibilities at the intersection of agentic coding × open protocols.
• The Fediverse Report, “A conceptual model of ATProto and ActivityPub”, 2024. A piece that explains the conceptual differences between ActivityPub and ATProto in terms even non-specialists can follow. What struck me is how differently the two protocols interpret “decentralization” itself.

Background

• Brookings Institution, “Can small language models revitalize Indigenous languages?”, 2025. Covers how SLMs are being used to preserve Indigenous languages, along with an ethical framework for community-led AI development.
• Mozilla Foundation, “Mozilla Data Collective Redefines How AI Data Is Created, Shared, and Who Benefits”, 2025. A new model for an AI data ecosystem in which communities hold sovereignty over their own data.
• Harvard Law School Systemic Justice Project, “Facebook and Genocide”, 2022. A paper analyzing Facebook’s role in Myanmar through the lens of its business model and structural failures.

The author is Oswarld (Kwangseob Ahn). Current roles: Adjunct Professor at Sejong University, Strategy Consultant at INLEVEL9. Career, research, books, and recent work are kept current on the About page. Latest · July 2026: HEMA-2: A Consolidation-Aware Tri-Memory Architecture with Multi-Channel Scheduling for Lifelong Conversational AI.

Footnotes

1. Agentic Coding: A method by which AI carries out a chain of development tasks — writing and modifying code, running tools, and more. The scope of what it can do depends on the permissions and tools granted, and a human still needs to check the requirements and results. Tools like Claude Code are a prime example. ↩

2. Open Protocol: A public agreement about how software communicates with other software. Just as HTTP is the agreement between web browsers and servers, ActivityPub is the agreement between social platforms. Anyone who follows the agreement can join the ecosystem. ↩

3. Low-code/No-code: A development approach that lets people build software through drag-and-drop or visual interfaces instead of complex programming. With the emergence of agentic coding, code can now be generated just by giving instructions in natural language, further expanding the possibilities for citizen developers. ↩

4. Small Language Model (SLM): A language model with a relatively small number of parameters. It can be tuned for specific tasks or languages and requires fewer computing resources to run, but being small doesn’t automatically mean it needs less training data or is free of bias. ↩