The Pac-Man Benchmark: Testing Local Agentic Coding AI

Search interest around "the Pac-Man benchmark" and "Qwen 3.6 27B" has spiked in local-LLM circles, but the two claims tangled up in that phrase deserve separate treatment. One is real and useful: a growing community habit of testing coding-capable language models by asking them to build a playable arcade-game clone in a single prompt. The other — a specific model called "Qwen 3.6 27B" beating named AMD GPUs by precise fractions of a second — does not match anything in Alibaba's public Qwen3 documentation and should be treated as unverified until a primary source surfaces.

This piece covers what's actually verifiable: why one-shot game clones became a popular agentic-coding smoke test, what the real Qwen3 model family looks like, and what local hardware realistically needs to look like if you want to run this kind of test yourself.

What the "Pac-Man benchmark" actually is

There's no standardized, peer-reviewed "Pac-Man benchmark" with a published leaderboard the way there is for something like HumanEval or SWE-bench. What exists is an informal pattern that's spread across coding-AI forums, YouTube demos, and local-LLM subreddits: give a model one prompt ("build a playable Pac-Man clone"), let it write and run the code, and judge the result on three loose criteria.

It's popular because failure is immediately obvious to a non-expert observer — a game that doesn't run is a much clearer signal than a subtle off-by-one error buried in a unit test. That's also its weakness: it's a single subjective prompt, not a reproducible suite, so results swing with prompt phrasing, temperature, and which quantized build you happen to run.

The real Qwen3 family (and where the "3.6 27B" label doesn't fit)

Alibaba's Qwen team ships the Qwen3 line as open-weight checkpoints under an Apache 2.0 license, spanning dense models from roughly 0.6B up to 32B parameters, plus mixture-of-experts checkpoints (30B-A3B and 235B-A22B), and Qwen3-Coder variants tuned specifically for coding and tool-use/agentic workflows. That's the documented lineup on the Qwen3 GitHub repository and the Qwen organization page on Hugging Face.

A model explicitly labeled "Qwen 3.6 27B" isn't part of that published naming scheme. It's plausible the label traces back to a community fine-tune, a merged/quantized checkpoint someone renamed, or a version string a specific tool surfaced — but readers chasing benchmark numbers attached to that exact name should confirm the checkpoint's provenance on Ollama's model library or Hugging Face before trusting any performance claims tied to it, including specific GPU-versus-GPU timing comparisons circulating online. This synthesis intentionally omits those figures because they can't be traced to a verifiable source.

What's safe to say generally: Qwen3-Coder-class models have been broadly competitive with other open-weight coding models in their size class on public benchmarks, and the 30B-32B tier is a common sweet spot for people trying to run agentic coding workflows on a single consumer or prosumer GPU.

Local hardware for agentic coding workloads

Running a 30B-class coding model locally, agentically (meaning the model can execute code, see the output, and iterate — not just complete text), puts different demands on hardware than simple chat inference. Context windows grow fast once tool output and file contents get fed back in, and iteration speed matters more than peak throughput when you're waiting on the model between agent turns.

On the AMD side specifically, ROCm's coverage of mainstream coding LLMs has closed a lot of ground, but generation-to-generation driver maturity still varies — that's covered in depth in our ROCm 2026 state-of-play piece, which is the better reference than any single anecdotal benchmark post for deciding whether a specific AMD card is ready for agentic coding work today. For a parallel case study in how unevenly local-AI hardware support can roll out across a GPU lineup, see how Intel Arc's Stable Diffusion support matured card-by-card rather than all at once — the same pattern shows up with ROCm and coding models.

If you're shopping for a card specifically to run this class of workload, treat any single-source benchmark screenshot — ours included — as a starting point, not a purchase decision. Cross-check against the model's own card on Hugging Face or Ollama, and where possible, against AMD's own ROCm documentation for supported card generations.

Running a one-shot game-clone test yourself

If you want to replicate the general idea rather than chase a specific unverified leaderboard number, the setup is straightforward:

1. Pull a coding-tuned model through Ollama or LM Studio (a Qwen3-Coder checkpoint at a size your VRAM comfortably supports is a reasonable starting point).
2. Give it a single, clearly scoped prompt: a playable clone of a simple arcade game, specifying the language/framework you want.
3. Run the output as-is — don't fix syntax errors by hand before judging the first pass.
4. Score it on your own three-point rubric: does it run, are the mechanics right, how many follow-up turns to "done."
5. Repeat with a different model or quantization level to compare, changing only one variable at a time.

The result is a useful personal signal for whether your hardware-and-model combination is ready for real agentic coding work — refactors, multi-file changes, running your own test suite — even though it isn't a substitute for standardized benchmarks like SWE-bench or LiveCodeBench when making a purchasing decision.

Why Pac-Man, specifically

Part of the benchmark's staying power is just that Pac-Man is a near-universal reference point — simple enough to implement in a few hundred lines, familiar enough that anyone can judge "does this feel right" without reading the code. If the naming convention has you in a nostalgic mood rather than a benchmarking one, SpecPicks' retro-gaming catalog has the genuine article: the Pacman (Neogeo) cartridge for real hardware collectors, the Pac-Man Arcade in a Tin for a self-contained 8-bit throwback, and the My Arcade Ms. Pac-Man Pocket Player for a portable version of the original.

Prices shown reflect the last recorded catalog price and may vary — check the live listing before buying.

The bottom line

The useful signal buried in "the Pac-Man benchmark" story is real: one-shot game-clone prompts are a legitimate, low-effort way to gut-check whether a local coding model and your GPU are ready for agentic workflows, and the Qwen3-Coder family is a genuinely strong open-weight option in that space. The specific numeric claims attached to a model called "Qwen 3.6 27B" beating named AMD GPUs by precise margins aren't traceable to an official source as of this writing, and readers should treat any such figures with skepticism until a primary benchmark citation appears. When evaluating hardware for local agentic coding, lean on documented model cards, reproducible benchmark suites, and vendor driver-support pages over single anecdotal posts.

Citations and sources

• Qwen3 GitHub repository — official model lineup and licensing
• Qwen organization on Hugging Face — published checkpoints and model cards
• Qwen3 on Ollama's model library — available local tags and quantizations
• AMD ROCm product page — official supported-hardware documentation

This piece is editorial synthesis based on publicly available information. No independent first-party benchmarking is reported.