Dev Journal: Architecting a Universe Before Writing a Single Line of Code

Samuel Jonathan JOSEPH — Fri, 25 Jul 2025 18:53:21 +0000

The starting gun for the Code with Kiro Hackathon has fired, and the excitement is palpable. Like many others, I'm eagerly awaiting approval to get my hands on the Kiro IDE, a tool I believe will fundamentally change how we translate ideas into reality. But is waiting a delay? Not at all. It's an opportunity. An opportunity to do the most critical work upfront: thinking, planning, and architecting.

While I wait for my development environment, I've poured all my energy into building the universe of my game, INFINITY WARS, on paper. I haven't just been idle; I've been architecting. The result is a comprehensive game design document and, more importantly, a complete technical blueprint for a functional prototype. The foundation is laid, and every brick is in its place, waiting for the code to bring it to life.

The Concept: INFINITY WARS - Where Math Becomes a Weapon
At its heart, INFINITY WARS is a strategic card game with a revolutionary core concept: what if you could weaponize the very idea of infinity? Players start with simple, finite mathematical sets—like {1, 2, 3}—as their units. But the entire strategic depth of the game revolves around a single, dramatic goal: achieving mathematical infinity.

A card transformed into ℵ₀ (Aleph-naught) becomes a god on the battlefield, immune to all finite attacks. It’s a moment of transcendence that shifts the balance of power completely. This isn't just about having a stronger monster; it's about creating a unit that operates on a different plane of reality. The game is a tense, 15-minute duel of resource management, strategic sacrifice, and knowing the perfect moment to make the leap into the infinite.

The Blueprint: A Modular, Event-Driven Engine
To build a game with rules this complex, a robust architecture is non-negotiable. My goal was to design a game engine so decoupled and logical that adding new cards with bizarre, reality-bending effects would be trivial. The entire system is built on a few core principles:

Data-Logic Separation: The CardDatabase knows what a card is (its stats, its cost). The EffectLibrary knows what a card does (its executable logic). They never mix.

Single Source of Truth: The GameStateManager holds the entire state of the game. It doesn't know the rules; it only knows the current reality of the board.

The Judge and The Executioner: The RuleValidator is a library of pure functions that only returns true or false ("Is this action legal?"). If the answer is yes, the ActionExecutor is called to actually change the game state.

Event-Driven Communication: The engine is not a monolith. When an action occurs, the ActionExecutor simply broadcasts an event, like CardPlayed. Other modules, like the UIManager or passive card effects, listen for these events and react accordingly. This keeps every component independent and focused on its one job.

Here’s a glimpse into that architecture with some pseudocode.

Pseudocode: The Anatomy of a Card
A card isn't just one object. It's a static definition and a dynamic instance. This separation is key.

// From types.ts - The definition of what a card IS
interface CardData {
id: string;
name: string;
cost: number;
// ... other static properties
effectId?: string; // A key to look up its effect in the library
}

// An instance of a card in play, with its own unique state
interface CardInstance {
uniqueId: string; // To track this specific card
data: CardData; // Reference to its static definition
isTapped: boolean;
currentAttack: number;
}

Pseudocode: The RuleValidator as Gatekeeper
Before any action is taken, we consult the "judge." This prevents illegal states and keeps the core loop clean.

// From RuleValidator.ts
function canPlayCard(player: PlayerState, card: CardData, gameState: GameState): boolean {
if (player.finitude < card.cost) {
return false; // Not enough Finitude
}
if (gameState.currentPhase !== GamePhase.MAIN) {
return false; // Can't play cards now
}
if (player.ensembleZone.isFull()) {
return false; // No space on the board
}
return true; // All checks passed!
}

Pseudocode: Action, Consequence, and Event
Here is the flow when a player plays a card. Notice how each module has a distinct role.

// From InputHandler.ts - The player clicks a card
function onCardClick(card: CardData) {
// 1. Ask the judge
if (RuleValidator.canPlayCard(player, card, gameState)) {
// 2. If legal, command the executioner
ActionExecutor.playCard(player, card);
}
}

// From ActionExecutor.ts - The action is performed
function playCard(player: PlayerState, card: CardData) {
// 3. Modify the game state
player.finitude -= card.cost;
GameStateManager.moveCard(card, 'Hand', 'EnsembleZone');

// 4. Announce what just happened
EventManager.broadcast('CardPlayed', { cardId: card.id, playerId: player.id });
}

Ready to Build with Kiro
This deep architectural work has been incredibly rewarding. I now have a complete, logical map of the entire game. When I finally get access to the Kiro IDE, I won't be asking it "How do I start?". I'll be telling it: "Here is the blueprint. Let's build this universe, together." I'm convinced that pairing this level of detailed, spec-driven design with an AI partner like Kiro is the future of development. The interesting problems are already solved; now comes the joy of bringing them to life.

The Flame to Conquer, The Desire to Create: Using Kiro IDE to Turn Mathematical Infinity into a Video Game

Samuel Jonathan JOSEPH — Wed, 23 Jul 2025 18:07:15 +0000

Hey dev.to community! 👋

There's a famous saying: "Mathematics is the alphabet with which the universe was written." This idea has always captivated me. It made me wonder: what if we used that alphabet to play, to compete, and to master its most powerful "words"?

For this hackathon, I don't just want to code an app. I want to tackle a monster: abstraction. My goal is to turn one of math's most mind-bending concepts—the different sizes of infinity—into a tangible, strategic, and above all... addictive card game mechanic.

**
The Concept:** A Game Where Infinity Changes All the Rules
I'm working on a prototype for a card game (codename: Project Aleph-Zero) where the goal isn't just to beat your opponent, but to break the very foundations of the game's logic.

Imagine a duel that starts conventionally, with finite-value cards. The strategies feel familiar. Then, a player manages to do the unthinkable: they summon ℵ₀ (Aleph-zero)—the first infinity—onto the field.

This is the game's "WOW" moment.

Suddenly, all "finite" attacks become useless, absorbed by this new, overwhelming power. The opponent's strategy is shattered. They have to rethink everything, because the rules of the world have just changed.

And that's just the gateway. What happens when even larger infinities enter the game? Or when a Paradox card is played, disrupting the duel's logic itself? This is what I want to explore.

My Partner in this Quest: Kiro, the AI Agent
A project this wild can't be built with just an IDE. It needs a creative partner, an oracle. That's where Kiro comes in. While I'm waiting for my invitation, here's how I plan to collaborate with this AI agent:

**🧠 The Strategic Brain: **I plan to use Kiro to simulate thousands of games. How do you balance a card that is, by definition, "infinitely" stronger than the others? Kiro will help me find the answer.

🔮 The Idea Generator: Asking it to draw from obscure mathematical theorems to propose unique card mechanics. "Kiro, design a card based on the Banach-Tarski paradox. What would it do?"

✍️ The Narrative Architect: Using the AI to generate lore and flavor text for the cards, turning abstract concepts into epic legends.

Current Status & Call to the Community
Right now, I'm in the most exciting phase: the drawing board, where rules are taking shape and the first cards are being sketched out. The prototype will be developed in Node.js for its speed, which is perfect for an MVP.

The name INFINITY WARS is a working title, but I'm convinced there's something more original out there.

*So I'm asking you:
*What mind-bending mathematical concept would you love to see turned into a legendary card?

Thanks for reading! I'm excited to share my progress on this journey into infinity with you all.

Forem: Samuel Jonathan JOSEPH

Dev Journal: Architecting a Universe Before Writing a Single Line of Code

The Flame to Conquer, The Desire to Create: Using Kiro IDE to Turn Mathematical Infinity into a Video Game