A Game Boy visual novel built around the pull between thinking in systems and thinking in independence, and what each one costs

The Situation

I have two tendencies that pull against each other in nearly everything I build. As a learning experience designer and a platform admin, thinking in systems is baked into me. I map workflows, set defaults, and look for the place where something will break before anyone gets there. Politically, and as an employee, I lean the other way. I like the idea of more independence and autonomy for teachers, learners, and myself. For a while now I’ve thought of them as an industrialist and an anarchist sharing the same desk. It’s a framing I’ve turned over and waffled on many times without ever writing it up properly, mostly because I haven’t settled the argument between them.

Neither side is clean. The systems side catches things, but it can feel cold. The independent side is warmer, but it’s also more isolated and more inward-looking. A reading from my doctoral game design course this fall gave me another way to see the problem: Roger Caillois describes play as running between paidia, the free and improvised end, and ludus, the end shaped by rules and effort. I wanted to build something small that held both of my tendencies on purpose rather than picking one.

The Approach in Brief

The defining choice was to give Meridian no game over and no wrong answer. Players arrive on a space station split between the Lattice, an orderly district where nobody falls through the cracks and everyone is quietly measured, and the Thicket, a hand-built district where nobody tells you what you’re for. They can stay as long as they like and lean toward either side without being punished for it. The structure around those choices supplies just enough clarity to keep the openness usable: each day asks for one place and one action, the people you meet fill a wall with reasons to stay, and once the wall is half full you’re offered the choice to leave.

What Came Out of It

Meridian went live on itch.io on October 7, 2026, as a free, in-development release that plays in the browser and runs as a ROM on emulators, retro handhelds, and original Game Boy hardware. Family and friends played early builds. They mostly liked it, but they also noted that it wasn’t always clear what was going on, and that feedback led to the one real change in the design: a stats screen that shows which way the player is leaning. It’s a small, friendly sample, and I read the response less as proof the design works and more as a sign of where the openness needed help. The project also gave me a finished answer to a question I’d been circling, which is how a game made half by AI and half by me would feel once it was done.

Key Takeaway

Making the industrialist and the anarchist into two halves of a station didn’t resolve the tension, but it did make each side’s cost easier to see. It’s also the closest I’ve come to writing that idea down. Systems thinking and independence both show up in the finished game, and neither one comes out as the right answer, which is also where I am in my own work.

Deeper Context

Meridian isn’t the prototype for my game design course. It’s a personal project that the course readings shaped. I’ve been making small Game Boy games on my own for a while, and I’d like to put some of them on physical cartridges someday. Meridian is the first one I’ve released publicly, and a second game, Fewer Buttons, is still in progress.

I started in GB Studio, which lets you build Game Boy games without writing code. I wanted more control over how things displayed than it gave me, so I moved to GBDK-2020, which means writing the game in C. That decision shaped everything about how the game got built, and I come back to it in What I’d Change.

The two halves of the station borrow from James C. Scott’s Seeing Like a State. Scott argues that states simplify what they govern so it can be counted and managed, and that those simplifications tend to erase the local, practical knowledge that held things together. The Lattice is my version of a legible order, and the Thicket is closer to what Scott calls metis, the knowledge that grows out of hands-on practice. This is a borrowing rather than a direct application, since Scott wrote about states, forests, and cities rather than imaginary space stations. I gave the Lattice real appeal on purpose. It’s the half of the station I’d be most useful in. I spend a good part of my working life configuring reporting fields in a statewide LMS, so I’m in no position to write the Lattice as a villain.

The Journey

The first pull was toward an entirely open game: a station to walk around, people to meet, and nothing asked of the player at all. That was my independent side designing. It also would have been a game where a new player opens the ROM, sees four shades of green, and has no idea why they’re there. Caillois was useful here because he doesn’t treat ludus as the enemy of paidia. Rules give free play something to push against. So the question became which rules would make the openness usable without telling the player what to value, which is about as close as I could get to letting both of my tendencies design the game together.

The daily loop came first. One place and one thing, then the day ends. That limit keeps each session short enough for a handheld, makes every choice feel like it costs something, and gives a player who doesn’t know what to do a small enough decision that they can just try something. The Lattice and Thicket choices are mixed into the same daily menu, so leaning toward one side happens through ordinary activities like unloading cargo, taking tea with Ilse, or mending with Bram rather than through a single “pick your side” moment.

In early builds that lean was invisible. I liked that, since it kept the player from treating the two halves as a meter to fill. Playtesters didn’t always know what was happening, though, so I added a stats screen that shows the lean. It was a concession for playability, and it’s probably the clearest place in the game where the systems side of me won an argument with the independent side. I think it was the right call, even if part of me misses the version where you only found out who you’d become by noticing it yourself.

The wall was the second structural piece. I wanted some visible record of progress, but not a score. The trinkets on the wall come from people, and they stand for relationships rather than achievements. That distinction mattered to me after writing about the difference between a game and a badge. A badge records what someone else decided was worth recording, while the wall fills with what happened to you.

The half-full wall is the one place the game asserts anything about ending, and I don’t think of it as the real ending. I kept it so that people who play for a while still get some sense of closure. Even then, it only offers the choice to leave and doesn’t make you take it. I also wanted that moment to be a bit melancholy. It’s the player saying goodbye to the game rather than the game saying goodbye to the player.

The Game Boy’s four shades pushed the art toward density and general shapes. The Lattice uses columns and rigid lines, and the Thicket is messier, with a woodier feel. I’m honestly not sure how well that comes across. Pixel art turned out to be much more of a skill than I expected, and the art is the part of the game I’d most like to keep improving.

The Work Itself

The game is playable in the browser below at:

On that page you can also see screenshots and download the ROM for free. It runs on a computer or phone, in emulators, on retro handhelds like the Miyoo Mini, and on an original Game Boy, Game Boy Color, or Game Boy Advance through a flash cart with battery save. It saves itself each morning, so a player can put it down and come back without managing anything. The itch page includes install instructions written for someone who has never loaded a ROM before, along with a plain AI disclosure.

What I’d Change

Once I moved from GB Studio to C, I let AI do the coding. It was easier, and I wanted the game to actually get made. Part of the project was also a deliberate test: I wanted to see what I could make with AI that still felt like a good use of it artistically, and how I’d feel at the end about a game that was half built by AI and half built by me. The story, characters, design, and pixel art are mine. Most of the code isn’t.

The music wasn’t part of the plan at all. Getting something to sound right on Game Boy hardware was beyond what I could do, so I hummed a few melodies into a microphone, shared the recordings with Claude, and went back and forth until the result was something like what I heard in my head. It’s close to how I draft my writing, by talking through ideas out loud before anything gets typed, and I’m comfortable with it in roughly the same way, since the melodies started with me.

The clearest way I’ve found to think about the rest comes from Ted Chiang. In his 2024 New Yorker essay “Why A.I. Isn’t Going to Make Art,” Chiang argues that art is the result of making a great many choices, at every scale, and that handing a prompt to a model means making far fewer of them and letting the machine fill the gaps by averaging or imitating. I admire Chiang’s writing enough that I read the essay as if it were addressed to me, and I don’t disagree with it. Held up against his measure, Meridian splits pretty cleanly. The story, the characters, the two halves of the station, the gate, and every pixel are choices I made, and the pixel art in particular is the weakest part of the game and also the most completely mine. In the code, I made far fewer choices. I decided what the game should do and judged whether it did it, but directing and reviewing involve fewer choices than writing the thing yourself, and I’d rather say that plainly than argue my way around it.

The finished ROM has no AI running in it, which fits a distinction I try to hold to (AI in the building, not the running), but that distinction doesn’t answer how much of the building I wanted to keep for myself. I still wonder how much I lost by not slowing down to learn some of those pieces, and whether the game would be better, or at least more mine, if I had. If I did it again, I’d pick a few parts of the code to write by hand from the start, so the test would have produced some learning alongside the finished game. I think the game has enough of me in it to call it mine. Whether it has as much of me as I’d want is still an open question.

Connections

You can play the game in your browser or download the ROM at Meridian on itch.io. For more on how I think about games versus gamification, see The Difference Between a Game and a Badge, and for James C. Scott applied to district-owned tools, see Leaving the Back Open. The play readings behind this project, Caillois included, are on my Research Interests and Readings page.

If you’ve played Meridian or built something that sits between open play and clear structure, I’d like to hear about it. You can reach me at licht.education@gmail.com, and there are more tools, articles, and resources at bradylicht.com.