Genre as compression, design as recomposition, and what building three very different games has revealed about my taste.
I am a relatively light gamer, at least by the standards of people who usually write about game design. I do not play every major release, follow every genre closely, or have the accumulated encyclopedic knowledge of someone who has spent decades inside gaming communities.
But the games I like tend to stay in my head for a long time.
Part of that is ordinary enjoyment. I like discovering a system, getting better at it, and occasionally disappearing into a game for an evening. Another part of the experience is more analytical. Once a game catches me, I start wondering which structural components made it work on me in the particular way it did.
Why did one tactical choice feel satisfying while another felt like routine execution? How much of the experience came from uncertainty rather than complexity? Was the tension produced by a difficult decision, by the difficulty of performing it, or by having incomplete information about what other players would do? Could a game preserve the part I liked if its controls, timing, or even genre changed substantially?
Those questions are probably influenced by what I spend the rest of my time doing. My professional life is much closer to statistics, machine learning, scientific computing, and healthcare research than to commercial game development. I am accustomed to complicated systems where useful reasoning often begins by separating things that arrive bundled together: signal from noise, decision from outcome, objective from constraint, observed state from latent state, important dimensions from redundant ones.
Games are attractive objects for this kind of thinking because many of those structures appear together in a form that someone actually has to inhabit. A game can contain optimization under constraints, incomplete information, strategic interaction among multiple actors, stochastic events, delayed consequences, and state transitions. Yet an analytically elegant system can still make a terrible game. The player has to understand enough of the system to reason about it, feel the consequences of choices, and find the resulting activity worth continuing.
For years, I could entertain design arguments mostly as arguments. Perhaps a real-time strategy game would remain interesting if the mechanical burden were reduced. Perhaps a dungeon game could achieve substantial tactical depth with a much smaller vocabulary of items and rules. Perhaps a healthcare management simulation would become more convincing if other institutions behaved as independent decision-makers rather than environmental modifiers.
Building the game is a more demanding way to find out.
That has become much more practical recently. I already write software, and AI-assisted development has lowered the cost of implementing prototypes enough that I can now take an idea that would once have remained a notebook sketch and construct something playable around it. The reduction in implementation cost matters to me less as a promise of making development effortless than as a reduction in the distance between a design hypothesis and something capable of contradicting it.
A thought such as “mechanical execution may be separable from strategic depth” is easy to defend in conversation. A playable prototype can make the weakness of that claim obvious within minutes.
That is one reason I have started building games.
The other reason is that the process exposes my own preferences more clearly than thinking about games from the outside. Every implementation forces choices. Some mechanics survive simplification. Others are removed without much regret. A feature that seemed essential in a reference game may become expendable once I identify the relationship I actually cared about. Another seemingly minor feature may turn out to be carrying much of the experience.
Three projects have made this especially visible.
Dreadstep is a compact turn-based dungeon game. The player explores dangerous spaces one step at a time, fights enemies, finds equipment, and learns how environmental rules interact. Its ancestry includes Diablo 1, NetHack, and DoomRL/Jupiter Hell Classic, although it inherits very different things from each.
Fog of Intent approaches a multiplayer online battle arena from another direction. Instead of asking the human player to execute every movement and attack in real time, it shifts attention toward plans, priorities, communication, uncertainty, and coordination. Modeled players carry out those intentions according to their own abilities and information.
Vital Margin is a strategy simulation about running a nonprofit health system. The player makes decisions about operations, investment, workforce, services, and institutional strategy while payers, competitors, clinicians, regulators, and communities pursue objectives of their own.
On the surface, these projects have very little in common. One has gothic dungeons and loot. Another begins with ideas from competitive multiplayer games. The third concerns healthcare institutions.
Yet I keep making similar choices in all three.
That repetition has changed how I think about genre, influence, and design. I increasingly see a reference game as a bundle that can be decomposed. Genre is a useful compressed description of such bundles. Building something new means reopening that compression, deciding which structures matter, and recombining them under a different objective.
The revealing step is selection. Once the familiar package has been taken apart, taste determines what I keep.
What exactly am I borrowing?
Dreadstep made this problem concrete first.
Imagine standing outside a closed room in a turn-based dungeon. You know there is at least one enemy somewhere beyond the door because you heard movement. Your health is low. You could open the door normally and preserve surprise as much as possible. You could kick it open, creating noise that might draw enemies toward you. Perhaps the floor inside is covered in water, and a cold effect could freeze it. Perhaps fire would later melt that ice. An item in your inventory could solve the immediate encounter, but spending it now would remove an option from a deeper and presumably more dangerous floor.
The rules involved can be individually simple. Their combination changes whether entering the room is a good idea.
That is close to what I want Dreadstep to do. I want individual turns to remain fast while the game accumulates enough state and interaction that a short sequence of actions can have meaningful consequences. A small ruleset should create situations worth reasoning through rather than requiring a huge catalog of commands and exceptions.
The game’s three major influences help explain why.
Diablo 1 is a real-time action role-playing game built around descending through an increasingly dangerous dungeon beneath the town of Tristram. The player fights monsters, finds randomized equipment, develops a character, and adapts to what the dungeon provides. Its appeal is larger than any mechanical summary, of course, but the parts most relevant to Dreadstep are the sense of descent, increasing danger, the identity of discovered equipment, adaptation, and atmosphere.
NetHack belongs to a very different tradition. It is a turn-based roguelike with an enormous accumulated vocabulary of objects, creatures, environmental rules, and surprising interactions. Knowledge of how the world behaves becomes a form of player skill. An apparently ordinary object may interact with another system in a useful or disastrous way. The player gradually learns that the dungeon is a place whose rules can be manipulated.
Doom, the Roguelike, later renamed DoomRL or DRL, begins from yet another source. It reinterprets the fast first-person action of Doom as a turn-based roguelike. Jupiter Hell Classic continues that lineage. The transformation is especially interesting to me because so much of the source game’s form changes while other relationships remain: positioning still matters, weapon choice still matters, enemies create different spatial threats, and tempo still matters even when “fast” now means making decisions through discrete turns.
Dreadstep does not try to average those games. I am taking different structural contributions from each.
| Reference | What I want to preserve |
|---|---|
| Diablo 1 | descent, danger, atmosphere, distinctive loot, adaptation |
| NetHack | composable rules, environmental experimentation, knowledge gained through play |
| DoomRL / Jupiter Hell Classic |
fast turns, tactical positioning, threat prioritization, readable combat |
The omissions are as important as the inheritances.
Trying to preserve every attractive property would produce a much larger game. NetHack gains part of its expressive power from decades of accumulated interactions. Diablo depends heavily on real-time combat feel, audiovisual atmosphere, progression, and a substantial item economy. Traditional roguelikes often accept significant command complexity because learning the interface and the world’s many possibilities is part of the genre.
My own objective is narrower. I keep coming back to something like decision density: how much meaningful tactical consequence can be produced by a relatively compact set of rules and a short sequence of turns?
I do not have a literal numerical objective function for this. Thinking in optimization terms is still helpful because it forces the costs into view. Adding another enemy type consumes content and learning capacity. Adding another interaction adds state the player may need to remember. Adding commands increases interface burden. An exception that solves one encounter may weaken the player’s ability to generalize from the rules elsewhere.
A mechanic therefore becomes especially valuable when a simple rule creates several downstream consequences.
Suppose kicking a door creates noise. Enemies can investigate noise. Suddenly kicking has positional consequences beyond opening the door faster. If cold freezes water, the player may change a surface to control movement. If fire reverses that transformation, the same environment remains dynamic. These are modest rules, but together they expand the space of situations the player can create.
The interesting quantity is not the number of rules. It is the number of strategically distinct situations those rules support.
This preference has an obvious ancestry in game-design discussions about emergence, interacting systems, and possibility spaces. Rules of Play by Katie Salen and Eric Zimmerman treats games as rule-based systems whose interactions produce play. Staffan Bjork and Jussi Holopainen’s work on game-design patterns similarly provides a vocabulary for recurring structures smaller than entire genres. I arrive at some of these questions through a more statistical vocabulary, but the design problem itself is familiar: how do relatively compact rules generate a useful space of play?
Dreadstep gives me one answer. I prefer complexity that appears downstream of interaction over complexity that has to be authored independently upstream.
That preference has limits. Five rules that interact beautifully can still produce five boring decisions. Emergence by itself is not enough. The interaction has to change what the player reasonably considers doing.
This is where the idea of consequential structure begins to matter. A rule earns its place when it alters feasible actions, risks, opportunity costs, information, or future states in a way the player can eventually understand.
Dreadstep also taught me something about influence. The transformation performed by DoomRL is more interesting than simply moving Doom onto a grid. It suggests that a radical change in form can expose which relationships were carrying part of the source experience.
That observation eventually pushed me toward a more general way of thinking about genre.
Genre compresses a much larger object
Suppose, as an illustrative mental model, that a game can be described by a long vector:
$$ G = (x_1, x_2, \ldots, x_p). $$The coordinates might represent properties such as mechanical execution demand, completeness of information, tactical horizon, strategic horizon, randomness, spatial dependence, economic progression, cooperation, competition, persistence, systemic composability, player control, causal legibility, and many others.
I am not suggesting that we could agree on a canonical vector for every game, much less measure all of these dimensions cleanly. The value of the representation is conceptual. It reminds me that characteristics which usually arrive together can sometimes be varied independently.
A genre label performs something like compression:
$$ G \longrightarrow \text{"MOBA"},\quad \text{"roguelike"},\quad \text{"ARPG"},\ldots $$Calling something a roguelike is useful because the word predicts many characteristics at once. A reader may infer turn-based play, procedural generation, repeated runs, resource pressure, grid-based movement, or some subset of a historically contested bundle. The prediction will be imperfect, but the label saves an enormous amount of description.
Compression works by discarding information. That is a virtue when communicating. It becomes a complication when designing.
If I say Dreadstep is a roguelike influenced by Diablo, the description does not reveal which parts of either lineage I consider essential. It does not tell the reader that I may care strongly about spatial commitment and learnable interactions while caring much less about preserving traditional command complexity. Two designers could start with exactly the same reference games, decompose them differently, and produce successors that barely resemble one another.
Game-design theory already contains several ways of resisting overly coarse descriptions. The MDA framework, associated with Robin Hunicke, Marc LeBlanc, and Robert Zubek, separates mechanics, resulting dynamics, and player experience. Elias, Garfield, and Gutschera’s Characteristics of Games compares games through multiple characteristics rather than treating genre as a sufficient description. Pattern-oriented approaches identify reusable structures that can appear across otherwise different games.
My vector-space analogy is another way of reaching the same intuition: a game occupies many dimensions at once, while genre communicates only a compressed portion of them.
The design process I keep following therefore runs in the opposite direction:
$$ \text{reference game} \longrightarrow \text{candidate dimensions} \longrightarrow \text{selection} \longrightarrow \text{recomposition under new constraints}. $$The first transformation is analytical. I ask what structures seem to generate the parts of the experience I care about. The last transformation is constructive. I have to turn the selected structures into a coherent new game.
Selection is where the apparently technical exercise becomes personal.
An optimization perspective can help me clarify objectives and constraints. Dimensional thinking can help separate bundled properties. Game theory can help identify strategic dependencies among actors. None of those tells me which experience deserves to survive.
That decision is taste.
Fog of Intent makes the consequences of that decision much easier to see because its starting intervention is far more aggressive than Dreadstep’s.
Fog of Intent: What happens when execution moves out of the foreground?
A normal match of League of Legends is played by two teams of five. Each player controls one champion in real time. Teams gather resources, develop their characters, contest parts of the map, fight over major objectives, and eventually try to destroy the opposing team’s base.
Even this basic description hides several kinds of skill that happen simultaneously.
A player needs strategic judgment about where pressure should be applied and which objectives matter. They need tactical judgment about a fight happening over the next few seconds. They need to coordinate with teammates who may have different information or preferences. They operate under incomplete information because much of the opposing team’s position is hidden. Then they have to execute: move accurately, aim or time abilities, manage the camera, react quickly, and perform a sequence of actions under pressure.
A rough representation is
$$ \text{performance}
f( \text{strategy}, \text{tactics}, \text{coordination}, \text{execution}, \text{information} ). $$
The expression is descriptive rather than mathematical. More importantly, those components interact. A mechanically excellent player can escape a strategically poor position. A strong plan can fail because the team cannot execute it. A player can make a reasonable decision based on the information available and still appear foolish once hidden information is revealed.
Fog of Intent asks what happens when I reorganize that bundle.
The human player does not control a champion moment by moment. Instead, the game focuses on higher-level decisions: where a player should go, what objective the team should prioritize, how aggressively someone should act, what contingency should trigger a retreat, what information should be communicated, and how much commitment a plan deserves. Simulated players then execute those intentions according to their abilities, current observations, and internal behavior.
A concrete situation makes the distinction easier to see.
Suppose your team is considering a major neutral objective. You believe an important opposing player is far away. One teammate wants to begin immediately; another is worried that the enemy may be moving through unseen territory. You can commit, delay, establish more information, or redirect attention elsewhere. Even after choosing correctly, the execution can vary. A simulated teammate may react slowly. Another may misunderstand the situation because their information differs from yours. The opposing team may have anticipated the plan.
The player is managing intent inside a system that contains other actors rather than manually performing every contributing action.
That creates a design question I find unusually interesting: how much of a MOBA-like strategic experience survives when direct mechanical execution is substantially reduced?
The analogy I use privately is an ablation study. In machine learning, an ablation changes or removes a component to examine what behavior depends on it. Fog of Intent uses a similar intellectual move as a design experiment.
If real-time execution is reduced, do pressure, timing, incomplete information, spatial control, risk, trust, communication, and adversarial anticipation remain compelling? Does the game reveal those structures more clearly because the mechanical layer no longer dominates the player’s attention?
The prototype could easily answer in an inconvenient way.
Perhaps the execution burden was carrying much more of the experience than my decomposition suggested. Perhaps the pleasure of a MOBA depends on the rapid coupling between deciding and physically performing the decision. A slower, intent-driven version may retain strategic concepts while losing the emotional cadence that made those concepts meaningful.
That would be useful information.
Decomposition is a hypothesis about separability. Building the transformed game tests whether the supposedly separable components still produce anything worth playing when the original coupling is broken.
Fog of Intent also pushes me toward a more careful representation of information. In many games, “hidden information” is treated primarily as a property of the interface: something exists in the game state, but the human cannot currently see it.
A multi-actor strategy game needs stronger distinctions.
There is a true state of the world. Each actor can observe only part of it. An actor can then hold beliefs or knowledge derived from those observations. Communication may transmit some information while leaving other information local. Two teammates therefore can occupy the same simulated world and rationally make different decisions.
Consider the earlier objective example. One teammate may have seen the opposing player leave a lane. Another may have missed it. A third may receive a warning through communication but interpret the risk differently. If the team commits and loses, the final outcome contains less information than the causal history.
I want the simulation to preserve enough of that history that the player can later distinguish among several explanations. The plan itself may have been weak. The information available may have justified the plan even though the hidden state made it fail. A teammate may have executed poorly. The opponent may have responded unusually well.
This matters because I repeatedly care about the difference between decision quality and outcome quality.
A good decision can generate a bad outcome. A poor decision can benefit from luck or an opponent’s mistake. Games often blur those categories because outcomes are immediate and emotionally salient. A system capable of reconstructing the causal path can teach the player something richer than “winning means correct.”
Fog of Intent therefore makes actor-specific information, independent execution, and post-hoc explanation part of the game’s design rather than mere implementation details.
At a very different scale, those same preferences appear in Vital Margin.
Vital Margin: Strategy among institutions that respond
Vital Margin is a management and strategy simulation in which the player leads a nonprofit health system.
The basic play is easier to understand through the kinds of decisions the player makes. You may decide where to invest scarce capital, whether to expand or contract a clinical service, how aggressively to pursue growth, how to respond to staffing pressure, or how much financial resilience to sacrifice in pursuit of another institutional goal.
A conventional management model could treat those choices as controls applied to a system. Increase capacity and observe demand. Change staffing and observe cost. Invest capital and watch a performance indicator move.
Healthcare organizations sit inside a more complicated strategic environment.
Payers negotiate. Clinicians have professional and personal incentives. Workers can leave, organize, or resist policy. Regulators change constraints. Competitors react to service expansion. Communities care about access and local obligations that may conflict with financial optimization. Political actors interpret visible decisions through their own objectives.
A decision therefore changes more than an internal variable.
A useful schematic is
$$ \text{decision} \longrightarrow \text{other actors respond} \longrightarrow \text{system state changes} \longrightarrow \text{future options change}. $$This is where game-theoretic thinking enters most directly into my design process.
I do not mean that every institution needs to solve a formal equilibrium model before taking a turn. Game theory is useful first as a reminder that other actors have objectives of their own. Their response should arise from some combination of information, incentives, authority, beliefs, and constraints. The world becomes less convincing when everyone outside the player’s organization behaves like a passive environmental coefficient.
Suppose the player expands a profitable service line.
In a simple management game, the relevant outputs might be revenue, market share, and capital cost. In Vital Margin, expansion can alter how another health system behaves. A payer may reassess bargaining power. Clinicians may move toward or away from the organization. Community groups may support the investment or question its effect on less profitable services. The move reshapes the strategic position from which subsequent decisions will be made.
That creates a kind of difficulty I find more interesting than simply locating the numerically optimal policy.
The player acts under imperfect control.
Some consequences arrive through other decision-makers. Some are delayed. Some depend on information the player cannot know with certainty. A locally attractive move can make a future decision harder because it changes incentives elsewhere in the system.
This is also where optimization has to become more explicit about its objective. A nonprofit health system could care simultaneously about financial viability, service capacity, workforce stability, community obligations, quality, strategic independence, and institutional survival. Improving one can make another harder.
There is no reason to assume that maximizing a single scalar quantity would produce the game I want.
The interesting decisions occur because desirable states compete and because other actors react to the player’s attempt to pursue them.
Vital Margin may look far removed from Fog of Intent, yet the underlying design preferences are strikingly similar. Both depend on actor-specific information. Both need independent agents whose actions follow their own incentives. Both separate a player’s choice from the execution and reactions that ultimately produce an outcome. Both become more useful when the player can later understand why events unfolded.
Even Dreadstep has the same structure in miniature.
The actors are simpler, the time scale is shorter, and the stakes are fictional. But opening a door can change what an enemy knows. Making noise changes behavior. Spending an item alters future options. Positioning changes the actions available on the next turn. A rule becomes interesting because another component of the system responds.
Across all three projects, I keep returning to games in which the player’s action changes the decision problem that comes next.
The invariants are where my taste becomes visible
Once I had built enough of these projects to compare them, the recurring choices became harder to dismiss as genre-specific preferences.
I like decisions that leave residue.
An action should consume something, expose something, commit the player, alter another actor’s behavior, or change the shape of future choices. Immediate feedback matters, but I am especially interested in consequences that persist into the next decision.
Incomplete information appears repeatedly for a related reason. If the player knows the entire state and the response to each action is fixed, many problems can collapse into optimization exercises. Partial information creates room for inference. Actor-specific information creates room for disagreement, signaling, and coordination.
I also keep preferring systems that respond for intelligible reasons. An opponent is more satisfying when its behavior follows from what it can perceive. An institution is more convincing when its policy reflects incentives and constraints. Even when the behavior is simplified, I want the player to be able to form some model of why it happened.
Compactness is another recurring preference.
I tend to prefer a limited vocabulary with strong identities over a large set of weakly differentiated options. Ten items whose effects force different plans are more attractive to me than a hundred whose primary distinction is a slightly different numerical bonus. A few systemic interactions can be more interesting than dozens of isolated mechanics if they combine in ways the player can reason about.
This is a taste, not a general theory of good games. Abundance itself can be pleasurable. Collection, spectacle, execution mastery, narrative richness, and sheer content volume can all justify complexity. My own projects repeatedly spend complexity elsewhere.
Legibility matters because composable systems are only strategically useful when the player can learn them. I want surprising outcomes, but I also want enough causal structure that surprise can eventually become understanding.
That creates a distinction between uncertainty and arbitrariness.
Dreadstep can surprise the player because an unseen enemy reacts to noise. Fog of Intent can surprise the player because another actor had different information or executed imperfectly. Vital Margin can surprise the player because another institution responded to incentives the player underestimated. In each case, a later explanation can convert the surprise into knowledge.
Pure opacity does not offer the same learning process.
I also seem willing to reduce execution burden when execution competes with a kind of reasoning I care more about. Turn-based play gives Dreadstep room for tactical deliberation. Fog of Intent makes this trade most aggressively by moving mechanical performance out of the foreground. Vital Margin abstracts enormous amounts of operational work so that institutional strategy can fit inside a game.
That preference has obvious boundaries. If I applied it indiscriminately, I could destroy genres whose meaning depends on execution. A fighting game derives much of its strategic structure from the player’s physical ability to perform under timing constraints. A rhythm game without timing is scarcely the same object. Even Fog of Intent may discover that execution and strategy in a MOBA are more tightly coupled than the project assumes.
So the recurring preference is more specific than “remove mechanics.”
I care about keeping the burden close to the decision I want the player to experience.
The other recurring distinction is between outcome and judgment. I want a game to allow the possibility that a sound decision fails and a weak decision succeeds. That requires randomness, incomplete information, independent actors, or some combination of them. It also requires enough internal state that the player can eventually separate those causes.
Taken together, these preferences point toward what I have started calling consequential structure.
By that I mean the relationships among information, feasible actions, constraints, uncertainty, responses, state transitions, and delayed effects that make one decision meaningfully different from another.
The phrase is broader than “decision depth.” Some structures shape the decision before the player consciously makes one. Atmosphere changes risk perception. Hidden information changes confidence. A reputation variable may narrow future institutional choices. A weapon’s identity can make the player seek a particular spatial situation. These are part of the conditions under which decisions become meaningful.
Once I started viewing my projects through that lens, the relationship among them became much clearer.
Fidelity can survive a change in form
When people describe a game as faithful to an influence, they can mean several different things.
A remake might preserve controls, timing, maps, progression, visual language, enemy behavior, and other recognizable forms. A spiritual successor may retain a narrower set of mechanics and aesthetics. Historical preservation has yet another reason to care about the original experience as closely as possible.
My projects tolerate more distance from surface form.
Dreadstep can change real-time combat into discrete turns, reduce the scale of the item catalog, and borrow environmental interactions from a different lineage. The question I care about is whether descent, adaptation, spatial danger, and composable rules still create consequential situations.
Fog of Intent makes an even larger transformation. It takes something normally experienced through rapid direct control and moves the player’s attention toward intent, information, coordination, and response. If those relationships remain interesting, the project has preserved something I value even though the interface and temporal structure may feel very different from League of Legends.
Vital Margin shows that this preference does not depend on remixing a specific predecessor. There the design begins from a real institutional problem rather than a particular game. Yet I still want the same kind of structure: partial information, constrained choices, independent actors, delayed reactions, and outcomes that can be traced back through a chain of causes.
I have found fidelity to consequential structure useful as a name for this design preference.
The central question becomes: does the transformed game continue to generate the kinds of consequential situations that made the source or subject interesting to me?
That standard is necessarily personal.
Someone else may identify Diablo most strongly with the feel of real-time combat, the audiovisual texture of the dungeon, or the cadence of acquiring increasingly powerful equipment. Another player may regard mechanical execution as inseparable from the strategic meaning of League of Legends. If they took those games apart, their selection step would keep different components.
That is precisely why influence can produce such different designs.
The reference game supplies material. Decomposition exposes possible pieces. Taste decides which pieces appear essential.
There is also an analytical danger here. The vector-space metaphor makes decomposition look cleaner than the actual object. Games are coupled systems. Changing one dimension can alter the meaning of several others.
Turning real-time action into turns changes more than reaction speed. It changes stress, perception, planning horizon, attention, and the meaning of commitment. Removing content can make a previously rich interaction repetitive. Making information more explicit can improve causal legibility while weakening tension.
The components of a game do not behave like perfectly separable columns in a dataset.
This is where implementation becomes epistemically useful to me.
On paper, I can say that I want to preserve strategic judgment while reducing execution. A prototype can reveal that the two depended on one another more than I expected. I can claim that a compact ruleset should create enough variety; a few sessions may show that the generated situations converge quickly. I can design institutions with independent incentives and discover that the resulting behavior is realistic but miserable to play against.
The playable game pushes back against the abstraction.
That is one reason lower implementation costs have mattered so much to my recent work. They let me move more design arguments out of the realm of taste stated as opinion and into the realm of taste exposed through construction.
I can take the object apart, put together the version I think should work, and then discover whether I understood the original relationship correctly.
What survives the decomposition
Genre labels remain useful to me. If someone describes a game as a roguelike, MOBA, management simulation, or action RPG, I immediately know much more than I did before. Compression is what makes that communication possible.
Design sometimes requires reversing the operation.
The process I keep following now looks roughly like
$$ \text{reference} \longrightarrow \text{decomposition} \longrightarrow \text{selection by taste} \longrightarrow \text{recomposition}. $$My scientific habits influence every stage.
Dimensional thinking encourages me to ask which properties have merely traveled together and which ones truly depend on one another. Optimization makes me state what I am trying to preserve and what costs I am willing to accept. Game theory makes independent actors and strategic response difficult for me to ignore. Statistical thinking makes me suspicious of conclusions drawn only from outcomes when the underlying decision process is richer.
Yet those tools stop before the most interesting choice.
They can help me analyze what is there. They cannot tell me what I should care about.
That answer becomes visible only through repeated selection.
Across a dungeon game, a reconstructed competitive strategy game, and a healthcare management simulation, I keep preserving similar things: incomplete information, constrained choice, strategic response, compact interactions, causal legibility, and consequences that reshape what becomes possible later.
I also keep discarding similar things when they compete with those goals: content volume that adds little strategic distinction, complexity that mainly creates bookkeeping, direct control over actors who become more interesting when they possess their own objectives, and execution demands that obscure the decision I want to examine.
Another designer could start with exactly the same reference games and make the opposite choices.
That possibility is what makes the exercise interesting.
I may be a light gamer, and I am still much more comfortable calling myself a scientist and software builder than a game designer. Building games has nevertheless given me a particularly concrete way to examine something that passive analysis could leave ambiguous. Once a game is decomposed far enough, “what makes this good?” stops being a general question about the object and becomes a sequence of commitments by the person rebuilding it.
The game that emerges carries those commitments.
That may be the clearest definition of design taste I have found so far: what I repeatedly choose to preserve once everything else has become negotiable.