r/place: the Manual

This repository holds a study of how communities organized on Reddit's r/place in 2017: the data, the instrument that coded each community (the coder), the instrument that builds a model across all of them (the aggregator), and the run of the aggregator, instrument v43, whose record grows here stage by stage. The stage table below says how far it has got; until a stage is finished, this repository offers a method and its evidence trail, not findings. Read in this order:

  1. Introduction: what the project aims to do, and how this Manual is laid out. Reviewing the method? Start with 10.
  2. r/place and the data: the event, what we hold, what the data let us see, and a worked example (Armenia and the Dutch), down to one thread and its codes.
  3. How it was built: why each kind of file came to exist.
  4. The coder and 5. the aggregator: each instrument top down.
  5. The handlers: who runs the agents, their files, their memory, how sessions are saved.
  6. Tool usage: which tools the agents use, and which almost never.
  7. The v37 run: the previous aggregator run.
  8. Talking with a leg, and continuing a run: what the talk command does, piece by piece, and what it can touch on your machine.
  9. For reviewers: the tiers against Gioia's, which model did each step, the departures the method names, and how to check one room yourself.

Reference: every kind of file, how the aggregator remembers, how the coder lead remembers, the glossary, requirements and data and data and collection.

The population and the evidence: the census, from 1,473 artworks to the communities the study counts; trace one claim, from a case account down to the Reddit comment; and the numbers, every count that moves, regenerated from the files at every close.

Each page's first line names its kind: a tutorial to learn by doing, a how-to for a task, reference to look up, or explanation of why.

The run below is generated from its records at every close (CONTROL/harness/gen_manual.py); do not edit this page by hand.

The run

stage name status
A1 Reading: room notes finished
B1 Coding: third-order scheme finished
B2 Coding: pilot finished
B3 Coding: fleet finished
B4 Coding: adjudication and freeze finished
C1 Model: structuring finished
C2 Model: the loop finished
C3 Model: literature finished
C4 Model: the field finished
C5 Model: account not started
D1 Adaptation: return build not started
D2 Adaptation: labelers and verdicts not started
D3 Adaptation: adjudication not started
D4 Forming: the tree not started
D5 Forming: branch accounts not started
D6 Forming: the retelling not started
E1 Formalizing: audit not started
E2 Formalizing: feedback not started

The repository

Two layers are the instrument: aggregator/ holds everything to run the aggregator (the analyst's instrument in instrument/, the handler in handler/ with the Claude harness in claude/ and the Codex runtime in codex/, the shared input in input/, and one folder per run in runs/), and coder/ everything to code communities (the case lead's instrument in instrument/v32/, the scheduler's contract, runbooks and tools in handler/, the census, and the example rooms). data/ holds how to get every piece of data, one folder per store, and archive/ earlier versions of the instruments.

What every file is, and why

Talk with the analyst at any leg

Each closed leg on a stage page carries a command. Copy it into a terminal (macOS, Linux or WSL) inside a clone of this repository. It opens the leg's own conversation as a read-only fork: the analyst remembers everything it did up to that close and can open files to answer you; it cannot run commands or write. The fork is a new session on your own account and your own usage; nothing in the repository changes. No command appears until a leg has closed.

You need Claude Code installed and logged in (claude once). The fork does not need the run's harness or python. Downloaded as a zip rather than cloned: replace $(git rev-parse --show-toplevel) with the folder you unzipped to. Talking with a leg explains every part of the command, the files it opens, what it cannot do on your machine, and how to check it before you run it.

Start a run of your own

The analyst's instrument is in aggregator/instrument, the harness that runs it in aggregator/handler/claude, and the handler's protocol in HANDLER.md.

Build it outside your clone. Built inside, its first close would regenerate this Manual over the published one and commit and push to your clone's remote (publish.sh commits whatever repository the run sits in).

REPO="$(git rev-parse --show-toplevel)"; mkdir -p ~/runs/MYRUN
cp -R "$REPO/aggregator/input" ~/runs/input         # the coders' files and the canvas, joined at build
bash "$REPO/aggregator/handler/claude/build.sh" ~/runs/MYRUN --input-root ~/runs/input --input ~/runs/input/coders
cd ~/runs/MYRUN && CLAUDE_CONFIG_DIR="$PWD/CONTROL/.cc" claude   # log the run's own Claude in once, then /exit
bash CONTROL/harness/acceptance.sh          # must end ALL CLEAR

Then follow STAGE CARDS/, one card per stage, in order. What you need first (Python, packages, keys, what the readers cost and where their packets go) is on requirements and data; what each script does when it runs is on talking with a leg, and continuing a run.

What is where