game-mechanics-design
Skill2 starsChanged 4 months agoMITView on GitHub
Selects and prototypes player-facing mechanics for meaningful choices, challenge, progression, quests, combat, collection, rewards, and tutorials. Use for deciding what the player repeatedly does and how that action supports the intended experience; defer numerical tuning to game-balance and cross-system feedback analysis to game-systems-design.
In this repository14 other files it gives its agents.
- game-balanceSkill
- game-design-vocabularySkill
- gamedev-mathSkill
- game-systems-designSkill
- godot-2d-gameplaySkill
- godot-3d-gameplaySkill
- godot-desktop-appsSkill
- godot-fundamentalsSkill
- godot-game-architectureSkill
- godot-mobileSkill
- godot-navigation-aiSkill
- godot-procedural-generationSkill
- godot-programming-patternsSkill
- godot-uiSkill
The file
Show its rules and text
We split this skill into the rules it gives an agent
19 rules. About 0 are common, 19 are distinctive, and 0 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈19
Distinctive · estimate
This author's own choices. Worth a look.
0
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 12
Use this skill to turn a desired player experience into a small, coherent, testable set of mechanics.
- Distinctive: line 16
Treat player motivations as hypotheses, not fixed personality labels.
- Distinctive: line 17
Prefer a few mechanics with strong interactions over many isolated features.
- Distinctive: line 20
Add progression, rewards, and currencies only when they strengthen the play itself.
- Distinctive: line 31
Read the project entry scene, gameplay scenes, input map, state-owning scripts, resources, save model, and existing tests.
- Distinctive: line 35
If no project exists, ask for or state explicit assumptions instead of inventing production constraints.
- Distinctive: line 50
Use Motivation, Choice, and Challenge to develop and test this target.
- Distinctive: line 54
Write the shortest repeatable loop as:
- Distinctive: line 67
If two consecutive steps do not change what the player understands or can decide, combine or remove one.
- Distinctive: line 73
Use Mechanic Selection Workshop for the selection matrix, mechanic specification, and vertical-slice procedure.
- Distinctive: line 79
Ensure at least two options are viable in the current context.
- Distinctive: line 89
Only after the core interaction works, evaluate:
- Distinctive: line 98
Use Progression, Quests, and Tutorials and Combat, Collection, and Economies.
- Distinctive: line 102
Create the smallest playable test that can disprove the design.
- Distinctive: line 119
Every mechanic supports the experience target or a required constraint.
- Distinctive: line 128
Keep tuning data separate from irreversible state transitions where the project permits it.
- Distinctive: line 130
Test save/load during every long-lived state, including mid-quest, full inventory, and partially spent rewards.
- Distinctive: line 131
Run visual tests for telegraphs, feedback timing, HUD readability, color-independent cues, and camera framing.
- Distinctive: line 132
Test at low and high frame rates, with keyboard, controller, and touch when supported.
≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Game Mechanics Design
Use this skill to turn a desired player experience into a small, coherent, testable set of mechanics. Do not begin with a genre feature checklist. Begin with the player's repeated decisions and the evidence needed to determine whether those decisions produce the intended experience.
Core Principles
- Treat player motivations as hypotheses, not fixed personality labels.
- Prefer a few mechanics with strong interactions over many isolated features.
- Make important options legible, genuinely distinct, and consequential.
- Build challenge from learned skills and understandable rules, not hidden exceptions.
- Add progression, rewards, and currencies only when they strengthen the play itself.
- Teach by arranging safe opportunities to act, observe, retry, and later combine skills.
- Protect player time. Failure should teach, and repetition should have a clear purpose.
Workflow
1. Inspect the Current Game
Before proposing changes:
- Confirm the Godot version, target devices, input methods, audience, session length, and multiplayer assumptions.
- Read the project entry scene, gameplay scenes, input map, state-owning scripts, resources, save model, and existing tests.
- Play the smallest runnable loop when possible. Record what the player can do, what changes, how success and failure occur, and what feedback is visible.
- Separate shipped constraints from ideas that are merely mentioned in notes or unused code.
If no project exists, ask for or state explicit assumptions instead of inventing production constraints.
2. Write the Experience Target
Express the target in one sentence:
The player should feel <experience> by repeatedly <activity> while deciding <tradeoff>.
Then identify:
- Primary motivation hypotheses, such as mastery, discovery, expression, completion, social connection, narrative curiosity, or relaxation.
- The intended emotional rhythm, including pressure, relief, surprise, and reflection.
- The acceptable cognitive, motor, time, and failure burden.
- Ethical boundaries around monetization, randomness, loss, social pressure, and retention.
Use Motivation, Choice, and Challenge to develop and test this target.
3. Map the Core Loop
Write the shortest repeatable loop as:
observe -> choose -> act -> feedback -> changed state -> next decision
For each step, record:
- Information available to the player.
- Player action and input burden.
- Rules and resources consulted.
- Immediate and delayed consequences.
- Audiovisual feedback.
- How the next decision differs from the previous one.
If two consecutive steps do not change what the player understands or can decide, combine or remove one.
4. Select Mechanics Deliberately
Generate several candidates, then score their fit against the experience target, platform, scope, accessibility, interaction depth, tutorial cost, content burden, and technical risk. Reject a mechanic that fails a non-negotiable constraint even if it is exciting in isolation.
Use Mechanic Selection Workshop for the selection matrix, mechanic specification, and vertical-slice procedure.
5. Shape Choice and Challenge
For each important decision:
- Ensure at least two options are viable in the current context.
- State what the player knows before choosing.
- Give each option a cost, opportunity cost, risk, or commitment.
- Make the consequence observable at an appropriate time.
- Decide whether the choice is reversible and communicate that honestly.
Build challenge by varying timing, space, resource pressure, uncertainty, coordination, or planning. Change one demand at a time when teaching; combine known demands later. Provide recovery paths where a single small mistake should not decide the entire run.
6. Add Supporting Systems
Only after the core interaction works, evaluate:
- Progression and unlocks.
- Quests and objective structure.
- Combat encounters and enemy roles.
- Collection and inventory constraints.
- Resource creation, conversion, storage, and spending.
- Tutorial prompts and practice spaces.
Use Progression, Quests, and Tutorials and Combat, Collection, and Economies. Trace every supporting system back to the core loop. Remove rewards that motivate bypassing the intended play.
7. Prototype the Riskiest Question
Create the smallest playable test that can disprove the design. Use placeholder presentation, deterministic scenarios, and exposed tuning values. Do not build a full progression tree or content catalog to test whether one combat decision is interesting.
Capture expected observations before testing, for example:
- Players can explain the tradeoff without designer help.
- At least two strategies succeed for different reasons.
- A first failure reveals information used on the next attempt.
- Players notice a state change through normal play, not a debug display.
8. Iterate from Evidence
Observe behavior before asking for opinions. Record confusion, hesitation, repeated choices, accidental inputs, unused systems, recovery behavior, and where players stop. Change one causal variable per test when practical. Keep a short decision log linking each revision to evidence.
Verification
Design Checks
- Every mechanic supports the experience target or a required constraint.
- Important choices have distinct consequences and no permanently dominant option.
- Challenge relies on knowledge or skills the game has already made learnable.
- Rewards do not erase the tradeoffs they are meant to support.
- Progression changes decisions rather than only increasing numbers.
- Tutorials can be skipped, replayed, and completed with remapped inputs.
Implementation Checks
- Keep tuning data separate from irreversible state transitions where the project permits it.
- Unit-test economy transactions, quest transitions, unlock prerequisites, reward bounds, and deterministic random tables.
- Test save/load during every long-lived state, including mid-quest, full inventory, and partially spent rewards.
- Run visual tests for telegraphs, feedback timing, HUD readability, color-independent cues, and camera framing.
- Test at low and high frame rates, with keyboard, controller, and touch when supported.
Playtest Edge Cases
- Novice and expert players reach different challenge limits.
- Players ignore the intended reward or optimize away the intended activity.
- Inventory is full when a mandatory reward arrives.
- A quest target is unavailable, already defeated, duplicated, or removed on reload.
- Random rewards produce long unlucky streaks or duplicate-only outcomes.
- Currency overflows, becomes negative, or can be duplicated through retries or disconnects.
- Tutorial conditions trigger after the player has already learned or rebound the action.
- Co-op players join, leave, or complete an objective out of order.
Expected Output
Produce a compact design artifact containing:
- Experience target and constraints.
- Core loop and major decisions.
- Selected mechanics with rejected alternatives and reasons.
- Progression, quest, combat, collection, economy, and tutorial implications that actually apply.
- Prototype scope, tuning variables, edge cases, and verification plan.
- Open assumptions clearly marked for validation.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

