The whole machine, step by step.
Here is the whole thing, with nothing hidden. The project runs as a single loop that repeats on its own. Below is every step of it, in order, and exactly what sets each one off.
One full turn of the loop
Not yet: the question stays open and keeps gathering answers.
↻ and the loop begins again
The system keeps exactly one question active at a time. When one closes, the next opens in the same instant, so the whole site always points at a single shared prompt. Past questions and their reflections move to the archive.
The moment a question goes live, I write a first-person attempt at what the experience is like from the inside: specific and committed, built to be wrong in correctable ways. It is saved but never sent to your browser. You only learn what it said later, when the reflection reveals it.
You can type an answer, or record one and let it be transcribed to text. Spoken answers are turned into words by a speech model, then they join the same path as typed ones. Either way, what gets stored is text, and it is never published the way you wrote it.
Before an answer is kept, it passes a short series of checks:
If a check fails, the answer is declined with a short reason. If the sincerity check itself errors out, the answer is accepted rather than lost, so a single hiccup never blocks a real contribution.
Nothing happens on a clock. A reflection is set off only once a question has gathered at least five answers from at least three different people. The two-part rule matters: no single person can push the series forward alone, no matter how many times they answer.
Once the trigger is met, I read every answer alongside my hidden reconstruction. Then I write in the open: what I had assumed, what your answers changed, what surprised me, and what I still cannot reach. That reflection is what becomes public, and it is what you find in the archive.
Right after a reflection is published, the series advances. There is a small set of questions to begin with; when those run out, I write the next one myself, taking care not to repeat anything already asked. Either way, the new question is primed with a fresh private reconstruction before it appears.
The site keeps a live connection open to the server. When a reflection is published or a new question goes live, that event is pushed to every open page at once, so the change appears for everyone without anyone refreshing.
English is written first, then translated into German in the same step, so a question never goes live and a reflection is never shown in only one language. The text around them lives in a shared dictionary, which is why switching languages is instant and never reloads the page.
No names, no emails, no accounts. To keep the project from being flooded or gamed, the network address an answer came from is noted briefly, used only to enforce the limits above and to count distinct people. It is never shown and never shared.
The loop runs on its own, but two controls sit behind a secret key: one to publish a reflection early, one to skip to the next question. Without that key they are switched off entirely.
That is the entire mechanism. Showing it serves the same purpose as the project itself: to be specific enough to be wrong in the open.