How to use the Game Concept Prototype agent skill (prototype)

What is an agent skill and what does this one do?

An agent skill is a folder of instructions and supporting files that an AI agent loads when you ask for a particular task. This skill covers one task: testing a game concept with a quick prototype. It is meant to run right after the /brainstorm and /setup-engine steps of the wider studio framework, and before you write game design documents (GDDs) or architecture docs.

The agent does the work itself. It sharpens the single question your idea needs to answer, loads the existing concept context, picks a prototype style, plans and builds a small test, debriefs the result, and gives a verdict: PROCEED, PIVOT, KILL or NOT ASSESSED. Because the agent writes the prototype code, the skill covers the whole prototype cycle rather than only answering questions about game design.

• Phase 1: define the question the prototype must answer
• Phase 2: load concept context from the project's game concept or game brief
• Phase 3: choose a path: HTML (browser-playable), Engine (engine project) or Paper (rules document and play log)
• Phase 4 to 6: plan, implement and run a playtest debrief
• Phase 7 to 9: write a prototype report, run a Creative Director review and summarise next steps

How do you install the prototype skill?

Download the ZIP of the skill from the directory page. Unzip it into either your user skills folder, ~/.claude/skills/, or a project's .claude/skills/ folder if you want the skill available only in that project. The folder must be named prototype so the skill can be found.

If you use the Claude apps instead of Claude Code, upload the ZIP there under Settings, then Capabilities, then Skills.

• User-wide: ~/.claude/skills/
• Single project: the project's .claude/skills/ folder
• Claude apps: Settings → Capabilities → Skills, then upload the ZIP

What does the skill need before it runs?

The skill needs an agent that can read files, write files and run the bash helper it lists. In Claude Code that means the agent must be allowed to run that helper. The skill also expects the project's .claude/hooks/yaml-helper.sh and its config files from the surrounding studio framework. That framework is not included in this skill folder, and the skill refers to /brainstorm and /setup-engine, which you must have separately.

For the engine path you also need a game engine. The skill files do not name which engine to use.

• Claude Code or another agent that can read and write files and run bash
• The project's .claude/hooks/yaml-helper.sh and config files from the studio framework
• The /brainstorm and /setup-engine steps, which are not in this skill folder
• A game engine, only if you choose the Engine path

How do you start a prototype session?

Start a session by typing /prototype followed by a short description of your concept. You can add optional flags to set the path, the review depth or spike mode. The skill's argument hint lists these flags.

Before building anything, the skill asks you how you want to use the session. Its first phase checks for an earlier PIVOT-NOTE.md for the same concept and, if one exists, starts from its revised hypothesis instead of a fresh one. It also reads your concept document, either design/gdd/game-concept.md or design/game-brief.md, to find the core fantasy and core loop.

• /prototype [concept-description]
• --path html|engine|paper chooses the prototype path
• --review full|lean|solo sets how much review runs
• --spike runs a lightweight mid-production spike

What kinds of prompts work well?

Name one mechanic and the question it should answer. The skill is built around testing a single mechanic, so a narrow question gives a more useful verdict than a whole game pitch. If you already know the path you want, pass it with --path. The skill's path guide suggests the Engine path for platformers, racing and shooters, where feel is the thing being tested, and HTML or Paper for logic puzzles, where timing matters less.

• Good: /prototype grappling hook movement, does swinging feel satisfying? --path engine
• Good: /prototype deck-building combat turn order --path paper
• Weaker: /prototype my whole open-world RPG, which tests too many things at once

What are the safety and scope limits?

The skill runs scripts, through the bash helper that resolves project settings, but the files do not show it making network calls. The skill is set to use no network. Its rules keep prototypes isolated: prototype code must never import from production source files, production code must never import from prototype directories, and if the verdict is PROCEED, production code is written from scratch rather than refactored from the prototype.

Effort is hard-capped at one day. If the engine work stalls for two hours, the skill tells the agent to reframe the question or switch paths. If the same concept gets a third PIVOT, the skill forces a KILL decision.

• Scripts: yes, via the listed bash helper
• Network: no
• Prototype code is throwaway and must not be merged into production
• Local prototypes cannot show how network latency changes feel; use real peers or latency simulation to test that

Tips for getting useful verdicts

Keep the scope to one mechanic and skip menus, game over screens, music and UI unless the UI is the mechanic itself. The skill's own rules say no polish. Consider building two or three different concept variants and comparing them, since the skill notes this usually beats iterating on one concept until it works or fails.

Use the spike mode for mid-production checks of a risky mechanic. It is a lightweight build with no GDD prerequisites and no phase gate implications.

• Write the question as something the playtest can answer yes or no
• Compare variants rather than polishing one
• Use --spike for a quick mid-production check
• Do not treat a local prototype as proof that a networked mechanic feels good