Codex game development 8 skills

Haosen's article groups 8 skills by development problem, covering design, implementation, interfaces and action feedback. The skills come from 7 repositories and mainly supply methods, references, templates and checks. Codex still needs to read the project, change its code and run the acceptance checks after installation.

Choose whether the game runs in a browser, Unity or Unreal before selecting a skill for the current problem. Limit each change to a system or screen, check it, then hand off the next task.

Use this when mechanics are unsettled, players ignore an option, or the team disagrees about a playtest. The skill separates direct observations, player reports and designer assumptions. Frameworks such as MDA help examine a particular question; player evidence is still required.

The deliverable is game-design-hypothesis.json. The bundled references/hypothesis-example.json supplies an example, and scripts/validate-design-hypothesis.py checks the data contract. A pass confirms that the fields and evidence boundaries meet the contract; playtesting is still needed to assess the hypothesis.

The designer should be able to name an observation that would disprove the hypothesis, and the prototype should switch independently between control and variant. Narrow the comparison if it lacks counterevidence or changes speed, rewards and warning timing together.

Use this to build a playable browser game from an empty project. Start a simple 2D prototype with Canvas; choose Three.js or another framework when the game requires a 3D scene.

The main loop reads input, updates state and draws the screen. The documentation recommends requestAnimationFrame and delta time for movement. assets/ contains starter templates, while references/ covers web APIs, collisions, controls and publishing.

Start a game, trigger a loss and restart. The score, obstacles and input state should all reset. If the game accelerates after returning to its tab or counts scores twice after a restart, inspect delta time and loop lifecycle before changing visual effects.

Use this in a Unity or Unreal project that needs a specific system changed. References include references/unity-patterns.md, references/unreal-cpp.md and references/performance-optimization.md. Load only the material for the current engine and problem.

The skill calls for pooling frequently spawned objects, state machines for game logic, and regular CPU, GPU and memory profiling. Its 60+ FPS figure is a target. Define acceptance criteria for the actual hardware, graphics settings and stress scenario.

Run acceptance checks on the target device or in the relevant engine. Compiling the code does not establish that scene changes, object reuse or multiplayer connections work.

Use this when health, cooldowns, danger signals and objectives compete for space. Supply the current screen, the player's task and the target device, then decide which information stays visible, appears in context or expands on demand.

The main file routes creation to references/patterns.md, diagnosis to references/sharp_edges.md and review to references/validations.md. Keep the whole reference directory when copying the skill. The main file alone omits the material these tasks rely on.

Important information should be distinguishable in the relevant game state. Screenshots can check hierarchy; pausing, switching menus and dismissing prompts still require interaction tests.

Use this when menus are clipped on a phone, positioned incorrectly on an ultrawide display, or open with a gamepad but provide no selectable button. The skill owns shared architecture; engine UI skills still provide concrete nodes, components and styling.

Assign initial focus when a screen opens, and use push/pop navigation to manage which screen receives input. The HUD subscribes to events such as health_changed and score_changed instead of rereading game internals every frame. Initialization must also display the current state.

Walk through the menu path and confirm focus can enter, move and return. Main buttons must remain visible and usable after resizing. Mouse testing alone cannot verify gamepad navigation.

Use this in a browser game that already uses Three.js. references/ui-patterns.md requires a single source of truth. The UI dispatches intents instead of reimplementing game rules.

Add mobile controls when mobile is a target. Touch handling needs cancellation cases such as pointercancel and lostpointercapture, as well as presses, so a character does not keep moving after the finger leaves.

Check that restart clears stale scores, menus leave the next decision visible, and every button has distinguishable focus and disabled states. A rendered interface still needs an interaction check to confirm that controls change game state.

Use this when collisions, hits or pickups happen correctly but their response is hard to perceive. Confirm that events such as on_hit exist before selecting a few feedback channels. Fix collision or damage errors first.

Apply shake to the camera or a visual offset so it does not move the collision body. Restore hit-stop with a timer unaffected by game-time scaling and account for overlapping events. Effects should decay without blocking the next input.

Test repeated and overlapping actions while observing decay, input and restored state. A screenshot cannot verify time scaling or continuous input.

Use this when the project has chosen Higgsfield and needs its template and room system. Prepare the Higgsfield CLI, an account, Git and Bun. Check account status, generation credits and fees before starting.

The official game flow uses the following entry point, where --category must identify a game genre. Replace the example subdomain with an available name. The old higgsfield game commands have left the current workflow.

Read the scaffold's app/AGENTS.md before implementation. The 6 exports from app/src/logic.js are meta, setup, validateAction, applyAction, isGameOver and viewFor. validateAction checks action legality, while viewFor decides which data a player receives.

Run the checks from the project's app/ directory. The official flow uses the following commands for logic checks, tests and the build.

higgsfield website deploy makes the game publicly accessible, while higgsfield website publish separately lists it in the community feed. Before listing, fill in the title, description, cover and other fields in app/src/app-meta.json. To check multiplayer rooms, open the same room path in multiple browser tabs and test illegal actions and data visibility.

Plugin installation commands from the sources target GitHub Copilot, Claude Code or Antigravity; they are not automatically Codex commands. For manual use, take the folder containing SKILL.md and preserve its existing subdirectories, including references/, scripts/ and assets/.

The game skill library's installation guide lists Codex's project directory, .agents/skills/, and user directory, ~/.agents/skills/. For project-only installation, follow these steps. Inspect files and scripts before use; if a directory already exists with the same name, compare and back it up before replacing it.

1. Obtain the chosen repository, record its commit and locate the skill directory in the table.

2. Copy the entire selected skill directory into the project's .agents/skills/, preserving its name and internal relative paths.

3. In a new Codex session, check that /skills lists it, then name the skill explicitly in the task. If it is not detected, give the agent the local SKILL.md path to read and check the host's loading settings.

4. Ask the agent to read the main file and the references needed for this task before reporting its change scope and acceptance method. Other skills named in the documentation need their own files before they can be loaded.

Limit this example to a single-level browser 2D game using simple shapes. Keep the same rules, state and acceptance list across stages so changing skills does not restart the project.

Add game-ui-ux for layout, focus and device switching when mobile or gamepad support is introduced, and add threejs-game-ui-designer once the project uses Three.js. Use game-developer for the implementation stage in Unity/Unreal. When adopting Higgsfield, recheck implementation locations against its template contract.

This example can use a desktop width of 1440 px and a phone width of 390 px as candidate checks, then add sizes and input devices from the actual player context. These are acceptance settings for this example, not substitutes for an engine's or another game's device requirements.