I cannot see your story from here — there is no analyser on this page reading your .ink file. You tell me where you are and I will tell you what to do next. Structure detection that genuinely looks at your manuscript is being built into the Workshop app, which is the only place that can honestly do it.

Already know what you are looking for? The ten shapes →

You are here because there is no story yet. Good. This is the shortest state and the one people spend the longest dreading.

You do not need an idea. You need a skeleton.

An idea will not save you and a blank page will not give you one. What gets you moving is a structure that already runs, so that the first thing you do is decorate rather than invent. So take mine.

Paste this into the Workshop app. It runs the moment you paste it, so you have a working game before you have made a single decision. It also loops forever — every room eventually leads back to another room, and the ending loops right back to the start. That is by design. Don't fix the loop. Decorating it is the point: the structure is given to you free, and your creativity goes on top of it.

Welcome to The Nine Rooms!
-> room_1


=== room_1
You are in the first room. There is a door to the north.
+ Go north
    -> room_2
+ Sit Here
    -> room_1

=== room_2
You are in the Second Room.
There is a door to the south.
There is a door to the east.
There is a door to the west.
There is a door to the north.
+ Go north
    -> room_3
+ Go south
    -> room_1
+ Go east
    -> room_4
+ Go west
    -> room_5

=== room_3
You have entered the third room.
There is a door to the south.
There is a door to the north.
+ Go north
    -> room_6
+ Go south
    -> room_2

=== room_4
You have entered the fourth room.
There is a door to the west.
+ Go west
    -> room_2
+ Stay Here
    -> room_4

=== room_5
You have entered the fifth room.
There is a door to the east.
+ Go east
    -> room_2
+ Stay Here
    -> room_5

=== room_6
You have entered the sixth room.
There is a door to the south.
There is a door to the north.
There is a door to the west.
There is a door to the east.
+ Go north
    -> room_9
+ Go south
    -> room_3
+ Go east
    -> room_8
+ Go west
    -> room_7

=== room_7
You have entered the seventh room.
There is a door to the east.
+ Go east
    -> room_6
+ Stay Here
    -> room_7

=== room_8
You have entered the eighth room.
There is a door to the west.
+ Go west
    -> room_6
+ Stay Here
    -> room_8

=== room_9
This is the Final Room. There is no escape from here.
Make your choice:
+ Win the Game
    -> end_game
+ Stay Here
    -> room_9

=== end_game
You have won the game! Or have you?
-> room_1

What you are actually looking at

Two things, and that is genuinely all so far.

A knot is just a named section of your story. You mark it with ===. Think of knots like chapters or scenes. A divert sends the reader to a knot, and it looks like an arrow, ->. Think of -> as “go to.” That's all it means.

So a room is just a named place in the graph, and it can stand for anything you want it to. It doesn't have to be a dungeon — it can be outside, in a labyrinth, anywhere. It doesn't have to be places, it can be choices. It doesn't have to be choices, it can be events. It doesn't have to be choices made by the protagonist at all.

Three premises, if you want one handed to you

These are all mine, and you are welcome to them. Take one and stop deliberating.

=== tavern ===
You walk into a dimly lit tavern.
The bartender looks up.
What'll it be?
* Ale, please.
    The bartender slides a foamy mug your way.
    -> tavern
* Just water.
    The bartender raises an eyebrow but pours you a glass.
    -> tavern
* I'm not thirsty.
    The bartender shrugs and turns away.
    -> market

=== market ===
You step outside into the bright sun.

VAR has_key = false
VAR onion_seeds = 0
VAR onion_sprouts = 0

=== room_4
This is a greenhouse - there are many pots and soil here, and a cabinet with a lock on it.
{ onion_sprouts > 0: You see {onion_sprouts} onion sprouts. }
There is a door to the west.
+ Go west
    -> room_2
+ { has_key } Unlock the cabinet.
    There is a secret tunnel in the cabinet!
    -> room_7
+ { onion_seeds > 0 } Plant an onion seed
    ~ onion_sprouts = onion_sprouts + 1
    ~ onion_seeds = onion_seeds - 1
    You plant an onion seed
    -> room_4

VAR trust = 0

=== arrival
The ferryman does not look up when you board.
+ ["It's cold."]
    ~ trust = trust + 1
    "It is," he agrees, and something in him unlocks a notch.
    -> crossing
+ [Say nothing.]
    ~ trust = trust - 1
    The silence sets, like something cooling.
    -> crossing

=== crossing
The water goes by underneath, {trust > 0: companionably|like an argument you are losing}.
{trust > 0: He offers you his coat.|He does not offer you his coat.}
-> END

It runs. You played it. And something is wrong with it that you cannot name, which is much worse than something being wrong with it that you can.

Here is the thing nobody tells you: the flatness is almost never in the prose. It is in the shape. Your reader makes a choice and the story does not carry it anywhere. So before you rewrite a single sentence, go and find out what shape you actually built.

Diamond first. Always.

If you learn exactly one shape, learn this one, because it is the shape that fixes flat.

Open, differ, converge. The reader picks a path, something changes, and the story comes back together. Divergence is cheap — three short branches. Convergence is rich — one long shared trunk, seasoned by what they picked. You write the trunk once, and it reads differently for everybody.

VAR approach = ""

The cave mouth yawns before you. How do you enter?

* [Torch raised high]
  Light floods the walls, revealing ancient paintings.
  ~ approach = "bold"
* [Creeping in the shadows]
  You slip inside silently. Something skitters away.
  ~ approach = "stealthy"
* [Calling out a greeting]
  Your voice echoes back threefold. Then silence.
  ~ approach = "friendly"
- -> cave_interior

=== cave_interior ===
The cave opens into a vast chamber.
{approach == "bold": The paintings continue deeper, guiding your way.}
{approach == "stealthy": Your eyes have adjusted. You see everything.}
{approach == "friendly": A faint voice answers from the dark.}
Something glints on the far wall.
-> END

Look at what that costs you: three short branches and one paragraph. Look at what it buys: the cave chamber knows how you walked in. That is the entire trick, and every other shape on this page is a variation on it.

Name the shape you built

Answer these about your own story. Answer honestly rather than aspirationally.

1. Do any two paths ever meet again? If no — every choice leads somewhere unique and nothing reconverges — you built a Time Cave, and that is why it feels unfinishable.
2. Is there one room the reader keeps returning to? Then you built a Weave or a Hub-and-Spoke — a Weave if the options run out, a Hub-and-Spoke if they unlock each other.
3. Does everything reconverge, every time, immediately? That is Branch-and-Bottleneck, and if it feels flat it is because nothing is surviving the bottleneck.
4. Does it reconverge and the trunk knows what you did? Congratulations, that is a Foldback, and you are further along than you thought.
5. Is it a straight line of obstacles? Gauntlet. Fine shape. Check that failing one does not end the story.
6. None of the above — it just goes forward and the choices are flavour? Then you have a spine with no shape on it yet, and a Diamond is the first one to put there.

The ramp

The shapes are tiered, and the tiers are not a ranking — they are an order of operations. Every shape in the Basic column can be built out of knots, choices and diverts alone. Everything in Intermediate wants a variable. Everything in Advanced wants a state model you already trust, which is why starting there goes so badly.

Every shape’s way out

This is the part I actually want you to keep. Each shape has a characteristic way of going wrong and a specific shape it turns into when you fix it. You are not abandoning what you built — you are growing it.

Full cards for all ten, with the code for each: The ten shapes →

You have a shape. Now you want the story to remember you, and this is the single move that separates a branching story from a good one.

It is also, and I am going to say this once and then leave you alone about it, the moment you start programming. Variables, conditionals, state. Nobody is going to make you call it that. But that is what you are doing, and you are about to find out you can.

VAR and ~

Sometimes you need the story to remember something — did the player pick up the key? Are they friendly or rude? Declare a variable at the top of the file with VAR, and change it anywhere with ~, which just means ‘do something behind the scenes’ — the reader never sees that line.

VAR has_key = false
VAR friendliness = 0

* Pick up the key.
    ~ has_key = true
    You grab the rusty key.

+ Look around the room.
    The room is cold and empty.

Conditions

Now that you can remember things, you can check them with conditions. Read { has_key } as ‘if has_key is true.’ Gate a whole block of text, or gate a single choice — and gating the choice is the stronger move, because a reader who never found the key never even sees that the option existed.

{ has_key:
    You unlock the door and step through.
- else:
    The door is locked. You need a key.
}

* { has_key } Unlock the door.
    The door creaks open.
* Try to force it open.
    It won't budge.

Plant, remind, payoff

Having a variable is not the same as the reader feeling it. The most satisfying use of state has three beats, and skipping the middle one is why so many stories with variables still read as flat.

1. Plant. The reader does something — picks up an item, helps someone, reads a note — and a flag flips. They should barely notice.
2. Remind. Later, one sentence that lets them know the story kept it. This is the beat everybody skips, and it is the one that does the work.
3. Payoff. Something is different. A path opens, a character reacts, an ending exists that otherwise would not have.

VAR knows_password = false

// PLANT
=== office ===
A sticky note on the monitor reads: "DELTA-7"
~ knows_password = true
You memorize it and move on.
-> corridor

// REMIND
=== terminal ===
A login prompt blinks on the screen.
{knows_password: The sticky note. DELTA-7. Could that be it?}

// PAYOFF
* {knows_password} [Type DELTA-7]
    Access granted. Files flood the screen.
    -> secret_files
* [Try to guess]
    You type "password." Denied. "admin." Denied.
    -> terminal_locked

Season the trunk, don’t duplicate it

Here is the discipline that keeps this from exploding on you. When state changes a scene, you do not write two copies of the scene. You write one, and you season it.

VAR trust = 0

=== arrival
The ferryman does not look up when you board.
+ ["It's cold."]
    ~ trust = trust + 1
    "It is," he agrees, and something in him unlocks a notch.
    -> crossing
+ [Say nothing.]
    ~ trust = trust - 1
    The silence sets, like something cooling.
    -> crossing

=== crossing
The water goes by underneath, {trust > 0: companionably|like an argument you are losing}.
{trust > 0: He offers you his coat.|He does not offer you his coat.}
-> END

One crossing. Not two. The {trust > 0: companionably|like an argument you are losing} is doing the entire job — same paragraph, different story. Write the trunk first, plain, all the way through. Season it afterwards. Do it in that order and you will never once find yourself maintaining two versions of the same scene.

Two things you get for free

Ink counts visits for you. A knot name evaluates to how many times it has been visited, and you never had to declare anything:

=== market ===
{market == 1: The market is overwhelming on first visit. So many stalls.}
{market == 2: The market feels more familiar now. You know where things are.}
{market > 2: You navigate the market on autopilot.}

+ [Browse the stalls] -> stalls
+ [Leave the market] -> town_square

And an irreversible choice needs no new syntax at all — just an assignment guarded so the choice that fires it can never fire again. Turning the key sets ~ door_sealed = true, and the choice that turned it required not door_sealed to appear at all. So the instant it fires, its own condition goes false, and the option is gone for the rest of the story. Once turned, it doesn't turn back.

VAR has_key = false
VAR door_sealed = false

=== room_9
The final room. {has_key: The lock is waiting for what you are carrying.|There is a lock, and you have nothing to put in it.}
+ {has_key and not door_sealed} [Turn the key]
    ~ door_sealed = true
    It turns once. It will not turn back.
    -> end_game
+ [Stay here] -> room_9
+ [Go back south] -> room_6

You are here because it has got away from you. That is not a sign you are bad at this. It is a sign you are far enough in for the structure to start mattering, and every branching story goes wrong in exactly one of two ways.

The two ways a branching story dies

Knowing which one you are drifting toward is half the craft.

Five heuristics, in order

1. Decide your shape first. Diamond? Branch-and-bottleneck? Quality-based? Pick it before you write a word of prose. That is what the ten shapes are for.
2. Pick your tracked state. What 3–7 variables actually matter? Go past ~7 and you'll lose track; go too few and choices stop feeling consequential.
3. Plan your bottlenecks before your branches. Know where the river reconverges before you let it split.
4. Aim for diamonds two to four beats long. Branch, let the player feel the difference, converge. Repeat.
5. Make divergence cheap and convergence rich. Short branches, long shared trunks, coloured by state.

Untangling what you already have

You do not have to start over. You almost never have to start over. Three moves, in this order:

1. Draw it. You cannot fix a shape you cannot see. Get a map of your own story out of an AI — it is genuinely good at this, and it will show you the branch you forgot to terminate.
2. Find the widest point and put a bottleneck just after it. Every path from that fan-out gets a divert to one shared knot. Everything downstream of that knot you now only have to write once.
3. Push the difference into variables. Whatever made those branches feel different — that goes into a VAR now, and gets read back in the trunk you just merged them into.

Draw a mermaid flowchart of the knots in this Ink story and how they connect --
which choice from which room leads to which knot. Use the room names as labels,
and mark any tunnel or loop clearly.

You think it is done. Let's find out. Nothing here needs anybody's permission — this is all stuff you can check yourself, before you ever hit publish.

Read it like a stranger

Play it in Preview, not in the editor. Typos hide in the Manuscript and jump right out in Preview, and so does every clunky transition you stopped being able to hear.

• Every path reaches -> END or loops back to a valid choice. No dead ends — a knot with no choices and no divert leaves your reader stranded.
• At least one variable gets a moment where an earlier choice visibly changes the story later on. That is the whole point of tracking it.
• You have played at least two different paths yourself, start to finish, and both make narrative sense.
• Your characters' lines still sound like them when you read them out loud, from the first scene to the last.
• Your choice transitions read as prose, not as clunk. Read them aloud too.
• Your # mood: tags match the scene rather than habit — # mood:danger on a calm beat reads as a bug.
• Nothing on any path contradicts something the reader already saw on that same path.

That last one is the hardest to check by hand, because it means walking every combination. Hand it to an AI — this is one of the things it is genuinely good at:

Here's my Ink script with variables and conditions:
[PASTE YOUR FULL SCRIPT]

Playtest this for me. Try these paths:
1. The "completionist" -- find everything, talk to everyone
2. The "speedrunner" -- take the most direct route to an ending
3. The "contrarian" -- choose the least obvious option every time

For each path, tell me:
- Does the story make sense from start to finish?
- Are there any dead ends (no choices and no -> END)?
- Are there moments where a variable SHOULD matter but doesn't?
- Any dialogue that contradicts what happened earlier on this path?

The three errors you will actually hit

Handing it over

Publishing happens in the Workshop app, and there are three things it wants from you that your story does not have yet.

1. Tags. A # mood: tag on its own line before the content it colours — wonder, calm, sadness, danger. A # live:characterId tag lights up the character voice indicator while that character is speaking.
2. Metadata. Title, the in-world author, themes. The metadata drawer walks you through it; underneath, it is building a JSON bundle with your compiled Ink, your characters, and that metadata block.
3. Review. Submit it. Review is LLM-backed and it hard-gates publish — your story's review status has to come back passed before it goes live. That is a real gate, not a formality. Work the checklist above and most stories clear it first time.

# mood:calm
-> arrival

=== arrival
# live:ferryman
The ferryman does not look up when you board.
+ ["It's cold."] -> crossing
+ [Say nothing.] -> crossing

=== crossing
# mood:sadness
"Go on, then," he says. "It doesn't get easier from here."
-> END

And then the next one

Publish it, then go and play what somebody else built. That part is not optional and it is not sentimental — you will learn more about your own choices from watching a stranger's story fail to remember them than from any amount of rereading your own.

What to learn next: threads (<- knot_name, pulling a parallel storyline into the scene you are in), LISTs for state that is more than true-or-false, and functions for text your story generates rather than text you typed. All of it builds directly on what you just did. None of it was needed to finish.

Ten shapes. They are composable — you can nest diamonds inside hub spokes, chain gauntlets into a branch-and-bottleneck spine, or use QBN to decide which shape fires next. Think of them like functions: pick a shape, fill in your content, connect it to the next one.

Every card carries the same three things: when to use it, the way you can tell you have accidentally built it badly, and the shape it grows into when you fix that. Paste any of the code straight into the Workshop app.

VAR approach = ""

The cave mouth yawns before you. How do you enter?

* [Torch raised high]
  Light floods the walls, revealing ancient paintings.
  ~ approach = "bold"
* [Creeping in the shadows]
  You slip inside silently. Something skitters away.
  ~ approach = "stealthy"
* [Calling out a greeting]
  Your voice echoes back threefold. Then silence.
  ~ approach = "friendly"
- -> cave_interior

=== cave_interior ===
The cave opens into a vast chamber.
{approach == "bold": The paintings continue deeper, guiding your way.}
{approach == "stealthy": Your eyes have adjusted. You see everything.}
{approach == "friendly": A faint voice answers from the dark.}
Something glints on the far wall.
-> END

The letter says: "Come to the docks at midnight."
* [Go to the docks]
  A figure waits in the fog.
  ** [Approach them]
    "You came." They hand you a key.
    *** [Take the key]
      The key opens a warehouse. Inside: gold.
      -> END
    *** [Refuse the key]
      "Your loss." They vanish into the fog.
      -> END
  ** [Hide and watch]
    They wait. Then leave a package on the ground.
    *** [Take the package]
      Inside: a map to somewhere far away.
      -> END
    *** [Leave it]
      You walk home. Some mysteries stay unsolved.
      -> END
* [Burn the letter]
  The paper curls and blackens.
  ** [Go to bed]
    You sleep soundly. Life goes on.
    -> END
  ** [Regret it immediately]
    You fish the scraps from the fire.
    "...docks...mid..." Useless.
    -> END

VAR ch1_choice = ""
VAR ch2_choice = ""

-> chapter_one

=== chapter_one ===
The king demands your counsel.
* [Advise war]
  "Strike first," you say. The king smiles.
  ~ ch1_choice = "war"
* [Advise diplomacy]
  "Send an envoy." The king frowns but nods.
  ~ ch1_choice = "peace"
- -> chapter_two

=== chapter_two ===
{ch1_choice == "war": Troops gather at the border.}
{ch1_choice == "peace": An envoy rides out at dawn.}
A spy brings disturbing news.
* [Interrogate the spy]
  Under pressure, they reveal a traitor.
  ~ ch2_choice = "traitor"
* [Follow the spy secretly]
  They lead you to a hidden camp.
  ~ ch2_choice = "camp"
- -> chapter_three

=== chapter_three ===
{ch2_choice == "traitor": You confront the traitor at court.}
{ch2_choice == "camp": You raid the camp at dawn.}
The kingdom's fate is sealed.
{ch1_choice == "war" and ch2_choice == "traitor": A bloody but decisive victory.}
{ch1_choice == "peace" and ch2_choice == "camp": A quiet triumph. No one even knows.}
-> END

// Foldback: paths FEEL different but arrive at the same outcome.
// Compare with Branch-and-Bottleneck where endings genuinely diverge.

-> prison

=== prison ===
The cell door is rusted. You need to get out.
* [Pick the lock]
  Click. Click. The door swings open.
  You slip into the corridor, heart pounding.
  -> courtyard
* [Smash the wall]
  Brick dust everywhere. A hole, barely big enough.
  You squeeze through, scraping skin on stone.
  -> courtyard

=== courtyard ===
// Same destination regardless of path above.
The courtyard stretches before you. The gate is ahead.
* [Climb the wall]
  Your fingers find holds in the old mortar.
  Over the top. You drop to the other side.
  -> road
* [Bluff the gatekeeper]
  "Shift change." He squints, shrugs, waves you through.
  -> road

=== road ===
// The ending is IDENTICAL. That's the point of Foldback:
// the player felt agency, but the story spine never moved.
Miles later, you stop to breathe.
You're free. The road stretches ahead.
Whatever happened back there — it's done now.
-> END

VAR wounds = 0
VAR has_rope = true

-> gate_one

=== gate_one ===
A chasm blocks the path. Far side, ten feet away.
* {has_rope} [Throw the rope across]
  The rope catches! You cross safely.
* [Jump for it]
  You leap — and barely catch the edge.
  ~ wounds = wounds + 1
  Your hands are bleeding. But you made it.
- -> gate_two

=== gate_two ===
A locked door. The lock is rusted.
* {wounds == 0} [Pick the lock with steady hands]
  Click. It opens smoothly.
* [Force it open]
  You slam your shoulder into it. It gives.
  ~ wounds = wounds + 1
  Something in your shoulder pops.
- -> ending

=== ending ===
You stumble into daylight.
{wounds == 0: Not a scratch on you. Perfect run.}
{wounds == 1: Battered, but alive. Could be worse.}
{wounds >= 2: You collapse. Barely made it.}
-> END

VAR talked_to_guard = false
VAR searched_alley = false

-> town_square

=== town_square ===
The town square. People bustle past.
+ {not talked_to_guard} [Talk to the guard]
  -> guard
+ {not searched_alley} [Search the alley]
  -> alley
+ {talked_to_guard and searched_alley} [Enter the locked tower]
  The clues align. You know the password.
  -> tower
+ [Leave town]
  You walk away, mystery unsolved.
  -> END

=== guard ===
"Saw someone in the alley last night," the guard mutters.
~ talked_to_guard = true
-> town_square

=== alley ===
Behind the crates: a torn note. "The password is MOONRISE."
~ searched_alley = true
-> town_square

=== tower ===
"MOONRISE," you whisper. The door swings open.
Inside, the truth awaits.
-> END

VAR saw_fish = false
VAR saw_herbs = false
VAR saw_fortune = false

-> market_square

=== market_square ===
The market bustles around you.
+ {not saw_fish} [Visit the fish stall]
  The fishmonger waves a gleaming trout.
  "Fresh today! Caught it meself!"
  ~ saw_fish = true
  -> market_square
+ {not saw_herbs} [Browse the herb cart]
  Lavender and rosemary scent hits you.
  The herbalist nods knowingly.
  ~ saw_herbs = true
  -> market_square
+ {not saw_fortune} [See the fortune teller]
  She turns a card. The Tower.
  "Change is coming," she whispers.
  ~ saw_fortune = true
  -> market_square
+ {saw_fish and saw_herbs and saw_fortune} [Leave the market]
  You've seen it all. Time to move on.
  -> END
+ [Leave the market early]
  You slip away through the crowd.
  -> END

LIST Knowledge = seeds, water, sunlight

-> garden

=== garden ===
{LIST_COUNT(Knowledge) == 0: The garden is dead earth. Nothing grows.}
{Knowledge ? seeds: Small green shoots push through the soil.}
{Knowledge ? water: The earth is dark and damp.}
{Knowledge ? sunlight: Golden light pools between the leaves.}

+ {not (Knowledge ? seeds)} [Plant the seeds you found]
  You press seeds into the earth, one by one.
  ~ Knowledge += seeds
  -> garden
+ {not (Knowledge ? water)} [Dig a channel to the stream]
  Water trickles in, soaking the ground.
  ~ Knowledge += water
  -> garden
+ {not (Knowledge ? sunlight)} [Cut back the dead branches overhead]
  Light floods in. The soil warms.
  ~ Knowledge += sunlight
  -> garden
+ {Knowledge ? (seeds, water, sunlight)} [Sit in your garden]
  It took time. But look at it now.
  -> END

VAR current_path = "none"

Two letters arrive. One sealed in red, one in blue.
* [Open the red letter]
  ~ current_path = "red"
  -> red_1
* [Open the blue letter]
  ~ current_path = "blue"
  -> blue_1

=== red_1 ===
The Red Court summons you. Intrigue and poison.
* [Continue on the red path]
  -> red_2
* [Defect to the blue side]
  ~ current_path = "blue"
  -> blue_2

=== blue_1 ===
The Blue Fleet needs a navigator. Salt and stars.
* [Continue on the blue path]
  -> blue_2
* [Defect to the red side]
  ~ current_path = "red"
  -> red_2

=== red_2 ===
The courtiers whisper your name.
{current_path == "red": You've been here all along. They trust you.}
{current_path == "blue": A defector. They watch you carefully.}
-> finale

=== blue_2 ===
The horizon stretches forever.
{current_path == "blue": The crew knows you. You belong.}
{current_path == "red": A landlubber on deck. You have much to prove.}
-> finale

=== finale ===
War comes regardless. But where you stand determines everything.
-> END

LIST Traits = brave, clever, kind
VAR reputation = 0

-> tavern

=== tavern ===
The tavern is loud tonight.
{Traits ? brave: The scarred fighter nods at you from across the room.}
{Traits ? clever: You notice the barkeep's loaded dice.}
{Traits ? kind: A child tugs your sleeve, eyes wide.}

* {not (Traits ? brave)} [Stand up to the bully]
  You shove him back. The room goes quiet.
  ~ Traits += brave
  -> tavern
* {not (Traits ? clever)} [Challenge the barkeep's game]
  "Those dice are weighted." He goes pale.
  ~ Traits += clever
  -> tavern
* {not (Traits ? kind)} [Buy the child a meal]
  The kid grins. Warmth blooms in your chest.
  ~ Traits += kind
  -> tavern
* {LIST_COUNT(Traits) >= 2} [You've made your mark. Leave.]
  ~ reputation = LIST_COUNT(Traits)
  The door swings shut behind you.
  Reputation earned: {reputation}.
  -> END

The escape routes, all in one place

These ten cards are condensed from the Ink Shape Catalog, which also carries a vibe prompt for each shape. For nesting them inside one another, the Shape Composition Guide. For where these shapes come from and what published work uses them, the Story Structure Atlas. For the AI prompts that fill them, the Vibe Authoring Toolkit.