Following the North Star

Two key factors that allowed me to become a game designer with a career in the board game industry (Paint the Roses #6) November 19 2019, 0 Comments

This is the sixth post in a series about our upcoming game Paint the Roses, written by the game’s designer, Ben Goldman.

I went to art school for graphic design, where I spent as much time designing board games as graphics. Games were how I slacked off.

It turned out to be productive slacking, as I now work full-time in the game industry and North Star Games is about to publish a product of that slacking: a game called Paint the Roses.

(It’s a cooperative game where you’re a gardener for the Queen of Hearts in Wonderland. You’re trying to plant her rose garden right so she doesn’t behead you. Problem: she’ll only give you partial information about how she wants it planted. So you and your teammates must deduce her wishes or lose your heads.)

In the interest of helping others find their way professionally, I want to share what I think are the 2 keys to my having ended up where I am.

Key #1: I combined graphic design with game design (talent stacking)

It’s not a stretch to say graphic design is as important to game sales as the games themselves, especially since Kickstarter became important. As a result, graphic design skills are in demand.

And while there are many incredible graphic designers, and many incredible game designers, few people do both things. If you can do both things, you have something.

This relates more generally to the cartoonist Scott Adams’ conception of the talent stack: the idea is you can combine multiple modest talents that become uniquely valuable by their combination. In Adams’ case, he wasn’t the funniest, or the best cartoonist, or the best businessman. But he was pretty good at all those things, and he could combine them uniquely to create the comic for which he’s now famous: Dilbert.

Even if you’re not good at graphic design, this general lesson applies: develop some skill that complements game design (or whatever it is you want to do for a living), and sell yourself on the strength of that combo.

Key #2: I gave myself weird design challenges

Teeming hordes of game designers pitch games to publishers every day. TEEMING. EVERY DAY. How do you design something that stands out enough to be published?

Turns out the way I slacked off doing game design in college was a good solution to this problem, though I didn’t know it at the time.

Each week I’d give myself an odd design challenge, then rapidly prototype a playable (but usually bad) game. There wasn’t much rhyme or reason to the challenges, just whatever felt interesting. Some favorites:

  • A game where the board is a Möbius strip.
  • A game where eating the components is core to victory.
  • A drinking game that is still fun for the designated driver.
  • A game about lasagna.
  • A positional strategy game with a limit of 9 spaces.
  • A game where players make their own win conditions.
  • A game that models having to do all the work in a group project.
  • A player elimination game without player elimination.
  • A cooperative deduction game that allows for lots of communication.

A Möbius strip racetrack in Mario Kart

Half the games I made doing this had no redeeming qualities. The other half were stinkers with embedded nuggets of intrigue. But that didn’t matter, because their oddness:

  • kept me from getting stuck in conceptual ruts
  • led to concepts other designers hadn’t considered. If you want to find gold, you have to go down unexplored paths. Weird design challenges are a great way to do that.

Those same weird restrictions also limited the design space I could explore for each challenge. That was helpful: like many (most?) novice game designers, my early designs tended to bloat. The restrictions limited the bloat.

One challenge that led to a nugget of intrigue was the last one above: "A cooperative deduction game that allows for lots of communication." That nugget is what eventually became Paint the Roses. The reaction to it so far is making me optimistic that it will sell well, and I'll get the chance to make more.

So there you have it: I have a career in games thanks to talent stacking and pursuing odd challenges. I recommend considering how you might employ both ideas in pursuit of your own aspirations.

Paint the Roses will launch on Kickstarter in 2020. To be alerted to new blog posts and the Kickstarter's launch via email, sign up here.

Previous posts in the Paint the Roses series

  1. Why I designed a logic game set in the illogical world of Alice in Wonderland.
  2. How to fix the biggest problem in cooperative games. 
  3. Feedback wanted for a key component in our next game.
  4. What can dictators teach us about game design?
  5. A new way to visualize game rules, as a network of ideas.

A new way to visualize game rules, as a network of ideas (Paint the Roses #5) November 12 2019, 4 Comments

This is the fifth post in a series about our upcoming game Paint the Roses, written by the game’s designer, Ben Goldman.

Nothing keeps people from playing games more than having to learn rules. Imagine how many fewer movies we’d watch if we had to read an instruction manual before watching a movie for the first time.

So it’s critical to minimize the frustrations of rules, which is hard, because rulebooks are tricky puzzles of information architecture.

I’ve been working on new ways to understand and shape that architecture. To that end, I present to you a new visualization tool I call the Context Stack.

Imagine a set of rules as a tower of information. The tower’s base contains rules requiring no special knowledge; then up the tower, the rules stack on top of each other such that each rule makes sense if you know the rules below it.

Here are example rules that would appear at different levels in the stack:

  1. Start the game with 7 Coins.
  2. Coins can be spent to upgrade land.
  3. Certain upgrades earn more coins.
  4. One kind of upgrade is a castle, which protects your land.
  5. You can spend 45 coins to purchase a castle.

Most people will understand the first rule without prior information, so it goes at the bottom of the stack. Each subsequent rule is easier to understand, or begs fewer questions, if you already know the rules lower down the stack.

Real rules are more complicated than this example, because they’re non-linear. They branch, each rule interacting with multiple others, sometimes in roundabout ways. That’s why rules are hard to write.

Wouldn’t it be nice, then, if we could visualize that network of rules? It might help us more easily see how to simplify and clarify them. That’s the Context Stack:

The graph above is the Context Stack for all the rules about “Whim Cards” in a cooperative deduction game I’ve designed called the Paint the Roses (you can read all our articles about the game here, and you can read the current rules-draft here). 

In the graph:

  1. Each dot represents a rule pertaining to Whim Cards in the rulebook
  2. Each dot’s position represents where that rule appears in the rulebook. The further apart two dots are, the more stuff there is between them in the rulebook.
  3. The arrows show you which rules you need to know to understand the rules they point to.

The arrows are the meat of the system. If you look at them, you can immediately see you should avoid two things:

  1. Long arrows: the longer an arrow is, the longer a reader must remember a rule before applying it to understand another rule.
  2. Arrows pointing left: A left-pointing arrow means you’ll read a rule before you have all the context you need to understand it.

Most games are complex enough that you can’t completely eliminate these problems. However, you can minimize them. Graphing rules in this way helps you:

  • ...see which rules might need moving.
  • ...understand the consequences of moving them. Moving any rule can change the length and direction of a lot of arrows. The graph makes it easier to avoid inadvertently creating new problems.
  • ...get clear on why you put certain rules in certain places. For example, I have two left-pointing arrows in my rules graph. I need to either eliminate them, or justify their existence. In this case, I arranged the rules this way for the sake of repetition: I mention a central rule multiple times to cement it in the reader’s mind: the two nodes marked “1” are the same rule repeated. The node marked “2” is that rule again but fully explained now that we have all the context to explain it.

Graphing rules this way helps me to “untangle” my rule books. I’ll see long arrows and left-facing arrows, look at those rules, and see if it can be rearranged to be a better-looking graph.

(Note: there are programs allowing you to drag-and-drop objects with arrows attached to them, which makes it easy to visualize ways of reorganizing. Most flowchart programs for example, or Powerpoint.)

Of course, no method is foolproof, If you’d like to help us improve the current rules for Paint the Roses, check out the rules and leave your feedback in the comments.

Paint the Roses will launch on Kickstarter in 2020. To be alerted to new blog posts and the Kickstarter's launch via email, sign up here.

Previous posts in the Paint the Roses series

  1. Why I designed a logic game set in the illogical world of Alice in Wonderland.
  2. How to fix the biggest problem in cooperative games. 
  3. Feedback wanted for a key component in our next game.
  4. What can dictators teach us about game design?

What can dictators teach us about game design? (Paint the Roses #4) November 05 2019, 1 Comment

This is the fourth post in a series about our upcoming Alice-in-Wonderland-themed game Paint the Roses.

The Dictator's Handbook, by Alastair Smith and Bruce Bueno de Mesquita, has a simple proposition: a ruler’s position determines his behavior more than you’d think. What looks like bad behavior from the outside is often the only logical behavior. 

Imagine you’re a despot. You’re well-off, but your people are poor and hungry. You have a budget to distribute. Do you:

  1. buy your generals expensive villas?
  2. build public schools and agricultural infrastructure?
  3. do a little of each?

Before you pick your answer, a hint: two of these answers end with your death at the hands of political rivals.

The only choice that keeps you alive is to fill the pockets of your generals, and keep everyone else poor and hungry:

  1. If you don't pay the generals, the military will install someone who will.
  2. You’re a despot, so your people would probably choose a different leader if they could. If they’re not weak, they’ll revolt.

In other words, you’re hostage to the system you’re in, despite your leadership role. This is why, for example, freedom fighters who overthrow oppressive regimes sometimes end up acting just as oppressively when they take over.

Most complex systems are like this: they incentivize emergent and unintended behaviors that can be hard to anticipate and understand from the outside.

Consider US elections: the electoral college wasn’t designed to incentivize candidates to ignore most states, but it does. It makes swing states the only ones that matter: two-thirds of campaign stops in the last election were in just 6 states.

Games, too, are complex systems that create unintended emergent behaviors. That’s why game designers have to playtest and iterate so much.

But it’s often even harder to understand the emergent incentives in games than in political battles. The reason: games are often played as low-stakes affairs, so players aren’t as hostage to a game’s incentives than they would be in a higher-stakes situation. As a result, they behave more randomly, and it can be harder to infer a game’s incentives from their behavior.

This causes lots of confusion about game design. For example, in a recent post about how I designed our upcoming game Paint the Roses to minimize quarterbacking, I claimed quarterbacking is a design flaw in most cooperative games. Many commenters said I was wrong, and that quarterbacking is a player problem.

Who’s right? If it’s true the low-stakes nature of games makes their incentives hard to see, maybe I can strengthen my argument by imagining how a high-stakes cooperative game will play out. Let’s do that:

Imagine you and your friends are going to play Pandemic, and you’ll each get $10,000 if you win. How would you play the game in that situation?

If one player is better at Pandemic than everyone else, unless you’re an idiot, you’ll have that player dictate every turn, while the other players watch.

This illustrates clearly that the incentive to quarterback is built into the game. It’s not a player-flaw.

You might object: if Pandemic is always played as a low-stakes affair, then none of this matters, because players will never face a situation where the game’s incentives so strongly drive their behavior. Here’s the problem: different players perceive the stakes of games differently. If you sit down with a player who cares a lot about winning, the problem emerges. Lots of players care about winning, and they're not wrong for caring. Games must accommodate the various common ways players approach them.

So there's a real problem, and cooperative games can be better than they are now if it's fixed. That's why it matters that our upcoming game does things differently. 

A larger lesson for game design

Game designers should look for ways to conduct high-stakes tests, so emergent incentives are clear.

How? Some ideas:

  1. The cheapest (but most unreliable) way is to do the thought experiment: try to imagine what players would do if the game were high-stakes.
  2. Put your game on an online platform with lots of players like Board Game Arena. Watch how the best and most committed players play.
  3. Hold a tournament for your unpublished game, and pay close attention to how the finalists and semi-finalists behave. It’ll work even better if you can offer a desirable tournament prize.

Any others?

Paint the Roses will launch on Kickstarter in 2020. To be alerted to new blog posts and the Kickstarter's launch via email, sign up here.

Previous posts in the Paint the Roses series

  1. Why I designed a logic game set in the illogical world of Alice in Wonderland.
  2. How to fix the biggest problem in cooperative games. 
  3. Feedback wanted for a key component in our next game.


Feedback wanted for a key component in our next game (Paint the Roses #3) October 29 2019, 2 Comments

This is the third post in a series about our upcoming Alice-in-Wonderland-themed game Paint the Roses.

As we design components for Paint the Roses, we hope readers can help us get one key component right: a sculpted Queen of Hearts who spends the game trying to behead you. We want to make her wonderful. Here's what she currently looks like:

She's 2.5 inches tall, and gets taller as the game progresses, by stacking risers under her, so she gets more imposing:

Why is the Queen important?

Paint the Roses is a cooperative game where you try to deduce the Queen’s whims, so you can plant her roses correctly, so you can keep your head.

The board is a garden, where you place tiles representing rose bushes. Surrounding it is a scoring track, where you get points for planting those bushes. Here's what it looks like, with an older, standee version of the Queen:

The Queen spends the game on the scoring track, chasing your scoring markers. You lose if she catches up to them. As the game goes on and she gets taller, she accelerates, which represents her growing desire to behead you. So if you want to win, your scoring must accelerate too.

To help us make the Queen great, answer the following questions:

Paint the Roses will launch on Kickstarter in 2020. To be alerted to new blog posts and the Kickstarter's launch via email, sign up here.

Previous posts in the Paint the Roses series

  1. Why I designed a logic game set in the illogical world of Alice in Wonderland.
  2. How to fix the biggest problem in cooperative games. 

How to fix the biggest problem in cooperative games (Paint the Roses #2) October 22 2019, 4 Comments

This is the second post in a series about our upcoming game Paint the Roses, written by the game’s designer, Ben Goldman.

Ask any gamer what the biggest problem with cooperative games is, and they’ll tell you it’s quarterbacking. 

Quarterbacking is when one player who knows the game well tells other players what to do on their turns, or even takes their turns for them.

That might sound jerky, but usually it's not. Rather, quarterbacking happens because it gives all players the best chance to win, and that’s what all the players want in a cooperative game. Cooperative games incentivize quarterbacking. Let us heed the wisdom of the ancient sage Ice-T: “Don’t hate the player. Hate the game.”


Quarterbacking is a problem for two reasons:

  1. When optimal play means players aren’t making decisions for themselves, it limits fun.
  2. If players don’t get a chance to be wrong, they don’t see what they could have done differently, so they don’t improve. Moreover, they’re not motivated to improve because their judgements don’t matter. This creates a vicious cycle where quarterbacking becomes entrenched, play after play, because the players don’t improve. 

So how do you design a cooperative game to prevent quarterbacking? There are two general solutions:

Solution #1: Limit Communication

Here, the rules say you can only communicate in narrow, specified ways. A well-known example is Hanabi. In Hanabi, the only way you may communicate with another player is to give them a certain kind of clue. So, if you see another player biff, you can’t say anything about it.

I have two gripes with this solution:

  1. One of the greatest qualities of tabletop games is that they’re social. Strict communication limits make a game less social. They conflict with the medium.
  2. Many players struggle to honor strict communication limits. Facial expressions and body language communicate a lot of information, and many players have trouble controlling those things. So information slips out anyway. Sometimes you can prevent this by insisting players act like statues with poker faces, but that makes a game REALLY antisocial. 

Thankfully, there’s another option:

Solution #2: Limit Information

Here, you limit what each player knows about the overall game state, by hiding lots of important information from them. An easy way to do this is to hide information in each player's private hand of cards. The more information each player is missing, the less effectively any player can quarterback, and the less you have to limit communication.

Great! If you do this, you can make a cooperative game social, but without lots of quarterbacking!

But most cooperation games don’t do this. Why not?

I don’t actually know. But I’m taking advantage: I’ve built a cooperative game called Paint the Roses around the principle of limiting information.

Paint the Roses

The first task was to figure out what kind of game it should be. What kind of game can work well when players lack information? Answer: a deduction game. The whole point of a deduction game is to challenge players to overcome ignorance.

So Paint the Roses would be a cooperative deduction game. Here’s how it works:

You’re a gardener who works for the Queen of Hearts in Wonderland. The Queen wants to behead you, but she needs an excuse: she needs you to make a mistake. So, rather than tell you how to plant her rose garden, she gives you a small clue about how to do it. She gives similar clues to the other gardeners, your teammates.

But: the queen won’t let the gardeners share what they know with each other. So the only way to deduce your teammates’ clues is to watch which rose bushes they plant, and where they plant them.

How Paint the Roses prevents quarterbacking but allows more table talk

In Paint the Roses, each player has a secret card, and you give information about your card by planting rose bushes in the garden. Each turn has 2 phases:

Tile Placement
Card Guessing

During Tile Placement, you place garden tiles based on your secret card. This leaves little room for quarterbacking. If you place a tile in a bad spot, the other players don’t know it’s bad, because they don’t know what’s on your card.

rose bush tiles on the board

examples of secret cards

During Card Guessing, your team tries to deduce what’s on your card based on how you planted.

In this phase, all players can talk, except you. Here it’s possible for one player to talk more than others. Does that lead to quarterbacking? Not really.

If you know the game better than other players, you can bring that knowledge to the conversation. However: 

  1. You don't know all the other player's secret cards. Because they all have information you don't, you can't just tell them what to guess. 
  2. You know when it’s your turn to place a tile, you won’t be able to help your teammates guess your card. Therefore, when it’s your turn to talk, you’re incentivized to teach your teammates how to reason about the game, rather than decide for them.

In other words (the point I’m about to make is the reason I'm writing this article):

This scheme replaces the incentive to quarterback with an incentive to help your teammates understand how to play well. 

It creates vivid, healthy table talk where everyone learns together, and everyone feels their collective understanding grow. 

I’m proud of this. I think this is a way to turn cooperative games’ weakness into a strength. I hope you feel the same when you play it.

The game will launch on Kickstarter in 2020. If you want to be alerted to new blog posts and Kickstarter launch via email, sign up here.

Previous posts in the Paint the Roses series

  1. Why I designed a logic game set in the illogical world of Alice in Wonderland


Why I designed a logic game set in the illogical world of Alice in Wonderland (Paint the Roses #1) October 15 2019, 5 Comments

Prototype box art for Paint the Roses

This is the first post in a series about our upcoming game Paint the Roses, written by the game’s designer, Ben Goldman.

Why has Alice’s Adventure in Wonderland endured? It was published in 1865, the year the American Civil War ended. But we’re still reading it, still making movies about it, still referencing it. It’s only 25,000 words long! The first (and shortest) Harry Potter Novel is three times that.

Yet this short, 150 year-old story still grabs the imagination. Why?

I think it has to do with the way it was written. It lacks detail. It’s so vague and dreamy, everyone who reads it imagines their own reality for it. Maybe you imagine a happy Disney wonderland, a creepy Tim Burton Wonderland, or an LSD-bender Jefferson Airplane Wonderland. We each get a custom experience.

But if I told you I designed a cooperative deduction game set in Wonderland, with the hard, not-at-all dreamy logic that implies? You might ask why I’d do that. 

First, how dare you. Second, I direct your attention to the book’s author: Lewis Carroll. He’s most known for his literary works. But Lewis Carroll is a pen name. His real name was Charles Dodgson, and his day job was mathematics. He was good at it. He even authored a bunch of celebrated mathematics books, which he wrote concurrently with Alice’s story.

When Alice's Adventure found its way to Queen Victoria, she enjoyed it so much she wrote to Dodgson to request the first edition of his next book. She got it: “An Elementary Treatise on Determinants.” Probably not what she expected. Dodgson denied this happened and maybe it didn’t, but it illustrates his strange writing life. He simultaneously wrote books about logic and madness. As if they were related.

Indeed, there’s a popular theory Wonderland is an allegory for trends in Mathematics in the late 19th century. Dodgson was a conservative mathematician, suspicious of new ideas then emerging, especially in logic. For example: imaginary numbers, which are the square roots of negative numbers. Imaginary numbers don’t exist on the number line. A number that’s not a number? How strange. And in Dodgson’s view, how distasteful.

As it turns out, Dodgson’s distaste was misplaced, as nearly every concept he objected to has since been accepted. But the legacy of Wonderland stays with us, and I still love it.

And since Wonderland may be a commentary on 19th century logic, it couldn’t be a more perfect setting for a deduction game. A logic game set in an allegorical world of logic. So I made one:

The game is called Paint the Roses. It tasks you and your teammates with planting the Queen of Hearts' garden. But each player knows only a little about how to do the planting, and must deduce the remaining planting rules from the way the other gardeners work. If you plant wrong, it's off with your head.

North Star Games will Kickstart Paint the Roses sometime in 2020. In the meantime, I’m writing a series of essays, which will cover different aspects of how the game works, why I designed it that way, and what I learned about design in the process. I’ll cover things like:

  • How quarterbacking (AKA the alpha player problem) works in cooperative games, and how Paint the Roses makes it impossible.
  • Scoring tracks: they can be used for more than just scoring!
  • How Paint the Roses compares to its closest relative, Hanabi.
  • An unusual graphical method to help make rulebooks clearer.
  • Etc.

I’ll also ask for help, as we're still crafting the final product. For example: there will be a deluxe version. What should it contain?

So put on your big weird hat and pour yourself a tea. If you want to follow along and help us make Paint the Roses the best it can be, sign up to receive post notifications here.