Here is the arithmetic that ends most first interactive stories. Three choices per scene, every path fully distinct: depth two is 9 scenes, depth five is 243, depth eight is over six thousand. Nobody writes six thousand scenes; the writers who try quietly abandon the story around scene eighty, with a structure too wide to revise and too shallow to matter.
The entire craft of branching structure is refusing that explosion without the reader noticing. IF writers have named the shapes that do it — time caves, gauntlets, branch-and-bottleneck, hubs — and they are all, in the end, disciplined ways of merging paths back together. This guide walks the shapes and the discipline, and shows where the story map earns its keep as the instrument you do this work on.
Set an endings budget first. Decide how many endings the story can afford at your standard of revision — for most writers, four to eight. Endings are the most expensive scenes you own; every branch ultimately drains into one, so the budget disciplines everything upstream.
Pick a shape on purpose. A time cave branches everywhere and never merges — glorious, brief, exhausting to write. A gauntlet is one main path with short fatal or rejoining detours. Branch-and-bottleneck diverges then reconverges at fixed story beats. A hub sends readers out on spokes that return. Most satisfying long work is branch-and-bottleneck with a hub somewhere in the middle; most abandoned work is an accidental time cave.
Place the bottlenecks before you branch. Mark the scenes every reader must pass through — the storm, the trial, the arrival. These are your convergence points, and they turn infinite branching into bounded chapters. On the StorySplice map, lay bottlenecks down as a spine first; the map view makes a missing pinch point visible as a graph that only ever widens.
Let paths diverge hard between bottlenecks. Convergence buys you divergence. Between two bottlenecks, paths can be radically different — different locations, allies, tones — precisely because you know they reunite. This is where Branch Wizard is useful: generate several diverging paths from the bottleneck scene in one action, then rewrite each in your own voice.
Merge with memory in the prose. StorySplice tracks no variables, so a merged scene must acknowledge the reader’s path through wording, not flags. The practical trick: write the shared scene neutrally, then add one path-specific approach scene on each incoming branch that lands the acknowledgment just before the merge. One sentence of memory is enough to make convergence invisible.
Watch the map, not your memory. Zoom out regularly. A healthy branch-and-bottleneck structure looks like a braid — widening, narrowing, widening. Run validation to catch orphan scenes and broken links, and treat any region of the map you flinch from as the region that needs revision.
Prune without sentiment. Any branch you would not happily revise twice more should merge into a neighbor or go. A pruned branch often survives as a single haunting choice-and-consequence beat on a surviving path — the good sentence outlives the dead structure.
State versus branches: an honest boundary
Some designs genuinely need tracked state — inventory puzzles, stat-driven combat, romance meters. Tools with variables (Twine’s SugarCube format, ChoiceScript) model those directly, at the cost of writing and debugging logic. StorySplice deliberately has no variables: structure is the state, which keeps authorship purely literary and keeps every consequence written rather than computed. Pure structure carries further than people expect — path identity can encode "has the lantern" or "betrayed the patron" — but it cannot cheaply encode combinations of many independent facts. If your design needs those, prototype the structure here and export to Twee for scripting; if it needs three or fewer, branches will do it with better prose.
Frequently asked questions
How long should the longest path be?
A reader’s single playthrough should feel like a complete story — for most works, 15 to 40 scenes from start to ending. Total scene count across all branches is typically two to four times the spine, not twenty times.
Is merging branches back together cheating?
It is the entire craft. Readers experience one path, not the graph; a merge they cannot detect costs them nothing and saves you exponential work. The sin is not merging — it is merging without memory in the prose.
When do I actually need variables instead of branches?
When outcomes depend on combinations of several independent facts — three items times four allies times a stat check. Below that threshold, branch structure with well-placed merges is cleaner and reads better.
Can the map handle really large stories?
Yes — zoom, pan, drag-to-rearrange, and undo/redo are built for graphs of hundreds of scenes, and validation scales with it. The map usually gives out later than the writer’s revision appetite does.