Vibe Authoring Toolkit

Vibe Authoring Toolkit

Vibe Authoring Toolkit

Prompt templates for AI-assisted interactive fiction

Vibe authorship is writing by directing an AI — you describe the shape, tone, and constraints, and the AI generates the Ink code. You then play-test, iterate, and refine. This toolkit gives you copy-paste prompts for every story shape. The key skill is learning to describe structure precisely enough that the AI gives you something useful on the first try.

Section 1 The Anatomy of a Good Vibe Prompt

Every effective prompt for generating Ink code has five components. Miss one and the AI will fill in the gap with guesses — usually bad ones.

  1. 1 Shape — Which structural pattern: diamond, gauntlet, QBN, hub-and-spoke, etc. This is the skeleton the AI builds on.
  2. 2 Content — Setting, characters, tone, genre. The flesh on the skeleton. Be specific: "a rain-soaked space station" beats "a sci-fi setting."
  3. 3 State — What variables or lists to track, what persists between knots. If you don't specify state, the AI won't track anything.
  4. 4 Constraints — Word count per passage, number of choices, which Ink features to use or avoid. Guardrails that keep output manageable.
  5. 5 Connection Points — Where this piece plugs into the rest of your story: entry knot name, exit divert target, variables it reads or writes.
Shape
Content
State
Constraints
Connection Points

Labeled Example

Write an Ink diamond: a single knot called "market_stall" where the player, a traveling merchant in a dusty bazaar, encounters a child trying to steal bread. Tone: bittersweet and warm. Offer 3 choices, each branch no longer than 4 lines. Each choice sets VAR empathy to a different value (0, 1, or 2). Use only basic Ink — no tunnels, no threads. All three paths converge at a gather that transitions to -> bazaar_exit. This knot reads VAR coins (defined elsewhere).
Section 2 Shape Prompts

Ten templates, one per shape. Copy the template, fill in the placeholders, and paste it into your AI assistant. Each template is designed to produce a single, testable chunk of Ink.

1. Diamond

Choices fan out then converge at a single gather point.

Template (copy this)
Write an Ink diamond: a single knot called [KNOT_NAME] where the player encounters [SITUATION]. Offer 3 choices that represent [APPROACHES]. Each choice sets VAR [VARIABLE] to a different value. All three paths converge at a gather that transitions to -> [NEXT_KNOT]. Tone: [TONE]. Keep each branch to [N] lines.
Filled Example
Write an Ink diamond: a single knot called "engine_room" where the player encounters a sparking coolant leak. Offer 3 choices that represent cautious/reckless/clever approaches. Each choice sets VAR engineering_skill to a different value. All three paths converge at a gather that transitions to -> bridge. Tone: tense and technical. Keep each branch to 5 lines.
Expected Output
  • One knot with exactly 3 top-level choices
  • A VAR declaration at the top
  • A gather ( - ) where all branches meet
  • A single -> next_knot divert at the end
  • No nested choices, no additional knots

2. Weave

A hub the player revisits, investigating once-only options until all are seen.

Template (copy this)
Write an Ink weave hub called [KNOT_NAME]. The player is in [LOCATION]. There are [N] things to investigate, each as a once-only choice (*). After investigating, the flow returns to the hub. When all [N] have been visited (use boolean VARs or once-only choice exhaustion), divert to -> [NEXT_KNOT]. Each investigation is [LINES_EACH] lines.
Filled Example
Write an Ink weave hub called "crime_scene". The player is in a ransacked apartment. There are 4 things to investigate, each as a once-only choice. After investigating, the flow returns to the hub. When all 4 have been visited (use boolean VARs to track each), divert to -> detective_office. Each investigation is 3 lines.
Expected Output
  • One knot with N once-only choices (using *)
  • Each choice sets a boolean VAR and diverts back to the hub: ~ saw_X = true then -> knot_name
  • A conditional gate: {saw_a and saw_b and saw_c: -> next}
  • Choices disappear after being selected (once-only * handles this)

3. Gauntlet

A linear sequence of stations, each with a clean path and a costly path.

Template (copy this)
Write a [N]-station Ink gauntlet. The player moves through [SCENARIO]. At each station, there's a "clean" path (gated by [CONDITION]) and a "costly" path (always available, increments VAR [PENALTY_VAR]). Stations are: [S1], [S2], [S3]. Exit to -> [NEXT_KNOT].
Filled Example
Write a 3-station Ink gauntlet. The player moves through a collapsing mine shaft. At each station, there's a "clean" path (gated by having rope or a lantern) and a "costly" path (always available, increments VAR injuries). Stations are: flooded_tunnel, unstable_bridge, cave_in. Exit to -> surface.
Expected Output
  • N sequential knots, each with exactly 2 choices
  • One choice gated by a conditional: {has_rope: ...}
  • One choice always visible, incrementing a penalty variable
  • Linear flow: station 1 -> station 2 -> station 3 -> exit
  • A VAR declaration for the penalty counter

4. Quality-Based Narrative (QBN)

Content appears and disappears based on tracked qualities/states.

Template (copy this)
Write a quality-based narrative knot called [KNOT_NAME]. Use LIST [LIST_NAME] = [VALUES] to track [WHAT_IT_REPRESENTS]. Show different text and choices based on the current list value. At least [N] variants. Each variant sets state that affects future QBN checks. Exit to -> [NEXT_KNOT].
Filled Example
Write a quality-based narrative knot called "tavern_gossip". Use LIST reputation = unknown, suspicious, trusted, legendary to track how the townsfolk perceive the player. Show different text and choices based on the current list value. At least 4 variants. Each variant sets state that affects future QBN checks. Exit to -> town_square.
Expected Output
  • A LIST declaration with ordered values
  • Conditional blocks checking current list value
  • Choices that advance the list: ~ reputation += trusted (add to set) or ~ reputation = trusted (single rank)
  • Meaningfully different text per quality level
  • At least N distinct branches

Two LIST paradigms: "Flag-bag" (+= item, multiple items active, test with ?) vs "Ordered rank" (= item, single value, test with ==). The catalog example uses flag-bag; this template works with either. Tell the AI which you want.

5. Hub-and-Spoke

A central hub with optional branches that gate a finale.

Template (copy this)
Write an Ink hub-and-spoke structure. The hub is [LOCATION/SITUATION]. There are [N] spokes: [SPOKE1], [SPOKE2], [SPOKE3]. Each spoke is gated by [GATE_TYPE] and sets a completion flag when done. When all spokes are complete, the hub diverts to -> [FINALE_KNOT]. Each spoke is a [INNER_SHAPE] shape internally.
Filled Example
Write an Ink hub-and-spoke structure. The hub is a space station command deck. There are 3 spokes: repair_oxygen, hack_comms, investigate_cargo. Each spoke is gated by having the right tool item and sets a completion flag when done. When all spokes are complete, the hub diverts to -> launch_sequence. Each spoke is a diamond shape internally.
Expected Output
  • A hub knot with N choices, each gated by conditionals
  • N spoke knots, each with their own internal structure
  • Boolean VAR flags: VAR spoke1_done = false
  • Each spoke sets its flag and diverts back to the hub
  • Hub checks all flags and diverts to finale when all true

6. Time Cave

Pure branching — every choice leads deeper, no paths converge.

Template (copy this)
Write a time cave starting at [KNOT_NAME]. The scenario is [SITUATION]. Branch 3 times with 2 choices each, giving 8 unique endings. No paths should converge. Each ending should feel meaningfully different. Keep branches to [N] lines each. Every leaf ends with -> END.
Filled Example
Write a time cave starting at "first_contact". The scenario is humanity's first encounter with an alien signal. Branch 3 times with 2 choices each, giving 8 unique endings. No paths should converge. Each ending should feel meaningfully different. Keep branches to 4 lines each. Every leaf ends with -> END.
Expected Output
  • 1 + 2 + 4 + 8 = 15 total knots (or nested weave structure)
  • Exactly 2 choices at every non-leaf node
  • 8 endings, each with -> END
  • No gathers, no convergence, no shared knots
  • Each ending tonally distinct

7. Branch-and-Bottleneck

Branches fan out within an act, then converge at a bottleneck before the next act.

Template (copy this)
Write a 3-act branch-and-bottleneck. Act 1: [SETUP], Act 2: [CONFRONTATION], Act 3: [RESOLUTION]. Each act offers [N] choices that fan out, then converge at a bottleneck before the next act. Track VAR [KEY_VARIABLE] across acts so the bottleneck text reflects earlier choices.
Filled Example
Write a 3-act branch-and-bottleneck. Act 1: arriving at a haunted lighthouse, Act 2: confronting the ghost, Act 3: escaping or staying. Each act offers 3 choices that fan out, then converge at a bottleneck before the next act. Track VAR courage across acts so the bottleneck text reflects earlier choices.
Expected Output
  • Three clear act sections with labeled knots
  • N choices per act that modify a tracked variable
  • Bottleneck knots between acts with conditional text
  • Variable referenced in bottleneck: {courage > 2: ...}
  • Clean linear act flow: act1 -> bottleneck1 -> act2 -> bottleneck2 -> act3

8. Foldback

Multiple paths that all fold back to a single pivotal scene.

Template (copy this)
Write a foldback sequence for [SITUATION]. Offer [N] different paths the player can take, each in its own knot. All paths converge at [CONVERGENCE_KNOT]. Use an integer VAR [PATH_VAR] (set to 1, 2, or 3) to track which path was taken. The convergence text should meaningfully reference the path chosen using conditionals on the integer. Then divert to -> [NEXT_KNOT].
Filled Example
Write a foldback sequence for escaping a sinking ship. Offer 3 different paths the player can take, each in its own knot. All paths converge at lifeboat_launch. Use an integer VAR escape_route (set to 1 for engine room, 2 for upper deck, 3 for cargo hold) to track which path was taken. The convergence text should meaningfully reference the path chosen. Then divert to -> open_sea.
Expected Output
  • An initial choice knot with N options
  • N separate path knots, each setting the tracking variable to a different integer
  • All paths divert to the convergence knot
  • Convergence knot uses conditionals: {escape_route == 1: You came through the engine room...}
  • Single exit divert at the end

9. Parallel Paths

Two storylines the player can switch between at bridge points.

Template (copy this)
Write two parallel storylines: [PATH_A_NAME] following [CHARACTER_A] and [PATH_B_NAME] following [CHARACTER_B]. The player picks which to follow. At [N] bridge points, offer a choice to switch to the other path. Both paths eventually converge at [CONVERGENCE_KNOT]. Track which path the player spent more time on.
Filled Example
Write two parallel storylines: "surface_crew" following Captain Reyes and "dive_team" following Dr. Okonkwo. The player picks which to follow. At 2 bridge points, offer a choice to switch to the other path. Both paths eventually converge at discovery_chamber. Track which path the player spent more time on.
Expected Output
  • Two sets of sequential knots (path A and path B)
  • A tracking variable: VAR time_on_a = 0
  • Bridge knots offering "Switch to [other path]?" choices
  • Both paths reachable from bridge points
  • Convergence knot with conditional text based on time tracking

10. Loop-and-Grow

The player revisits a location that changes each time.

Template (copy this)
Write a loop-and-grow knot called [KNOT_NAME] set in [LOCATION]. The player revisits this location multiple times. Use sticky choices (+) that evolve. Track visits with a counter or LIST. On visit 1: [INITIAL_STATE]. On visit [N]: [EVOLVED_STATE]. After [MAX] visits or when [CONDITION], break out to -> [NEXT_KNOT].
Filled Example
Write a loop-and-grow knot called "garden" set in an abandoned rooftop garden. The player revisits this location multiple times. Use sticky choices (+) that evolve. Track visits with a counter or LIST. On visit 1: the garden is dead and overgrown. On visit 4: it's blooming and there's a bird nesting. After 5 visits or when the player finds the hidden key, break out to -> greenhouse.
Expected Output
  • A single knot that diverts to itself: -> knot_name
  • Visit counter: VAR visits = 0 incremented each loop
  • Sticky choices (+) with conditional text per visit
  • Description text that changes based on visit count
  • An escape condition that breaks the loop
Section 3 Iteration Prompts

You generated something. Now make it better. These prompts help you refine, expand, debug, and reshape AI output without starting over.

Expand a Branch

Template (copy this)
Take the [CHOICE_NAME] branch in [KNOT_NAME] and expand it into a full [SHAPE] shape. Keep the same entry variable state and exit divert.

Add State Tracking

Template (copy this)
Add a LIST called [NAME] = [VALUES] to this Ink code. Update it based on player choices at [DECISION_POINTS]. Add conditional text that references the list at [DISPLAY_POINTS].

Merge Two Sections

Template (copy this)
I have two Ink knots: [KNOT_A] and [KNOT_B]. Combine them into a single [SHAPE] where [KNOT_A] content and [KNOT_B] content interleave. Preserve all variable tracking.

Debug My Ink

Template (copy this)
This Ink code has a bug — [DESCRIBE SYMPTOM]. The code is: [PASTE CODE]. Find and fix the issue. Explain what was wrong.

Change the Tone

Template (copy this)
Rewrite this Ink passage in [NEW_TONE] tone while keeping the exact same structure, choices, and variable logic: [PASTE CODE]
Section 4 Vibe Authorship Workflow

The loop. Every piece of AI-generated Ink goes through this cycle at least once. Most go through it three or four times.

1. Pick a shape
2. Fill in the prompt template
3. Generate with AI
4. Paste into Inky
5. Play-test
6. Does it work?
Yes
Connect to story
No
Use iteration prompt
Back to step 3

Pro Tips

  1. Start with the shape, not the content. Structure first, prose second.
  2. Generate small pieces and connect them. Don't ask for a whole story at once.
  3. Always specify your variables and connection points. The AI can't guess your story's state.
  4. Play-test after every generation. Ink bugs compound fast.
  5. The AI is your writing partner, not your ghostwriter. Edit its output — add your voice.

Pause & Reflect

What changes when the AI writes your story? You just learned to generate Ink code with prompts. That means you could build a story in 20 minutes that used to take 2 hours. What do you do with the time you saved? Do you polish more? Explore more branches? Or do you notice something subtle — that the story feels different when you didn’t write every word? What’s the difference? Does it matter?

Where is the line between “vibe authoring” and “not writing at all”? There’s no trick answer here. Some people think directing an AI is creative work. Others think it’s delegation. You’re going to have to decide for yourself where the line is. What’s the minimum amount of your own words, your own choices, your own judgment that a story needs before it counts as yours?

Prompts are choices too. Look at the templates above. Each one asks you to fill in [PLACEHOLDERS]. Those placeholders are your creative decisions — the setting, the characters, the tracked variables, the tone. The AI fills in the middle, but you define the shape and the meaning. Is that enough? Is that more or less creative than writing every word yourself? What would you tell someone who says AI-generated fiction isn’t “real” writing?