Game Design Prototyping Companion

Track game design prototype ideas, branching outcomes, dead ends, baselines, and next experiments, and optionally generate a simple SVG visualization of prot...

Security Scan

The skill's files and runtime instructions match its stated purpose (recording prototype nodes and optionally rendering a local SVG); there are no hidden network calls or unexplained credential requests.

Purpose & Capability

The name/description ask for prototype logs and optional SVG visualization; included references, example JSON, and a renderer script all directly support that purpose. There are no unrelated credentials, binaries, or config paths requested.

Instruction Scope

SKILL.md confines actions to producing structured prototype data and, if requested, writing a JSON file and running the bundled script to render an SVG. The instructions do not request reading unrelated system files, environment variables, or sending data to external endpoints.

Install Mechanism

This is an instruction-only skill with no install spec (low risk). The packaged renderer is a Python script that reads JSON and writes an SVG; the skill does not declare the Python interpreter as a required binary or provide a shebang. Users or the agent will need a Python runtime available to execute the script.

Credentials

No environment variables, credentials, or config paths are requested. The script only reads the provided JSON input path and writes the SVG output path.

Persistence & Privilege

The skill is not forced-always and does not request persistent privileges or modify other skills. It only writes an output SVG file when run, which is expected behavior for its purpose.

Assessment

This skill appears coherent and benign. Before installing or running it: 1) ensure the agent environment has a Python runtime available (the skill's script expects to be invoked but the SKILL.md doesn't declare 'python'), 2) run the renderer (scripts/branch_map_svg.py) on JSON you create or review first — it reads whatever input path you give and will write the specified output.svg locally, so avoid passing sensitive filesystem paths, and 3) verify the produced SVG before sharing externally. If you plan to allow autonomous invocation, be aware the agent could run the script on any file it has access to, so restrict agent filesystem permissions or only permit runs with vetted JSON inputs.

Track prototype evolution, not just prototype results.

Use this skill when prototyping produces branching decisions, dead ends, alternative paths, and backtracking. The aim is to preserve learning structure: what was tested, what was learned, what branch it created, which path was followed, and which paths remain available to revisit.

This skill can also generate a simple SVG branch map from a lightweight text or JSON structure.

What to produce

Generate one or more of these outputs:

1. Prototype log - what was tested and why
2. Branch record - what paths emerged from the result
3. Decision state - which branch is current, parked, dead, baseline, or promising
4. Backtrack notes - what can be revisited later and under what condition
5. SVG branch map - a visual map of prototype evolution

Core principle

A prototype is not just a yes/no answer. It often creates a tree:

• one branch becomes the current path
• another becomes a dead end
• another becomes a parked idea worth revisiting later
• another reveals a stronger question than the original one

The skill should preserve that tree.

Workflow

1. Define the prototype node

For each prototype node, record:

• Node ID
• Prototype name
• Question being tested
• What was built or simulated
• What was learned
• Result state

Use result states such as:

• baseline
• promising
• branch trigger
• dead end
• parked
• production candidate

2. Record branch options

When a prototype produces several next moves, capture each branch explicitly.

For each branch, record:

• Branch ID
• Parent node
• New idea or variation
• Reason it exists
• Current status

3. Mark the chosen path without deleting the others

Do not treat the selected branch as the only meaningful output. Preserve:

• abandoned paths
• deferred paths
• weird side paths
• stronger substitute ideas revealed by the test

4. Add backtrack logic

If a branch is not chosen now, record:

• what would justify revisiting it
• what blocker currently prevents it
• what later discovery might make it relevant again

5. Generate a visual map when useful

Use scripts/branch_map_svg.py to render a simple SVG from a branch-map JSON file.

Read:

• references/branch-map-format.md for the input structure
• references/example-branch-map.json for an example

Response structure

Use this structure unless the user asks for something else:

Prototype Node

• Node ID: ...
• Question: ...
• Built / simulated: ...
• Learned: ...
• State: ...

Branches Created

1. ...
2. ...
3. ...

Current Chosen Path

• ...

Parked / Revisit Later

• ...

Suggested Next Prototype

• ...

Visualization workflow

When the user wants a visual branch map:

1. write the branch data to JSON using the format in references/branch-map-format.md
2. run scripts/branch_map_svg.py <input.json> <output.svg>
3. return the SVG path and summarize what the map shows

Style rules

• Preserve branching history.
• Prefer explicit node IDs over vague prose.
• Distinguish clearly between what was learned and what was merely assumed.
• Do not erase dead ends; label them.
• Do not confuse the current path with the best possible path forever.

References

• references/branch-map-format.md for the JSON structure
• references/example-branch-map.json for a starter example
• references/state-labels.md for recommended branch/node labels

Working principle

Prototype trees are design memory. If you only remember the path you chose, you lose the intelligence of the paths you rejected.