How Game Difficulty Should Be a Conversation, Not a Wall: A Field Guide for Small Teams

Difficulty design is deciding how hard a game pushes back, and who gets a say when it’s too much. When I call difficulty a conversation, not a wall, I mean something buildable, not a vibe: the player declares intent, the game reads signals, and both sides adjust over time. The neighboring concepts — dynamic difficulty adjustment, assist modes, difficulty selectors, rubber-banding, retry economy, flow — each cover one slice of that exchange. For a solo developer or a two-person team, this isn’t a discourse topic. It’s retention, reviews, and refund rates, and there’s no publisher around to absorb the loss when you tune it wrong. So, in order: the model, five reusable patterns from games that execute it well, two instructive failures, and a one-week audit you can run before your next patch.

What “Difficulty as a Conversation” Actually Means

Strip the paint off any difficulty system — a five-mode selector, an invisible rubber band, whatever — and you find one question underneath: who is allowed to decide what the player experiences? A wall answers: the designer, once, at ship. A conversation answers: the designer set a default, and everyone keeps negotiating after that. I count three moves in the loop, and you can audit any game, yours included, against them:

• Declaration. The player states intent — through a menu, an assist toggle, or plain behavior. Dying four times on the same jump is a declaration, whether or not you built anywhere to receive it.
• Listening. The game collects the signal: telemetry, a death counter, or the budget version, which is you watching a playtester with your eyes open.
• Response, out loud. The game adjusts, and tells the player it adjusted. This is the move where most systems go silent, and silence is where the trust leaks out.

A wall fails moves two and three. That’s the whole thesis. Everything below is casework.

Why the Wall Is So Expensive for Small Teams

The wall’s costs are financial long before they’re philosophical. Steam’s refund window is two hours of play. If your difficulty curve front-loads its spikes, hour one is where refunds, negative reviews, and “great game, unplayable” tags get minted. A publisher can eat that across a catalog. A solo developer reads those reviews at 2 a.m. and ships a panicked patch that flattens the curve for everyone — a wall swapped for a hallway, which is its own failure mode.

The best short text on the alternative is the Assist Mode post from Celeste’s developers. Two decisions in it are worth memorizing. First, the default path is the intended experience: assists don’t replace the mountain, they change who can climb it. Second, the menu copy frames using assists — game speed, invincibility, infinite stamina — as a normal way to play the game rather than a confession. That’s the response move of the loop, executed in localization strings instead of systems. It costs almost nothing, which is exactly why a small team should steal it first.

There’s an accessibility floor under this conversation, too, and pretending otherwise is where the discourse goes sour. The Game Accessibility Guidelines project treats tunable challenge as a baseline recommendation, not a concession to a debate. Review outlets such as Can I Play That? grade difficulty settings as core features, because for many disabled players those settings are the difference between playing a game and watching someone else play it. Hold the opinion that options dilute a game if you want. Just know exactly who you’re excluding when you act on it.

Five Patterns From Games That Talk Back

Pattern 1 — The opt-in contract: Hades’ Pact of Punishment

Beat your first escape and Hades lets you bolt conditions onto future runs through the Pact of Punishment — faster enemies, thinner healing, tighter timers — in exchange for better bounty payouts. Every condition is named, priced, and reversible. God Mode works the same way in spirit: an opt-in toggle that grants a damage-resistance bonus which creeps up gently each time you die. Both features are contracts with receipts. The game names the trade, the player signs it, the rewards acknowledge the signature. The solo-dev translation fits in one sentence: a difficulty menu should read like a contract, with each line stating what changes and what you get. “Hard mode: enemies hit 50 percent harder, bosses drop double resources” is a conversation. “Hard” is a shrug.

Pattern 2 — Listening without lying: Mario Kart vs. Resident Evil 4

Mario Kart’s item tables are famously position-based: run first and the game starts handing out blue shells; run last and you get the bullet. Rubber-banding survives player scrutiny because it’s legible — people can build a mental model of the rule and play around it, even when it’s costing them. Resident Evil 4 (2005) went the other way: a hidden adaptive layer, long since documented, that nudged drop rates and enemy pressure based on how you were performing. People love that game anyway, but notice the cost. When adjustment is invisible, players misattribute their wins, and “I finally got good” may quietly mean “the game eased off.” My working rule: dynamic difficulty adjustment is fine; silent dynamic difficulty is a loan against player trust, and you don’t get to know the interest rate in advance.

Pattern 3 — Retry economy is the real difficulty dial

Celeste respawns you on the screen where you died, near-instantly, and Super Meat Boy did the same a decade earlier. Both games are spiky by the standards of their genre, and both are famous for feeling fair. The reconciliation: the wall most players hit isn’t the spike, it’s the walk back to the spike. A brutal two-second jump with a one-second retry can feel easier than a mild mistake that costs a checkpoint’s worth of re-traversal. Before you tune damage values or timer strictness, tune the cost of failure itself — respawn point, death animation length, load time, distance to re-attempt. It’s the cheapest difficulty knob in your engine, and the last one most designers reach for.

Pattern 4 — Information as a difficulty currency

Into the Breach shows you exactly what every enemy will do next turn. Nothing is hidden, and the game is still hard, because its difficulty lives in puzzle density and consequence rather than withheld information. Make players guess and you inflate difficulty with noise — and noise punishes inexact players unevenly. Sekiro is the instructive counterpoint: it walls by design, and FromSoftware appears to have accepted that exclusion consciously, as the price of a particular fantasy about overcoming. The lesson isn’t “be Sekiro” or “don’t be Sekiro.” It’s that they knew the trade and paid it on purpose. Most small teams pay the same trade by accident, in patch notes written in a panic.

Pattern 5 — Failure as dialogue: Sifu’s aging meter

Sifu makes every death legible in one visible number: your age. Die and you age, trading some maximum health for raw damage, and you restart the level with a tally of what failure has cost. The game narrates your losses inside its own fiction — the conversation model wearing a story coat. Then Sloclap added difficulty tiers in a post-launch update: the conversation continuing after ship, in public. That’s the behavior this blog exists to document. Difficulty decisions as versioned, written reasoning, not vibes baked into a gold master.

An Instructive Failure: Listening to the Wrong Signal

The Elder Scrolls IV: Oblivion is the cleanest failure case I know, precisely because its heart was in the right place. The game listened to a signal — your character’s level — and scaled the world to match. But level was a proxy for time invested, not skill. A player who leveled non-combat skills got a world that grew teeth while they grew none. Moves two and three? Executed competently. It listened, it responded, and it answered a question the player never asked. A conversation where the game answers the wrong question is worse than silence, because it teaches players their input was heard and then ignored.

There’s a social version of this failure, too. David Sirlin’s old “Playing to Win” essays on scrub mentality describe players who treat self-imposed rules as moral law; difficulty discourse runs on the same fuel, where “the intended experience” becomes an identity defended at the gates. When designers echo “git gud” in patch notes or bake shame into menu copy, they install the community’s wall into the UI. You can’t stop a forum from gatekeeping. You can decline to ship it.

The Solo-Dev Budget Version: A One-Week Difficulty Audit

Here’s the version that fits one person and one week, ideally scheduled before a content patch rather than after a review wave.

• Days 1–2: instrument, don’t guess. Add a debug overlay that counts deaths and retries per encounter. You don’t need a telemetry platform; a plain text log you read after each session is enough. Watch three playtesters. On my last jam build, the counter told me players were dying to the tutorial’s second enemy — the one I’d mentally priced as free. Mark every point where someone dies twice without changing their approach: that’s your game failing to send a signal, not a player failing to learn.
• Day 3: write three honest toggles. Game speed, invincibility, and skip-this-encounter cover a startling range of players — tired parents, motor-impaired players, your own testers grinding content. Make them savable, and put them in the pause menu, not in an ini file.
• Day 4: audit your copy. Delete shame language — “casual,” “the experience as intended,” anything with a smirk — and replace it with Celeste-style framing: these are ways to play this game. For most players, the localization strings are where the conversation actually happens.
• Day 5: publish the findings as a patch note addressed to players. Something like: “Deaths per hour on the Chapter 2 boss averaged 23; we widened the arena and added a checkpoint at the halfway mark.” Supergiant’s Hades patch notes read like lab reports, and that transparency was an asset across Early Access. Versioned difficulty decisions, stated in public, compound into trust — and into a paper trail other designers can learn from.

Reading the Player’s Half of the Conversation

Small teams can’t run focus groups, but you have more signal than you think: retry heat maps from your debug overlay, assist-toggle uptake percentages, refund timestamps clustered around one encounter, review keyword frequency (“cheap,” “unfair,” and “grindy” are different complaints with different fixes), and streamer VODs, which are free, honest playtests with commentary attached. Two cautions from my own scars. Don’t tune to your loudest negative review — the player who bought the genre and the player who bought the hype need different curves. And don’t flatten the spikes your best players call the point of the game; a conversation where one party only agrees isn’t a conversation.

FAQ

What does “difficulty as a conversation” mean in game design?

It’s a design stance in which challenge is negotiated rather than fixed. The player declares intent through settings or behavior, the game reads signals such as death and retry counts, and the game responds visibly through tuning, information, or options. A wall, by contrast, is difficulty fixed at ship: no listening mechanism, no response.

Is dynamic difficulty adjustment bad for indie games?

No, but silent dynamic difficulty is risky. Invisible adjustment spends player trust, because players misattribute their success and can feel deceived when they notice the pattern. Legible adjustment — Mario Kart’s position-based items, Hades’ opt-in God Mode — keeps the loop visible while staying responsive. If you adjust quietly, tune toward the player’s stated intent, never away from it.

Do difficulty options dilute the designer’s intended experience?

Not if the default path is designed as the intended experience and the options extend it rather than replace it. Celeste is the standard case: the mountain stays the mountain, and assist mode changes who can climb it. The honest version of the objection is about budget — options take time to build, test, and localize — which is a real cost for a small team, not a moral argument.

How do I add difficulty options cheaply as a solo developer?

Ship three toggles (game speed, invincibility, encounter skip), tune your retry economy before your damage numbers, and rewrite menu copy so options read as ways to play rather than confessions. Then publish what you changed and why in the patch note. The package is roughly a week of work, and it covers most of what players actually ask for.

What is the difference between difficulty options and accessibility options?

They overlap but answer different questions. Difficulty options adjust how hard the game pushes back. Accessibility options remove barriers to interacting with the game at all — control remapping, subtitle size, colorblind modes, camera-shake toggles. A game can ship five difficulty modes and still be unplayable for a specific player, so a difficulty menu is never a substitute for an accessibility pass.

Where This Column Goes Next

I want this to be a recurring column, not a one-off: a Difficulty Patch Log, where I take one named, versioned difficulty change from a small-team game — a boss retune, a heat-system rework, an assist-mode addition — and autopsy the reasoning against what shipped. Sloclap’s post-launch Sifu tiers and Supergiant’s Early Access notes are already on my list. If you’ve shipped, or survived, a difficulty patch that deserves a write-up, send me the patch note and your reasoning; the best submissions become case studies. And as terms keep recurring here — dynamic difficulty adjustment, retry economy, assist mode, legibility — they’ll anchor a glossary page I want this site to grow into.

Until then, the compact version: declare, listen, respond out loud. Players forgive spikes in games that talk to them. Walls never get that forgiveness retroactively.