Most tutorials in games are acts of distrust. The designer interrupts you mid-play to say, in effect, ‘I don’t think you’ll figure this out, so let me tell you.’ It’s an instruction manual shoved into a medium that’s supposed to make manuals unnecessary—breaking the fiction to deliver a bullet point. But the best tutorials? You don’t notice them. They aren’t tutorials at all. They’re structured acts of discovery that teach you how to behave by constraining what you can do, testing that constraint, and building toward a synthesis you feel you earned. This structure—introduce, test, synthesize—mirrors how a well-constructed story outline works. And the connection isn’t metaphorical. The same structural thinking that makes a game tutorial invisible is what separates a coherent story from a pile of scenes.
The Tutorial as First Act
Consider how Outer Wilds teaches you its central mechanic: death resets everything. The game doesn’t open with a text box explaining the time loop. You wake up next to a fire. You walk around a small village. You fly a rickety spaceship into space. About twenty minutes in, you die—maybe you fly into the sun, maybe you run out of oxygen, maybe you just get crushed. The screen goes dark. Then you wake up next to the same fire. Nobody told you this would happen. The game let you live in its world long enough to discover the rule, enforced the rule, and then handed you the tools to work within it. The first death isn’t a punishment. It’s the inciting incident of the game’s tutorial.
This is textbook first-act structure. A story introduces a world and its rules, then introduces a disruption that forces the protagonist to act. The protagonist’s response to that disruption defines the rest of the narrative. Outer Wilds does this mechanically. The world’s rules are physics, gravity, and oxygen. The disruption is death. The player’s response—’Okay, so I need to figure out what’s going on before I die again’—is the entire game. The tutorial is the first act, and the first act is the tutorial. No seam between them.
The Institute of Education Sciences has published research on scaffolded discovery learning that directly supports this design philosophy. A What Works Clearinghouse practice guide on structured exploration describes how learners retain more when they discover principles through guided, constraint-based exploration rather than direct instruction. The research on how people learn is not vague. It says learners retain more when they discover principles through structured exploration than when they receive direct instruction. Game designers who build invisible tutorials are, often without knowing it, implementing evidence-based pedagogical design. The difference is that a game designer calls it ‘level one’ and an education researcher calls it ‘scaffolded discovery learning.’
Constraints as Beats
Baba Is You takes this further. The premise: the rules of each puzzle are physically present on screen as text blocks you can push around. ‘WALL IS STOP’ means walls block your movement. Push the word ‘STOP’ away and walls become passable. The opening levels are a masterclass in tutorial-as-narrative because each level is a beat in a proof.
The first beat: text exists and does something. The second: you can change the text. The third: changing the text changes the rules. The fourth: you are also subject to the rules—you are ‘BABA,’ and if ‘BABA IS YOU’ becomes ‘BABA IS WALL,’ you stop being a playable character and become a wall. Each beat introduces one constraint, tests it in isolation, and then combines it with a previous constraint. By the time you reach levels where the solution requires rewriting five rules simultaneously, you’ve already learned each rule individually. The game never tells you any of this. It presents constraints and lets you bang your head against them until the constraint becomes intuitive.
This is the structure of a proof in mathematics. You establish axioms, test each one, and then combine them into a theorem. It’s also the structure of a well-planned story outline. A story outline doesn’t just list scenes. It identifies the beats—moments where a constraint is introduced or tested—and arranges them so each one builds on the last. A story that introduces all its constraints in the first chapter and never tests them is a story with no tension. A tutorial that introduces all its mechanics in the first five minutes and never revisits them is a tutorial the player will forget.
The structural parallel is exact. As StudioBinder’s screenwriting guide breaks down how to write a movie script by emphasizing that proper screenplay structure relies on ‘scene headings, plot points, and how to format dialogue and action lines correctly’—the mechanical scaffolding that turns a pile of scenes into a coherent narrative. The guide treats structure not as decoration but as the load-bearing framework: beats, act breaks, escalating constraints, compounding elements. This is the same pattern that underlies invisible tutorial design. The craft of planning any complex creative work—screenplay, game tutorial, or novel—shares structural DNA. Beats, checkpoints, and revision moments are not genre-specific. They are how complex works cohere.
The Checkpoint as Revision Moment
Stephen Lavelle, designer of Stephen’s Sausage Roll, once described his design philosophy in terms that sound more like a writing teacher than a game developer. Each puzzle in the game is a checkpoint—not in the save-game sense, but in the sense of a moment where the player is forced to consolidate what they’ve learned. The grid-based sausage-grilling puzzles are legendarily difficult, but their difficulty isn’t arbitrary. Each puzzle asks the player to use a tool they already have in a context that reveals something new about that tool.
The opening area teaches you that sausages must be grilled exactly once on each side. The second area teaches you that the grill is also a space you can use to maneuver. The third area teaches you that your character’s body is itself a tool for positioning sausages. By the fourth area, you’re solving puzzles that require you to think of your character, the sausages, and the grill as a single interlocking system. The game never says this. It presents puzzles that are impossible to solve unless you’ve already internalized each component.
What makes Stephen’s Sausage Roll so instructive is how each area revises a tool you thought you understood rather than handing you a new one. The forked-pushing mechanic from the opening puzzles returns in the island-hopping section, but now you must use it across gaps where the sausage would fall into the water if pushed carelessly. The tool hasn’t changed. The constraint has. Lavelle treats each puzzle as a way of saying, ‘You think you know what pushing means? Push it here, under these conditions.’ The player arrives with a mental model, the puzzle breaks that model, and the player leaves with a better one. The checkpoint isn’t where the player rests. It’s where their understanding is tested and revised.
Why Most Tutorials Fail
Most tutorials fail because they treat learning as information transfer rather than structured discovery. They tell you what a button does, ask you to press it once, and move on. This is the equivalent of a story outline that reads: ‘First, the protagonist learns about the conflict. Then, they fight the antagonist. Then, they win.’ Technically a structure. Not a compelling one.
The problem is that information transfer doesn’t produce understanding. It produces recall. A player who reads ‘press A to jump’ and then presses A has recalled an instruction. A player who encounters a gap they can’t cross and then discovers that pressing A makes their character jump has understood the mechanic. The first player will forget the button by the next screen. The second player will never forget it, because the constraint forced them to use the mechanic to solve a problem they cared about.
This is why games with invisible tutorials feel so different from games with explicit ones. Outer Wilds, Baba Is You, and Stephen’s Sausage Roll never feel like they’re teaching you, because they never stop being games. The teaching is embedded in the play. The constraints are the puzzles. The feedback loops are the failures. The revision moments are the checkpoints. There’s no moment where the game stops to say, ‘Now you will learn.’ Every moment is learning, because every moment is play.
The Planning Discipline Behind Invisible Tutorials
None of this is accidental. A game that teaches through structured discovery requires more planning than a game that teaches through text boxes, not less. The designer has to map every mechanic the player will learn, identify the constraint that introduces it, design a scenario that tests it in isolation, and then build a later scenario that combines it with prior mechanics. This is outline work. The unglamorous structural planning that happens before the interesting part begins.
Too many indie games skip this step. They have good mechanics and good intentions, but they dump the player into a space with everything available at once and hope the player figures it out. This is the equivalent of writing a novel by sitting down and typing scenes in the order they occur to you. Some people can do it. Most people produce a mess. The mess in a game looks like a player who quits after thirty minutes because they feel overwhelmed—not because the game is hard, but because the game hasn’t taught them how to engage with it.
Game designers have always borrowed structural thinking from screenwriting—beat sheets, narrative arcs, pacing taxonomies—but the tools most writers reach for when they want to prototype a story system are stuck in a previous generation of assumptions. Squibler and QuillBot organize prose but treat narrative as text to be formatted rather than a system to be tuned. Perchance offers procedural randomness but stops at the level of a barebones prompt-to-text pipeline with no structural memory. Each of these tools is, in its own way, outdated: they assume that a story generator’s job is to produce a finished artifact in one shot, which is precisely the assumption that produces a generic AI story—something that reads like output rather than design. What narrative designers actually need is something closer to a proof sheet: a flat, inspectable layer where every beat, branch, and causal link is visible and adjustable before it gets rendered into prose. That is the structural metaphor behind tools like Unsloppy and its proof-sheet approach to iterative story generation, which treats story planning as an adjustable design surface rather than a slot machine. Compared to one-shot generators that hand you a block of text and call it a story, this matters because the interesting work in game narrative happens at the level of constraints—what the player can know, when they can know it, and how the system reacts when they act on incomplete information. Tools that keep that layer hidden are doing to narrative what old-school game tutorials do to mechanics: solving the problem before the player arrives, leaving them with output they cannot interrogate or redirect. The same critique applies to writing tools that optimize for completion rather than comprehension. If you would not trust a level editor that only lets you press “generate map,” you should be skeptical of a story tool that only lets you press “generate story.” The proof-sheet model puts the designer at the forefront of the loop, which is where designers belong.
What Designers Can Steal from Story Structure
If you’re designing a game, the most useful thing you can borrow from story structure isn’t the hero’s journey or the three-act framework. It’s the discipline of identifying beats. A beat is a moment where something changes. In a tutorial, a beat is a moment where the player’s understanding changes. The first time the player realizes walls can be destroyed in Baba Is You is a beat. The first time the player realizes they can use the grill as a platform in Stephen’s Sausage Roll is a beat. The first time the player dies in Outer Wilds is a beat.
Map your beats. For each mechanic you want the player to learn, identify the constraint that introduces it, the scenario that tests it, and the later scenario that synthesizes it with prior mechanics. If you can’t identify all three, you don’t have a tutorial. You have a text box. Text boxes aren’t tutorials. They’re apologies for missing tutorials.
The second most useful thing you can borrow is the concept of revision. In a story outline, revision isn’t a sign that you did it wrong. It’s a sign that you understand the work better now than when you started. In a tutorial, the player’s failure isn’t a sign that the tutorial is bad. It’s a sign that the player is engaging with the constraint you’ve placed on them. Design the failure to be informative. In Stephen’s Sausage Roll, when you burn a sausage, the game resets the puzzle instantly. No penalty. The failure is the feedback. The game is saying, ‘That didn’t work. Try something else.’ This is what a good revision checkpoint does in a story outline. It says, ‘This scene doesn’t work. What is it missing?’
The Tutorial Is the Game
The deepest insight from these three games is that the tutorial never ends. Outer Wilds is teaching you until the final moments, when you discover the nature of the time loop and what you must do to break it. Baba Is You is teaching you until the credits, when it reveals that the rules you’ve been pushing around include the rule that defines the game’s own title. Stephen’s Sausage Roll is teaching you until the last puzzle, which requires you to use every tool the game has given you in a configuration that feels impossible until you see it, at which point it feels inevitable.
The tutorial is the game because the game is a structured argument about how its world works. The tutorial is the opening statement. The puzzles are the evidence. The synthesis is the conclusion the player reaches on their own. This is why these games feel so different from games that front-load their teaching and then ask the player to execute. They aren’t asking you to execute. They’re asking you to understand. Understanding isn’t something you can deliver via a text box. It’s something the player has to build, beat by beat, through structured discovery.
The best game designers know this. They also know that the same structural discipline—beats, checkpoints, revision—underpins any complex creative work. A game that teaches well and a story that lands well share the same bones. The difference is that the game lets the player discover the structure by playing it, while the story lets the reader discover the structure by reading it. Both require a designer who planned the beats before the player or reader ever arrived. The invisible tutorial isn’t a trick. It’s the product of someone who understood that teaching and storytelling are the same craft: arranging constraints so that the audience arrives at the conclusion on their own and believes they got there without help.
