I don't like punishing games.

I get bored and frustrated easily by many punishing games. I don't even like the language of "punish." This is not to say that I dislike difficult games, but rather that I think the word "punish" carries an ethos of meritocracy, masochism, and exclusivity. It wears the guise of an educator, implying a desire to teach through aversion. However, over time, both in academia and in the general nurturing of humanity, we have found that punishment as a learning tool is inefficient in the long run. Typical methods of punishment tend to produce trauma to some degree, which is why they create aversion.

Player-generated forms of punishment, particularly in competitive scenarios, often invoke this implication. They take on a pivotal role in designing tactical solutions, evaluating the actions of others, and finding moments to make forward progress toward the game's goals. In single-player games, the player is essentially doing the same thing—but instead of analyzing opponents' mistakes, they are searching for scripted avenues of success. Finding mistakes can be fun here, too, but in general, players are testing the boundaries of the game world. Many games teach these boundaries or rules as they progress, revealing new tools and mechanics over time.

"Punishment" becomes an important feedback signal as players gain a clearer picture of the game's systems. However, this is also where punishment can convolute the learning process. Save systems are a great example of this. One of the first things I do when designing a game loop is determine what information I need to save or might need to save as the game evolves. Typically, I try to keep this list as small and manageable as possible. "Do I need to know the player's location?" "Am I loading between scenes?" Answering questions like these in a binary fashion makes it easy to see how complex these systems can become.

Some games save at campfires or bonfires, while others only save at level transitions. Some allow manual saves, while others don’t. Older games had hardware restrictions that necessitated limited save slots, but those limitations no longer exist. Some modern games don’t save anything except a series of achievements that act as keys for world and event generation. Regardless of their technical origins, save systems are integral to how developers meter progress—and, simultaneously, punishment—in their games.

This is where the true balancing act and genre-defining dissonances emerge. Some players like campfire saves but dislike losing their money. Others don’t mind losing money but hate enemy respawns upon reloading. Two examples that come to mind are Horizon Zero Dawn versus Hyper Light Drifter. Roguelikes and Metroidvanias have entrenched these design principles across a wide spectrum of mechanics. For many players in these genres, there seems to be as strong a desire for punishing mechanics as there is for fair ones. I believe every player has a personal threshold—once crossed, the game becomes truly unbearable.

As I write this, I realize that the topic of save systems and punishment is overwhelming in scope due to how player- and game-specific they are. If we analyzed 100 different game save files from Steam and cross-checked what data was being stored—without even considering the save implementation itself—we would likely struggle to find two identical architectures.

In Floppy/Write, I have decided to only save the player-entered data in their computer and nothing else. This means the player always starts from the same place. They can never save momentary states—no loading health from room to room, no status effects or AI states persisting across scene boundaries. To me, this means the world must be entirely seamless, with events existing in isolated bubbles. It’s not the only solution, but it offers the best balance between player retention and minimal save data, limiting it to a single array of string data.

Right now, I have two kinds of enemies:

Character NPCs – These determine their hostility based on in-world conditions. They often have identities and full questlines.

Generic enemy "Agent Smith" cop NPCs – These are brainless and hunt the player relentlessly when triggered by surveillance and alarms.

Everything in the game depends on keys—players will never experience certain events unless they create the right conditions for them. However, this could lead to frustrating ambiguity and repetition if players can’t figure out the necessary conditions. This, in turn, could push the game over my personal threshold for punishment, making it obnoxiously difficult.

To compensate, I’m tempted to add a manual save function in a menu. However, this would remove any sense of metering, enabling exploration without losing progress or solutions that have already been discovered. Despite this, I remain committed to the idea of the player having a home base—a room that serves as both the beginning and end of every run. I'm not willing to give that up. Instead, my job as a developer is to be highly prescriptive about progression, ensuring that the tools and options available at any given time align with the player's journey.

For me, the threshold where punishing mechanics stop being enjoyable is when they exist solely to limit progression and elongate playtime. This is similar to SBMM (skill-based matchmaking) or EOMM (engagement-optimized matchmaking) systems, where punishment is used to fabricate the feeling of success in what would otherwise be uneventful moments.

A better approach is to provide feedback that encourages adaptation rather than enforcing rigid penalties. Games can guide players toward mastery by offering meaningful responses to their choices—contextual hints, subtle nudges, or dynamic challenges that respond to their progress. When players feel free to experiment without the looming threat of arbitrary setbacks, they engage more deeply with mechanics and develop a stronger sense of agency. The goal should be to foster an environment where players learn through discovery, refining their skills through exploration rather than retreating from failure. True mastery comes not from avoiding mistakes altogether, but from confidently navigating challenges and understanding how different approaches shape outcomes.