1. Identify scenes of player onboarding.

2. Map out the hint system.

3. Observe how difficulty settings affects the narrative and mechanics.

1. Play Detritus once on the default difficulty. Log every moment where you felt lost, stuck or there was significant friction.

2. Replay at a different difficulty level and compare the friction points.

3. Identify player failure states and note which ones are recoverable and which ones aren't.

Draft an opening to your own game that teaches mechanics without exposition.

Design a puzzle that can be solvable in two different ways. Try to aim for a puzzle that both solutions should feel natural, rather than an obvious solution and an obscure one.

Prototype a difficulty switch in an engine of your choice.

(Extension) Prototype a hints selection system that reacts differently on different challenge levels.

A slow play of a game is not about writing a review. We want to get our fingers into the joins of the thing and try to pull it apart to see how it works. Questions like "Did I enjoy this?" are irrelevant. Instead of "Did I like the writing?", we want to ask: "Was the writing effective? Where was it effective? Where did it fall down?"

The following are aspects of a game we can tease apart in our slow play.

What does the blurb tell me I'm here for? Does the very first screen reinforce this? Is the game open in its intentions, or shy?

Does the game set up any expectations on where it might go? If you were to predict the ending from the beginning, would you be dead-accurate, or wildly wrong?

How are we expected to interact with this story? Is it a traditional interface or something new?

Does it offer us any consistent actions? What are the important actions? Which actions are just there for fun?

Are the interactions constrained or free? How does the game signal this?

How does the game inform you of your progress in the game?

Are there multiple measures of progress? If so, are they independent?

Does the measures of progress tell you how far you are in the game, or just that you are moving towards the end? Can you go backwards?

Am I expected to optimize progress? Can you?

How is interactivity modelled? Is there a world state? How fine-grained is it? Is it visible?

Is the player fully in control of the state, or is there randomness or external forces?

Can you get into an unwinnable state? Is it noticeable if you do? Where is this game on the Zarfian Cruelty Scale?

Can you map out the game's environment? Its choices?

Where did you encounter friction in the game? Was it productive?

Is the friction accidental or intentional? Did the author anticipate the friction? Did it guide you or provide a barrier?

Where might you have expected friction but found it smooth?

How much happens in the first five minutes? What is the pace over the first thirty minutes?

If this is an IF Comp game, how well does it match the suggested two-hour judges' timing window?

Does the game adopt a different pace at different points in the game? How does it convey that pace?

Does the game take notice of the passing of time? Does it change if you are going too slow or too fast?

Does the game use images, sounds, or music? Are they optional or mandatory? Are they integral or just window dressing?

Does the author use a wide variety of effects, or keeps it restrained?

What images would you cut from this game? What images would be beneficial to add to the game?

Does the author account for players using screen readers? English-as-a-second-language players? People playing on mobile?

What sort of tone does the game start with? Does it end with the same tone? Is the player responsible for tone? Does it match the blurb? The title?

Does the author signpost significantly heavy topics? Can the player negotiate a path around heavy topics rather than straight through?

Does the writing style match the intended tone of the game? Is the authorial voice interesting? Why?

If you were the author of this piece, where would you have done something differently? Could you mimic or replicate the style?

Choose a piece of interactive fiction you are familiar with. Do a slow play, taking notes however works best for you. An hour of slow play should provide plenty of notes and give you enough practice.

If you need a piece to look at, head to the Interactive Fiction DataBase.

The arbitrary landscape we stake out as Interactive Fiction looks a bit like this in 2026:

Parser games

Games with a world model, where the player interacts via verbs.

Choice games

Games primarily in text where your main interactions are making choices.

Quality-based narrative

Games in which you amass a large variety of resources (not just inventory items) that give you access to small choice-based passages called storylets.

This is neither complete nor a proper taxonomy. Broader views of interactive fiction might include: visual novels, gamebooks, tabletop role-playing games, participatory theatre, or tarot cards. Nevertheless, the above three types are quite common and a good way to start thinking about how you might approach the problem of having fiction that interacts with the player.

One way to approach interactivity is to think of it as interacting with a game world. The game simulates the world and the resulting interactions and environment do the storytelling for you. This style of interaction is great for puzzles and exploration.

The parser is the middleman between the player and the world model. The player types commands that are interpreted as actions, the action is simulated which results in textual output. In slow-motion:

1. The player types: PICK UP SWORD

2. The parser breaks the command into pieces and tries to understand the pieces via grammar: it assumes a verb of PICK UP and a direct object SWORD.

3. The game world takes that action and determines if it succeeds (or even makes sense). It simulates a successful action, such as moving the sword to the player's inventory.

4. This action is turned into some form of output: You pick up the sword.

This interactivity loop is both a blessing and a curse. There is an incredible freedom of feeling that a player could type anything in and a good game will resolve it satisfactorily. But there is an incredible onus on the developer (and player!) to make that freedom work. Typically these games will have a set list of actions that they allow so you don't have to deal with a player typing PONTIFICATE VIS-A-VIS MAN'S INHUMANITY TO MAN, unless the developer wants that in the game.

Point-and-click adventure games can be seen in this light with their set of verbs down the bottom of the screen and the ability to apply them to anything in the scene.

But even with a small set of prescribed verbs, all of the objects in the world will be fair game. The feeling of freedom, simulation and coherency falls apart after the player types LICK <object> for the tenth time and get only a boilerplate vague response.

Parser games are therefore tricky for players and developers alike, but were some of the first examples in the genre.

Modern parser games are often written in Inform 7, TADS 3, Quest or ADRIFT. That said, most of these platforms were released in the early 2000s, and not seen a huge development for several years.

Another way to approach interactivity is to think of it as a series of choices. In choice games, picking up a sword is a choice in a story. We would want to record the choice, but you don't need to model objects, inventories, containment and all the other parts of the game world simulation.

A classic version of this are Choose Your Own Adventure books. These were interactive fiction in a static medium of a physical book. You would read passages and at the end of each passage might be a choice you can make. Each choice would indicate a page to turn to if you make that choice.

Modern choice games are often written in Twine, ChoiceScript or ink. The programmatic approach allows much greater flexibility in how choices are presented and honoured. For example, a game like Detritus provides a simulation of its world. You have an inventory and explore a dynamic world. Your interactions are choosing items from a menu, but sometimes that is picking up objects from the room, sometimes it's weaving a path through narrative.

Choice games tend to be easier for people to begin developing in. Twine has easy-to-use tools that lay out your game like a flow chart. ChoiceScript allows you to write your game as a text file with intuitive formatting to provide choices.

Our last type of interactive fiction could be seen as a choice game, but it has enough design changes to warrant a specific look. Quality-based narrative (QBN) imagines your fiction as a vast array of storylets -- little chunks of story that might have choices within -- often presented as cards. A player might select a particular card, which might be interpreted as exploring a place or talking to a person, and the scene will play out.

The "quality" mentioned in QBN is that a player will often have a wide array of qualities, which can encapsulate all sorts of things like player character attributes, money, inventory, factions, temporary afflictions, story hooks, progress in a chase... Cards might be presented or withheld from the player because of their current qualities.

Parser games tend to have an emergent story, and choice games can provide a very explicit story. QBNs are somewhere in between. Cards will have an explicit narrative, but in-between cards provides something more implicit. You might play a sequence of cards and fail at all of them. They aren't particularly linked, but your narrative as a player might be "Today my character is having a rough go at it."

The primary example of QBNs is Fallen London who developed and perfected this form. Others exist like cyberpunkdreams, but none have had the same success.

Interactive fiction continues to grow and evolve. It's a niche form of gaming, but is often a frontrunner in experimenting with different approaches to interactivity and storytelling. Many of the tools in this space are free to use. There is a small but vibrant community of developers and players.

• Interactive Fiction FAQ by the IF Technology Foundation.

• What is IF? at IF Wiki.