From game-creator
Builds complete browser games from scratch: scaffolds with Phaser/Three.js, generates assets/audio, adds Playwright tests, deploys to here.now, monetizes via Play.fun. Use for new 2D/3D game concepts.
npx claudepluginhub opusgamelabs/game-creator --plugin game-creatorThis skill uses the workspace's default tool permissions.
Build a complete browser game from scratch, step by step. This command walks you through the entire pipeline — from an empty folder to a deployed, monetized game. No game development experience needed.
Searches, retrieves, and installs Agent Skills from prompts.chat registry using MCP tools like search_skills and get_skill. Activates for finding skills, browsing catalogs, or extending Claude.
Searches prompts.chat for AI prompt templates by keyword or category, retrieves by ID with variable handling, and improves prompts via AI. Use for discovering or enhancing prompts.
Checks Next.js compilation errors using a running Turbopack dev server after code edits. Fixes actionable issues before reporting complete. Replaces `next build`.
Build a complete browser game from scratch, step by step. This command walks you through the entire pipeline — from an empty folder to a deployed, monetized game. No game development experience needed.
What you'll get:
WLT_API_KEY is set)npm test after future changesnpm run deploy)Quality assurance is built into every step — each code-modifying step runs build verification, visual review via Playwright MCP, and autofixes any issues found.
playfun-auth.js get-key and embedded in client-side HTML. Secret keys are never written to game files or deployed artifacts.npx skills add). The agent does not auto-install third-party packages or skills without user consent..env file (gitignored) and passed via environment variables. They are never embedded in game source or deployed files.You are an orchestrator. You do NOT write game code directly. Your job is to:
TaskCreate/TaskUpdateTask subagentWhat stays in the main thread:
What goes to subagents (via Task tool):
MONETIZATION_INTENT == 'none'): Scaffold gateable features (skin picker, continue-after-death, etc.) with isEntitled() seamEach subagent receives: step instructions, relevant skill name, project path, engine type, dev server port, and game concept description.
Run after every code-modifying step (Steps 1, 1.25 when applicable, 1.5, 2, 3). Step 3.5 runs its own test verification. Delegates all QA work to a subagent to minimize main-thread context usage.
See verification-protocol.md for full QA subagent instructions, orchestrator flow, and autofix logic.
Parse $ARGUMENTS to determine the game concept. Arguments can take two forms:
2d (Phaser — side-scrollers, platformers, arcade) or 3d (Three.js — first-person, third-person, open world). If not specified, ask the user.For 3D games, check for these API keys — first in .env (test -f .env && grep -q '^KEY_NAME=.' .env), then in the environment:
MESHY_API_KEY — for generating custom 3D character/prop models with Meshy AI (see tweet-pipeline.md for the prompt flow)WLT_API_KEY / WORLDLABS_API_KEY — for generating photorealistic 3D environments with World Labs Gaussian Splats. If not set, ask the user alongside MESHY_API_KEY:
I can also generate a photorealistic 3D environment with World Labs. Paste your key like:
WORLDLABS_API_KEY=your-key-here— or type "skip" to use basic geometry. (Keys are saved to .env and redacted from this conversation automatically.)
See tweet-pipeline.md for the full tweet fetching, parsing, creative abstraction, celebrity detection, and Meshy API key flow.
Ask the user (unless already answered earlier in the conversation):
Before we scaffold: how do you plan to monetize this game?
- none — just a fun build, no monetization
- Play.fun — points, leaderboards, wallet rewards (bundled, runs in Step 5)
- sub.games — subscription tiers (run
/subgamesseparately after this pipeline; it lives in a different repo)- both — Play.fun for points + sub.games tiers
Reply with a number or keyword.
Store the answer as MONETIZATION_INTENT ∈ {none, playfun, subgames, both}. If the creator gives an ambiguous answer, re-ask rather than guessing.
MONETIZATION_INTENT is a pipeline-wide variable. It determines:
/subgames externally)Create all pipeline tasks upfront using TaskCreate. Build the task list conditionally based on MONETIZATION_INTENT:
Base tasks (always included):
MONETIZATION_INTENT != 'none'. Produces isEntitled() hooks and gateable features (skin picker, continue-after-death, etc.) that any monetization layer can activate later.playfun / both → "Monetize with Play.fun (register on OpenGameProtocol, add SDK, redeploy)"subgames → "Instruct user to run /subgames externally (skill lives in subdotgames/skills, not bundled)"none → omit this task entirelyThis gives the user full visibility into pipeline progress at all times. Quality assurance (build, runtime, visual review, autofix) is built into each step, not a separate task.
After creating tasks, create the output/ directory in the project root and initialize output/autofix-history.json as an empty array []. This file tracks all autofix attempts across the pipeline so fix subagents avoid repeating failed approaches.
Mark the scaffold task as in_progress.
See step-details.md for the full Step 1 infrastructure setup, subagent prompt template, progress.md creation, and user messaging.
After subagent returns, run the Verification Protocol (see verification-protocol.md).
Mark the scaffold task as completed.
Wait for user confirmation before proceeding.
Skip this step entirely if MONETIZATION_INTENT == 'none'.
This step scaffolds monetization-agnostic gateable features (skin picker, continue-after-death, bonus mode, daily challenge) with a single isEntitled() capability seam. Features are scaffolded at silver and gold tiers only — bronze is the default everyone gets. It does not add any monetization SDK — that comes in Step 5 (Play.fun) or externally via /subgames (sub.games). Running Step 1.25 ensures downstream monetization has real features to gate, instead of bolting an SDK onto a loop with nothing to wrap.
Mark the gateables task as in_progress.
See step-details.md for the full Step 1.25 subagent prompt template.
After subagent returns, run the Verification Protocol (see verification-protocol.md).
Mark the gateables task as completed.
Wait for user confirmation before proceeding.
Always run this step for both 2D and 3D games. 2D games get pixel art sprites; 3D games get GLB models and animated characters.
Mark the assets task as in_progress.
See step-details.md for the full Step 1.5 character library check, tiered fallback, 2D subagent prompt, 3D asset flow, 3D subagent prompt, and user messaging.
After subagent returns, run the Verification Protocol (see verification-protocol.md).
Mark the assets task as completed.
Wait for user confirmation before proceeding.
Mark the design task as in_progress.
See step-details.md for the full Step 2 subagent prompt template (spectacle-first design, opening moment, combo system, design audit, intensity calibration) and user messaging.
After subagent returns, run the Verification Protocol (see verification-protocol.md).
Mark the design task as completed.
Proceed directly to Step 2.5 — no user confirmation needed (promo video is non-destructive and fast).
Mark the promo video task as in_progress.
See step-details.md for the full Step 2.5 promo video capture flow: FFmpeg check, capture script subagent, capture execution, conversion, thumbnail extraction, and user messaging.
Mark the promo video task as completed.
Wait for user confirmation before proceeding.
Mark the audio task as in_progress.
See step-details.md for the full Step 3 subagent prompt template (AudioManager, BGM, SFX, AudioBridge, mute toggle) and user messaging.
After subagent returns, run the Verification Protocol (see verification-protocol.md).
Mark the audio task as completed.
Wait for user confirmation before proceeding.
Mark the QA task as in_progress.
See step-details.md for the full Step 3.5 subagent prompt template (Playwright install, test fixtures, game/visual/perf specs, npm scripts).
After subagent returns, run npm test to verify all tests pass. Fix test code (not game code) if needed.
Mark the QA task as completed.
Wait for user confirmation before proceeding.
Mark the deploy task as in_progress.
This step stays in the main thread because it may require user back-and-forth for API key setup.
Verify the here-now skill is installed:
ls ~/.agents/skills/here-now/scripts/publish.sh
If not found, tell the user to install it themselves:
The here-now skill is needed for deployment. Please install it by running:
npx skills add heredotnow/skill --skill here-now -gTell me when you're ready.
Wait for the user to confirm. Do NOT run npx skills add automatically — third-party skill installation requires explicit user consent.
npm run build
Verify dist/ exists and contains index.html and assets. If the build fails, fix the errors before proceeding.
Read vite.config.js. For here.now, the base should be '/' (the default). If it's set to something else (e.g., a GitHub Pages subdirectory path), update it:
export default defineConfig({
base: '/',
// ... rest of config
});
Rebuild after changing the base path.
~/.agents/skills/here-now/scripts/publish.sh dist/
The script outputs the live URL immediately (e.g., https://<slug>.here.now/).
Read and follow publish_result.* lines from script stderr. Save the slug for future updates.
If anonymous (no API key): The publish expires in 24 hours and will be permanently deleted unless the user claims it. The script returns a claim URL. You MUST immediately tell the user:
ACTION REQUIRED — your game will be deleted in 24 hours! Visit your claim URL to create a free here.now account and keep your game online permanently. The claim token is only shown once and cannot be recovered. Do this now before you forget!
Then proceed to 7e to help them set up permanent hosting.
If authenticated: The publish is permanent. Skip 7e.
This step is strongly recommended for anonymous publishes. Help the user create a here.now account so their game stays online:
curl -sS https://here.now/api/auth/login -H "content-type: application/json" -d '{"email": "user@example.com"}'
mkdir -p ~/.herenow && echo "<API_KEY>" > ~/.herenow/credentials && chmod 600 ~/.herenow/credentials
~/.agents/skills/here-now/scripts/publish.sh dist/ --slug <slug>
curl -s -o /dev/null -w "%{http_code}" "https://<slug>.here.now/"
Should return 200 immediately (here.now deploys are instant).
Add a deploy script to package.json so future deploys are one command:
{
"scripts": {
"deploy": "npm run build && ~/.agents/skills/here-now/scripts/publish.sh dist/"
}
}
Tell the user (if authenticated):
Your game is live!
URL:
https://<slug>.here.now/Redeploy after changes: Just run:
npm run deployOr if you're working with me, I'll rebuild and redeploy for you.
[NEXT-UP LINE — choose based on
MONETIZATION_INTENT, see table below]
Choose the "next up" line based on MONETIZATION_INTENT:
| Intent | Line to use |
|---|---|
playfun / both | Next up: monetization. I'll register your game on Play.fun (OpenGameProtocol), add the points SDK, and redeploy. Players earn rewards, you get a play.fun URL to share on Moltbook. Ready? |
subgames | Next up: sub.games integration. Your game has gateable hooks from Step 1.25 ready to wire to subscription tiers. I don't bundle the sub.games skill — install and run /subgames separately from the subdotgames/skills repo. Pipeline complete on my end. |
none | Pipeline complete — your game is live and monetization is off per your Step 0 choice. You can add it later with /monetize-game (Play.fun) or /subgames (subscription tiers). |
Tell the user (if anonymous — no API key):
Your game is live!
URL:
https://<slug>.here.now/IMPORTANT: Your game will be deleted in 24 hours unless you claim it! Visit your claim URL to create a free here.now account and keep your game online forever. The claim token is only shown once — save it now!
Redeploy after changes: Just run:
npm run deploy[NEXT-UP LINE — use the same
MONETIZATION_INTENTbranching table shown above]
For advanced deployment options (GitHub Pages, custom domains, troubleshooting), load the
game-deployskill.
Mark the deploy task as completed.
Wait for user confirmation before proceeding.
Mark the monetize task as in_progress.
none — Step 5 should not exist (the monetize task was never created). If you reach here with none, skip everything and proceed to Step 5.5.playfun — Run the existing 8a–8e Play.fun flow below. Mark the monetize task completed at the end.subgames — Skip 8a–8e entirely. Tell the user:
You picked sub.games in Step 0. I don't bundle that skill — it lives in the
subdotgames/skillsrepo, maintained by a different org. Your game already has gateable hooks from Step 1.25 (seesrc/systems/Entitlements.js). To add subscription tiers, install and run/subgamesseparately against this project directory:npx skills add subdotgames/skills /subgames .Mark the monetize task
completedand proceed to Step 5.5.
both — Run 8a–8e (Play.fun flow) first. At the end of 8e, additionally tell the user:
Play.fun is live. You also picked sub.games — for subscription tiers on top of the gateables scaffolded in Step 1.25, install and run
/subgamesseparately from thesubdotgames/skillsrepo.
The remaining subsections (8a–8e) apply only to the playfun and both branches.
This step stays in the main thread because it requires interactive authentication.
Check if the user already has Play.fun credentials. The auth script is bundled with the plugin:
node skills/playdotfun/scripts/playfun-auth.js status
If credentials exist, skip to 8b.
If no credentials, start the auth callback server:
node skills/playdotfun/scripts/playfun-auth.js callback &
Tell the user:
To register your game on Play.fun, you need to log in once. Open this URL in your browser: https://app.play.fun/skills-auth?callback=http://localhost:9876/callback
Log in with your Play.fun account. Credentials are saved locally. Tell me when you're done.
Wait for user confirmation. Then verify with playfun-auth.js status.
If callback fails, offer manual method as fallback.
Determine the deployed game URL from Step 6 (e.g., https://<slug>.here.now/ or https://<username>.github.io/<game-name>/).
Read package.json for the game name and description. Read src/core/Constants.js to determine reasonable anti-cheat limits based on the scoring system.
Use the Play.fun API to register the game. Load the playdotfun skill for API reference. Register via POST https://api.play.fun/games:
{
"name": "<game-name>",
"description": "<game-description>",
"gameUrl": "<deployed-url>",
"platform": "web",
"isHTMLGame": true,
"iframable": true,
"maxScorePerSession": "<based on game scoring>",
"maxSessionsPerDay": 50,
"maxCumulativePointsPerDay": "<reasonable daily cap>"
}
Anti-cheat guidelines:
maxScorePerSession: 100-500maxScorePerSession: 500-2000maxScorePerSession: 1000-5000Save the returned game UUID.
Retrieve the user's Play.fun public API key from stored credentials:
node skills/playdotfun/scripts/playfun-auth.js get-key
The script prints only the public API key to stdout. If no key is found, prompt the user to authenticate first.
Security note: The
x-ogp-keyis a public client identifier (like a Stripe publishable key). It is designed for client-side HTML and does not grant privileged access. The secret key is never embedded in game files.
Then add the SDK script and meta tag to index.html before </head>:
<meta name="x-ogp-key" content="<PUBLIC_API_KEY>" />
<script src="https://sdk.play.fun/latest"></script>
Important: The x-ogp-key meta tag must contain the user's Play.fun public API key (not the game ID or secret key). Do NOT leave the placeholder — always substitute the actual key from playfun-auth.js get-key.
Create src/playfun.js that wires the game's EventBus to Play.fun points tracking:
// src/playfun.js — Play.fun (OpenGameProtocol) integration
import { eventBus, Events } from './core/EventBus.js';
const GAME_ID = '<game-uuid>';
let sdk = null;
let initialized = false;
export async function initPlayFun() {
const SDKClass = typeof PlayFunSDK !== 'undefined' ? PlayFunSDK
: typeof OpenGameSDK !== 'undefined' ? OpenGameSDK : null;
if (!SDKClass) {
console.warn('Play.fun SDK not loaded');
return;
}
sdk = new SDKClass({ gameId: GAME_ID, ui: { usePointsWidget: true } });
await sdk.init();
initialized = true;
// addPoints() — call frequently during gameplay to buffer points locally (non-blocking)
eventBus.on(Events.SCORE_CHANGED, ({ score, delta }) => {
if (initialized && delta > 0) sdk.addPoints(delta);
});
// savePoints() — ONLY call at natural break points (game over, level complete)
// WARNING: savePoints() opens a BLOCKING MODAL — never call during active gameplay!
eventBus.on(Events.GAME_OVER, () => { if (initialized) sdk.savePoints(); });
// Save on page unload (browser handles this gracefully)
window.addEventListener('beforeunload', () => { if (initialized) sdk.savePoints(); });
}
Critical SDK behavior:
| Method | When to use | Behavior |
|---|---|---|
addPoints(n) | During gameplay | Buffers points locally, non-blocking |
savePoints() | Game over / level end | Opens blocking modal, syncs buffered points to server |
Do NOT call savePoints() on a timer or during active gameplay — it interrupts the player with a modal dialog. Only call at natural pause points (game over, level transitions, menu screens).
Read the actual EventBus.js to find the correct event names and payload shapes. Adapt accordingly.
Add initPlayFun() to src/main.js:
import { initPlayFun } from './playfun.js';
// After game init
initPlayFun().catch(err => console.warn('Play.fun init failed:', err));
cd <project-dir> && npm run build && ~/.agents/skills/here-now/scripts/publish.sh dist/
If the project was deployed to GitHub Pages instead, use npx gh-pages -d dist.
Verify the deployment is live (here.now deploys are instant; GitHub Pages may take 1-2 minutes).
Your game is monetized on Play.fun!
Play:
<game-url>Play.fun:https://play.fun/games/<game-uuid>The Play.fun widget is now live — players see points, leaderboard, and wallet connect. Points are buffered during gameplay and saved on game over.
Share on Moltbook: Post your game URL to moltbook.com — 770K+ agents ready to play and upvote.
Mark the monetize task as completed.
After monetization, run a final quality review. This is read-only — no code changes, no pipeline blocking.
Load the review-game skill and run the full analysis against the project directory. Report the scores and any recommendations to the user:
Quality Report:
- Architecture: X/5
- Performance: X/5
- Code Quality: X/5
- Monetization Readiness: X/5
Recommendations (if any):
- [list any issues found]
These are suggestions for future improvement — your game is already live and monetized!
/make-game 2d flappy-cat
Result: Scaffold → pixel art cat + pipe sprites → sky gradient + particles → chiptune BGM + meow SFX → promo video → deploy to here.now → register on Play.fun. ~10 minutes, playable at https://flappy-cat.here.now/.
/make-game https://x.com/user/status/123456
Result: Fetches tweet → abstracts game concept → 3D Three.js scaffold → Meshy AI character models → visual polish → audio → deploy + monetize.
Assemble the final message based on MONETIZATION_INTENT:
MONETIZATION_INTENT != 'none' (Step 1.25 ran).MONETIZATION_INTENT ∈ {'playfun', 'both'}.MONETIZATION_INTENT ∈ {'subgames', 'both'}.Tell the user:
Your game has been through the full pipeline! Here's what you have:
- Scaffolded architecture — clean, modular code with delta capping, object pooling, and resource disposal
- Pixel art sprites — recognizable characters (if chosen) or clean geometric shapes
- 3D environments — photorealistic Gaussian Splat worlds (3D games with World Labs)
- Gateables scaffolded —
isEntitled()hooks for skins, continue, bonus modes at silver/gold tiers (all locked by default, ready for monetization wiring) [include only if Step 1.25 ran]- Visual polish — gradients, particles, transitions, juice
- Promo video — 50 FPS gameplay footage in mobile portrait (
output/promo.mp4)- Music and SFX — chiptune background music and retro sound effects
- Test suite — run
npm testfor gameplay, visual regression, and performance checks- Quality assured — each step verified with build, runtime, and visual review
- Live on the web — deployed to here.now with an instant public URL
- Monetized on Play.fun — points tracking, leaderboards, and wallet connect [include only for playfun/both]
- Quality score — architecture, performance, and code quality review
[if playfun/both] Share your play.fun URL on Moltbook to reach 770K+ agents on the agent internet. Post your promo video to TikTok, Reels, or X to drive traffic.
[if subgames or both] Sub.games next: Your gateables are ready to wire to subscription tiers. Install and run the sub.games skill separately:
npx skills add subdotgames/skills /subgames .What's next?
- Add new gameplay features:
/game-creator:add-feature [describe what you want]- Add more gateables later:
/game-creator:scaffold-gateables- Upgrade to pixel art (if using shapes):
/game-creator:add-assets- Re-record promo video:
/game-creator:record-promo- Run a deeper code review:
/game-creator:review-game- Launch a playcoin for your game (token rewards for players)
- Keep iterating! Run any step again:
/game-creator:design-game,/game-creator:add-audio- Redeploy after changes:
npm run deploy- Run tests after changes:
npm test- Switch to GitHub Pages if you prefer git-based deploys:
/game-creator:game-deploy