gamedev-skills/awesome-gamedev-agent-skills

prototype-fast

Builds a throwaway playable prototype in about an hour to answer one question, usually "is this mechanic fun?": a one-question brief, a greybox, a debug HUD, a playtest and a keep, kill or retune call.

소스 보기

사용 방법

  1. 설치 명령을 복사하고 자신의 에이전트 환경에 설치하기 전에 소스 패키지를 확인하세요.
  2. 필요한 도구, 인증 정보, 지원 환경은 원본 문서에서 확인하세요.
  3. 입력과 원하는 산출물을 설명하고 출처와 결과를 대조하세요.
npx skills add https://github.com/gamedev-skills/awesome-gamedev-agent-skills --skill prototype-fast

시작 전 확인

  • 설치에는 모델 구독, API 한도, 파일 접근 권한이 포함되지 않습니다.
  • 별점 수와 설치 수는 활동 지표이며 독립적인 품질·보안 검증이 아닙니다.
원본 Skill 문서

원본 저장소의 제목, 예시, 코드, 표, 링크, 이미지를 유지해 표시합니다.

Prototype Fast

Get a mechanic playable fast to learn whether it is worth building. The output is a decision (keep, kill or retune) written down in the repo, not a product. The agent writes the brief, builds the smallest thing that answers it, instruments it, and asks the user to play; the user's report decides.

When to use

  • Validating one mechanic or "what if", a quick slice of one interaction, or de-risking an idea

before committing real time.

Not for: a jam with a deadline and submission (game-jam); level layout and blockout (level-design); shipping (steam-publish, itch-publish); the production build of a validated feature (engine or genre skill).

Workflow

  1. Write the brief first to prototypes/<idea>/BRIEF.md (Pattern 1) and confirm it with the

user: one question, the core verb, keep and kill signals, a timebox. Two questions means two prototypes; one that tests everything decides nothing.

  1. Default to throwaway. Hard-code values, one file is fine, no architecture. Choose "keep"

structure only when the user says the code will grow, because prototypes that pretend to be production code rot into the shipping codebase.

  1. Contain it. Build in prototypes/<idea>/ (a separate project or folder the main game

never imports) or on a throwaway branch.

  1. Greybox everything but the verb. Boxes, circles, capsules, the engine's default font,

no audio or one debug beep. Spend nothing on what the question does not depend on.

  1. Instrument the question. Draw a debug HUD with the values being judged (speed, jump

height, timing window, time to first success) and expose the tuning values as named constants at the top of the file, so a retune is a one-line change.

  1. Run it yourself first (Verify), then ask the user to play without explanation and

report: did they do the core verb unprompted, how long it took, did they replay, what felt off. If someone else can play, ask the user to watch them and report the same.

  1. Make the call against the brief and append it to BRIEF.md: keep (schedule a rewrite in

the real project), kill (one line on what was learned), or retune (change one constant and play again).

Patterns

1. BRIEF.md

text
QUESTION:   The one thing this must prove, ideally yes/no.
CORE VERB:  The single action the player repeats.
THROWAWAY:  yes (default) | no, because ...
TIMEBOX:    e.g. 60 min; stop when it ends, even if unfinished.
KEEP IF:    observable signal (see Pattern 3).
KILL IF:    observable signal.
RESULT:     <date> keep | kill | retune - evidence from the playtest

2. Only the verb is real (engine-neutral pseudocode)

text
const RUN_SPEED = 8.0, JUMP_VELOCITY = 12.0, GRAB_WINDOW = 0.15   # tune here

on update(dt):
    read_input()
    apply_core_mechanic(dt)                  # the only thing being tested
    draw_box(player)                         # a box, not a sprite
    draw_debug_hud(speed, airtime, window_hits, time_to_first_success)
    # enemies, menus, saves, audio, art: stubbed or absent

3. Keep, kill or retune

text
KEEP when, with placeholder art:
  - a fresh player does the core verb on purpose within about 30 s, unprompted, and
  - they replay the loop without being asked.
KILL when:
  - the verb only feels good after it is explained, or
  - making it fun needs systems far beyond the prototype, or
  - art or levels are being added to avoid admitting the verb is flat.
RETUNE when one value is clearly off (too slow, window too tight): change it, play again.

Verify

Run these yourself before handing the prototype to the user:

  1. It launches from the command line (the engine's run or headless command, or a local web

server on 127.0.0.1) with no errors in the log or console.

  1. The loop completes: start, perform the verb, succeed or fail, restart. Drive it with a

scripted input or a short automated run where the engine allows; otherwise play it once.

  1. The debug HUD shows the values named in the brief and they change as expected.
  2. git status (or a search for imports) shows nothing outside prototypes/<idea>/ changed

and the main game does not import it.

  1. BRIEF.md has a RESULT line after the user's playtest.

Gotchas

  • Polishing too early. Art, menus and audio make a flat verb look finished and delay the

verdict.

  • No kill criteria. Without a written "kill if", every prototype "has potential" and nothing

is cut. Decide the signal before anyone is attached to the code.

  • Building systems instead of the mechanic. Inventory, saves and settings are not the

question. Stub them.

  • The spike becomes the product. A keep authorizes a rewrite in the real project, not a

copy-paste of prototype code and its assumptions.

  • Prototyping inside the real codebase. It tangles experiments with shipping systems and

makes the spike expensive to delete.

  • Only the author playtests. The author knows the controls and the intent. One uncoached

player reveals more in two minutes than an hour of self-play, so always ask the user for a report rather than judging it yourself.

Related skills

  • game-jam: the same scope discipline under a deadline with a submission.
  • level-design: when the question is about a level's layout rather than a mechanic.
  • game-feel: juice, only after the verb is proven.
  • Engine cores (godot-gdscript, phaser-core, love2d-core, unity-csharp-scripting, ...)

for the greybox itself and for the rewrite after a keep.

같은 저장소의 Skills

더 많은 Skills

모든 Skills
gamedev-skills
커뮤니티

game-ui-ux

Engine-neutral design rules for game HUDs and menus: anchors and containers, scaling, safe areas, gamepad focus, HUDs driven by events instead of polling, and accessibility minimums. Use for menus, health bars or inventory screens that break on ultrawide or phones. Pair with godot-ui-control or roblox-ui. Not for button juice (game-feel) or rebinding (input-systems).

24시간 설치 수
433
GitHub Stars
1만
업데이트
11월 12일
gamedev-skills
커뮤니티

game-feel

Adds engine-neutral juice to a working mechanic: trauma-based screen shake, hit-stop, eased tweens, squash and stretch, and knockback. Use when the game feels flat, weightless or not punchy, or hits and jumps should feel satisfying. Not for coyote time (platformer), input buffering (input-systems), camera follow (camera-systems) or HUD layout (game-ui-ux).

24시간 설치 수
431
GitHub Stars
1만
업데이트
11월 12일
gamedev-skills
커뮤니티

create-game-assets

Plans, generates or sources, and validates consistent game art: style guides, sprites, pixel art, tilesets, icons and textures, with QA and licence records. Use when making or AI-generating game art, fixing fake transparency, or checking Steam AI disclosure. Not for engine import (godot-tilemap, godot-animation, unity-tilemap-2d), UI layout (game-ui-ux) or sound (audio-design).

24시간 설치 수
365
GitHub Stars
1만
업데이트
11월 12일
gamedev-skills
커뮤니티

performance-optimization

Finds and fixes game frame-rate problems by measurement in Godot, Unity, Unreal or Roblox: CPU- vs GPU-bound, then the biggest fix (draw calls, pooling, GC spikes). Use for low FPS, stutter, a first-use hitch, or requests to optimize or profile. Not for build size (unity-build-size), physics jitter (physics-tuning) or network lag (roblox-networking, godot-multiplayer).

24시간 설치 수
360
GitHub Stars
1만
업데이트
11월 12일