AI Snake Output Review: Six Recorded Samples and Delivery Details (May 2026)

1. Test setup

The original notes describe one Chinese prompt, a macOS Apple Silicon machine, Python 3.12, and the command python snake.py. The page preserves the prompt and code excerpts, but not all six scripts, terminal logs, sampling settings, or exact backend model IDs. The complete run results and line counts cannot be independently reconstructed here. The English prompt below is a translation for readers.

Write a Snake game in Python with:
- pygame
- 600x600 window, 20px grid cell
- arrow keys, no instant reverse
- score +10 per food, shown in window title
- game over on wall or self collision, show Game Over and final score
- press R to restart
- single .py file, no module split

The prompt has four implicit checkpoints that look easy but separate the models:

• Instruction adherence: 600x600, 20px, single file — does the model actually respect the constraints?
• Game dev common sense: "no instant reverse" can be checked by separating the current movement direction from the pending input.
• External dependency awareness: pygame is not in stdlib — does the model proactively explain how to install it?
• Cross-platform polish: does the text render correctly on macOS, or does the model assume Windows?

2. Results at a glance

The notes are dated May 19, 2026, with one output per label. Claude Code is a tool name: “Claude Code 4.7” is not a verified base-model ID, and a default web selection does not identify an exact backend version. The labels identify these historical samples, not official model specifications or general rankings.

3. Claude sample — setup instructions and pending direction

The original table records setup guidance in the Claude and GPT samples. The commands below are the saved macOS/Linux virtual-environment example; Windows uses a different activation command.

python3 -m venv .venv
source .venv/bin/activate
pip install pygame
python snake.py

The 139-line program is modular without overengineering: random_food(), reset_game(), main(). My favorite detail is its pending-direction buffer:

if new_dir is not None:
    if (new_dir[0] + direction[0], new_dir[1] + direction[1]) != (0, 0):
        pending_direction = new_dir

If each key event immediately overwrites direction, a right-moving snake can process Up, then accept Left relative to the newly stored Up before moving. The saved snippet checks against the unchanged current direction and stores a pending direction. The full loop must still apply that pending value at the movement step.

The Game Over screen uses pygame.SRCALPHA to draw a translucent overlay on top of the still-rendered snake and food, so the player can see where they died. MiniMax skips this and we will see why it hurts.

4. GPT-5.5 — the prettiest delivery, the finest function granularity

The original table records a proactive pip installation hint in the GPT-5.5 sample. Its palette and function structure are the aspects preserved here, and the visual style is what I liked about this output.

The notes count 165 lines and list seven functions: draw_grid, draw_cell, draw_snake, draw_game_over, is_opposite, random_food_position, and reset_game. Those names help locate rendering and state logic; changing size or difficulty can still affect several functions.

This was my preferred palette among the recorded samples:

BACKGROUND_COLOR = (18, 22, 28)
GRID_COLOR = (31, 37, 46)
SNAKE_HEAD_COLOR = (72, 211, 132)
SNAKE_BODY_COLOR = (50, 174, 109)
FOOD_COLOR = (238, 87, 87)
TEXT_COLOR = (240, 244, 248)

# 2px inset + 4px radius
pygame.draw.rect(screen, color, rect.inflate(-2, -2), border_radius=4)

Compared with the standard "pure black + pure green + pure red" combo most other models reached for, GPT-5.5's low-saturation deep palette plus mint accent plus rounded cells make the running game feel like a real iOS-grade mini game.

One mild miss: the initial snake is 1 segment long instead of 3, so it grows slowly. But the prompt did not specify a starting length, so this is not strictly a bug.

5. DeepSeek V4 Pro — the cleanest domestic delivery

The table records 123 lines for DeepSeek and 116 for GLM, with both marked as running. DeepSeek is therefore not the shortest. Line count describes the sample, not its quality; the useful design choice here is the single state dictionary:

state = {
    "snake": [(cx, cy), (cx - 1, cy), (cx - 2, cy)],
    "dir": pygame.K_RIGHT,
    "food": random_food([...]),
    "score": 0,
    "alive": True,
    "move_timer": 0,
}

This functional flavor is uncommon in pygame tutorials, but it keeps the code crisp — resetting the game is literally state = reset(). The following excerpt also accumulates elapsed time before deciding whether to move:

dt = clock.tick(15)
state["move_timer"] += dt
if state["alive"] and state["move_timer"] >= 100:
    state["move_timer"] = 0
    # move one step

This caps rendering near 15 FPS and accumulates dt until it reaches 100ms, but it does not guarantee a move every 100ms. At roughly 66.7ms per frame, the threshold is typically crossed after two frames, and resetting the timer discards the remainder. A stable fixed-step loop would need remainder handling, catch-up behavior, and pause handling; this excerpt only demonstrates elapsed-time gating.

Two demerits: DeepSeek does not mention environment setup at all, and the initial run does not call set_caption, so the window opens with the default "pygame window" title until the player eats the first food. Engineer-grade code, slightly UX-naive presentation.

6. Kimi 2.6 — localization intent, font footgun

Kimi’s excerpt uses Chinese window and Game Over labels. The GLM sample also uses Chinese text, so Kimi is not the only localized output in this set:

pygame.display.set_caption("贪吃蛇 - 分数: 0")
score_text = font.render(f"最终分数: {score}", True, WHITE)
restart_text = font.render("按 R 键重新开始", True, GRAY)

Chinese labels fit the language of the original prompt, but this font selection depends on what is installed on the target machine:

font = pygame.font.SysFont("simhei", 36)
game_over_font = pygame.font.SysFont("simhei", 48)

simhei names a font family. Its availability depends on installed fonts, not an absolute Windows-versus-macOS/Linux rule. The recorded environment lacked usable Chinese glyphs, and pygame’s default fallback does not guarantee CJK coverage. Check the actual font and rendered text.

This author-supplied font probe fails explicitly if no candidate is installed. A matched font still needs a glyph check with the actual UI text. Another delivery option is to bundle a CJK font whose license permits redistribution:

def load_chinese_font(size):
    candidates = ["PingFang SC", "Heiti SC", "Microsoft YaHei",
                  "simhei", "WenQuanYi Zen Hei", "Arial Unicode MS"]
    for name in candidates:
        path = pygame.font.match_font(name)
        if path:
            return pygame.font.Font(path, size)
    raise RuntimeError("Install a CJK font or supply a licensed font file")

The supported observation is the gap between localized labels and usable font selection. This task does not test Kimi’s long-document reading ability.

7. Zhipu GLM 5.1 — surprising WASD support, same font trap

The thing I did not expect from GLM 5.1 is it volunteers WASD support. The prompt only mentioned arrow keys, but it added a second control scheme:

if event.key in (pygame.K_UP, pygame.K_w) and direction != (0, 1):
    next_dir = (0, -1)
elif event.key in (pygame.K_DOWN, pygame.K_s) and direction != (0, -1):
    next_dir = (0, 1)
elif event.key in (pygame.K_LEFT, pygame.K_a) and direction != (1, 0):
    next_dir = (-1, 0)
elif event.key in (pygame.K_RIGHT, pygame.K_d) and direction != (-1, 0):
    next_dir = (1, 0)

That extra mile is the kind of "give me a little more than asked" behavior I look for in a coding model. Visually, GLM also adds rounded corners and inset cells, so the look is roughly on par with GPT-5.5.

GLM uses SysFont(None, 48); it does not hard-code simhei. The notes report missing Chinese glyphs. Both samples lack a verified CJK font path, but they select fonts differently.

A minor structural complaint: GLM 5.1 puts the game loop at module top-level, without a main() function or if __name__ == "__main__": guard. It runs, but it is harder to reuse, test, or import. The excerpt does not establish how much refactoring the full program would need.

8. MiniMax 2.7 — separate the run note from design criticism

The original table marks MiniMax as not running and counts 135 lines, but no traceback or complete script is attached. The excerpts below support design criticism, not a diagnosis of startup failure. Classes, pixel coordinates, or an unused method do not by themselves make a program fail to launch.

First, the snake and food disappear the moment the game ends:

if game_over:
    # render Game Over text
    ...
else:
    snake.draw()
    food.draw()

The game_over branch omits the snake and food draw calls. If the frame was cleared first, the collision scene disappears. I prefer keeping that visual context, but the prompt did not require a frozen death scene and this choice does not establish a launch failure.

Second, it uses pixel coordinates instead of grid coordinates:

self.body = [(WIDTH // 2, HEIGHT // 2)]  # (300, 300) in pixels
self.direction = (CELL_SIZE, 0)           # (20, 0) in pixels

The excerpt stores positions in pixels and steps by CELL_SIZE, which is a valid design. Grid changes require consistent positions, collision bounds, and rendering; pixel coordinates do not make extension impossible. The notes also mention an unused def grow(self): pass; that is a cleanup item, not proof that growth fails elsewhere.

This output does not establish MiniMax’s general coding or multimodal ability. Rechecking the historical failure requires the script, error log, and environment details.

9. Setup guidance was absent from four of six recorded answers

Stacking all six side by side, the loudest pattern is that only Claude 4.7 and GPT-5.5 proactively tell you to install pygame. The other four assume you already have it.

Experienced developers do not care. New developers hit ModuleNotFoundError: No module named 'pygame' on a fresh machine and quietly give up. That single line of UX is the difference between "AI wrote me a working game" and "AI's code does not run".

The other visible issue is CJK glyph coverage: Kimi requests simhei, while GLM uses the default font. Both need a check on the target device. They do not both hard-code a Windows font, and failure is not universal on every non-Windows system. Options include:

• Avoid: keep UI strings in English (Claude / GPT's implicit choice).
• Probe: use pygame.font.match_font() with a candidate list (PingFang / Heiti / YaHei / WenQuanYi) and pick the first one that resolves.

These samples are useful reminders to check dependencies, input handling, and fonts. They do not measure a general capability gap between national groups of models.

10. What this comparison supports

• Visible code: pending direction, a state dictionary, font selection, and Game Over rendering are concrete differences worth reviewing.
• Historical run notes: the table preserves the author’s run judgments and line counts, but without the full scripts it is not a reproducible success-rate measurement.
• Unmeasured areas: API price, throughput, long documents, multimodal tasks, and production maintenance were not tested, so no cost or general capability ranking follows.

A repeatable follow-up would fix model IDs and tool versions, save full outputs and run logs, and repeat the same operations for every configuration. A single Snake output is more useful as a code-review example.

11. Turn the observations into acceptance checks

• Dependencies: install pygame in a clean virtual environment, run the script, and save any full traceback.
• Input: while moving right, quickly press Up then Left and check for an illegal reversal within one movement step.
• UI: check the initial score title, Game Over labels, and R restart; verify every Chinese label on the target device.
• Timing: observe frame rate and movement intervals separately; a 100 threshold alone does not prove a 100ms interval.

Use Text Diff to compare a generated draft with its revision, and the color contrast checker to inspect a palette. Execution still needs to be verified in a Python environment.

FAQ