Objective scoring · real API calls

The Accuracy Test

The flow-field battle showed which model makes the prettiest thing. This one removes taste from the equation entirely. Each prompt below is a fully deterministic specification — there is exactly one mathematically correct output. We then execute each model's real code and diff it against the reference, cell by cell and pixel by pixel. No opinions. Just a score.

Test 1 — Spec transcription: pixel-art sunflower

A 16×16 grid where every cell's color is determined by an explicit geometric formula and a strict rule-ordering. 256 cells, exactly one correct answer. This tests whether a model can follow a long, precise instruction list without improvising.
▸ View the exact prompt sent to all three models
Create a single self-contained HTML file (inline CSS and JS only, no external libraries, no images) that renders a pixel-art sunflower on an HTML canvas. Follow this specification EXACTLY. Every rule is deterministic. Do not improvise, do not add flourishes, do not deviate.

CANVAS
- One <canvas> element with id="art", width exactly 512, height exactly 512.
- Disable image smoothing (ctx.imageSmoothingEnabled = false).
- The canvas is a 16 x 16 grid of cells. Each cell is exactly 32 x 32 pixels, with no gaps, no borders, no padding.
- Cell coordinates: x is the column index 0 to 15, left to right. y is the row index 0 to 15, top to bottom.
- Cell (x, y) occupies canvas pixels from (x*32, y*32) to (x*32+32, y*32+32).
- Every cell must be filled with exactly one flat solid color from the palette below. No gradients, no transparency, no anti-aliasing, no strokes, no outlines.

PALETTE (use these exact hex values, nothing else)
- BG            = #0B0B14
- DISC          = #4A2C10
- DISC_HIGHLIGHT= #7A4A1E
- PETAL_LIGHT   = #FFD447
- PETAL_DARK    = #E8A317
- STEM          = #3E7B27
- LEAF          = #56A93B

DRAWING RULES
Apply these rules in the exact order listed. A later rule overwrites the color set by an earlier rule.

Define d = (x - 7.5)^2 + (y - 5.5)^2  for each cell (x, y).

Rule 1: Fill all 256 cells with BG.
Rule 2: For every cell where d <= 6.25, set the cell to DISC.
Rule 3: For every cell where d <= 2.25, set the cell to DISC_HIGHLIGHT.
Rule 4: For every cell where d > 6.25 AND d <= 20.25, set the cell to PETAL_LIGHT if (x + y) is even, or PETAL_DARK if (x + y) is odd.
Rule 5: For every cell where x is 7 or 8, AND y is greater than or equal to 10 AND y is less than or equal to 15, set the cell to STEM.
Rule 6: Set exactly these eight cells to LEAF, given as (x, y): (5,12), (6,12), (4,13), (5,13), (9,12), (10,12), (10,13), (11,13).

CONSTRAINTS
- No text anywhere on the canvas.
- No animation, no requestAnimationFrame, no interactivity, no event listeners.
- No border, margin, or padding on the canvas element.
- Do not add a title, caption, legend, or any DOM element other than the canvas.

Return ONLY the raw HTML code. No explanation, no markdown fences, no commentary.
Reference
computed from the spec
ground truth
Claude Opus 4.8
real output · ranks below the three leaders
100%
256 / 256 cells
Kimi K3
real output
100%
256 / 256 cells
GPT-5.6 Sol
real output
100%
256 / 256 cells
Result: a three-way tie at 100%. Every model placed all 256 cells correctly, used the exact palette, respected the rule-override order, and obeyed every constraint. That is a real finding, not a dodge — at pure instruction-following, these three are now indistinguishable. So we raised the difficulty.

Test 2 — Mathematical implementation: Mandelbrot set

Same idea, but now the model has to implement math correctly rather than transcribe rules. 160,000 pixels, an exact coordinate mapping, an exact escape condition, and an exact color formula. Off-by-one errors and boundary-condition mistakes become visible pixels.
▸ View the exact prompt sent to all three models
Create a single self-contained HTML file (inline CSS and JS only, no external libraries, no images) that renders the Mandelbrot set to an HTML canvas. Follow this specification EXACTLY. Every value is precise. Do not improvise, do not optimize away precision, do not deviate.

CANVAS
- One <canvas> element with id="frac", width exactly 400, height exactly 400.
- Render by writing directly into an ImageData buffer and calling putImageData once at the end.

COORDINATE MAPPING
- Pixel columns px run 0 to 399 inclusive, left to right.
- Pixel rows py run 0 to 399 inclusive, top to bottom.
- For each pixel, compute the complex constant c = cr + ci*i where:
    cr = -2.10 + (px / 400) * 3.00
    ci = -1.50 + (py / 400) * 3.00
  Use the pixel's top-left corner exactly as written above. Do NOT add 0.5 for pixel centering.

ITERATION
- Start with z = 0 (zr = 0, zi = 0).
- Iterate z = z*z + c.
- Complex squaring: new zr = zr*zr - zi*zi + cr, new zi = 2*zr*zi + ci. Compute the new zi using the OLD zr value.
- Let MAX_ITER = 120.
- Escape condition: the point escapes when zr*zr + zi*zi > 4.0. Test this condition BEFORE performing each iteration step, starting from the initial z = 0.
- Let n be the number of completed iteration steps at the moment the escape condition is first satisfied. If the escape condition is never satisfied within MAX_ITER steps, the point is considered inside the set.

COLORING
- If the point is inside the set, the pixel is exactly rgb(0, 0, 0), alpha 255.
- If the point escaped, compute t = n / 120, then:
    R = Math.floor(255 * t)
    G = Math.floor(255 * t * t)
    B = Math.floor(255 * Math.sqrt(t))
  Clamp each channel to the range 0 to 255. Alpha is 255.

CONSTRAINTS
- No animation, no requestAnimationFrame, no interactivity, no event listeners.
- No text anywhere on the canvas.
- No smoothing, no scaling, no CSS transforms on the canvas.
- Do not add any DOM element other than the canvas.

Return ONLY the raw HTML code. No explanation, no markdown fences, no commentary.
Reference
computed from the spec
ground truth
Claude Opus 4.8
real output · ranks below the three leaders
100.0000%
0 wrong pixels
Kimi K3
real output
99.9963%
6 wrong pixels
GPT-5.6 Sol
real output
100.0000%
0 wrong pixels
CheckClaude Opus 4.8Kimi K3GPT-5.6 Sol
Pixel-exact match vs spec160,000 / 160,000159,994 / 160,000160,000 / 160,000
Canvas exactly 400×400OKOKOK
Single putImageData callOKOKOK
No animation / listeners / textOKOKOK
Max channel error02550
Where Kimi K3 lost 6 pixels. The spec says to test the escape condition before each iteration step, which means a point can still escape on the final check at step 120. Kimi's loop exits at n < 120 and never performs that last test, so six points that should render pure white were painted black instead — the maximum possible error on those pixels. Note they appear as mirror-symmetric pairs about the real axis, which is exactly what a genuine mathematical boundary looks like, not random noise. GPT-5.6 Sol caught it by adding an explicit post-loop check.