Recover the Project, Verify Its Baseline, Then Extend It Safely

A source-first workflow for inspecting an unfinished game prototype, restoring a reproducible baseline and planning a small playable continuation with AI assistance.

Seele Editorial TeamUpdated November 17, 2026

Recover a trustworthy project baseline

An unfinished prototype can contain useful systems alongside missing assets, broken launch instructions or unclear ownership. Start by confirming which repository and branch are the intended handoff, who owns the project, and whether its license permits continued work. Record the engine version, dependency lockfiles, build scripts, entry scene and target platform before modifying anything.

Use a read-only first pass. List project files, scenes, scripts, assets and configuration; locate TODO markers and launch errors; distinguish observations from guesses. A missing dependency is not proof that the source is broken, and a scene file that looks complete is not proof that it launches. If there is no known-good build, state that the baseline is unverified.

Make a clean copy or branch before changing files. Write down the exact setup and launch steps, then try them in the intended environment. Record command output, errors and version information. The fictional Mosslight example assumes a small 2D adventure source tree with an unfinished second room; these details illustrate a workflow and are not observations from a real repository.

A developer reviews an unfinished game project folder beside a simple adventure scene sketch.
Start with source ownership, project inventory and a reproducible baseline.

Continue with a small, reviewable playable target

Define continuation as one reachable end-to-end path, not a promise to finish every planned system. For Mosslight, the proposed target is to launch the first room, collect a glow seed, open a vine gate, enter a second room and reach a marked exit. Before implementation, ask the project owner to confirm that the controls and seed-gate rule match the intended design.

Separate blockers from optional improvements. A missing asset path or startup error may block a build; a new crafting system does not. Fix one confirmed blocker at a time, keep edits small, and preserve unrelated scenes and art. Ask an AI assistant to cite file paths and show a diff. If files do not match the inventory or an edit crosses the agreed boundary, stop and request clarification.

Once the baseline launches, use a short continuation plan: restore the entry route; make one missing interaction explicit; connect the second room; add one clear completion marker; then review the diff. The old room remains the regression reference. Avoid adding combat, save migration, procedural maps or multiple endings until the narrow path is understood.

A two-room adventure map links a starting chamber through a vine gate to a marked exit.
A narrow continuation makes the player route explicit and reviewable.

Trace the example

The handoff starts with a file inventory and project-owner confirmation, followed by a clean baseline copy. If launch is impossible, the documented output becomes a blocker report rather than a fabricated success story.

After a reproducible launch exists, record the known controls and interaction rules. The planned Mosslight continuation reuses those controls to connect one second room, one seed-gated passage and one exit marker. This keeps the target small enough to review as a single path.

A future build review should capture startup instructions, the entry scene, seed count before and after the gate, room transition and completion route. These are evidence to collect later. No project source, implementation, build or playtest has been supplied for this article.

A developer compares a clean project backup with a short connected adventure route on paper.
The desired handoff is a traceable change and a route ready for future verification.

Write the six prompts

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

Prompt 1: inventory source without edits

Inspect this supplied project without editing files. Identify repository/branch context, engine version, dependency files, entry scene, build and launch instructions, scripts, assets, TODOs and known errors. Cite paths and command output. Label uncertain details unknown.

Prompt 2: establish a verified baseline

Create a baseline report from the supplied source. Separate confirmed launch behavior from inferred design intent. List blockers, missing files, ownership questions and setup steps; do not claim the project runs unless a build was actually launched.

Prompt 3: propose a bounded continuation

Propose one minimal continuation path using existing controls and systems. State the intended player route, the files likely involved, assumptions needing owner confirmation and features explicitly out of scope.

Prompt 4: fix one confirmed blocker

Resolve only the confirmed startup blocker described here: [insert verified error]. Preserve unrelated scenes and assets. Before editing, explain the smallest patch; then show the diff and stop if the source differs from the inventory.

Prompt 5: extend the existing route

Connect one additional room to the verified entry route using existing movement and interaction rules. Keep a clean baseline copy, avoid unrelated refactors, and summarize changed files and behavior.

Prompt 6: prepare future verification

Write a future verification checklist for launch, original room, interaction, room transition, completion marker and restart. State the evidence to capture. Do not mark checks passed without running the build and observing them.

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

Prepare future build checks

A continuation is ready for human review only when the source baseline and the change are traceable. These future checks are proposed evidence, not 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 identityOwner, repository/branch, engine and license context are confirmedHandoff notes and project version
BaselineSetup and launch steps are reproducible or blockers are documentedCommand, environment and output
Patch scopeOnly approved files and behavior changedDiff against clean copy
Playable routeEntry, existing interaction, new room and exit form one pathObserved route and state changes
Regression/restartOriginal area still works and restart reaches documented startFresh launch observations

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

What should I check before continuing an unfinished game prototype?

Confirm project ownership and version, inventory dependencies and entry points, then establish a reproducible launch baseline or record blockers.

Should AI rewrite the prototype before it is understood?

No. Begin with read-only inspection and a clean copy; ask for file-cited observations before approving a small change.

How large should the first continuation target be?

Choose one end-to-end player route that reuses existing systems and can be reviewed as a bounded change.

Was the Mosslight project built or tested?

No. Mosslight is fictional. No source repository, implementation, build or playtest is claimed.

What if the project cannot be launched?

Record the environment, exact setup steps and observed error, then resolve a confirmed blocker or request the missing owner context.

SEELE AI

Turn this guide into a playable build.

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

Start creating