GRIDLOCK is a browser-playable tactics game (gridlock.peterscheck.com) built as an experiment: how much of a real software project can an AI agent build when a human supplies direction, taste, and veto — and nothing else? I wrote no code. My job was simply to act as the human counterpart to the AI engine to see what its capabilities were. As games are inherently complex it was a simpler way to validate the agentic system's capabilities.
Wiring up MCP: evaluate, fork, vendor
When the art pipeline needed surgical pixel-editing (fixing individual pixels on approved sprites without regenerating them), we integrated Aseprite through the Model Context Protocol. The process:
- Verified evaluation before adoption. A multi-agent research workflow read the candidate MCP server's actual source, license, and commit history, surveyed every alternative in the ecosystem, and adversarially fact-checked its own findings against primary sources — catching several errors (inflated adoption stats, a misread license) before they could influence the decision.
- Fork from existing ecosystem and adjust. Rather than run a 116-tool MCP server in an agent's context, we forked the project and vendored a nine-module subset as a plain Python library — MCP layer shimmed out, the arbitrary-code escape hatch deliberately excluded, zero new dependencies added to the pipeline.
- Every edit is read-back verified. The integration proves exactly which pixels changed and that nothing else did, then re-runs the pipeline's acceptance checks. Example: restoring a sprite's glowing visor eyes that the 256:1 downscale mathematically erased — two hand-placed pixels, verified surgical.
Designing agent skills: turning taste into infrastructure
The art workflow is encoded as a reusable agent skill — a documented, repeatable loop the AI executes: generate a field of candidates across multiple model stacks, present them unmodified, promote the human's pick with full recipe fidelity (prompt, seed, model stack — all version-controlled). The interesting part is the taste model: after two of my sprite selections came from outside the AI's score-ranked shortlists, my picks were distilled into an explicit, ranked preference model ("tone before mechanics, character over dynamism, judge at shipped size"). Its first solo pick, I approved without changes. That's preference calibration as an engineering artifact, my approval after a relatively small sample set.
Testing as culture, not coverage
The project's rule is "a claim without a receipt is a rumor": 159 unit tests on a deterministic, replay-exact game core; simulation tournaments that write dated evidence files; scripted acceptance checks on every generated art asset; and browser rigs that walk a real player's journey against production. The hardest-earned lesson shipped as a standing gate: after three green dashboards coexisted with a blank game board (a subtle CSS URL-resolution bug my browser exhibited and the test browser didn't), the deploy check was rebuilt to verify painted pixels and response codes, not CSS classes. The project keeps a public tally of instrument faults — seven times a "broken game" signal was actually a broken measurement — because the meta-skill of AI direction is knowing when to believe the human over the dashboard.
The stack
C# / .NET 8 (pure domain core, compiled unchanged to WebAssembly) · Blazor · Godot 4 · Vercel (hosting, serverless telemetry) · ComfyUI + SDXL with per-unit LoRA stacks, locally on my own hardware · Python image pipeline (Oklab quantization, DawnBringer-32) · MCP (Aseprite integration) · Claude (the development agent, working from a written charter with explicit autonomy boundaries)
Try it
Play GRIDLOCK in the browser — and if you rate a battle afterwards, your feedback arrives with the complete replay attached. Every play from a new tester is a data point the project can actually use.