On this page
A test going green is one of the most reassuring sounds in software. The CI bell rings, the checkmark turns, the PR merges. Everyone moves on.
But a green check only proves one thing: the code you asserted on did what you asserted. It says nothing about the thousand things you didn't think to assert on.
When an agent is writing the code and the tests, the set of things nobody thought about gets very large, very fast. The step that closes that gap has a name now, AI verification, and this post is the short version of why it exists.
Why a green check passes on a broken page
Most testing tools look at the surface. They render the page, take a picture, literally or figuratively, and compare it to what they expected. Playwright's visual comparisons are the literal version: a screenshot diffed against a stored one.
If the button is there and the text matches, the test passes. A passing test is a receipt for the assertion, not for the app.
The trouble is that an app is not its screenshot. A checkout page can render perfectly while the charge silently 500s. A success toast can appear while the order never reaches the database.
The DOM says one thing; the program is doing another. A picture can't see the difference, which makes a false green the only bug that shows up with its own alibi.
A false green is the most expensive kind of bug: nothing flags it. It ships, and you find out from a user.
What "proof" actually requires
To know an app works, you have to look at the app, not the picture of it, the network calls it made, the state it ended in, the errors it swallowed, the source line where the behavior diverged from intent. That's the difference between it looks done and it is done.
This is the layer most tools skip, because reaching it is hard. It means running inside the program, not beside it. It means asserting on behavior and state instead of pixels. It means a verdict you can trace to a line of code, not a diff you have to eyeball.
Trust, earned per run
When green means "the page rendered," you learn to distrust green, you click through the flows yourself, just in case. That instinct is correct, and it's also unsustainable once an agent is shipping all day.
The fix isn't more screenshots. It's a green that's earned: backed by the real signals the program emitted, reproducible on every run, and pointed at the exact place things broke when they break. A checkmark you don't have to second-guess.
That's the whole game, making the green mean what everyone already assumes it means.
If the word "verify" is doing a lot of work in your team's vocabulary, verification vs validation separates the two questions a green is usually assumed to answer. For a working setup with a coding agent, see using Claude Code for QA automation.
Fun fact
Volkswagen's diesel software could tell when a car was on an emissions test and turned full emissions controls on only during the test. On the road, the same cars emitted nitrogen oxides at up to 40 times the standard (US EPA). Every test was green, and the cars were not.
Conclusion
A green check proves the assertions you wrote held, and nothing about the ones you did not write. A page can render perfectly while the charge returns 500 and the order never reaches the database, and every picture of it will agree with the toast.
So the next time a suite goes green on an agent's change, ask what the green actually read. If the answer is pixels or DOM text, open the network log and the app's state before you merge, or make your checks read them for you.
FAQ
What is a false green?
A false green is a passing test on a broken app. The check asserted on something that looked right, such as a rendered page or a success toast, while the program did something else, like a charge request that returned 500. Nothing flags it, so it ships and you find out from a user.
Why can a test pass when the app is broken?
A test only checks what its author asserted, usually what reached the screen. The app also sends requests, changes state and logs errors while the test runs. None of that is in the assertion, so none of it can fail the test, and when an agent writes both code and tests, the unasserted part grows fast.
Are screenshot tests enough to prove an app works?
No. A screenshot test shows the page looks the way it did before, not that the app behaved correctly. A checkout can render perfectly while the charge fails and the order never reaches the database. To prove behaviour, a check has to read the network calls, the application state and the console, not only pixels.
What should a passing check actually verify?
A passing check should verify the network requests and their status, the state the app ended in, and any errors it logged or swallowed, then point at the source line when something diverged. A green earned that way is reproducible on every run and means what people already assume a green check means.
Why Reticle
Your agent says it works. Reticle checks.
- Checks each change inside the running app: network, state and console, not a screenshot.
- Returns a pass or fail with the evidence and the file:line to fix.
- Open-source SDK on your machine, or the platform on every preview and PR.
No credit card required.


