You Can’t Design Fun Directly

Fun isn’t just something you tack on at the end, like an extra layer of polish. Fun is a side effect; the flame that appears when the fuel – the player experience, systems and core loop – align perfectly. You don’t design the flame – you apply the fuel, and it naturally catches fire. 

When those systems line up with the experience you’re aiming for, fun emerges. When they don’t? No amount of whimsical effects or “make it more fun” meetings will save it.

Think of it this way: if the core loop is boring, all the extra dressing is for nothing. You need the core experience to be great before you dress it up nicely.

Start With The Player Experience, Not The Features

Before you start throwing in Path of Exile-level skill trees, ask yourself: what do I want the player to feel?

That’s your north star: the emotional goal that serves as the focal point for your design. Mechanics are just tools; the hammer and nails, not the house. Starting with features over feel often leads to a pile of disconnected cool stuff that never really gels together. Designing for experience means that every mechanic will resonate the way you want it to. 

For example, look at Doom (2016). The push-forward combat system isn’t just a mechanic – it reinforces the power fantasy. In RimWorld, the systems directly feed emergent storytelling, making you care about your weird little space colony because the game keeps giving you moments worth caring about. 

If you nail the feeling first, it’ll become obvious which game mechanics don’t belong – and that’s half the battle. 

Map Mechanics to Desired Player Behaviors

Players don’t play what you build, they play what the mechanics incentivise. If your systems quietly reward hoarding, they’ll hoard. If they reward speed, they’ll sprint through your lovingly-crafted levels and ignore everything else.

A framework that I find useful when designing is assigning verbs to the player experience – and that will define the systems that you then need to create. If you want to create tension, for example, you need systems that withhold control or force tradeoffs. 

Here’s a quick cheat sheet to get you on track:

Desired Feeling	Supporting Mechanic
Tension	Resource scarcity, countdowns, fog of war
Mastery	Skill trees, score multipliers, escalating difficulty
Agency	Systems with trade-offs, low randomness
Surprise	Emergent interactions, low transparency mechanics

Here’s the framework: Feelings -> Verbs -> Mechanics. Define the feelings you want your player to experience, choose the verbs that match those feelings, and, using the verbs chosen, define the mechanics which will best support those verbs. 

Define Your Core Loop First. Everything Else Serves It.

I’ve said this many times – if your core loop isn’t fun in isolation, nothing else will save it. Your do a thing → get a thing → feel good about it → do it again cycle should be refined, superbly crafted, and effortlessly enjoyable – and if it’s not, you need to make it so.

A core loop is essentially a feedback loop – a cycle of player actions and game responses that reinforce each other and create momentum. Positive feedback loops reward players for mastery and encourage engagement, whilst negative feedback loops can introduce challenge and tension by pushing players to adapt.

A good loop is the rhythm that keeps the game alive – propelling the player forward with momentum. It should feel satisfying even when stripped down to its bare mechanics – before art or sound ever touch it. Greybox your loop early! If your playtesters are bored at this stage, you’ve got a system problem, and no amount of wrapping will fix it.

Let’s look at Slay The Spire. The loop is simple: 

Fight Battles → Claim Rewards → Tune Your Deck → Repeat.

Everything else – Relics, Shops, Random Events  – exist to feed or disrupt that loop. 

If you want more information on how to nail your core loop, I’ve got a whole article about that you can find here!

Use Mechanics That Generate Decisions, Not Just Actions

Pressing buttons isn’t inherently fun. Making meaningful choices under pressure is. A good mechanic forces players to weigh options, make trade-offs, and occasionally curse themselves for a bad call five minutes later. If there’s one “right” way to play and everything else is suboptimal, the game’s essentially been completed before the player even gets their hands on it.

When evaluating a mechanic, ask yourself:

• Does it force trade-offs?
• Does it reward different player types? 
• Does it scale with mastery or plateau quickly?

A weak mechanic can be easily spotted: it’s either already solved (as in, there’s a defined optimal approach), or irrelevant.

Don’t Just Combine Features – Create Intersections

The best features in games don’t just combine, they interlock. What I mean is: good game mechanics work together to create more than the sum of their parts. Otherwise, you get something like mechanic soup – a pool of features which don’t quite work together, and often feel bloated.

In Frostpunk, hope, heat and resources are all intertwined to create something bigger. A decision in one system affects all of the others. Every choice has side effects that keep you thinking.

Interlocked mechanics create emergent gameplay – where systems intersect and collide to create unexpected, player-driven stories and strategies. This is where the real fun begins.

Tune For Flow, Not Complexity

A complex game isn’t automatically a deep one. Having too many mechanics just adds noise. The real goal is to create flow – that sweet rhythm of tension and release that keeps players locked in. If 

Think of good flow like good music, creating a rhythm: it builds, peaks, eases off, then builds again. Risk and safety. Input and payoff. The best games know when to give players room to breathe before throwing them back into the storm.

When designing, watch for these red flags:

• Mechanics that slow progression into a crawl
• Systems that overwhelm with choices instead of layering over time
• UI/UX friction that turns interesting decisions into annoying chores

Players don’t brag about how many menus they survived. They brag about the moments that made them forget they were holding a controller.

Test Early. Tune Ruthlessly. Cut Without Mercy.

Playtesting isn’t just about bug hunting; it’s crucial to making a good game. The best designers don’t just think their way into mechanics – they know that they have to observe player behaviour. You’ll quickly learn:

• What they avoid doing.
• What feels flat or repetitive.
• Where they’re confused vs. curious.

Sometimes, the hardest part is the most necessary: killing a system that you love can make the rest shine. 

Final Checklist: Choosing A Mechanic

Every mechanic that you love should pass at least 3 out of these 5 criteria:

1. Does it tie into the core loop? 
2. Does it add meaningful decisions?
3. Does it create synergy with other systems? 
4. Does it evolve with player mastery? 
5. Does it support the emotional/experiential goal? 

Design The Conditions For Fun, Not the Outcome

You can’t add fun like a seasoning at the end. Fun happens when the right mechanics, incentives, and systems align with the experience you’re aiming for.

When a mechanic is working, it often disappears – feeling so natural players stop noticing it. They’re too busy doing the thing to think about the scaffolding holding it up.

Stop chasing “fun” as if it’s a mysterious ingredient you sprinkle over a design doc. Understand your systems, the behaviours they produce, and the systems that they enable – that’s where you’ll find the fun.