---
name: game-design-brief
description: Turn a game idea ("add minesweeper", "make a game about X", "more games") into a one-page brief before any code - the one verb, what the player sees, how a run ends, the difficulty ramp, controls on keyboard / mouse / touch, scoring and best, every feedback moment (sound + visual), which kind of game it is on games.slopped.site (registry canvas, DOM table, standalone folder, own subsite), its name and deadpan copy, and measurable acceptance targets for the playtest bots. Use at the start of any new game or a big change to one, and when handing a game to a subagent (the brief is the hand-off).
---

# Game design brief

A game built from a one-line request comes out generic: "a fun game" averages every game the machine has seen, which is what pathway 3 of the Slop Curriculum teaches and what the Slopwright complains about. Write this brief first, in the conversation or in the subagent's prompt. It takes five minutes and decides everything the code would otherwise decide by default.

## The brief (fill every line)

```
Name:            plain or a dry pun; no trademarks (Blocks, not Tetris; Mines, not Minesweeper is fine either way)
One verb:        the single thing the player does (flap, steer, drop, swipe, match). If it needs two, pick one.
Pressure:        what makes the verb hard right now (a gap closing, a timer, the pile growing)
A run ends when: the fail state, or the win state for a puzzle; how long a first run lasts (target)
Ramp:            what rises with score/time, from what to what, and where it stops rising
Screen:          what's on it at a glance; what the player must read in under 1 s
Controls:        keyboard / mouse / touch, each one line. Touch is gestures on the canvas, not on-screen arrows.
Score & best:    what scores, what a good score is, what's saved (best, wins, fastest, today's)
Feedback:        every event → sound + visual (score, combo, near miss, fail, new best, level up)
Seed:            endless random, daily (YYYYMMDD), or shareable seed; how fairness is guaranteed (game-procgen)
Kind:            registry canvas | DOM table | standalone folder | own subsite (below)
Copy:            card subtitle (< 45 chars, deadpan), instructions (plain), touch instructions
Done when:       playtest targets (below) + phone screenshot looks right + check.mjs passes
Not doing:       what's out of scope this round (levels, online scores, accounts…)
```

## Which kind of game

| Kind | When | Where it lives |
| --- | --- | --- |
| **Registry canvas** | one screen, one verb, endless or short: Flappy, Snake, Stack, Blocks | an entry in `GAMES` in `games/public/games.js` (480×600 canvas, shared loop, HUD, bests, touch gestures). See `slopped-games` |
| **DOM table** | turn-based, lots of discrete things to tap, needs accessibility per item: Solitaire, FreeCell, puzzles | `table: '<id>'` + its own IIFE file (`cards.js`, `puzzles.js`) exposing one global |
| **Standalone folder** | its own menus, levels, controls schemes: SK8 2026 | `games/public/<name>/index.html` with a link back to `/` |
| **Own subsite** | its own world and identity, 3D, many assets: Backrooms | `slopped-subsite` checklist |

Pick the smallest kind that fits. Most ideas are registry games.

## Acceptance targets (measured, not felt)

From `game-playtest` (write the smart policy as part of the game):

- Idle player: no free points; at least 1.5 s before the first unavoidable threat (genre exceptions noted in `PLAYTEST_META`).
- Mashing: low score. The smart bot's median score is 5× the masher's or more.
- Smart bot: median run 30–90 s, and runs **end** (endless < 10% at 120 s).
- Every point scored makes a sound and a burst/floater (the audit checks).
- `update()` well under 1 ms.
- Phones: no sideways scroll at 390 px, nothing to aim at smaller than 42 px, works one-handed in portrait.
- Generated content is fair over many seeds (`game-procgen`).

Puzzles (tables) replace the run targets with: a solver or constructive guarantee that every deal/board is solvable (or say which aren't), and a first game finishable in a few minutes.

## Keeping the machine on the rails while building

- Give the brief, the kind, the files it may touch, and the files it must not (another agent's work, `reference/`). Uncommitted work can't be rolled back, so ask for small edits, not rewrites.
- Ask for the smart policy and the check results in the report, plus phone screenshots it has actually looked at.
- One verb at a time: get the core loop fun (playtest numbers), then add juice, then the ramp, then copy. A machine asked for "polish" first adds confetti.
- Things it will drift on unless told: trademarks in names, on-screen arrow buttons on phones, `Math.random()` inside a seeded generator, `100vh`, forgetting the main site's Games card and the counts.

## Example (illustrative: check games.js for what Blocks actually does)

```
Name: Blocks · One verb: drop (place a falling piece) · Pressure: the pile grows, gravity speeds up
A run ends when: a new piece can't spawn; first run ~1–2 min · Ramp: gravity per level (every 10 lines), capped
Screen: the well, the next piece, held piece, ghost · Controls: ←/→ move, ↑ rotate, ↓ soft drop, Space hard
drop, C hold | touch: drag to move, tap to rotate, swipe down to drop · Score: lines (1/2/3/4 → 100/300/500/800 × level)
Feedback: lock (thud), line clear (rising chime + row flash), 4 lines (bigger), level up (flash), top out (crash)
Seed: 7-bag random · Kind: registry canvas · Copy: "Lines go away. Nothing else does."
Done when: smart bot clears lines and eventually tops out; idle tops out; no free points
```