It reads your players' data over MCP, drives the running game with WebMCP, and Glitchless bots check the fix.
Before the fix
The bug, in fx.js, on every pickup
for (let i = 0; i < CONFETTI_PER_BURST; i++) { // 800
const geometry = new THREE.SphereGeometry(…);
const material = new THREE.MeshStandardMaterial(…);
const piece = new THREE.Mesh(geometry, material);
piece.castShadow = true;
scene.add(piece); // never removed
}
Each piece also casts a shadow, so a pickup adds 1,600 draw calls a frame.
Glitchless finding
Critical
Frame-time spikes on level 2
p95 51 ms against a 16.7 ms budget
74% of hitches come within 1.5 s of a powerup
Particles sit at 1,600 and never drop
From frame times on real players' machines, not your own.
WebMCPglitchless_measure()draw calls a frame: 3,494
Editfx.jsone InstancedMesh, pieces reused
Glitchless bots, before and after
Per frame
Before
After
Draw calls
4,652
286
Render time
12.3 ms
1.3 ms
Frame time (p95)
33.1 ms
16.8 ms
Slow frames
6.4%
0.1%
Three bot runs on each build, with the same seeds.
The problem
Vibe-coded games break where you can't see.
You test on one machine. Your players bring every other one.
Your agent debugs it with real data.
An MCP server gives it your players' data. WebMCP lets it drive the running game. When a release gets worse, an alert in Discord, Slack or email hands it the finding. Here's Claude Code fixing the bug above.
MCPglitchless_triage()
1. [CRITICAL] Frame-time spikes on level-2: p95 51.44ms vs 16.7ms budget
2. [CRITICAL] Frame-time spikes on level-3: p95 70.84ms vs 16.7ms budget
3. [HIGH] TypeError: Cannot read properties of undefined (reading 'position')
4. [HIGH] Difficulty spike on level-3 at x≈46.1: 68% of the level's deaths
74% of hitches came within 1.5s of a powerup, and the particles gauge sat at 1,600.
Confetti is back to 0 and draw calls are at their level baseline.
Draw calls a frame3,494→296
Render time a frame (p95)10 ms→1.3 ms
From a real Claude Code session, trimmed. Tools appear under their current names.
Bots play every change before your players do.
Glitchless bots play the old build and the new one with the same seeds, then compare frame time, draw calls, errors and deaths. If anything gets worse, the check fails and the pull request waits.
Your agent can run them too, with the glitchless_playtest tool. On a Steam Deck, npx glitchless-deck sends the build, starts it and measures it there.
The confetti fix against the baseline
Pass
Metric
Baseline
Fix
Change
Slow frames (% over budget)
6.4
0.1
−98%
Frame time p95 (ms)
33.12
16.78
−49%
Render CPU per frame (ms)
12.33
1.26
−90%
Draw calls per frame
4,652
286
−94%
Hitches per minute
4.32
1.81
−58%
Deaths per run
2
2
0%
Level completion (%)
100
100
0%
From glitchless-playtest: three autoplay runs on each build of Zoomies, in Chrome on an M3 Max.
Vibe analytics
A dashboard built for your game.
Your agent asks what you want to know, adds the events that answer it and lays out the pages: kills by weapon for a shooter, wrecks for a racer, leaks per wave for tower defense. Retention, players now and revenue are built in, and every panel exports to CSV.
You ask
Which weapon does the killing?
Your agent addsglitchless.track('kill', { weapon, enemy })
You see
The shotgun gets 511 of 836 kills, and the top error fires inside fireShotgun.
Blastpit, an arena shooter. Kills by weapon, rounds cleared and the error behind them, from 12 bot runs.
Paste one prompt.
Your agent clones Glitchless, starts the server, adds the SDK to your game and checks that data arrives.
Setup prompt for any coding agent
Add Glitchless to this game. Glitchless shows how the game runs and plays for real players: stutters and what causes them, crashes and errors, the game's own moments (modes, rounds, levels, purchases), where players get stuck or quit, who comes back, and bug reports players send. Its MCP server lets you, the coding agent, read that data, fix what players hit and check that the fix worked.
1. Get the Glitchless agent kit, outside this project so it never gets committed:
git clone --depth 1 https://github.com/glitchless-gg/glitchless ~/.glitchless
If that folder already exists, run `git -C ~/.glitchless pull` instead.
If the intake URL in step 2 starts with http://localhost, make sure a local Glitchless server is running there: if http://localhost:7777/v1/health answers, use it. Otherwise, with Docker, run `docker run -d --name glitchless -p 7777:7777 -v glitchless-data:/data ghcr.io/glitchless-gg/glitchless` (or `docker start glitchless` if that container already exists). Without Docker, in ~/.glitchless run `npm install && npm run build`, then `npm run server` in the background. The dashboard is at the same address.
2. Read ~/.glitchless/plugin/glitchless/skills/instrument/SKILL.md and follow it for this game. It covers Three.js (and React Three Fiber), Phaser 3 and 4, Babylon.js, PlayCanvas, Unity 6.3 or later, Godot 4.5 or later, Unreal Engine 5.8, and GameMaker 2024.2 or later; for Godot it sends you to ~/.glitchless/godot/addons/glitchless/README.md.
Use these settings:
- intake URL: http://localhost:7777
- client token: gl_pub_dev (it's public and can only send data, so it's fine inside the game build). On Glitchless Cloud without a token for this game, do the sign-in in step 3 first and make the game with the glitchless_create_game tool: it returns the token.
- privacy: keep the default anonymous mode. Ask me before turning on install mode (what retention, D1/D7/D30, needs) or full mode, because either needs a line in the game's privacy policy.
If the game already reports its own analytics or counters, list them for me and send the same moments to Glitchless with track(), under the same names. Remove the old reporting only when I say so.
If the game sells anything, send each purchase as track('purchase', { amount, currency, item }), so the dashboard can show revenue and conversion.
Ask me whether players should be able to send bug reports from inside the game (a hotkey or a button, with a note and a screenshot). If yes, turn them on as the skill describes; the note is whatever the player types, so it needs a line in the privacy policy too.
For a web game with a production build (Vite or another bundler), also add the source map upload the skill describes (glitchless-sourcemaps), so errors from the minified build show the real file and line. It uploads with a secret key that can upload source maps, read from GLITCHLESS_API_KEY at build time; ask me for one. Skip this while the game sends to a local server.
3. Add two MCP servers to your own MCP settings, in whatever way your tool adds them. For example, `claude mcp add` in Claude Code, ~/.codex/config.toml in Codex, or .cursor/mcp.json in Cursor.
- glitchless: command `npx`, arguments `-y glitchless-mcp`, with the environment variable GLITCHLESS_URL=http://localhost:7777. A local server from step 1 needs nothing more. On Glitchless Cloud, connect it to my workspace once: run `npx -y glitchless-mcp login` in a terminal (or, once the server is loaded, call its glitchless_sign_in tool), show me the link and the code it gives, and wait while I approve it. That saves a workspace key that reaches every game I have, so name this game in its tools (game: "<the game's name>"). Signed in, you can do the rest of this setup yourself with its tools: glitchless_create_game makes a game and returns its client token, glitchless_set_dashboard saves its dashboard, and glitchless_share_board makes a read-only link to a board. If I'd rather give you a secret key for this one game, it's GLITCHLESS_API_KEY in my environment: set that instead. Never put a key in the game, in a file that gets committed, or in your reply.
- webmcp, for a game that runs in a browser (Three.js, Phaser, Babylon.js, PlayCanvas): command `npx`, arguments `-y @jason.today/webmcp@latest --mcp`. It lets you drive the running game: measure frame times, inspect the scene and reproduce problems. Unity, Godot, Unreal and GameMaker builds don't need it: they measure themselves with --glitchless-measure (-glitchless-measure in Unreal and GameMaker).
- For an Unreal game, Epic's Unreal MCP (UE 5.8, Experimental) can sit beside Glitchless: it is your hands in the editor (open maps, look inside Blueprints, edit actors, start Play In Editor), and Glitchless says what is wrong and whether a change fixed it. If the project uses it, or I ask for it, follow the "Agents in the editor: Unreal MCP" part of the instrument skill: it adds the Glitchless Toolset plugin, so Unreal MCP can also measure the game in Play In Editor. Unreal MCP listens on http://localhost:8000/mcp; the Glitchless server stays on its own address.
If your tool needs a restart to load new MCP servers, tell me.
4. If your tool loads skills from a folder (for example ~/.claude/skills, ~/.codex/skills or the project's .agents/skills), copy ~/.glitchless/plugin/glitchless/skills/instrument, ~/.glitchless/plugin/glitchless/skills/dashboard and ~/.glitchless/plugin/glitchless/skills/triage there. If it doesn't, remember this for later: when I ask what's wrong with the game, read ~/.glitchless/plugin/glitchless/skills/triage/SKILL.md and follow it; when I ask for a dashboard or for metrics, read ~/.glitchless/plugin/glitchless/skills/dashboard/SKILL.md.
5. Check that it works. Run the game, play it or let it run for a minute, then confirm sessions arrive: call the glitchless_list_games tool, or ask me to look at http://localhost:7777.
6. Give the game its own dashboard: follow ~/.glitchless/plugin/glitchless/skills/dashboard/SKILL.md. Ask me what I want to know about my players (where they get stuck, which modes they play, whether they come back, what they buy), add the events that answer it, then save pages that fit this game with the glitchless_set_dashboard tool (with game set to this game's name if you're signed in to a workspace).
7. Tell me what you changed, file by file, the events you track, and anything you weren't sure about. If I use Glitchless Cloud, also tell me I can turn on alerts (Discord, Slack or email) in Settings → Alerts, and that you can make a read-only link to any board with glitchless_share_board, for a dev log or a "Live stats" button. On my own server, alerts go to a Discord or Slack webhook set in GLITCHLESS_ALERT_WEBHOOK.
