Przejdź do treści
Biblioteka skilli
Programowanie · Budowanie i kod

playable-prototype

/playable-prototype

Zamienia dokumenty projektu gry w grywalne prototypy w przeglądarce, z liczbami z projektu i wbudowanymi testami, i poprawia prototypy wyglądające generycznie.

Licencja
MIT
Ostatnia zmiana repozytorium
02.11.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
19
Skrypty
3
Komentarze HTML
0
Adresy URL w SKILL.md
1
Przestarzałość

Brak sygnałów. Repozytorium zmienione 02.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co sprawdzić przed instalacją
  • 3 skrypty w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.

Skrypty: scripts/check.py, scripts/play.py, scripts/slop_audit.py

Co robi i kiedy

Zamienia dokumenty projektu gry w grywalne prototypy w przeglądarce, z liczbami z projektu i wbudowanymi testami, i poprawia prototypy wyglądające generycznie.

Wyzwalacze z opisu

AI-made

Argumenty

/playable-prototype [design document path or one-pager]
Oryginalny opis (EN)

Turns game design documents into playable, testable browser prototypes, and fixes prototypes that look generic or "AI-made" (AI slop: landing-page title, app-like HUD, web fonts) so they look like real games. Produces a single-file HTML5 game whose numbers come straight from the design (cards, stats, curves, economy), with procedural placeholder art and sound, built-in self-tests (?test=1) including bots that play it start to finish, and automatic screenshots. Use when the user wants to prototype, greybox or make a design playable, build a vertical slice, test a core loop, share a playable dem

Jak działa

  1. Workflow
  2. If it looks AI-made: the swaps
  3. Output contract (every prototype)
  4. Principles
  5. References
Sekcje z nagłówków SKILL.md, w oryginale · 150 linii, 1 659 słów
Podgląd SKILL.md
---
name: playable-prototype
description: Turns game design documents into playable, testable browser prototypes, and fixes prototypes that look generic or "AI-made" (AI slop: landing-page title, app-like HUD, web fonts) so they look like real games. Produces a single-file HTML5 game whose numbers come straight from the design (cards, stats, curves, economy), with procedural placeholder art and sound, built-in self-tests (?test=1) including bots that play it start to finish, and automatic screenshots. Use when the user wants to prototype, greybox or make a design playable, build a vertical slice, test a core loop, share a playable demo, or build a quick game from a GDD, one-pager, beat list, card list or economy model. Includes pixel-art and 3D (three.js) templates. Hands production art and engine work to asset or engine tools. Also triggers on 프로토타입, 플레이 가능하게, 그레이박스, 데모 게임 만들기, AI가 만든 것 같다, AI 슬롭; プロトタイプ, 遊べる試作, グレーボックス, デモ版; 原型, 可玩原型, 灰盒, 做个试玩版; prototipo jugable, demo jugable.
argument-hint: "[design document path or one-pager]"
license: MIT
compatibility: Any agent that reads SKILL.md folders. Scripts need Python 3; check.py also needs a local Chrome, Chromium or Edge.
metadata:
  author: bunhine0452
  version: "1.11.0"
  repository: https://github.com/bunhine0452/ai-game-designer
---

# Playable prototype

Turn a design into something people can play in five minutes, and prove that it matches the
design. The goal is not a finished game. It's the **cheapest playable test of the design's
riskiest assumption**, built so the numbers can be trusted and the result can be shared as a link.

**Language (required):**
- Answer in the language of the user's latest message.
- In a non-English answer, write **every** technical term the first time it appears as the
  localized term plus the English term in parentheses, e.g. `그레이박스 (Greybox)`,
  `자체 테스트 (Self-test)`, `プロトタイプ (Prototype)`, `原型 (Prototype)`. After that, use the
  localized term alone.
- Standard terms are in `references/glossary.md` if bundled, or `../game-design/references/glossary.md`.
- Game UI text follows the design's language. Offer an English toggle when the audience is broader.

## Workflow

1. **Find the design inputs.** Collect the documents: the brief or one-pager (pillars, core
   loop, risks), beat lists, card, unit or tower tables, economy configs, progression tables.
   If there are none, run the `game-design` workflow first (a provisional brief is enough).
2. **Pick the scope from the design itself.** Build the test the design names as its riskiest
   assumption (e.g. "a 2-week greybox: 6×6 field, 3 monsters, 3 days"). Cut everything else.
   One core loop, one session's worth of content, a clear end state. See `references/design-to-code.md`.
3. **Copy numbers verbatim, with provenance.** Put tables in the code as data, with a comment
   naming the source file and version ("cards: tidecaller-starter-v3.csv"). Never "improve" a
   number silently. If a value is missing, choose one, mark it `// placeholder`, and list it in
   your answer.
4. **Start from the template.** Copy `assets/template.html` (or `template-pixel.html` /
   `template-3d.html`; see `references/3d-and-pixel-prototypes.md`). It already has the contract: a
   single state object, a seeded RNG, logic separate from UI, change-only DOM updates, and the
   `?test=1` / `?shot=1` hooks. Structure rules: `references/prototype-structure.md`.
5. **Make the pillars visible.** Every pillar becomes a mechanic or UI element you can point
   to (e.g. "no failure, only detours": crops pause instead of dying; "transparent odds": a
   Rates plaque one tap away, and the pity counter where the player decides). Show the pillar
   in play; never print the design's claims about itself ("no ads, no paid speed-ups"). Run the `design-review` ethics checks on any monetization
   in the prototype. Use free currency only, and don't simulate real-money purchases.
6. **Write the self-tests with the game,** not after it:
   - *fidelity*: formulas and tables equal the design numbers (e.g. "chapter 1 = 41.4 min");
   - *rules*: invariants of the core loop (crest at 10 resets to 5; prune refunds 80%);
   - *bots*: a simple policy plays the whole session to an end state, many seeds, no errors;
   - *balance probes*: report the bot's outcome (win rate, resources left) as information.
   Details and pitfalls: `references/testing-and-bots.md`.
7. **Make it look and feel like a game, not a dashboard or a web page.** Clear the
   presentation bar in `references/assets-and-feel.md` and the anti-slop checklist in
   `references/anti-slop.md` before you call it done. The usual failures are web defaults:
   a landing-page title (kicker, gradient headline, tagline, two buttons, footer), a top bar
   of icon buttons, designer notes on screen, middle-dot chains, stock fonts, system emoji.
   Replace each with a choice only this game would make. Then add art and sound that respect
   the art direction: procedural SVG/canvas shapes following the style guide's shape language
   and palette; WebAudio tones for key events; captions for every sound cue. For production
   art, hand off to asset tools (e.g. an image or canvas-design skill, an engine plugin).
8. **Verify, screenshot, share.**
   ```bash
   python3 scripts/check.py path/to/games/ --title --sheet   # self-tests, runtime errors, game + title shots, one contact sheet
   python3 scripts/check.py my-game/index.html --no-shot
   python3 scripts/slop_audit.py path/to/games/   # AI-look tells: no FAIL allowed
   ```
   It runs headless Chrome with a throwaway profile, reads `<pre id="selftest">`, saves
   `screenshots/<name>.png` from the `?shot=1` state (and `<name>-title.png` with `--title`),
   and fails if the page recorded an uncaught error while the screenshot state ran.
   With no interactive browser tool, play it through with real input instead:
   `python3 scripts/play.py game/index.html "wait 1; shot title; key Enter; click 640 400; key Escape; shot pause"`. Look at every screenshot before
   reporting, and screenshot the title screen too (`?shot=title`): that is where the
   generated look shows first. If the user wants a link, GitHub Pages serves the files as-is (add `.nojekyll`).
9. **Report:** what was built and the assumption it tests, the source of each number,
   placeholders, test results (with the bot outcomes), the screenshot, how to play, and the
   next playtest question with a pass criterion.

## If it looks AI-made: the swaps

When a build "looks generated", replace each web default with the game-native version
(details and examples in `references/anti-slop.md`):

| Web default (the tell) | Game-native replacement |
|---|---|
| Landing-page title: kicker, gradient headline, tagline, Start + Learn more, credit footer | The logo drawn into the world (painted, carved, stencilled, reflected) and a menu of verbs with a cursor; credits move to a Credits screen |
| Top bar with the game name and a row of icon buttons | No name in the HUD; one menu button plus Esc opens a pause menu (sound, language, speed, help, quit) |
| Designer notes on screen ("No ads", "12 min at 1x", formulas, "Demo speed") | Show the virtue in play; numbers stay in the doc and tests; dev controls go in the pause menu |
| Middle-dot chains, tricolon slogans, bilingual labels | Layout or a real sentence; the active language only |
| Stock web fonts, gradient text, glass panels, card grids | Type and materials from the setting; ledgers, manuals and objects from the world |
| System emoji, one face for every creature | Icons drawn in the game's line style; faces with a temperament |

Then verify: `scripts/slop_audit.py` (no FAIL) and `scripts/check.py --title`, and look at both
screenshots.

## Output contract (every prototype)

- One `index.html`, no build step, no external scripts (fonts optional). Works at phone width.
- An HTML comment at the top and a Credits screen naming the design document it implements.
  No header, footer or provenance line on the title or play screens.
- A title screen that is a game screen: the logo drawn into the world and a menu of verbs
  (start, how to play, settings or language, credits, leave), keyboard-focusable.
- `?test=1` writes JSON `{game, pass, results:[{name, pass, info}]}` into `<pre id="selftest">`
  and sets `document.title` to `SELFTEST PASS|FAIL`.
- `?test=1` includes the **anti-fun screen** that applies (`references/testing-and-bots.md`):
  beatable, not trivial, no dominant option, outcome in doubt, decisions and questions keep coming.
- `?shot=1` builds a deterministic, representative mid-game state for the screenshot, and
  `?shot=title` shows the title screen.
- A one-line error hook in `<head>` records uncaught errors as `<html data-error>` (the templates
  have it), and the frame loop clamps `dt` to `[0, max]`.
- Pixel-art prototypes keep the **pixel contract**: sprites drawn at native size, whole-pixel
  positions, integer upscaling and bitmap text. `?test=1` asserts that a drawn frame holds
  palette colours only. Audit the screenshot with
  `gdd-art-direction/scripts/pixel_audit.py audit` and fix every fail flag.
- Optional storage wrapped in try/catch; the game works without it.
- Screen-first layout: a fixed 16:9 stage scaled to fit the window, with the play space as the
  hero. No sidebar of stat text. Numbers live on the units, cards and diegetic gauges.
- One menu button plus Esc opens a pause menu (sound, language, speed, help, quit). No row of
  icon buttons, no game name in the HUD, no frosted-glass panels.
- On-screen copy passes `scripts/slop_audit.py`: no designer notes, formulas or pacing
  numbers, no middle-dot chains, one language at a time, no system emoji beside drawn art.
- Accessibility: keyboard and pointer input, captions for audio cues, a reduce-flashing option
  when anything flashes, readable text sizes, no color-only signals.

## Principles

- **Fidelity over flourish.** A prototype that quietly changes the design's numbers tests
  nothing. Show the numbers, cite them, test them.
- **The bot is your first playtester.** If a scripted player can't finish, a human won't. If
  it wins easily with no thought, the challenge is missing.
- **Decouple logic from the screen.** Game rules record outcomes (`pending = "reward"`), and
  the UI decides how to show them. That one rule makes bots and tests possible.
- **Original work only.** Prototype the user's design. Use reference games as lessons, never
  as assets, names or layouts to copy.
- **Fidelity is the floor, not the bar.** Correct numbers in a stat-dump UI still read as
  "terrible" to players. Ship one polished loop rather than six greyboxes.
- **Decide, don't default.** Every web default (hero section, pill, toggle, gradient text,
  stock font) reads as "nobody chose this". Pick type, materials and menus from the setting.
- **Playtest in a real browser.** Click through every screen with the mouse before you report.
  Headless tests and screenshots miss hover, timing and end-of-fight bugs.
- **Small and finished beats big and broken.** End the session cleanly (a win, a summary,
  "the demo ends here") so testers can say what they felt.

## References

- `references/design-to-code.md`: from documents to scope and data; genre starter patterns.
- `references/prototype-structure.md`: single-file architecture, state, rendering, input.
- `references/testing-and-bots.md`: self-test categories, bot design, real pitfalls found.
- `references/assets-and-feel.md`: procedural art, WebAudio, juice, captions, hand-off.
- `references/anti-slop.md`: why prototypes read as AI-generated, and what replaced each tell.
- `assets/template.html`: starter file with the full contract. `template-pixel.html` (integer-scaled
  pixel pipeline, native-size palette sprites, 3×5 bitmap font, pixel-contract test, BFS bot) and `template-3d.html` (pinned three.js, fixed-step
  simulation separate from rendering, draw-call budget test).
- `references/3d-and-pixel-prototypes.md`: pixel rendering pipeline and feel; three.js setup, physics, camera and headless WebGL tests.
- `scripts/check.py`: headless self-test runner and screenshotter.
- `scripts/slop_audit.py`: static check for AI-look tells (copy, chrome, fonts, emoji).
- `scripts/play.py`: real-input play-through in headless Chrome (clicks, keys, screenshots, GIF frames, assertions).
- `examples/README.md`: eight live prototypes built with this workflow (including a three.js game and a pixel-art puzzle), and what each demonstrates.
Pliki w paczce (19)
  • SKILL.md 12 KB
  • assets/template-3d.html 9 KB
  • assets/template-pixel.html 14 KB
  • assets/template.html 10 KB
  • examples/README.md 4 KB
  • examples/from-one-pager/moth-lantern.html 56 KB
  • examples/from-one-pager/one-pager.md 1 KB
  • examples/from-one-pager/report.md 4 KB
  • examples/polish/after.html 15 KB
  • examples/polish/before.html 3 KB
  • references/3d-and-pixel-prototypes.md 4 KB
  • references/anti-slop.md 12 KB
  • references/assets-and-feel.md 4 KB
  • references/design-to-code.md 4 KB
  • references/prototype-structure.md 4 KB
  • references/testing-and-bots.md 6 KB
  • scripts/check.py 11 KB
  • scripts/play.py 11 KB
  • scripts/slop_audit.py 17 KB

Wersje

W bazie nie ma innych skilli o nazwie playable-prototype.

Migawka bazy z 13.11.2026 · wersja paczki c942934b0cb9 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 91build-world
    Buduje grywalne prototypy gier 3D w three.js, Roblox, Unity lub Unreal i publikuje gotowe gry do zabawy w przeglądarce.
  • 100game-vibe-code
    Prowadzi agenta AI od pomysłu do grywalnej, sprawdzonej gry w przeglądarce, z jedną funkcją na iterację i zrzutami testów.
  • 100game-generalist
    Tworzy grywalny prototyp gry z jednego zdania: szkic do grania, stałą oprawę, testy botów i link do wypróbowania w przeglądarce lub silniku.
  • 100game-design
    Wskazuje właściwy krok projektowania gry: od pomysłu i pitchu, przez pętlę rozgrywki i tempo, po ekonomię i dokument projektu.
  • 96game-studio
    Koordynuje projekt gry: projekt, implementację silnika, grafikę, animację, dźwięk i kontrolę jakości opartą na dowodach.
  • 100video-game-forge
    Projektuje i buduje małe gry przeglądarkowe, których grafikę tworzą obrazy i klipy AI, z silnikiem sterowanym danymi gry.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.