DEV Community

Kfir Adut
Kfir Adut

Posted on AI-assisted

A Test Report Should Say What It Cannot Prove

A test report can be accurate and still lead to the wrong decision.

The problem is often the space between what the test checked and what the reader thinks it checked. "Passed" is a short word. It can quietly absorb claims about usability, reliability and readiness that were never part of the test.

In my game projects, Instinct does much of the implementation and testing. I remain responsible for the direction and the decision to ship. That makes the handoff report part of the product work. I need to know what the evidence supports before deciding what should happen next.

I have written about stop rules before. This is the reporting side of the same problem: how to describe a result without letting it become larger than the observation behind it.

Start with the claim

"The feature works" is too broad to test usefully.

"A hostile shot cannot award the same near-miss reward twice" is narrower. So is "the intended gameplay screen appears after launch." Neither statement proves that someone understands the mechanic or enjoys playing it.

Those are different questions. They need different evidence.

Before reading a result, I want to see the claim in a sentence. If the sentence contains several claims, it probably needs to be split. A test should not inherit a bigger job because the report uses a convenient label.

Put the observation beside it

A useful report connects a claim to an observation someone can inspect.

For a hypothetical game build, that might mean a regression trace showing that one projectile cannot award twice. For a visual claim, it might mean a capture of the relevant screen. For a touch-input claim, it requires evidence from the target interaction, not a desktop approximation quietly presented as the same thing.

These are examples of evidence requirements, not a claim that a current candidate has passed them.

The distinction matters because one artifact can be real but irrelevant. A screenshot proves that something was rendered. It does not, by itself, prove that it was the right screen, the right build or the state the task required.

Add the limit while the result is still fresh

I would put a short limit beside every meaningful result:

  • Claim: the same projectile cannot award the reward twice.
  • Evidence: the regression route checks repeated contact with that projectile.
  • Limit: this does not establish that the reward feels fair on a phone.
  • Next question: can a player understand why the reward appeared?

The limit is not an apology. It stops a precise result from becoming a vague promise.

It also makes missing evidence visible. A device check that has not happened is not a failed device check. But it is not a pass, either. Reports need language for all of those states.

Keep the next step proportional

The report should make the next action easier to choose.

If the remaining question is about player understanding, another run of the same logic test will not answer it. The useful next step could be a clearer cue or a focused playtest. If the remaining question is about an incorrect screen, adding a feature is a distraction.

This is where fast AI-assisted work can help or hurt. Preparing another candidate is cheap enough that it can hide the fact that the missing evidence has not changed.

I do not want a longer report for its own sake. I want a report that prevents me from approving a different claim from the one that was tested.

The strongest handoff is often a modest one: this is what we observed, this is what it supports, and this is what we still do not know.

Related writing

How this article was prepared

Instinct helped draft this article from my published project writing. I remain responsible for what appears under my name.

Top comments (1)

Collapse
 
howcani_howcani_77e786a89 profile image
howcani howcani •

The sentence I'd put at the top is the one about states: "A device check that has not happened is not a failed device check. But it is not a pass, either. Reports need language for all of those states." That's the part most reporting formats don't have, and I have a concrete case of what it costs when the language is missing.

I spent today re-running a published reproduction package whose CI entry point has four gates. On my run, all four printed NOT RUN and the script exited 2 — because they take their input set from git ls-files, and I was running it from an archive export that carries no .git. Every other step passed. Now: if that format only had pass/fail, exit 2 with four unread gates would have to be reported as one of two lies — a pass (the script finished, nothing failed) or a failure (four gates didn't run). What the script actually does is print its own sentence: "a coordinate of the run, not a finding about the work", and hand the reader the distinction. The number of steps that ran is not the number that could have run, and the report says so as data rather than as a footnote.

That's the same move as your "limit beside the result", one level down: a limit tells the reader what the result does not cover; a third state tells the reader that the instrument could not form an opinion, which is a different and more dangerous gap because it can be silently converted into either verdict by whoever writes the summary.

There's a second thing your report structure is quietly protecting against, and it's the sharpest one I hit today: the report is only as good as who writes it. I took one failing test and moved three lines into it — the test body writes its own results file containing tests="1" failures="0", then exits before reaching its assertion. The same tree, the same defect, and the run that should report FAILED (failures=1) / exit 1 now reports a green receipt and exit 0. Nothing about the observation changed; only the authorship of the verdict did.

So your four-part structure (claim, evidence, limit, next question) gets stronger if you also pin who produced the verdict — if the answer is "the file under test", the report is a claim rather than a measurement. For your game builds that likely means the harness writes the outcome and the agent's own summary is treated as an input, not as the receipt.