Lean: I Built a Game Where Changing Your Mind Is the Whole Point

The question that broke my team wasn’t the one I expected. It was: one animal becomes the only pet anyone may keep — dog, cat, or bird?

The debate blew straight through the timer. It kept going after the reveal chart had already shown how the room shifted. And weeks later, it’s still alive: it’s become shorthand on our team, the thing someone invokes when we need to actually talk through a disagreement instead of circling it. A throwaway question about pets turned into a durable reference point for how we argue.

That’s Lean doing what I hoped it would. It’s a little web game: a group joins a room with a 4-letter code, everyone secretly votes on a trivial question, two random people have to make their case, the room debates, everyone gets a final chance to lock in. Then the reveal: an animated chart replaying how the room’s opinion moved over the course of the argument.

The twist that makes it work: there’s no winner. Nobody scores points for being right, because there is no “right.” The thing the game celebrates — literally, with end-of-session awards — is movement. The top award, “Open Mind,” goes to whoever reconsidered the most.

Where this came from

Three threads, none of which contain this game, all of which led to it.

The first was a Staff Engineer Den at work, one of those recurring sessions where staff engineers get together and talk through whatever’s on our minds. That week the topic was how to get a team working together more closely, and somewhere in the discussion a coworker tossed out an idea: get a fun debate going, something silly like the best flavor of ice cream, and argue it for real. The conversation moved on. My head didn’t. (The ice cream question is in Lean’s bank partly as a quiet thank-you for that comment.)

At the time I happened to be reading Supercommunicators by Charles Duhigg, which my manager had recommended. The book’s central claim is that conversations derail when people don’t recognize what kind of conversation they’re actually having, and that the good communicators are the ones who figure out what a discussion is really about. That idea is baked directly into Lean: every question is trivial on the surface but tagged with a hidden layer underneath, because “what is this debate actually about?” turns out to be the fun part.

The third thread is older. I worked at ADP on StandOut, an employee engagement platform, and I’ll be honest: a lot of what the engagement industry does is cheesy. But the data underneath it wasn’t. Engaged workers performed measurably, sometimes dramatically, better than disengaged ones, and a big component of engagement came down to whether people felt they could contribute and discuss things openly. I spent enough time around those numbers to trust the goal even when the delivery made me wince. Lean is my attempt at a delivery mechanism I’d actually want to use.

The research says the silly thing works

Once I started building, I went looking for whether any of this had legs beyond my intuition, and it holds up better than I expected.

Icebreakers, despite their trust-fall reputation, measurably help with what organizational psychologists call psychological safety: the shared sense that it’s okay to speak up, question, and be wrong in front of your team, which Amy Edmondson’s work links to more honest and effective teams. One mechanism buried in that literature stuck with me: people who don’t speak in the first few minutes of a meeting tend not to speak at all. Lean forces everyone to take a position, privately and cheaply, in the first sixty seconds.

Harvard’s Julia Minson, who studies how people engage with opposing views, argues that practicing on small, trivial disagreements is what prepares you for the big frazzling ones. Her research also shows we systematically overestimate how unpleasant disagreement will be; when people actually engage, the other side usually turns out more reasonable than expected. Arguing about pineapple pizza is a practice field for arguing about architecture decisions.

And the psychology literature on intellectual humility, the capacity to recognize your beliefs might be wrong and update when warranted, ties it to better learning, better relationships, and more tolerance for disagreement. It also names the obvious problem: our norms reward being right and punish backing down. So Lean inverts the reward. Votes stay hidden until the reveal so you can’t just drift toward the crowd, and the end-of-session awards are all warm: “Open Mind” for the most reconsidering, “The Scenic Route” for wandering the options and landing back home, “Quiet Conviction” for holding a lean all session. There’s deliberately no award for persuading people. I left “who changed whose mind” out of the stats entirely, because the moment you score persuasion, people start debating to win instead of to think.

Stanford got here first

Here’s my favorite thing I learned while writing this post. The loop at Lean’s core (secret vote, structured discussion, second vote, compare) is a miniature version of deliberative polling, a method political scientist James Fishkin invented in 1988. Fishkin’s version polls a representative sample on real policy questions, has them deliberate in small groups, then polls again. After running it over a hundred times in dozens of countries, the findings are remarkably consistent: deliberation reliably shifts opinions, the shifts persist, and, the finding I find most striking, the process measurably depolarizes participants.

I did not set out to build the party-game version of a Stanford research instrument. But the structure converged for the same reason: if you want to know what a group actually thinks, you have to separate the first instinct from the considered position, and the only way to see the difference is to measure both. Lean’s reveal chart is a before-and-after poll with the suspense left in.

The questions are built the same way. “Is a hot dog a sandwich” is secretly about definitions. “Everyone gets the same indoor temperature” is about who bears the cost of a shared standard. The pet question that wrecked my team is tagged preference vs. ethics, and that’s exactly where the debate went: it starts as “dogs are better” and ends up somewhere near “what do we owe the animals we keep?” The game shows each question’s hidden layer, subtly, so the debates have somewhere to go once the jokes run out.

The build: one Go binary, zero dependencies

The engineering brief I gave myself was: no ceremony. The entire thing is a single self-contained Go binary. Standard library only, frontend embedded with embed.FS, rooms held in memory, realtime updates over Server-Sent Events. No database, no build step, no npm. go build, copy one file to the server, done.

A few decisions worth writing down:

SSE over WebSockets. I wanted an excuse to use WebSockets and this wasn’t it. The data flow is almost entirely one-directional — the server pushes room state, clients send occasional tiny POSTs (vote, advance). SSE handles that with plain HTTP, automatic reconnection built into EventSource, and no upgrade dance. The one gotcha is reverse proxies love to buffer SSE streams into uselessness; the server sends X-Accel-Buffering: no and the nginx config needs proxy_buffering off and a long proxy_read_timeout. (Caddy just works.)

In-memory rooms as a feature. Rooms are a map[string]*Room behind a mutex. A restart drops live games, idle rooms self-evict after 90 minutes, and nothing is ever written to disk. For an icebreaker game that’s what you want. Nobody’s hot takes about chocolate are being logged.

The host is the pacemaker, with a safety net. Every timed phase can end two ways: the clock expires, or the host taps to move on — whichever comes first. The host can accelerate but never drag. After playing real rounds, I extended this further and gave the host more control over time mid-game, because real groups don’t debate on a fixed schedule: some questions die in forty seconds and some need the full clock plus extra. Auto-advancement also pauses whenever the host disconnects, so a dropped phone doesn’t let the game run away without its moderator.

Identity in localStorage. No accounts. Your player ID lives in your browser; refresh or briefly lose signal and you resume exactly where you were. Latecomers can join mid-round but only participate from the next question — they spectate the current one, which turns out to be a nice onboarding: you watch one reveal and immediately get why the hidden votes matter.

The signature piece is the reveal itself — an animated SVG chart that replays the round’s vote timeline. Every vote change during the debate was snapshotted server-side, so the chart draws the actual story of the argument: lines drifting as people waver, a deliberate deceleration near the end for suspense, then the final standings. It’s the payoff the whole design funnels toward, the moment the room finds out whether anyone budged.

Open by design

Lean is open source — the code, the question bank, all of it: https://github.com/programmerstilesj/lean

I thought briefly about whether a project like this needs “protecting” and concluded the honest answer is that game mechanics can’t really be owned — copyright covers my code and my questions, not the idea of vote-debate-revote, and that’s fine. Fishkin got to the mechanism thirty-eight years before I did anyway. If someone clones it, the dated repo and this post are my proof of authorship, and the idea spreading is sort of the point of an idea like this.

If you try it with your team, I’d genuinely love to hear which question started the best argument. For us it was the pets — and technically, that debate never ended.

Lean runs at lean.stilestech.com. It’s a single Go binary; the README covers deployment with systemd behind nginx or Caddy in about ten lines.