DEV Community

Cover image for From Twitch Plays Pokemon to Open Chaos: A Decade of Crowd Development and the Next Ten Years
tumf
tumf

Posted on • Originally published at blog.tumf.dev

From Twitch Plays Pokemon to Open Chaos: A Decade of Crowd Development and the Next Ten Years

#github #ai #casual

Originally published on 2026-01-12
Original article (Japanese): Twitch Plays PokemonからOpen Chaosへ：群衆開発10年史と次の10年

Recently, I came across a project called Open Chaos on Hacker News that garnered 387 points, and I must admit, I was genuinely excited.

"An OSS that evolves through community voting" — this concept is actually the latest form of "crowd development," which has been evolving in various shapes for over a decade. How the experiment that began with Twitch Plays Pokemon in 2014 has transformed by 2026, and what might happen in the age of AI. Let’s summarize.

What is Open Chaos?

Open Chaos is a project that automatically merges the most supported pull requests (PRs) through community voting every Sunday at 09:00 UTC.

The Mechanism is Simple

  1. Anyone can submit a PR.
  2. Vote using GitHub reactions (👍/👎).
  3. Score = 👍 - 👎.
  4. The PR with the highest score is automatically merged.
  5. Repeat infinitely.

The scope of changes is "everything." Complete UI overhauls, new feature additions, backend enhancements, gamification — even the rules themselves are determined by community voting.

The current repository is publicly available at skridlevsky/openchaos, and the tech stack consists of modern components like Next.js 16, Tailwind CSS v4, and Vercel.

The Paradoxical Reality: "Chaos" Creates Order

What’s interesting is the content of the PRs that are actually being voted on while promoting "chaos."

PR Number Content 👍 Vote Count
#6 Implementation of +1/-1 reaction calculation 862
#13 Rewritten in Rust 459
#51 Daily merging 342
#47 IE6 mode (GeoCities style) 163

The top vote is for "improving the voting system." Despite aiming for chaos, people are seeking order — this paradoxical behavior has been a topic of discussion on Hacker News.

"Am I the only one who's noticing that this 'open chaos' project's most voted PRs are to add structure to the project?"

Perhaps humans instinctively seek a certain level of order.

The Genealogy of Crowd Development: A Decade of Evolution

Open Chaos did not emerge suddenly. Experiments in "crowd creation" have been ongoing for at least the last ten years.

2014: Twitch Plays Pokemon

Image of the crowd controlling a game experiment

In February 2014, an experiment began where viewers played Pokémon through the Twitch chat. When viewers submitted commands (like "A," "B," "up," "down," etc.), those commands were reflected in the game.

Problems became apparent quickly. When tens of thousands of people sent commands simultaneously, the character could not move properly. This resulted in a scene where the character continuously bumped into walls for 16 days.

Anarchy vs Democracy

To solve this issue, the developers introduced a "Democracy mode," where the most voted command within 30 seconds would be executed.

However, this created new conflicts.

  • Anarchy faction: "Chaos is what makes it fun. Democracy goes against the original intent."
  • Democracy faction: "If we can't progress, it’s meaningless. We should move forward rationally."

Ultimately, the community found a compromise by switching modes based on the situation, achieving completion in 16 days and 17 hours. It is said that over 1.16 million participants took part.

Lesson: Crowd decision-making requires "direction." Complete disorder does not function.

1982: Nomic (The Rule-Changing Game)

In fact, the idea behind Open Chaos has existed for much longer.

In 1982, philosopher Peter Suber devised a game called Nomic. This is a meta board game where "changing the rules is part of the game move."

  • Players propose rule changes.
  • If approved by vote, the rules change.
  • There are rules to change the rules themselves.

As an implementation example using GitHub, there is mburns/nomic. The flow of proposing via PR → reaction voting → merging is very similar to Open Chaos, but Nomic has "win conditions (200 points)" and possesses a structure as a game.

Difference between Open Chaos and Nomic: Open Chaos has no "win conditions." It is based on the premise of continuous evolution.

2019: GitConsensus (Governance Automation Tool)

GitConsensus is a tool that generalizes a voting system using GitHub reactions.

It defines rules in a configuration file called .gitconsensus.yaml and automatically merges based on the number of reactions. While Open Chaos is an "experiment of a single project," GitConsensus is designed as a "tool that can be used in any repository."

This opens up the possibility for projects to progress based on community consensus even in the absence of OSS project maintainers.

However, GitConsensus has not been updated since 2019 and is not actively used today. The idea of "describing governance in code" was advanced but did not lead to actual adoption.

2026: Open Chaos (Adding Entertainment Value)

What distinguishes Open Chaos from GitConsensus is its entertainment value.

  • Public Website: You can check real-time voting status at openchaos.dev.
  • Countdown: Displays the time until the next merge.
  • Humorous PRs: IE6 mode, rewriting in Rust, daily merging, etc.

This is not a "governance tool" but rather a "showcase as a social experiment." It can be seen as a recreation of the "audience participation entertainment" element from Twitch Plays Pokemon on GitHub.

Technical Deep Dive: Implementing Voting → Automatic Merging with GitHub API

If you want to implement a mechanism like Open Chaos in your own repository, you can achieve it using GitHub Actions + GitHub API.

Basic Implementation Pattern 

# .github/workflows/auto-merge.yml
name: Auto Merge by Votes

on:
  schedule:
    - cron: '0 9 * * 0'  # Every Sunday at 09:00 UTC

jobs:
  auto-merge:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Get PR reactions
        id: get_prs
        uses: actions/github-script@v7
        with:
          script: |
            const { data: pulls } = await github.rest.pulls.list({
              owner: context.repo.owner,
              repo: context.repo.repo,
              state: 'open'
            });

            // Retrieve reactions for each PR
            const prScores = await Promise.all(pulls.map(async (pr) => {
              const { data: reactions } = await github.rest.reactions.listForIssue({
                owner: context.repo.owner,
                repo: context.repo.repo,
                issue_number: pr.number
              });

              const score = reactions.reduce((acc, r) => {
                if (r.content === '+1') return acc + 1;
                if (r.content === '-1') return acc - 1;
                return acc;
              }, 0);

              return { number: pr.number, score, createdAt: pr.created_at };
            }));

            // Sort by score (prioritize newer PRs in case of ties)
            prScores.sort((a, b) => {
              if (b.score !== a.score) return b.score - a.score;
              return new Date(b.createdAt) - new Date(a.createdAt);
            });

            return prScores[0]?.number || null;

      - name: Merge winning PR
        if: steps.get_prs.outputs.result
        uses: actions/github-script@v7
        with:
          script: |
            const prNumber = ${{ steps.get_prs.outputs.result }};
            await github.rest.pulls.merge({
              owner: context.repo.owner,
              repo: context.repo.repo,
              pull_number: prNumber,
              merge_method: 'squash'
            });
Enter fullscreen mode Exit fullscreen mode

Design Philosophy Differences from GitConsensus

GitConsensus describes settings like the following in .gitconsensus.yaml:

version: 1
quorum: 5          # Minimum number of votes
threshold: 0.65    # Approval rate required for passage
merge_method: squash
Enter fullscreen mode Exit fullscreen mode

In contrast, Open Chaos follows a "unconditionally merge the PR with the most votes" rule. There are no quorum or threshold requirements.

This difference reflects the distinct purposes of the two:

  • GitConsensus: Aims for "healthy OSS governance."
  • Open Chaos: Enjoys "unpredictable evolution."

Crowd Development in the Age of AI Agents

An interesting observation was made in the comments on Hacker News:

"Is most code not written by LLMs these days anyway?"

"Isn't most of the code these days written by LLMs?"

Indeed, workflows where Claude or ChatGPT generate code and humans review and merge it are becoming increasingly common.

The Future of AI Agents Automatically Generating PRs

What happens if AI agents participate in Open Chaos?

Scenario 1: Democratic Evolution

  • Multiple AI agents automatically generate different proposals.
  • Humans vote to determine the direction.
  • AI becomes a "means" to realize human intentions.

Scenario 2: AI Domination

  • AI agents generate a massive number of PRs.
  • Humans cannot keep up, effectively allowing AI to decide the direction of evolution.
  • Open Chaos becomes a "playground for AI."

Both scenarios are technically feasible already. If AI agents use the GitHub API to create PRs and vote through reactions, it could be implemented in just a few hours.

The Importance of GitConsensus-like Rules

If AI agents participate, having "quorum" and "threshold" rules like those in GitConsensus becomes important.

  • Prioritize human votes: Count only human reactions.
  • Label PRs from AI: Identify them with an ai-generated label.
  • Evaluate AI PRs separately: Ensure they do not compete with human PRs.

Technically, this can be determined using the user type in the GitHub API (user.type === 'Bot').

Conclusion: What Will Happen in the Next Ten Years

Ten years have passed since Twitch Plays Pokemon in 2014. Crowd development has evolved as follows:

Year Project Features
1982 Nomic Changing rules is part of the game move
2014 Twitch Plays Pokemon Real-time crowd control
2019 GitConsensus Governance automation
2026 Open Chaos Entertainment value + complete autonomy

What will happen in the next ten years? Personally, I anticipate the following evolutions:

  1. AI agent participatory projects: Collaboration between humans and AI in development.
  2. DAO-like governance: A fusion of token voting and GitHub reactions (DAO = Decentralized Autonomous Organization).
  3. Self-evolving OSS: Communities maintaining projects even in the absence of maintainers.

Open Chaos is an "experiment." However, there is much to learn from this experiment. How to aggregate the will of the crowd and provide direction — this is a question not only for OSS but also for organizational management and democracy.

For those like me who are "looking for interesting projects," I highly recommend voting for Open Chaos. Your vote might determine the future of the project.

Reference Links

Top comments (0)