Claude Game Studio

Claude game design skill

A Claude game design skill turns your idea into a written plan for the rules, a complete round and playtest checks.

Same brief, two games: one has a dash that depends on your load, the other makes heavy loads sway on cobblestones. Compare and play both Claude Code builds.

design-game v1.0.0 · By Claude Game Studio · CC0 1.0 · For Claude Code project skills

Install in your project

mkdir -p .claude/skills/design-game && test ! -e .claude/skills/design-game/SKILL.md && curl -fL https://claudegamestudio.com/downloads/design-game/SKILL.md -o .claude/skills/design-game/SKILL.md

Run this from your game's folder. It stops if the skill already exists. You can also download the text above and save it as .claude/skills/design-game/SKILL.md.

Open Claude Code in this project and paste:

/design-game Make a tiny browser game about delivering lanterns before the festival starts. Save the design before building.

One idea becomes rules

“Deliver lanterns before the festival starts” becomes a courier, three stalls, a gate, a carrying limit and a visible clock.

Carrying more slows the courier. Change the limit and deadline in the game below to see which trips still finish.

Editable rules demo

Lantern Run uses the same street and delivery goal in two rule sets. Start with constant speed, then switch to load and deadline. Try carrying one lantern with an 18-second round, then a 24-second round. Claude Game Studio authored both rule sets for this demo.

On the scripted route with a one-lantern limit, the courier delivered five of six before the 18-second deadline. With 24 seconds, the same route delivered all six in 21.1s. Use the longer round if you want the player to be able to finish with small trips.

One brief, two Claude Code games

On 20 November 2026, we gave Sonnet 5.5 the same six-lantern brief in two fresh Claude Code 2.1.329 projects. One used /design-game. The other used the brief alone. Both projects received the same build prompt after Claude saved their designs.

Claude Code build with the skill

Skill instruction · Connect requirements to rules. The design turns quick small trips into a dash the player can use only with a light load.

Dash (load ≤1 only) is a 0.4 s hop that clears a crowd. · Lantern Run design
The blue courier is airborne with one lantern as a crowd walker crosses the street below.
One lantern · The courier is halfway through a 0.4-second dash as a crowd walker crosses. With three lanterns, the same input showed Too heavy to dash!

Brief alone · Lantern Street

The design makes heavy trips faster overall but riskier at cobblestone patches. Standing still lets the sway meter fall.

A load of 3 needs to be at low sway before crossing. · Lantern Street design
At the first cobblestone patch, Dropped! appears over the courier and two carried lanterns remain.
Three lanterns · Entering the cobbles at high sway dropped one. After a one-second stop at the same spot, the courier entered with all three.

This was one run per setup. Each game timed out and restarted with an empty bag in the game-code checks. Download the exact prompts and test results.

The frames come from scripted checks of those same two games in Chromium. Download the inputs and measured outcomes.

Give Claude your idea

Replace the lantern idea in the command above with yours. Read the resulting design.md before asking it to write code. Keep your device, controls and scope in the request when they matter.

Anthropic's skills documentation describes the file as instructions and explains project discovery and slash commands. The Agent Skills specification defines its name, description and optional licence fields. This package is one readable text file; it installs no hooks, server or extra tools.

What to look for in the design

  1. The first view tells a player what they can move and where to go.
  2. The main action has a visible consequence, such as a heavier bag changing movement speed.
  3. The round says how to win, how to lose and what restart clears.
  4. The build checks describe real actions: collect at capacity, deliver the last lantern and restart after time runs out.
Read design.md and build the game it describes. Keep the rules editable. Play a full round, check win and loss, then restart from each. Report the actions you actually checked.

Connect the idea to mechanics

The skill tells the agent to Connect requirements to rules. Here is that instruction applied to the lantern brief. Each phrase earns a rule the player can see; the full filled design gives the coordinates, speeds and round settings.

Deliver lanterns

Collect at stalls, return to gate

Orange cargo travels with you; the delivered count rises at the gate.

Before the festival

A visible 18s or 24s deadline

The clock stops at victory or loss; the same route can be tried again.

A tiny browser game

One street, two directions

Keyboard and touch move the same courier; the whole round fits on one screen.

Read each column from the brief's words to a rule, then to feedback. These are design choices for this example.

A deadline changes viable trips

We ran a scripted courier through the actual game rules at 120 updates per simulated second. It moves right until full or all stalls are visited, returns to the gate and repeats. With three lanterns, load reduces speed from 200 to about 98 pixels per second. The following times describe that route, with no reaction time added.

  • Rules
    Constant speed
    Carry limit
    3
    Deadline
    None
    Delivered
    6/6 · Win
    Simulated time
    9.2s
  • Rules
    Load slows movement
    Carry limit
    1
    Deadline
    18s
    Delivered
    5/6 · Time up
    Simulated time
    18.0s
  • Rules
    Load slows movement
    Carry limit
    2
    Deadline
    18s
    Delivered
    5/6 · Time up
    Simulated time
    18.0s
  • Rules
    Load slows movement
    Carry limit
    3
    Deadline
    18s
    Delivered
    6/6 · Win
    Simulated time
    15.7s
  • Rules
    Load slows movement
    Carry limit
    1
    Deadline
    24s
    Delivered
    6/6 · Win
    Simulated time
    21.1s
Rule simulation, 20 November 2026. Open the exact results. The simulation uses the two authored rule sets above.

Check the shortcut and restart

The near-stall shortcut

A restock rule that refills every stall after every deposit lets the courier collect the nearest lantern six times. Our reproduction reaches the win state without visiting the other two stalls. The revised rule keeps collected stalls empty until the whole set has been delivered. That makes the rest of the street part of the round.

A finished round stays finished

The checks also execute movement after a win and after a timeout. Position, clock and cargo stay fixed. Restart creates new stock, empty hands, zero deliveries and zero elapsed time. Use the same checks after adjusting capacity or difficulty so a rule change does not quietly break the end of the round.

  • Observed behavior
    Refilling after every deposit skips two stalls.
    Change
    Wait for all three deliveries.
    Executed result
    The near stall stays empty after a one-lantern deposit.
  • Observed behavior
    One-lantern trips miss the 18s deadline.
    Change
    Give that route 24 seconds.
    Executed result
    Six delivered in 21.1s of simulation.

Have a finished brief? Choose a starter and assets from the Claude Game Studio kit, then give Claude Code your design.md. See the step-by-step build from a kit starter.

Read and edit the skill

This is the complete v1.0.0 download, published by Claude Game Studio on 18 November 2026. Edit the text to fit your engine, device and game. The CC0 licence covers this skill, Lantern Run's design and its demonstration source. Paid kit assets retain their own terms.

Complete SKILL.md
---
name: design-game
description: Turns a browser-game idea into a buildable design with a player decision, complete round, readable feedback and observable play checks. Use before building a small game or when a prototype has actions but no interesting choice.
license: CC0-1.0
compatibility: Designed for Claude Code project skills. Reads project files and writes design.md; building or browser testing is a separate task.
metadata:
  author: Claude Game Studio
  version: "1.0.0"
---

<objective>
Turn the user's idea into a small game someone can understand, finish and replay. Make design judgments yourself from the brief and existing project. Produce design.md before implementing code.
</objective>

<quick_start>
Read the supplied idea and the existing game, if any. Identify the player, device and desired feeling. If unspecified, use a short single-player browser round with keyboard and touch controls. Preserve explicit requirements. Ask only when a missing answer would change the core game.
</quick_start>

<process>
1. Find the player's decision. State the main verb and one choice with a cost the player can see. Explain why both choices can be reasonable. If a choice is always better, change its cost or reward. Theme alone is not a mechanic.
2. Define the complete round: initial view, controls, objective, repeated action, change in difficulty, win, loss and restart. Name what persists after restart. Make every promised input possible on the target device.
3. Connect requirements to rules. For each important phrase in the brief, write the mechanic it implies and the feedback that teaches it. Choose initial numbers with units; label them as design settings until measured. Work through one normal route and one edge case to check feasibility.
4. Cut scope to the smallest complete expression of that decision. Name the room, actors, assets and sounds actually needed. Read existing source and licensing before requesting replacements. Keep the first screen readable before adding detail.
5. Save design.md with premise, first second, verb/decision, loop, scope, look/sound and done-means checks. Add a short change table when revising an existing game. End with three observable checks covering a full round, an input/feedback edge case and restart. Run the game only when the user also asked to build or test; record what actually happened.
</process>

<pitfalls>
- A delivery game with constant speed and unlimited carrying makes returning early pointless. Consider load, expiry, hazards or limited stock; choose the cost that fits the brief.
- A sword game needs swing, hit and damage checks. Do not inherit magazine/reload checks from a shooter starter.
- Difficulty needs a readable warning and a possible response. An invisible timer or unavoidable hit does not teach a choice.
- Verify whether the round can actually be won before tuning its presentation. Preserve terminal states until restart.
</pitfalls>

<success_criteria>
The design preserves the user's idea, specifies an observable player decision and contains a complete playable round. Every number is a proposed setting or has an identified measurement. Existing work and licence constraints are respected. No fabricated playtest, user response, model cost or promised result. Report unrun checks plainly. Do not install packages, spend, publish or change permissions for a design-only request.
</success_criteria>

The file-copy check placed the exact download into a fresh project skill folder and confirmed its contents matched.

Questions

What is a Claude game design skill?

A Claude game design skill is a reusable set of instructions that turns an idea into a game's actions, rules and play checks. This download asks Claude Code to save design.md before building, including the player's decision, a complete round and restart behavior.

How do I install a Claude game design skill?

Save SKILL.md in .claude/skills/design-game/ inside your project. Start Claude Code in that project and type /design-game followed by your idea. The command on this page downloads the file and stops if one already exists at that path.

What licence covers this skill?

Claude Game Studio releases this standalone skill and the Lantern Run example under CC0 1.0, so you can copy, edit and use them commercially. Claude access and the paid game kit are separate.

Can I use this skill to develop a game?

Use it to define the game first. After reviewing design.md, ask Claude Code to build that design and check a complete round. The skill itself contains text instructions; the browser game below is a separate worked example you can play and edit.