Blood Rogue is a roguelite deckbuilder I built from scratch in TypeScript: five acts, seven classes, turn-based party combat in the browser. The hardest design problem in it, by a wide margin, was not the cards or the classes. It was the bosses. This post is about a rubric I wrote to stop getting them wrong, and what writing it down taught me.

The diagnosis

The first pass at the act bosses was bad in a specific, measurable way. When I ran them through the combat simulator, the intent pools came back verb-poor, defensively biased, and flat: a boss would buff itself, raise a shield, maybe poke the hero for chip damage, and otherwise wait to be killed. Difficulty was a single knob, hit points, and turning it up didn’t make the fights interesting, it made them longer. A boss with 1,200 HP and no ideas is not a harder version of a boss with 600 HP and no ideas. It is the same empty fight, twice.

The tell was that none of the bosses asked the player a question. They just stood there with a large number over their head.

A boss is a counter-deck

The reference I kept coming back to is Slay the Spire, which is the modern gold standard for this, and the insight I stole wholesale is: a boss is not a stat check, it is a counter-deck against a way of playing: telegraphed, turn by turn.

Every enemy shows its intent for the next turn. A boss cycles through a deliberately shaped pool of intents that the player can read and plan around. Once I started classifying intents instead of just writing them, the same five verb families kept appearing:

• Spike: “block now or eat 30 damage.” Tests your defensive ceiling on a known turn.
• Tax: make the player pay an economy cost: discard a card, lose energy, take a debuff, get a dead card shuffled into the deck.
• Setup: a telegraphed multi-turn ramp that creates a known kill window, or a known punish window.
• Protection: buff or shield another enemy, forcing the player to re-think target priority.
• Disruption: reorder the player’s normal turn so their reflexes stop working.

The rule I landed on: every act boss needs at least a Spike, a Setup, and one of Tax / Protection / Disruption. Miss a family and the fight gets predictable from a single angle, which is the same as being boring.

One anchor mechanic, not bigger numbers

The thing that actually makes a boss memorable is a single anchor mechanic, one idea the whole fight is built around, that isn’t “more damage.” In Slay the Spire it’s things like Hexaghost’s fixed seven-turn clock that detonates whether you’re ready or not, or the Slime Boss splitting in half at 50% so that a one-turn burst deck gets punished for over-committing, or Time Eater ending your turn the instant you play your twelfth card, a hard counter to the play-thirty-cards-in-one-turn deck.

Each one counters an archetype. The fight is the argument the boss is making about how you’ve chosen to play.

So I rebuilt Blood Rogue’s bosses around anchors of their own. The Act 1 Briar Matron is a poison-pressure fight, an aura that bleeds you every turn, so the question is whether you can race it or have to answer it. The Sepulcher Devourer cleaves your summons, which specifically punishes the summon-everything builds that trivialize everything else. The Idol Patriarch drains your energy and dispels your aura setups, so the engine decks have to fight without their engine. The Ashen Lord turns the screws on burn and discard. The final Siege Tyrant distorts time and sunders the board. None of them is “the same boss with a bigger number.” Each one is aimed at a specific way the player might have gotten comfortable.

Phases are built in, not bolted on

The second rule that fell out of the rebuild: escalation has to live inside the intent pattern, not on a flag. My first version had an enragedOnly boolean: below 50% HP, switch on the scary moves. It felt exactly as cheap as it sounds, because the fight didn’t transform, it just got a buff applied to it at an arbitrary line.

The bosses that work escalate structurally. The clock keeps ticking and the detonation gets bigger each cycle. The boss splits, or revives at full HP carrying its accumulated strength, or enters a second phase that recolors the whole pattern. The phase transition is the fight, and everything before it is teaching you to read what’s coming. A flag is a difficulty setting. A phase is a story.

And a smaller rule that turned out to matter a lot: every turn has to do something to the player. No boss gets a turn that is purely self-buff with no pressure. That’s a free turn for the player and a wasted turn for the fight. If a boss is going to spend a turn setting up, the setup itself has to be a threat you can see coming.

The part that was really about my day job

What I didn’t expect was that the most valuable artifact wouldn’t be any individual boss. It was the rubric itself, written down with one operational goal: a designer should be able to use this doc to approve or reject any proposed boss in fifteen minutes. Diagnose the intent pool, check the verb families, name the anchor mechanic, confirm the escalation is in the pattern and not on a flag. If it fails any of those, it goes back.

That is an executable standard, and it is the same move I make constantly in engineering: the value isn’t the one good decision, it’s the written-down rubric that lets anyone make that decision consistently without me in the room. A code review checklist, a definition of done, an architecture-acceptance bar: they are all the same shape as a boss-design rubric. Write the standard so the next hundred judgments are cheap and consistent, instead of relitigating taste every time.

I went into Blood Rogue to build a game. I came out of it with a sharper sense of when a “more hit points” answer is hiding a missing idea, which, it turns out, is most of the time, and not only in games.