Keep the Core Loop, Then Grow One Playable Slice at a Time

A practical workflow for inventorying a game jam build, protecting its core loop and using AI prompts to expand it into a coherent indie-game prototype.

Seele Editorial TeamUpdated November 17, 2026

Inventory the jam build before changing it

An existing game jam build has constraints worth preserving: its control feel, working interactions, assets, and the small loop that made the game playable. Before asking an AI tool to add content, write down what the build actually contains. The example here, Lantern Run, is fictional: one top-down room, movement, an interact action, one lantern cell, one gate and an exit. It is a planning model, not a supplied or tested project.

Create an inventory with four columns: confirmed working behavior, existing content, known defects, and unknowns. Mark unknowns instead of treating assumptions as facts. Capture the engine and project version, startup route, input map, scene or level boundaries, asset ownership, and any build instructions that are available. If no source or playable build is available, say so and use the inventory as a request list for the project owner.

Freeze the core loop in one sentence. For Lantern Run: move through a room, find the cell, use it to open the gate, and reach the exit. Keep this sentence as a scope test. A proposed change belongs in the first expansion slice only if it strengthens that loop or gives the player a clear reason to repeat it.

A small top-down adventure prototype is sketched beside a game controller and development notebook.
Begin with a clear record of the jam build and its original playable loop.

Choose a vertical slice that protects the original loop

A vertical slice is a small, end-to-end sample of the intended game, not a pile of disconnected features. For the fictional Lantern Run plan, the slice contains two connected rooms, one locked route, one optional cache, and a return to the exit. It reuses movement and interaction while adding one new obstacle: a timed light bridge that uses the existing lantern resource.

Set explicit limits before implementation: two rooms, one new obstacle, one reusable room template, and no inventory overhaul, combat system, dialogue tree, or multiplayer. These exclusions protect the jam build from growing in several directions at once. Keep the old room as a regression reference and preserve its original route through the exit.

Split work into small changes that can be reviewed in isolation: document the current loop; add the second room connection; add the light bridge using the existing interaction; add the optional cache; then tune signage and pacing. After each change, compare the old room and the new route against the inventory. If an AI-generated edit replaces controls or unrelated scenes, revert that change and restate the boundary.

A two-room top-down level sketch connects an original gate to a new light bridge and optional cache.
A bounded slice extends the route while reusing the original gate and resource.

Trace the example

The example starts from a known specification rather than an asserted project state. A first planning pass confirms that the build or its source is available and records how to launch it. If neither is available, the first deliverable is a project handoff checklist, not a fabricated reconstruction.

Next, preserve a clean baseline and make the new route additive: the original room remains accessible, the new room connects through the existing gate interaction, and the timed bridge consumes the same lantern cell. The optional cache is placed off the critical path, so the player can still finish without finding it.

For a future playable check, record the baseline route, the new route, the resource count before and after the bridge, restart behavior, and any existing controls that changed. These are proposed evidence fields only. No implementation, build, run, or playtest has been performed for Lantern Run.

A developer compares an original single-room prototype map with a connected two-room expansion plan.
The planned outcome is a small additive slice; a real build still needs review and playtesting.

Write the six prompts

Use one prompt per design decision so later checks have a clear source of truth. These drafts describe Lantern Run; they have not been run and do not represent a generated playable game.

Prompt 1: inventory the supplied build

Inspect the supplied game jam project without editing it. Report the engine/version, launch path, scenes or levels, input bindings, interaction code, assets, known defects and unknowns. Cite file paths for each observation. If a detail cannot be confirmed, label it unknown; do not invent a working behavior.

Prompt 2: preserve the original loop

Summarize only the existing playable loop in one sentence. List the controls and resources it uses, and name the files or scenes that implement them. Do not add new mechanics or rename controls.

Prompt 3: bound the vertical slice

Propose one vertical slice that preserves the existing loop. Limit it to two connected rooms, one new obstacle, one optional reward and one reusable content pattern. List excluded features and explain how the original route remains available.

Prompt 4: plan additive edits

Plan the slice as small additive edits. For each edit, name likely files, behavior to change, behavior to leave untouched, and a manual check. Do not overwrite the project or unrelated scenes; ask for missing context before editing.

Prompt 5: implement one approved change

Implement only the approved obstacle using existing movement, interaction and resource rules. Show a concise diff, keep the old route intact, and stop if the project structure differs from the supplied inventory.

Prompt 6: prepare future regression checks

Prepare a future regression checklist for launch, movement, original gate, new route, resource use, optional reward and restart. Record expected observations without claiming they passed. Flag any check that needs a real build or human playtest.

SEELE’s official page describes general plain-English prompting, a playable first version, browser testing and refinement; it does not verify Lantern Run. See Free AI game maker for workflow context only.

Prepare future build checks

Use the original jam loop as a baseline and check the expansion route against the written scope. The list below defines evidence to collect from a future build; it does not describe completed tests. These are future checks, not passed tests. Record the before and after state so a later build can be compared with the specification.

Future checkExpected ruleEvidence to capture
Project inventoryObserved project details have file or build evidence; unknowns remain labeledEngine/version, launch path, controls, scene paths and defects
Baseline loopOriginal movement, cell, gate and exit remain reachableBefore/after route and resource state
Scope boundarySlice stays within two rooms, one obstacle and one optional cacheRoom list and approved change log
Resource useNew bridge follows the agreed lantern-cell ruleResource count before and after interaction
Restart and regressionRestart returns to the documented start and original route still worksFresh run observation and control comparison

No real game run, browser test or measured result is available for this fictional example. The illustrations are original concept art and are not screenshots.

Frequently asked questions

Can AI expand a game jam build without changing its core loop?

It can help plan bounded edits, but the project owner must verify the supplied source and review each change against the written baseline.

What should be documented before expanding a jam prototype?

Record confirmed behaviors, controls, scenes, assets, known defects and unknowns, with file or build evidence where available.

What is a vertical slice for a small indie game?

It is a limited end-to-end sample that demonstrates the intended loop with a small amount of representative content.

Was Lantern Run built or playtested for this guide?

No. Lantern Run is a fictional planning example. No source project, playable build, implementation or playtest is claimed.

Why keep the original jam room?

It provides a baseline for checking whether new content preserves the controls and loop that already worked.

SEELE AI

Turn this guide into a playable build.

Start with a focused brief, then iterate in the Seele AI Workspace.

Start creating