By The Intrepid — 11 Aug 2025

From Cyberpunk Hack to Container Revelation

How a simple Lasers & Feelings hack accidentally became the DevOps approach to RPG design

It Started With a Simple Question

Like most RPG design stories, this one began with someone asking "what if?" What if we made a cyberpunk version of Lasers & Feelings? Simple enough. The original L&F is brilliantly minimal—one stat line, basic roles, roll dice, tell stories. How hard could it be to add some neon and chrome?

The first challenge was obvious: find the perfect binary tension. Lasers & Feelings uses the exploration vs. emotion spectrum that captures classic space opera perfectly. For cyberpunk, we needed something that felt equally fundamental to the genre.

After cycling through dozens of options (Logic vs. Instinct, Data vs. Drive, Tech vs. Soul), we landed on Code vs. Chrome. Code for the digital, analytical, hacker mindset. Chrome for the physical, instinctive, street-level approach. It captured both the human/machine tension and the cerebral/visceral split that defines cyberpunk fiction.

So far, so normal. Just another genre hack.

The Rabbit Hole Opens

But then something interesting happened. As we brainstormed additional cyberpunk elements—cyberware stress, corporate heat, Net diving mechanics—the question of scope kept coming up. How much should go in the "core" game versus optional expansions?

Someone mentioned CBR_PNK's brilliant "one last job" focus, which distills cyberpunk down to its essential narrative structure. That got us thinking: what if we went even more minimal? What if we created the absolute thinnest possible cyberpunk framework?

The breakthrough moment came when someone said: "Let's think of it as the Alpine container image of cyberpunk RPGs."

Suddenly we weren't just making another L&F hack. We were architecting something completely different.

The Container Metaphor Takes Hold

The Alpine Linux analogy was perfect. Alpine is a minimal Docker base image—just enough OS to run your application, nothing more. What if we created a cyberpunk RPG base image? Just the essential mechanics, zero bloat, designed to be extended?

circuit_breaker:stable became exactly that:

Code vs. Chrome stat line
Four core roles
Basic gear mechanics
Net diving rules
Essential cyberpunk flavor

180 words. Fits on a business card. Completely playable.

But here's where it got interesting: the container metaphor suggested a modular architecture. Other systems could build on this foundation:

FROM circuit_breaker:stable
ADD hedge_magic
ADD zombie_apocalypse  
ADD mission_generator

Each layer adds functionality while maintaining the base's elegant simplicity.

Infrastructure as Game Design

The more we developed this approach, the more the containerization metaphors fit. We started thinking about:

Versioning: circuit_breaker:v1.2-glitchpunk
Dependencies: Heat layer requires base image
Environment variables: ENV TONE=neonoir
Reproducible builds: Same flags = same mission type

The final PDF literally became a Dockerfile:

FROM circuit_breaker:stable

# Base game mechanics
ADD cyberware
ADD heat  
ADD generator
ADD net
ADD factions

# Runtime example
EXPOSE character
CMD [“circuit_breaker”, “-D”, “FOREGROUND”]

We'd accidentally created the first Infrastructure as Code approach to RPG design.

The Bigger Picture

What started as "let's hack L&F for cyberpunk" had evolved into something much more significant: a new way to think about modular game design.

Traditional RPG design often follows the kitchen sink approach—pack everything into one book and let GMs ignore what they don't need. The container approach flips this: start with the absolute minimum viable game, then provide optional layers that extend functionality.

This has profound implications:

For Designers: Clear separation of concerns. The base image handles core mechanics, layers add specific features. No more monolithic rule books.

For GMs: Pick exactly the complexity level your table wants. Want just the base cyberpunk experience? Use the minimal image. Want full corporate intrigue? Build with all layers.

For Communities: Modular systems are forkable. Someone can take Circuit Breaker and create their own layers, or build entirely different games on the same foundation.

Beyond Circuit Breaker

The container metaphor suggests an entire ecosystem:

heist:circuit-breaker (cyberpunk)
heist:blackwater (pirates... or private security firms, depending on your dystopic threshold)
heist:deadlands (weird west)
heist:corporate (extends circuit-breaker)

Each implementing the core "assemble crew, plan job, execute under pressure" pattern for different genres and contexts.

We realized we hadn't just hacked Lasers & Feelings—we'd discovered a new paradigm for how modular RPGs could work.

The Real Innovation

Looking back, the technical innovation isn't the container metaphor itself. It's the realization that the perfect binary tension is all you need to define a genre-specific game engine.

Code vs. Chrome isn't just a clever stat line—it's the DNA that makes every mechanic feel cyberpunk. The Net diving rules, gear system, even the faction mechanics all emerge naturally from that central tension.

This is why L&F hacking is so addictive. You spend 90% of your time searching for that perfect binary, and once you find it, the rest of the game designs itself.

What We Built

Circuit Breaker ended up being:

A complete cyberpunk RPG in around 180 words
A demonstration of modular design with stackable layers
A proof of concept for Infrastructure as Game methodology
An accidental reframing of RPG architecture

More importantly, it suggests a future where RPG communities work more like open source software projects—forking base images, submitting pull requests for new layers, and collaboratively building ecosystems around minimal, composable foundations.

The Commit Message

The final PDF ends with:

git commit -m "2025 The Grey Ledger Society + CGCG Helix CC BY-SA 4.0"
git push origin main

Because the best innovations often come from taking ideas seriously enough to follow them to their logical conclusion, even when they lead somewhere completely unexpected.

What started as a simple cyberpunk hack became a glimpse of how game design might work in the age of containers, microservices, and collaborative development.

Not bad for 180 words about Code and Chrome.

Code & Chrome is available as a free download on itch.io.