@ericrisco/rsc 0.1.35 → 0.1.36

package/README.md

@@ -12,7 +12,7 @@
   ██    ██   ███████     ███████ 
 ```
 
-# `rsc` — 231 agent skills, one CLI, zero bloat
+# `rsc` — 242 agent skills, one CLI, zero bloat
 
 **A self-recommending skill catalog for 17 coding assistants** — Claude Code,
 Codex, GitHub Copilot, Cursor, Gemini, Windsurf, Cline, Antigravity, Zed and more.
@@ -243,7 +243,7 @@ just asks in plain language.
 
 ## The catalog
 
-232 skills, grouped by what you're trying to do. Click any skill to read its
+243 skills, grouped by what you're trying to do. Click any skill to read its
 `SKILL.md`. It fires on its own when a task matches.
 
 ### 🧭 Core & control plane
@@ -326,6 +326,12 @@ Each with a `02-DOCS` feedback loop that learns from your own results. `remotion
 
 [fastapi](skills/fastapi/) · [nextjs](skills/nextjs/) · [react](skills/react/) · [react-native](skills/react-native/) · [vue-nuxt](skills/vue-nuxt/) · [angular](skills/angular/) · [svelte](skills/svelte/) · [astro](skills/astro/) · [solid-js](skills/solid-js/) · [htmx](skills/htmx/) · [nodejs](skills/nodejs/) · [nestjs](skills/nestjs/) · [django](skills/django/) · [laravel](skills/laravel/) · [rails](skills/rails/) · [spring-boot](skills/spring-boot/) · [phoenix](skills/phoenix/) · [flutter](skills/flutter/) · [swift-ios](skills/swift-ios/) · [kotlin-android](skills/kotlin-android/) · [compose-multiplatform](skills/compose-multiplatform/) · [expo](skills/expo/) · [tauri](skills/tauri/) · [electron](skills/electron/) · [rust](skills/rust/) · [wordpress](skills/wordpress/) · [shopify](skills/shopify/) · [no-code-app](skills/no-code-app/) · [chrome-extension](skills/chrome-extension/) · [api-design](skills/api-design/)
 
+### 🎮 Game development
+
+Three engines + engine-agnostic disciplines. Every engine skill pins the current version and bans deprecated APIs, so the agent stops emitting stale Godot-3 / legacy-Unity code.
+
+[godot](skills/godot/) · [unity](skills/unity/) · [unreal](skills/unreal/) · [game-design](skills/game-design/) · [game-storytelling](skills/game-storytelling/) · [level-design](skills/level-design/) · [gamedev-shaders](skills/gamedev-shaders/) · [gamedev-multiplayer](skills/gamedev-multiplayer/) · [gamedev-physics](skills/gamedev-physics/) · [gamedev-pathing](skills/gamedev-pathing/) · [gamedev-shipping](skills/gamedev-shipping/)
+
 ### 🗄️ Databases & data layer
 
 [postgresdb](skills/postgresdb/) · [mysql](skills/mysql/) · [mongodb](skills/mongodb/) · [redis](skills/redis/) · [supabase](skills/supabase/) · [neon](skills/neon/) · [planetscale](skills/planetscale/) · [sqlite-turso](skills/sqlite-turso/) · [prisma-orm](skills/prisma-orm/) · [drizzle-orm](skills/drizzle-orm/) · [firebase](skills/firebase/) · [dynamodb](skills/dynamodb/) · [vector-db](skills/vector-db/) · [clickhouse-analytics](skills/clickhouse-analytics/) · [duckdb](skills/duckdb/) · [db-migrations](skills/db-migrations/) · [backups](skills/backups/)

package/manifest.json

@@ -1,7 +1,7 @@
 {
-  "version": "0.1.35",
+  "version": "0.1.36",
   "counts": {
-    "skills": 232
+    "skills": 243
   },
   "skills": [
     {
@@ -1737,6 +1737,156 @@
       ],
       "profiles": []
     },
+    {
+      "id": "game-design",
+      "description": "Use when designing or repairing the design of a game — inventing mechanics and systems, shaping the core loop, layering moment-to-moment / session / meta loops, planning progression, economy, currencies and sinks/faucets, tuning difficulty curves and balance, killing dominant strategies, adding 'juice'/game feel as design intent, prototyping and playtesting, or controlling scope, and especially when the ask is 'why isn't my game fun'. Triggers: 'design the core loop', 'my game isn't fun / doesn't hook', 'balance the economy', 'the difficulty curve feels off', 'players found a dominant strategy', 'how do I scope this', 'reward / progression loop', 'diseñar la mecánica', 'el juego no engancha', 'com equilibro l'economia'. NOT writing engine code, scripts or shaders (route to godot/unity/unreal), NOT narrative, dialogue or story beats (route to game-storytelling), NOT level layout or encounter placement (route to level-design).",
+      "tags": [
+        "game-design",
+        "mechanics",
+        "core-loop",
+        "balancing",
+        "progression",
+        "playtesting",
+        "scope",
+        "fun"
+      ],
+      "recommends": [
+        "level-design",
+        "game-storytelling",
+        "godot",
+        "unity",
+        "unreal"
+      ],
+      "profiles": [
+        "full"
+      ]
+    },
+    {
+      "id": "game-storytelling",
+      "description": "Use when designing a game's STORY as an interactive system: premise, theme and narrative pillars; branching narrative and meaningful choice; dialogue trees with state and flags; quests, objectives and fail states; worldbuilding; environmental and systemic storytelling; and keeping story in harmony with play (avoiding ludonarrative dissonance). Engine-agnostic — it designs the narrative graph, variables and beats, then hands the wiring to the engine skill. Triggers: 'write my game's story/premise', 'branching narrative', 'dialogue system/tree', 'quest structure', 'worldbuilding', 'meaningful choices', 'illusion of choice', 'Ink/Yarn Spinner/Twine/articy narrative', 'story keeps fighting the gameplay'. NOT core mechanics, systems or balance (that's game-design); NOT spatial/level layout or encounter placement (that's level-design); NOT the actual dialogue-node code, save format or plugin wiring inside an engine (that's godot/unity/unreal).",
+      "tags": [
+        "game",
+        "narrative",
+        "story",
+        "dialogue",
+        "quest",
+        "branching",
+        "worldbuilding"
+      ],
+      "recommends": [
+        "game-design",
+        "level-design"
+      ],
+      "profiles": [
+        "full"
+      ]
+    },
+    {
+      "id": "gamedev-multiplayer",
+      "description": "Use when adding multiplayer, netcode, or replication to a game — syncing players/state across a network, online co-op or PvP, client-server vs peer-to-peer, server-authoritative design, client-side prediction + server reconciliation, snapshot interpolation, lag compensation, tick/netrate, and per-engine wiring: Godot 4.x MultiplayerSpawner/MultiplayerSynchronizer/@rpc/ENetMultiplayerPeer/set_multiplayer_authority, Unity Netcode for GameObjects (NetworkObject/NetworkBehaviour/NetworkVariable/[Rpc]/ServerRpc/ClientRpc), Unreal Actor replication (Replicated/ReplicatedUsing, Server/Client/NetMulticast RPCs, relevancy). Triggers: 'how do I sync players', 'client and server desync', 'players rubber-band or teleport', 'who has authority', 'laggy movement', 'cheater set their own health'. NOT single-player gameplay, AI, or input (route to engine skill godot/unity/unreal), and NOT matchmaking, dedicated-server hosting, or backend infra (route to deployment).",
+      "tags": [
+        "multiplayer",
+        "netcode",
+        "replication",
+        "networking",
+        "prediction",
+        "authority"
+      ],
+      "recommends": [
+        "godot",
+        "unity",
+        "unreal",
+        "gamedev-physics"
+      ],
+      "profiles": [
+        "full"
+      ]
+    },
+    {
+      "id": "gamedev-pathing",
+      "description": "Use when implementing AI navigation or pathfinding in a game - moving enemies/NPCs/units toward goals, \\\"how do enemies navigate the level\\\", A*/Dijkstra/JPS/HPA* search, choosing grid vs waypoint-graph vs navmesh, baking a navmesh and tuning agent radius/height, off-mesh/nav links, dynamic obstacles and re-baking, steering (seek/flee/arrive/pursue/wander/path-following/flocking), local avoidance (RVO/ORCA, crowds), and flow fields for many agents to one goal. Per-engine: Godot 4.x (NavigationServer2D/3D, NavigationRegion, NavigationAgent, get_next_path_position), Unity (NavMeshAgent + NavMeshObstacle + AI Navigation baking), Unreal (RecastNavMesh + AIController + Behavior Trees/EQS). Triggers: \\\"my enemies get stuck\\\", \\\"units clump together\\\", \\\"navmesh not updating\\\", \\\"agentes se atascan\\\". NOT physics/rigidbody collision response or character-controller tuning (gamedev-physics), and NOT high-level enemy AI behaviour design like aggro/states/difficulty (game-design).",
+      "tags": [
+        "pathfinding",
+        "navmesh",
+        "navigation",
+        "steering",
+        "a-star"
+      ],
+      "recommends": [
+        "godot",
+        "unity",
+        "unreal",
+        "gamedev-physics"
+      ],
+      "profiles": [
+        "full"
+      ]
+    },
+    {
+      "id": "gamedev-physics",
+      "description": "Use when working with a game engine's physics — rigid bodies, colliders, collision layers/masks, character controllers, joints, forces vs impulses, raycasts/shapecasts, or when physics is unstable. Triggers: \\\"my character falls through the floor\\\", \\\"bullet tunnels through walls at high speed\\\", \\\"rigidbody jitters / vibrates / explodes\\\", \\\"objects that should collide pass through each other\\\", \\\"which collision layer and mask do I set\\\", \\\"kinematic vs dynamic body\\\", \\\"move_and_slide / CharacterBody\\\", \\\"AddForce vs impulse vs setting velocity\\\", \\\"physics in FixedUpdate or _physics_process\\\", \\\"slope and step detection\\\", \\\"trigger / Area overlap not firing\\\", Godot RigidBody/StaticBody/CharacterBody/Area, Unity Rigidbody/Collider/CharacterController, Unreal Chaos/collision presets. NOT rendering, materials, or visual jitter from shaders (use gamedev-shaders); NOT AI navigation, pathfinding, or navmesh (use gamedev-pathing).",
+      "tags": [
+        "physics",
+        "collision",
+        "rigidbody",
+        "character-controller",
+        "colliders"
+      ],
+      "recommends": [
+        "godot",
+        "unity",
+        "unreal",
+        "gamedev-pathing"
+      ],
+      "profiles": [
+        "full"
+      ]
+    },
+    {
+      "id": "gamedev-shaders",
+      "description": "Use when writing shaders, materials, VFX, or post-processing for a game engine, or asking \\\"how do I make this effect\\\" — covers the vertex→fragment pipeline, UVs / normals / coordinate spaces, and per-engine authoring in Godot 4.x (shader_type spatial/canvas_item/particles, source_color, hint_screen_texture, ShaderMaterial), Unity 6 (Shader Graph vs HLSL, URP/HDRP, ShaderLab), and Unreal 5.x (Material graph, material domains, Custom HLSL node). Includes recipes for dissolve, rim/outline, toon/cel, water/flow, force field, hologram; full-screen post-process; and shader performance (overdraw, texture-sample cost, branching, mobile). Triggers: \\\"write a dissolve shader\\\", \\\"rim light\\\", \\\"toon shading\\\", \\\"screen-space effect\\\", \\\"my shader is slow on mobile\\\", \\\"cómo hago un shader de agua\\\". NOT gameplay or engine-API code (→ godot / unity / unreal) and NOT physics simulation, collision, or rigid bodies (→ gamedev-physics).",
+      "tags": [
+        "shaders",
+        "vfx",
+        "materials",
+        "post-processing",
+        "shadergraph"
+      ],
+      "recommends": [
+        "godot",
+        "unity",
+        "unreal",
+        "gamedev-shipping"
+      ],
+      "profiles": [
+        "full"
+      ]
+    },
+    {
+      "id": "gamedev-shipping",
+      "description": "Use when exporting, building, packaging, or publishing a game — per engine (Godot export templates, Unity Build Profiles, Unreal Shipping vs Development) and per platform: desktop (Windows/macOS/Linux; macOS codesign + notarytool notarization), web (the COOP same-origin + COEP require-corp headers threaded SharedArrayBuffer WebAssembly builds need, and that Godot's C#/.NET edition can't export to web), mobile (Android JDK 17 build template, AAB vs APK, release keystore; iOS provisioning). Also store prep (icons/splash, metadata, age ratings, AAB for Play, Mac App Store, Steamworks/SteamPipe, itch.io butler), headless-export CI/CD, build/version numbers, and ship-time size/startup optimization. Triggers: 'export my game', 'build for Steam', 'ship to web/mobile', 'publish to the Play Store', 'notarize my Mac build', 'itch.io upload', 'SharedArrayBuffer is not defined'. NOT for writing gameplay/runtime code (that's the engine skill — godot/unity/unreal) or hosting a normal web app/API/container (→ deployment).",
+      "tags": [
+        "export",
+        "build",
+        "release",
+        "packaging",
+        "store",
+        "steam",
+        "itch",
+        "notarization",
+        "webassembly",
+        "aab"
+      ],
+      "recommends": [
+        "godot",
+        "unity",
+        "unreal",
+        "deployment"
+      ],
+      "profiles": [
+        "full"
+      ]
+    },
     {
       "id": "gcp-essentials",
       "description": "Use when running a small product on the core of Google Cloud with the gcloud CLI: creating a project, deploying a container to Cloud Run, standing up a Cloud Storage bucket, a managed Cloud SQL Postgres/MySQL, and wiring them together with least-privilege IAM. Triggers: 'deploy to Cloud Run', 'gcloud run deploy', 'set up a GCP project', 'crear bucket en GCP', 'desplegar a Cloud Run', 'service account sin claves JSON', 'why is my Cloud Run running as the default service account', 'connect Cloud Run to Cloud SQL', 'turn off the bucket public access'. NOT AWS (that is aws-essentials).",
@@ -1845,6 +1995,29 @@
       ],
       "profiles": []
     },
+    {
+      "id": "godot",
+      "description": "Use when writing, reviewing, or debugging Godot 4.x games in GDScript (typed) or C# — nodes/scenes/custom Resources, autoload singletons and an EventBus, signals via Callable, @onready/@export/@tool, static typing, CharacterBody2D/3D + velocity + move_and_slide(), _process vs _physics_process, .tscn/.tres text formats, and headless GUT/gdUnit4 tests. Enforces Godot 4 APIs and rejects Godot 3 leftovers: yield→await, onready→@onready, .instance()→.instantiate(), KinematicBody→CharacterBody, Spatial→Node3D, string connect(\\\"sig\\\",obj,\\\"m\\\")→Callable. Triggers: 'write a Godot player controller', 'my move_and_slide does nothing', 'port this Godot 3 script to 4', 'connect a signal in Godot', 'GDScript won't type-check', 'CharacterBody2D won't move', 'add an autoload', 'escribe un script de Godot', 'por qué no se mueve mi personaje'. NOT Unity MonoBehaviour or Unreal (route to unity/unreal); NOT pure C++/CMake tooling unrelated to GDExtension (that is cpp); NOT shader code in .gdshader (that is gamedev-shaders).",
+      "tags": [
+        "godot",
+        "gdscript",
+        "game-dev",
+        "csharp",
+        "godot4"
+      ],
+      "recommends": [
+        "gamedev-shaders",
+        "gamedev-multiplayer",
+        "gamedev-physics",
+        "gamedev-pathing",
+        "gamedev-shipping",
+        "game-design",
+        "cpp"
+      ],
+      "profiles": [
+        "full"
+      ]
+    },
     {
       "id": "google-workspace",
       "description": "Use when building server-side automation that reads or writes Gmail, Drive, Calendar, or Sheets against a real Google Workspace account via the official client libraries and a GCP service account — picking the auth mode, scoping OAuth scopes, building the authed client, and debugging 403/429/unauthorized_client errors. Triggers: 'send mail from a service account in a cron', 'unauthorized_client when impersonating a user', 'which Drive scope to upload to a shared drive', 'set up domain-wide delegation client ID', 'getting 403 insufficient permissions from the Sheets API', 'automatizar Gmail con cuenta de servicio sin login del usuario', 'enviar correos desde un script sense login d'usuari'. NOT generic SMTP/marketing/deliverability email (that is email-connector).",
@@ -2289,6 +2462,26 @@
       ],
       "profiles": []
     },
+    {
+      "id": "level-design",
+      "description": "Use when designing a game level, map, arena, or encounter — laying out a blockout/greybox, fixing pacing that drags or spikes, guiding players without hand-holding, placing secrets and rewards, or diagnosing a level that plays as boring, confusing, or where players get lost or stuck. Engine-agnostic craft: the blockout->greybox->playtest->art pipeline, sightlines and landmarks, tension/release rhythm, the introduce->develop->twist->combine encounter progression, readability via light/color/composition, and traversal heatmaps. Triggers: 'design this level', 'my level is boring/confusing', 'players keep getting lost', 'how do I pace this', 'blockout', 'greybox', 'encounter design', 'where do I put the secret'. NOT systemic mechanics or economy tuning (that's game-design), NOT narrative or story beats (that's game-storytelling), and NOT engine-specific level tooling — nav meshes, occlusion, tilemap editors, lightmap baking (that's the godot/unity/unreal skill).",
+      "tags": [
+        "level-design",
+        "blockout",
+        "pacing",
+        "encounter",
+        "playtest"
+      ],
+      "recommends": [
+        "game-design",
+        "godot",
+        "unity",
+        "unreal"
+      ],
+      "profiles": [
+        "full"
+      ]
+    },
     {
       "id": "linkedin-api",
       "description": "Use when wiring an app to LinkedIn's organic Posts / Community Management API — completing 3-legged OAuth, publishing text/article/document posts to a member profile or company page, or pulling impressions/engagement/follower stats and logging them as a durable feedback record. Triggers: 'connect our app to the LinkedIn Posts API', 'publish to our company page programmatically', 'pull last month's impressions for our org posts', 'my /v2/ugcPosts call returns 403', 'unauthorized scope w_organization_social at consent', 'log post performance into the wiki', 'publica a la pàgina de LinkedIn per API', 'conectar la API de LinkedIn y traer las impresiones'. NOT writing the post copy (that is linkedin-content), planning cadence (that is linkedin-strategy), or DM sequences (that is linkedin-outreach).",
@@ -4474,6 +4667,52 @@
       ],
       "profiles": []
     },
+    {
+      "id": "unity",
+      "description": "Use when writing, reviewing, or structuring Unity game code in C# for current Unity 6 LTS (6000.x) — GameObjects and Transform hierarchy, MonoBehaviour lifecycle, prefabs and prefab variants, ScriptableObjects for data, scenes and additive loading, the new Input System, coroutines vs async/await/Awaitable, Addressables, and build/player settings for 2D and 3D. Triggers: 'my Unity script', 'Awake vs Start', 'why is my physics jittery', MonoBehaviour .cs files, 'set up the new Input System', 'ScriptableObject config', 'load a scene additively', 'Instantiate a prefab', 'convert Input.GetAxis to the new system', 'build for Android/WebGL', 'por qué no se llama mi Start', 'com carrego una escena en additiu'. NOT Godot/GDScript (that is godot); NOT Unreal/Blueprint/C++ engine work (that is unreal); NOT the netcode wire protocol itself (that is gamedev-multiplayer).",
+      "tags": [
+        "unity",
+        "csharp",
+        "game-dev",
+        "monobehaviour",
+        "input-system"
+      ],
+      "recommends": [
+        "gamedev-multiplayer",
+        "gamedev-physics",
+        "gamedev-shaders",
+        "gamedev-pathing",
+        "gamedev-shipping",
+        "godot",
+        "unreal"
+      ],
+      "profiles": [
+        "full"
+      ]
+    },
+    {
+      "id": "unreal",
+      "description": "Use when building, scripting, or debugging a game in Unreal Engine 5 (UE5) with Blueprint and/or C++ — gameplay framework (Actor/Pawn/Character/GameMode/PlayerController), Actor lifecycle and tick, UPROPERTY/UFUNCTION/UCLASS reflection and garbage collection, Enhanced Input, dynamic multicast delegates, UMG widgets, Paper2D sprites/flipbooks, and Blueprint↔C++ parity (exposing C++ to Blueprint, calling Blueprint from C++). Triggers: \\\"UE5\\\", \\\"Unreal\\\", \\\"Blueprint\\\", \\\"make a Character in C++\\\", \\\"expose this to Blueprint\\\", \\\"BlueprintCallable\\\", \\\"why is my UObject garbage collected\\\", \\\"Enhanced Input mapping context\\\", \\\"UMG widget\\\", \\\"Paper2D flipbook\\\", \\\".uproject\\\", \\\"GameMode vs GameState\\\". NOT for Godot (→ godot), NOT for Unity/C#/MonoBehaviour (→ unity), NOT for language-only C++ memory/RAII questions with no Unreal types (→ cpp).",
+      "tags": [
+        "unreal",
+        "ue5",
+        "blueprint",
+        "unreal-engine",
+        "gamedev"
+      ],
+      "recommends": [
+        "cpp",
+        "gamedev-shipping",
+        "gamedev-multiplayer",
+        "game-design",
+        "gamedev-physics",
+        "godot",
+        "unity"
+      ],
+      "profiles": [
+        "full"
+      ]
+    },
     {
       "id": "vector-db",
       "description": "Use when operating a vector store as a data layer — choosing or migrating between Pinecone, Qdrant, Weaviate, or pgvector; designing a collection/index (distance metric, dimensions, HNSW m/ef_construction, named vectors); filtering on metadata/payload; running hybrid dense+sparse search; or picking quantization to cut RAM and cost. Symptoms: search returns garbage, filters get silently ignored, recall is low, queries are slow, the bill is too high, a filtered query returns fewer than k rows. Triggers: 'set up a vector database', 'my similarity search ignores the metadata filter', 'ef_search vs recall', 'move off Pinecone to pgvector to cut cost', 'hybrid search with RRF', 'why does my filtered query return fewer than k results', 'crear una colección en Qdrant con cuantización binaria', 'la cerca vectorial retorna resultats dolents'. NOT how to produce, chunk, or judge embeddings (that is embeddings-search).",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ericrisco/rsc",
-  "version": "0.1.35",
+  "version": "0.1.36",
   "description": "Eric Risco's agent-skills catalog as a granular, self-recommending CLI installer.",
   "type": "module",
   "bin": {

package/scripts/lib/domains.js

@@ -17,6 +17,7 @@ export const DOMAINS = [
   { title: 'AI — run it on', ids: ['replicate', 'runpod', 'modal', 'huggingface', 'ollama', 'together-fireworks', 'fal'] },
   { title: 'Languages', ids: ['typescript', 'python', 'java', 'csharp-dotnet', 'php', 'ruby', 'cpp', 'elixir', 'bash-scripting', 'sql', 'go'] },
   { title: 'Frameworks & app stacks', ids: ['fastapi', 'nextjs', 'react', 'react-native', 'vue-nuxt', 'angular', 'svelte', 'astro', 'solid-js', 'htmx', 'nodejs', 'nestjs', 'django', 'laravel', 'rails', 'spring-boot', 'phoenix', 'flutter', 'swift-ios', 'kotlin-android', 'compose-multiplatform', 'expo', 'tauri', 'electron', 'rust', 'wordpress', 'shopify', 'no-code-app', 'chrome-extension', 'api-design'] },
+  { title: 'Game development', ids: ['godot', 'unity', 'unreal', 'game-design', 'game-storytelling', 'level-design', 'gamedev-shaders', 'gamedev-multiplayer', 'gamedev-physics', 'gamedev-pathing', 'gamedev-shipping'] },
   { title: 'Databases & data layer', ids: ['postgresdb', 'mysql', 'mongodb', 'redis', 'supabase', 'neon', 'planetscale', 'sqlite-turso', 'prisma-orm', 'drizzle-orm', 'firebase', 'dynamodb', 'vector-db', 'clickhouse-analytics', 'duckdb', 'db-migrations', 'backups'] },
   { title: 'Ship & operate — platforms', ids: ['vercel', 'netlify', 'cloudflare', 'railway', 'render', 'fly-io', 'coolify', 'hetzner', 'digitalocean', 'aws-essentials', 'gcp-essentials'] },
   { title: 'Ship & operate — devops', ids: ['docker', 'github-actions', 'git-workflow', 'domains-dns', 'monitoring', 'email-deliverability', 'scaling', 'deployment'] },

package/scripts/lib/recommend.js

@@ -16,6 +16,10 @@ const OUTCOMES = {
   'building-agents': 'Your own AI agent',
   'secure-coding': 'Make it secure',
   deployment: 'Put it online',
+  godot: 'Your game (Godot)',
+  unity: 'Your game (Unity)',
+  unreal: 'Your game (Unreal)',
+  'game-design': "Design a game that's fun",
 };
 
 export function hasOutcome(id) {

package/skills/game-design/SKILL.md

@@ -0,0 +1,170 @@
+---
+name: game-design
+description: "Use when designing or repairing the design of a game — inventing mechanics and systems, shaping the core loop, layering moment-to-moment / session / meta loops, planning progression, economy, currencies and sinks/faucets, tuning difficulty curves and balance, killing dominant strategies, adding 'juice'/game feel as design intent, prototyping and playtesting, or controlling scope, and especially when the ask is 'why isn't my game fun'. Triggers: 'design the core loop', 'my game isn't fun / doesn't hook', 'balance the economy', 'the difficulty curve feels off', 'players found a dominant strategy', 'how do I scope this', 'reward / progression loop', 'diseñar la mecánica', 'el juego no engancha', 'com equilibro l'economia'. NOT writing engine code, scripts or shaders (route to godot/unity/unreal), NOT narrative, dialogue or story beats (route to game-storytelling), NOT level layout or encounter placement (route to level-design)."
+tags: [game-design, mechanics, core-loop, balancing, progression, playtesting, scope, fun]
+recommends: [level-design, game-storytelling, godot, unity, unreal]
+profiles: [full]
+origin: risco
+---
+
+# Design games that are fun on purpose
+
+Engine-agnostic game design: mechanics, loops, progression, economy, balance, feel, and the discipline of prototyping and scope. No engine APIs live here — when the design is settled, the implementation belongs to `godot`, `unity`, or `unreal`.
+
+## The one rule
+
+> Fun is discovered, not designed. You cannot reason your way to a fun game on paper; you find it by building the smallest playable version and playing it. Every hour spent planning a mechanic you have not prototyped is an hour spent guessing. Prototype the riskiest assumption first, play it, then decide.
+
+> The design of a game is the set of **verbs** it gives the player plus the **loops** those verbs live in. Everything else — art, story, levels — dresses that skeleton. If the skeleton is not fun in greybox, nothing dresses it into fun.
+
+## When to use / When NOT
+
+**Use when:**
+- Inventing or reworking mechanics and systems, or defining the player's verb set.
+- Shaping the core loop, or layering moment-to-moment → session → meta.
+- Planning progression, unlocks, pacing, or an in-game economy.
+- Tuning a difficulty curve, hunting a dominant strategy, or setting up data-driven balance.
+- Adding "juice" / game feel **as a design concept** (what feedback, why).
+- Prototyping, planning a playtest, deciding what to measure, or cutting scope.
+- The vague-but-critical ask: "why isn't my game fun / why doesn't it hook?"
+
+**Do NOT use — route instead:**
+
+| The ask | Route to | Why not here |
+| --- | --- | --- |
+| Write the movement/AI/shader/save code | `godot` / `unity` / `unreal` | This skill decides *what* to build; the engine skill builds it. |
+| Author the story, dialogue, characters, lore | `game-storytelling` | Narrative design is its own craft; this skill owns systems and verbs. |
+| Lay out a level, encounter, or world map | `level-design` | Spatial/encounter design applies the mechanics this skill defines. |
+| Netcode, prediction, lag compensation | `gamedev-multiplayer` | A technical domain, not core design intent. |
+| Ship / store page / build pipeline | `gamedev-shipping` | Release logistics, not design. |
+
+(`godot`, `unity`, `unreal`, `game-storytelling`, `level-design` are linkable siblings; the rest are known ids you name but cannot link yet.)
+
+## Loops: moment-to-moment → session → meta
+
+A game is loops nested inside loops. Each layer must reward on its own **and** feed motivation to the layer above it.
+
+```text
+moment-to-moment  (seconds)   the primary verb: aim+fire, jump, place, click, parry
+        │  feeds
+session loop      (minutes)   a run / match / mission: setup → tension → resolution
+        │  feeds
+meta loop         (sessions)  mastery, unlocks, collection, rank — why you return tomorrow
+```
+
+- **Moment-to-moment first.** The thing the player does constantly must feel good with *no* goal attached — jumping in Mario is fun in an empty room. If this layer is flat, no progression system rescues it. (Bungie's "30 seconds of fun" rule: perfect the small loop, then repeat it.)
+- **Session loop** gives a run shape — a beginning, a rising middle, a payoff. It should end on a hook (almost-had-it, one-more-run).
+- **Meta loop** is the reason-to-return: it spends the currency and mastery earned in sessions on lasting change (new verbs, new options, status).
+- **Reward funding.** A reward at one layer should fund desire at the next. Misfunded loops fail predictably: fun moment-to-moment + empty meta = "great but I bounced"; rich meta + flat moment-to-moment = "I grind and I don't know why."
+
+Depth vs breadth of loops, feedback-loop math, and worked loop teardowns: **[references/mechanics-and-loops.md](references/mechanics-and-loops.md)**.
+
+## MDA: the working lens
+
+Mechanics → Dynamics → Aesthetics. The designer authors **Mechanics** (rules, entities, numbers). At runtime those produce **Dynamics** (emergent behavior as players interact). Players only ever feel the **Aesthetics** (the emotional response). You design left-to-right; the player experiences right-to-left — so you must reason backward from the feeling you want to the rule that causes it.
+
+- **"Fun" is not a design target — name the aesthetic.** MDA's vocabulary: sensation, fantasy, narrative, challenge, fellowship, discovery, expression, submission (relaxation). "Make it more fun" is unactionable; "raise the *challenge* and *discovery*, drop the *submission*" is a to-do list.
+- **Design the verbs, not the features.** The verb set *is* the game. A tight set of verbs with deep interaction (chess, Tetris) beats a wide set of shallow ones. Before adding a feature, ask: does it add a verb, deepen an existing verb, or just add a number?
+- **Second-order design.** Ask what the rule makes players *do*, not what it literally says. Every incentive is also a de-incentive for everything else — rewarding kills steals attention from exploring.
+
+The eight aesthetics with examples, emergence vs scripted content, and interaction-depth heuristics: **[references/mechanics-and-loops.md](references/mechanics-and-loops.md)**.
+
+## Progression & economy
+
+Progression controls the rate at which the game reveals its depth; economy is the currency plumbing underneath it.
+
+- **Pacing.** Interleave tension and release; teach → test → twist. Run difficulty and novelty as two curves so a lull in one is covered by the other.
+- **Unlocks earn their keep.** Each unlock should add a verb or a *meaningful choice*, not just +10%. Gate content to pace the complexity the player must hold at once.
+- **Currencies need distinct jobs.** Soft (earned, spent freely) vs hard/premium (scarce). Never add a currency without a distinct **sink** it exists to feed — currencies without sinks are clutter.
+- **Sinks and faucets.** Faucets create currency; sinks destroy it. Balance the two or the economy drifts.
+
+Model the drift with the core identity — no engine needed, a spreadsheet does it:
+
+```text
+net_income_rate = faucet_rate − sink_rate
+time_to_afford  = cost / net_income_rate          # tune this against desired pacing
+cost(n)         = base × growth^n                 # escalating sink; growth ≈ 1.07–1.15
+```
+
+- **Avoiding runaway.** If `net_income_rate` rises over time, costs must rise at least as fast or currency becomes meaningless (hyperinflation, trivialized late game). Fixes: escalating/exponential sinks, consumable sinks, caps, prestige resets.
+- **Kill snowballs.** Positive feedback loops (rich-get-richer) let a leader accelerate out of reach and end matches early. Counter with negative feedback / catch-up (rubber-banding, comeback mechanics, escalating cost of dominance) — tuned so it aids without feeling like punishment for winning.
+
+Currency taxonomies, inflation math, prestige/reset design, and a balancing-spreadsheet layout: **[references/progression-and-economy.md](references/progression-and-economy.md)**.
+
+## Difficulty & balancing
+
+- **The curve is a sawtooth, not a ramp.** Rising baseline with peaks (bosses, gauntlets) and valleys (recovery, reward). Aim for the *flow channel*: challenge tracking skill, between boredom (too easy) and anxiety (too hard).
+- **Few high-leverage knobs.** Most balance lives in a handful of variables (damage, health, spawn rate, cost, cooldown). Identify them, tune **one at a time**, and never chase a symptom by touching five knobs at once.
+- **Data-driven balance.** Externalize tunables into data (tables/config), not hard-coded constants, so designers iterate without a rebuild and you can diff and A/B numbers. (The engine skill wires the loader; this skill decides *which* numbers are tunable.)
+- **Dominant strategies kill choice.** When one option strictly beats the rest, all other choices die. Hunt them in playtest data and telemetry; fix by nerfing the outlier or buffing counters toward **intransitive** balance (rock-paper-scissors: every option beaten by another).
+- **Perceived ≠ actual difficulty**, and difficulty options/accessibility widen the audience — decouple challenge from exclusion.
+
+Flow-channel tuning, dominant-strategy detection, symmetry vs asymmetry, and difficulty-option patterns: **[references/progression-and-economy.md](references/progression-and-economy.md)**.
+
+## Feel / "juice" (as design intent)
+
+Game feel is the tactile sensation of control — the moment-to-moment made physical. It is a **design** concern here; the engine skills implement the effects.
+
+- **Every input needs an immediate, legible reaction** — visual, audio, and/or haptic. Perceived latency is the enemy; responsiveness beats fidelity.
+- **Juice vocabulary** (specify the intent, let the engine do it): hit-stop / hit-pause (freeze a few frames on impact to sell weight), screenshake (scaled to significance, never gratuitous), anticipation & follow-through and squash-and-stretch (animation principles that read intent), particles, easing/tweening curves, and layered sound.
+- **Feel is often hidden generosity.** Coyote time, input buffering, and forgiveness windows make a game feel *fair* and responsive without the player ever knowing why.
+- **Design-level, not code-level here.** Decide *what* should feel weighty and *why*; specify the effect and its trigger. The keyframes, curves, and shaders belong to `godot` / `unity` / `unreal`.
+
+## Prototyping & playtesting
+
+- **Prototype the riskiest assumption first.** Whatever most determines whether the game works — prove or kill it before building anything else.
+- **Paper → greybox → vertical slice.** Test rules and economies on paper/cards; test mechanics in an untextured blockout; only then build a polished slice. Find the fun before you buy the art.
+- **Watch, don't coach.** In a playtest, shut up and observe. Note confusion, boredom, and quit points. The first-time experience is gold and you get it exactly once per tester.
+- **Behavior over opinion.** Players are unreliable at saying *what* is wrong but reliable at signaling *that* something is. Weight what they do over what they say. Measure both: qualitative (struggle/quit points, think-aloud) and quantitative (completion rate, time-per-section, death heatmaps, D1/D7 retention).
+- **Kill your darlings.** Cut any mechanic that does not serve the core loop, however clever. A pile of clever unrelated mechanics is not a game.
+- **Scope is the #1 reason indie games die** — not talent, not tools. Cut *features*, not *quality*. A finished small game beats an unfinished ambitious one. Define the "one thing" the game is about and protect it ruthlessly; build a vertical slice, not a broad shallow map of half-features.
+
+Playtest protocols, metrics/retention definitions, the prototyping ladder, and concrete scope-cutting tactics: **[references/playtesting-and-scope.md](references/playtesting-and-scope.md)**.
+
+## Documenting design
+
+- **One page that lives beats a 100-page bible that dies.** Nobody reads the bible; it is stale the day after it is written. Write a living one-pager and let it grow only where a real decision needs recording.
+- **The one-pager holds:** the hook / fantasy, the core loop, the verb set, the target aesthetic (named MDA emotion), the MVP scope, and — explicitly — what is *out*.
+- **Design pillars** (2–4 words each, e.g. "tense stealth", "readable chaos") are decision filters: every feature must serve a pillar or it is cut. Pillars end arguments faster than any spec.
+- **Keep it a communication tool, not an archive.** A wiki page beats a locked document; version it, link it, prune it.
+
+## Anti-patterns
+
+| Anti-pattern | Why it bites | Do instead |
+| --- | --- | --- |
+| Designing on paper for months before building | Fun is only found by playing | Prototype the riskiest assumption first |
+| "Make it more fun" as a task | Unactionable | Name the target MDA aesthetic and the mechanic behind it |
+| Adding features instead of deepening verbs | Wide-and-shallow, no mastery | Deepen verb interaction before adding verbs |
+| Currency with no sink | Meaningless clutter, inflation | Give every currency a distinct sink or cut it |
+| Faucets outpacing sinks | Hyperinflation, trivial late game | Escalating/consumable sinks, caps, prestige |
+| Unchecked positive feedback loop | Leader snowballs, match ends early | Add negative feedback / catch-up, tuned gently |
+| One dominant strategy left standing | Choice dies, meta collapses | Nerf outlier / buff counters toward intransitive balance |
+| Tuning five knobs at once | Can't attribute cause | Change one high-leverage variable at a time |
+| Hard-coded balance constants | No iteration, no A/B, needs rebuild | Externalize tunables into data |
+| Guiding testers during playtests | Contaminates the first-time signal | Watch silently; weight behavior over opinion |
+| Scope creep / feature list as ambition | #1 indie killer | Cut features not quality; ship a vertical slice |
+| 100-page design bible | Nobody reads it; goes stale | Living one-pager + pillars |
+
+## Project grounding
+
+If the workspace has a `02-DOCS/` harness, record the design in `02-DOCS/wiki/design/` — a `game-design.md` one-pager (hook, core loop, verbs, pillars, MVP scope, what's out) plus an `economy.md` if there is a currency system. Write each as an OKF v0.1 wiki article per the harness [`wiki-article-template.md`](../harness/references/wiki-article-template.md): YAML frontmatter with a non-empty `type:` (use `type: design`), a `timestamp` in ISO 8601, and standard markdown links — never wikilinks. Index it in `02-DOCS/wiki/index.md`. This is **recorded, not gated** — skip silently if there is no harness.
+
+## Related skills
+
+- `../level-design/SKILL.md` — applies these mechanics in space: layout, pacing beats, encounter design.
+- `../game-storytelling/SKILL.md` — narrative, dialogue, and how story wraps the systems you define here.
+- `../godot/SKILL.md`, `../unity/SKILL.md`, `../unreal/SKILL.md` — implement the settled design; all engine APIs, feel/juice code, and data-driven tuning loaders live there.
+- Known siblings to name but not yet link: `gamedev-multiplayer`, `gamedev-physics`, `gamedev-pathing`, `gamedev-shaders`, `gamedev-shipping`.
+
+## Checklist
+
+- [ ] The **core verb** is named and is fun in greybox with no goal attached.
+- [ ] The three loops (moment-to-moment / session / meta) are identified and each is reward-funded by the layer below.
+- [ ] The target **aesthetic** is named (MDA vocabulary), not "fun".
+- [ ] Every currency has a distinct sink; faucets vs sinks are modeled and do not run away.
+- [ ] Difficulty follows a sawtooth in the flow channel; high-leverage knobs are identified and data-driven.
+- [ ] No dominant strategy survives; options are intransitively balanced.
+- [ ] Feel/juice intent is specified (what + why), deferred to the engine skill for how.
+- [ ] The riskiest assumption was prototyped and playtested; behavior (not just opinion) was observed.
+- [ ] Scope is cut to a vertical slice; a one-page living doc + pillars exist, not a bible.
+- [ ] Engine specifics were deferred to `godot`/`unity`/`unreal`; narrative to `game-storytelling`; layout to `level-design`.

package/skills/game-design/evals/README.md

@@ -0,0 +1,13 @@
+# Evals for game-design
+
+`cases.yaml` is the trigger and capability spec for this skill, read by the catalog's
+skill-eval harness. `should_trigger` asserts the skill fires on design-intent asks — core
+loops, economy/inflation, balance, difficulty curves, feel, scope, and the vague "why isn't my
+game fun" — including a Spanish phrasing. `should_not_trigger` asserts near-misses route to the
+right sibling: engine code to `unity`/`godot`/`unreal`, story to `game-storytelling`, layout to
+`level-design`, netcode to `gamedev-multiplayer`, release to `gamedev-shipping`.
+
+The `capability` case checks that an economy/loop-repair answer stays engine-agnostic: it
+diagnoses loop funding, models faucets vs sinks with the pseudo-formula, stops runaway inflation
+with escalating sinks/prestige, names the MDA aesthetic, and defers implementation to the engine
+skills.

package/skills/game-design/evals/cases.yaml

@@ -0,0 +1,47 @@
+skill: game-design
+
+should_trigger:
+  - prompt: "I've been building my game for months and it just isn't fun to play. What's wrong?"
+    why: "The signature 'why isn't my game fun' trigger; answer diagnoses which loop is starved and pushes prototype-the-core-verb-in-greybox."
+  - prompt: "Help me design the core gameplay loop for a roguelike deckbuilder."
+    why: "Core-loop design plus moment-to-moment → session → meta layering is the central job."
+  - prompt: "My in-game gold keeps inflating so late-game upgrades feel free. How do I fix the economy?"
+    why: "Economy/faucets-vs-sinks and runaway-inflation fixes (escalating sinks, caps, prestige); the pseudo-formula applies."
+  - prompt: "Everyone in my card game just plays the same one deck because it beats everything. How do I rebalance?"
+    why: "Dominant-strategy detection and pushing toward intransitive (rock-paper-scissors) balance."
+  - prompt: "The difficulty in my platformer spikes weirdly — some levels are trivial, then a wall. How should the curve work?"
+    why: "Difficulty curve as a sawtooth in the flow channel, high-leverage knobs, one-at-a-time tuning."
+  - prompt: "I keep adding features and never finishing. How do I decide what to cut?"
+    why: "Scope control (the #1 indie killer): cut features not quality, define the one thing, vertical slice, cut list, kill your darlings."
+  - prompt: "El juego no engancha después de la primera partida, ¿cómo lo arreglo?"
+    why: "Spanish — starved meta loop / return-reason; diagnoses reward funding across loop layers."
+  - prompt: "How do I make combat feel punchier and more satisfying without touching the story or the netcode?"
+    why: "Game feel / juice as design intent (hit-stop, screenshake, feedback); explicitly excludes story and netcode."
+
+should_not_trigger:
+  - prompt: "Write the C# script that moves my player character and handles jumping in Unity."
+    route_to: unity
+    why: "Engine implementation code; this skill decides what to build, the engine skill writes it."
+  - prompt: "Write the dialogue tree and backstory for my game's main antagonist."
+    route_to: game-storytelling
+    why: "Narrative and character writing, not systems/mechanics design."
+  - prompt: "Lay out the rooms and enemy placement for level 3 of my metroidvania."
+    route_to: level-design
+    why: "Spatial and encounter layout applies mechanics; it is not core mechanic/economy design."
+  - prompt: "Implement client-side prediction and lag compensation for my multiplayer shooter."
+    route_to: gamedev-multiplayer
+    why: "Netcode is a technical domain, not moment-to-moment or economy design intent."
+  - prompt: "Set up my Steam store page and build the release pipeline for launch."
+    route_to: gamedev-shipping
+    why: "Release logistics, not design."
+
+capability:
+  - scenario: "A solo dev's incremental/idle game feels grindy and the currency inflates until upgrades are free; they ask how to fix the design."
+    must_include:
+      - "Diagnoses which loop is starved (moment-to-moment / session / meta) and checks that each layer's reward funds the next"
+      - "Models the economy with net_income_rate = faucet_rate − sink_rate and time_to_afford = cost / net_income_rate"
+      - "Prescribes escalating/exponential sinks (cost(n) = base × growth^n), consumable sinks, caps, or prestige resets to stop runaway inflation"
+      - "Requires each currency to have a distinct sink, and tunables to be data-driven rather than hard-coded"
+      - "Names the target MDA aesthetic instead of 'more fun', and frames unlocks as new verbs/choices not just +N%"
+      - "Recommends prototyping the fix and playtesting for behavior (retention, time-per-tier), not just opinion"
+      - "Defers engine implementation to godot/unity/unreal and records the design in 02-DOCS/wiki/design/ only if a harness exists"