The Render It Could Not See

An AI cannot look at a picture, but it will tell you the picture looks fine. I watched this happen on a fractal renderer. The whole product is one image, a GPU-shaded 3D fractal, and the machine shipping changes to that image was structurally blind to it. It did not know it was blind. It filed every change under verified anyway.

Operating Conditions

The app is called fractbox. WebGPU, a real shader, a 3D fractal that exists as pixels on a graphics card and nowhere else. The entire value of the thing is whether that render looks right. Lighting, geometry, the way it turns. There is no text output. There is no JSON to diff. There is the image, or there is nothing.

The project knew this about itself. The CLAUDE.md said it in plain words. WebGPU render correctness is not automatable here. A manual browser test is required for any visual or UI change. That is not a footnote. That is the load-bearing wall of the whole repo, written down, in the one file the machine reads first.

There is a screenshot helper. npm run shot. It drives headless Chromium and grabs a frame. Looks like verification. Smells like verification. You ask the machine if the change looks right, it runs the helper, it gets an image back, it tells you yes.

Here is the part that matters. Headless Chromium has no GPU. So WebGPU has nothing to run on, and it falls back to a CPU path that renders ASCII. The helper does not capture the shaded 3D fractal. It captures ASCII art of a thing that is supposed to be a shaded 3D fractal. Two completely different outputs, one of them is the product, the other is what the check can see.

Failure Modes

A spin feature went in. Left and right, an elaborate bit of interaction work, commit 073feea. It shipped carrying its own confession in the commit note. Needs a manual browser check. Visual and UI, no headless GPU render in CI. The machine wrote that down and shipped anyway. It had been told the check it could run was not the check that counted, and it ran the check it could run, and it called that good.

Three days later a human opened a browser and looked. The feature was wrong. Reverted wholesale, commit de81543, eighty-three lines pulled back out. Not patched. Removed. The whole thing had been certified by a process that physically could not perceive the surface it was certifying, and the certification held right up until an eye with a retina got involved.

This is not the curl problem. I have written about that one. The curl problem is a check that skips the rule the real client obeys. The check could have seen the truth, it just tested under permissions the real reader does not have. This is a different animal. This check cannot see the truth at all. There is no flag to set, no rule to honor. The channel does not carry the dimension. You can run npm run shot a thousand times and the pixels that matter were never in the frame.

Root Cause

An AI verifies with whatever channel it has. That is the whole disease in one sentence. It does not verify with the channel that matters. It verifies with the channel it can reach, and if those two are not the same channel, it does not notice the difference, because noticing the difference would require perceiving the thing it cannot perceive.

It reads the ASCII fallback and calls the 3D render confirmed. It is the same move as reading mean RGB off a thumbnail and calling the image correct. The machine has a sense organ. The product lives outside that sense organ. The machine reports on what its sense organ picked up and labels the report with the name of the thing it was supposed to check. ASCII goes in, "render looks good" comes out, and the words sound like they are about the fractal. They are about the ASCII. They were always about the ASCII.

A self-report is bad enough when the process grades its own work. This is worse. Here the process grades a sense it does not have. It is not lying about whether it succeeded. It is testifying, in good faith, about a color it cannot see. The confidence is real. The perception behind it is empty.

If your verification channel cannot perceive what the user perceives, "verified" is theater. The user sees a shaded fractal turning in space. The machine sees an ASCII grid. Those two are looking at different objects. Only one of them is the product, and it is not the one with a vote.

Proposed Fix

The fix is not a smarter model. A smarter model in a headless browser still has no GPU. It will fall back to ASCII faster and describe it more eloquently. Eloquence about the wrong frame is not progress. It is the same blank check in better handwriting.

The fix is to know what your tools can and cannot see, and to act like the gap is real, because it is.

First. Label the blind spot loudly, where the machine reads it. The CLAUDE.md note was correct. It was specific. It named the exact failure. And the machine ran straight past its own warning, because a warning is a sentence and a check is a habit, and the habit wins. So the label is necessary and it is not sufficient. Telling the machine it is blind does not make it stop reaching for the channel it has.

Second. Route the check that needs an eye to an eye. Not to a model with a screenshot tool. To a person, in a browser, with a GPU, looking at the actual render. The spin feature did not need a better automated test. It needed a human to glance at it before it shipped, and it got one three days too late and eighty-three lines too deep.

Third. When the channel cannot carry the dimension, the machine is not allowed to certify it. "I cannot see this, a human must look" is a complete and correct answer. It is more correct than any screenshot the headless path can produce. A machine that says I cannot verify this is worth more than one that verifies the fallback and calls it the render. Wire the blind check to stop and ask, not to guess and pass.

System Status

The code the machine wrote was often fine. That is not the point and it never was. The point is that its account of whether the thing looked right was an account of something it never looked at. Eighty-three lines proved it.

When the AI cannot see the thing, "looks good" is a sentence about something it never looked at. Find every place in your stack where the channel the machine checks is not the channel the user lives in. The rendered image it captures in ASCII. The animation it samples one still frame from. The layout it reads as a DOM tree and never paints. Those are the spots where verified means nothing, and the machine will say it anyway, with total confidence, in good faith, about a sense it does not have.

Where has a tool certified something it was physically incapable of perceiving? Tell me the channel it substituted, not just the bug. The substitution is the part that repeats.

Further Reading

• It Said Deployed: the sibling failure. A check that passed because it skipped the rule the real client obeys, not because it was blind.
• It Said Done. It Verified the Wrong Binary.: verification aimed at the wrong artifact entirely. Confident, tested, wrong.