We Built a Game to Teach Our Decision Framework. We Also Learned More Than We Thought We Would.

What a pixel-art side project showed us about specs, testing, and where a person still has to decide

shards of clarity hero
Benjamin Scott on Nov 19, 2026 · 13 minute read

We recently had fun building a game. As a developer turned design engineer, I’ve gotten even more interested in how ideas are communicated. AI outputs are almost always walls of all-text, but what does it look like when the world is more interactive, where learning can actually be fun?

Glare is a decision framework that comes packed with huge amounts of value and infromation. But there's no real way to communicate the feeling that Glare provides.

So we tried making Glare easier to understand and more fun to look at. Fewer walls of text, more of the visuals, feelings and interactivity that make a framework easier to take in.

Why a game

Glare is how we help teams make design decisions with evidence instead of opinions. It's built around real results, backed by metrics you set up before the work starts, not after. Define what matters. Measure it. Focus on what the signals say. Lead the team with the results.

That's easy to say and hard to break down, grasp, and actually feel. Most people meet a framework as a complex diagram that takes twenty minutes to make sense of. They nod, forget it, and walk into the next meeting with nothing they can use.

So we tried something else. We made a pixel game in the style of old Zelda (top-down, not a platformer) and called it Shards of Clarity. Yes, we love the name. You carry Ray, a raygun. You collect Glare gems. You talk to users and gather evidence. Doors that say OPINION BLOCKED won't open until you have enough proof. The boss is the HiPPO: the highest-paid person's opinion and, fittingly, an actual hippo. He's been doing this for twenty years and knows (or thinks he knows) what users want.

A user in the game says: Just make it faster!

It started as a side project. Everyone else was building games with Opus 5.5, so we tried our hand too, with one twist: make it useful as well as fun. A bit of an experiment.

Bryan's pixel character greets the player in the hub room

Then something clicked. If the game was going to teach Glare, we should build it with Glare. So we did.

Define before you build

The first instinct, for most people anyway, is to start prompting away. We didn't. We built an asset library first: the atomic building blocks that let us move faster and stay aligned on what we wanted. Sprites, characters, items, theme, branding. Not the story yet, just the world. And because we're a feedback-heavy team, every asset had a spot where anyone could approve it or leave a note, so we iterated on the pieces before building anything with them.

The Glare Game Assets library page with status counts and a screen mock

Under it sat a one-page spec Bryan had written for pixel art (had to dig for this from our project Radar). Twelve colors. A 1px black outline. Light from the top left. No gradients, no glow, no anti-aliasing. We built the building blocks first, and then allowed everything else to fill in.

The twelve-color Glare Pixel Core palette with hex values

That page did a lot of the carrying. Every time a new character showed up, the spec answered the questions that could have caused a bit of bike-shedding (my favorite term). What color is a shadow? Shadow Purple. Can we add a gradient here? No. It meant a sprite drawn on day one and a sprite drawn three weeks later still looked like they belonged in the same world. We came in with a design system already in place and stuck to it, so the world felt cohesive from the start.

This is a miniature version of the Define facet of Glare. On a real team, Define goes much further: you agree on the audience, the user needs and the metrics before anyone builds. Here, we only defined the elements of the world. But the move is the same. Agree on what matters before you make things. Write it down somewhere everyone, and every tool, can read. Otherwise you get the same debate in every review, and the loudest taste wins.

Playable before perfect

We spent a while trying to write the story first, and honestly, we lost traction. Who is the player? What's the mission? Why is there a boss? Every answer raised more questions.

So we went back to the simplest idea: a game where you run around, shoot things, and work your way to a boss room, like the games we grew up on (some of them from before I was born). We built it in a day: a hub, three mission rooms, and a boss. Five rooms of 16-pixel tiles on a plain canvas. No engine nor 3D library was needed to build this thanks to the simplistic view. Twenty years ago, this would have taken months. We did it in a day.

Crafting the story arc got easier the moment there was something to play. Once you could walk into a room and talk to the users, it was obvious they should give you evidence. Once evidence existed, it was obvious the HiPPO should demand it before you could fight him. The story came out of exploring the world, and it ended up more interesting and more useful than anything we'd planned on paper.

The User Needs room with three users, two Zombie PMs and the player

That's a Glare habit too. Put a hunch in front of people early and you get alignment. Spend a week on a polished deck instead, and you hand people something that takes too long to understand, and nobody buys in. A rough version people can react to beats that every time.

When a Bad Test Passes

We built most of the game with Claude, and we like having it check its own work. So we had it build a bot that played the game using only the keyboard, the way a person would, and report back.

The bot was immediately useful. It found a loophole: there were exactly three users and the boss door wanted three pieces of evidence. You could talk to three people, walk straight to the boss, and skip every other room. Fast, and kind of lame. We raised it to five pieces and made you go find the rest. It also found that losing to the boss reset the boss to full health, so every retry started from zero. It lost seven times in a row before it won, so we made the boss keep its damage between tries.

One run came back with the boss beaten in a few seconds. That was the doorway. When you entered the boss room, you spawned on top of the door that locks behind you. The player was stuck inside a wall. The boss walked up, hit a stuck target over and over, and the bot's own simple attack routine happened to win. The report said "too easy." The truth was "broken."

The HiPPO boss says: I have been doing this for twenty years. I know what users want.

This is common in engineering: a test that passes looks like a valid answer, and that's what makes it dangerous. Crashes get caught in a minute, because failures are easy to spot. A clean "boss defeated" looks like success: the bot made it through, ship it. Without a person checking, it would have pointed us straight toward a broken game.

This is the Measure facet of Glare, and it's the part we most want people to take from this post. When you're building something, you need to know whether it's working, because that's what tells you whether you're hitting real results. And a signal is only as good as what produced it. Bad data in, bad data out. Before you act on a signal, look at the full picture, not just the number it shows you.

What people found that the bot couldn't

The bot played the game the way it was designed to be played. People don't. (In high school I was a game glitcher. Think Call of Duty Zombies, jumping into the one spot where nothing can reach you.)

In one of the first real playtests, someone pressed E at a random moment and the whole game froze. The bot only pressed E when it meant to. A person presses keys to see what happens. They run into walls. They poke at everything. Game designers have been running into this forever.

Then someone went full screen and the text turned to low-res mush. We fixed it. Then someone opened the game file on its own, outside the page it was embedded in, and the fonts didn't load at all. Not what we expected, but it's what a user wanted to do, so we fixed that too. Then someone got stuck in that same boss doorway, by hand.

And then there was Bryan, ZURB's fearless leader and the game's intro character. We gave the AI a photo of him and had it draw him: gray hair, black tee. The first version looked, in the words of the team, like "weird skull dude." We had it redraw him. Then again. It couldn't get there on its own, so a person stepped in and directed the fixes piece by piece. The answer was less detail, not more: glasses and gray hair, nothing else in the small version. The big portrait finally got the teeth right.

Bryan's final pixel portrait with glasses and a big grin, beside the small in-game sprite

No metric would have caught that. A sprite can pass every rule in the spec and still look bad. Some signals only come from a person looking at the thing and saying "that's not right." Visual work especially.

That's the line between automated checks and human judgment, and Glare cares about both. The bot was great at "does it work." People were the best source for "does it feel right."

Every mechanic is a Glare idea

We didn't set out to map the game onto the framework one-to-one. It mostly happened anyway, because that's how we work at ZURB. Each piece of the game is a small nod to a Glare idea.

In the game In Glare
Doors marked OPINION BLOCKED open only with five pieces of evidence Decisions move on signals, not on whoever argues hardest
Users tell you what they want; the evidence is what they need Wants vs. needs, one of the first distinctions in Define
Scope Creep enemies grow while you ignore them Unfocused work gets bigger and harder to stop
The Signal meter fills as you collect proof Confidence should track evidence, not effort
Zombie PMs get turned back human, not defeated The goal is alignment, not winning the meeting
The bot's "too easy" report A clean number from a broken process is still a broken number

The HiPPO boss with the text OPINION BLOCKED below it

Shoot the boss without evidence and it bounces: OPINION BLOCKED.

What we'd tell someone building the next one

Write the spec before the first asset. Set the rules and decide what you're looking for up front. A one-page rulebook settled more arguments than any review, and it kept the AI's output consistent across weeks.

Ship the rough version early. The story only made sense once there were rooms to walk into, and having something real early kept the idea from stalling.

Let a script play, then watch what it did. Automated playtests found real problems fast, so they're far from useless. But they also produced one confident, wrong answer. You need the context of what actually happened.

Put it in front of people who don't know the rules. They press the wrong key. They open the wrong file. They tell you the character doesn't look like a character. That's the stuff that actually matters.

Keep the decision with a person. Every fix in this game came from someone deciding what a signal meant. The tools made some signals cheap. Judgment is still expensive, and it still matters most.

You can play Shards of Clarity here: [play link]. It's short, about five minutes. If you beat the HiPPO, or find a new way to break it, tell us in the [Glare forum]. We'd especially love to hear where it got the framework wrong.

[EMBED: playable game goes here] Click the game to start. Arrows to move, Space to fire, E to talk. On a phone, use the on-screen pad.

Win screen: Shard of Need, with time, PMs restored and Signal left

Beat the boss and you get the first shard. Measure, Focus and Lead are next.

How we built it

It's simpler than you'd think. A plain HTML canvas, no game engine, one single file. Every sprite is a 16-by-16 grid of letters, one letter per palette color, so the art lives as text that a person or a model can read and edit. That turned out to be really useful. Portraits are 32 by 32. Sound is generated in the browser. Claude wrote most of it. And because it's all one file, you can download it and play it offline.

Four characters from the game's asset library, each shown large beside its small in-game sprites

Related Posts