Assertion Satisfied Elsewhere

What goes wrong

A test or check searches a wider subject than its target — the whole page, the whole log, a flattened row — so the same word coming from an unrelated element or a neighbouring line satisfies it; the target can be broken or removed and the check stays green.

Example

A UI test asserts the page contains 'Saved'; the word also sits in the page header, so the test keeps passing after the save button stops working.

Not to be confused with

The check runs and looks for the right thing but in too wide a place; not test data that never reaches the code under test (Unreached Branch Test), not two candidate values that happen to be equal (Coincident Alternative Oracle), and not a substring matching a longer sibling word (Substring Check Matches Sibling Word).

Discovered by

@sks24git GitHub

Field notes · 19

@sks24git2026-11-05beat 1 review round

A self-check served its own sample through the same tally the real run reads at the end. Its serve marked a shared item as used, so a real page that never got that item passed the final check.

Keep a test's traffic out of the totals it audits. Its own hits cover a real miss.
Clean up test state on the error path too. A cleanup only on success leaks the first time it matters.

@sks24git2026-11-05beat 5 review rounds

A text check pinned a key sentence by searching for its words, and the same words were also quoted in a pointer to it. Delete the real step and the check still finds the quote and stays green.

Pin text by a string only its owner holds. A quote of a rule satisfies a search for the rule.
Break each guard once on purpose. A check never seen red guards nothing.

@sks24git2026-11-05beat 1 review round

A guard test searched the whole build file for a package name, and the new comment above the install line held that name too. Drop the package and the test still passes on the comment alone.

Match the instruction, not the file text. A text search finds comments; prove the guard by deleting the thing it guards.

@sks24git2026-11-05beat 1 review round

A test checked that each row's number existed somewhere in a reference table without pairing it to the row's label. Swapping two rows' numbers keeps the test green while the chart shows the wrong value for each entry.

Assert pairs, not membership in a set. A set check passes when two rows swap their values, so test each label together with its own figure.

@sks24git2026-11-03beat 1 review round

A test checked that a label appeared on a page, but the same words also sat in a filter menu on every render. The row could lose its label and the test stayed green.

Assert on the element, not the page text. Shared words elsewhere make a check that cannot fail.
When one flag changes the wording, assert both branches by what they say. Absence proves little.

@sks24git2026-10-30beat 5 review rounds

A test looked for a marker in a prompt that also pasted in the whole rule book, and the rule book holds the same marker. The check passes even when the prompt section it guards is gone.

Assert on the part you built, not on the whole page. Copied text can satisfy the check for you.

@sks24git2026-10-29beat 1 review round

A guard test counted a marker across the whole config and checked only the first matching step. A new step added the marker twice, so the count still passed while the step it guarded lost the marker unseen.

Bind each guard to the exact step it protects. A count over the whole file passes when a neighbor adds copies.
Rerun old guards against your new copies. New steps can satisfy them by accident.

@sks24git2026-09-15

A rename detector checked a doc tag's promised names against the file minus that one tag's block. Every other tag's text stayed in the haystack, so two tags naming one identifier certified each other after a rename.

Subtract every witness of the same kind, not the one under test. Prose that names a token is never evidence the token exists.
Fixture tokens must live nowhere but the fixture.

@sks24git2026-09-15

Closing a gap added a second, byte-identical copy of a message in the same block. The check guarding it searches the block flat, so either copy satisfies it and either one can be deleted with the suite green.

Assert where a thing is, not that it exists. Two identical copies answer for each other under a flat search.
A fix that duplicates text weakens the check that guards it.

@sks24git2026-09-14beat 1 review round

A checker that a comment names an identifier searched the whole file, so other comments witnessed the name. Rename the code and leave the prose, and the check that exists for that rename stays green.

Prose is what a claim is about, never its witness. Search code only, or the comment proves itself.
Half a principle is the whole defect. Apply it to every case, not the one in front of you.

@sks24git2026-09-13

A canary page proved a checker still reads what it claims, but it was broken in the wrong place: the container overflowed and satisfied the assertion alone. The half that reads children could be deleted, all green.

Break the fixture in the shape of the defect. Merely broken passes for the wrong reason.
Assert on what the failure names. "Something faulted" is not the claim you meant.

@sks24git2026-09-13beat 3 review rounds

Two assertions read as if they pinned an input field and a time zone, but each was answered by unrelated markup elsewhere on the same page. Blank the field, delete the zone — every case stayed green.

A substring assertion is answered by the nearest similar string, usually foreign markup. Pin the whole tag.
Mutate per assertion, not per test: red proves something is alive, not your line.

@sks24git2026-09-12beat 1 review round

A test asserted a preview by grepping for a column name, and the tool prints that header even for an empty result. The dry-run legs also ran without the read-only guard, so removing it entirely stayed green.

Assert a value, never a header. Empty output still carries the shape you grepped for.
Run the safety switch in the test the way production runs it, or you test its absence.

@sks24git2026-09-10beat 2 review rounds

A number argument was parsed without validation, so a typo became a run of zero iterations. Every statistic came back undefined and the tool exited zero, which reads as a successful measurement.

Validate the arguments a measurement depends on and exit loudly. Zero samples must never leave through the success door.

@sks24git2026-09-10beat 1 review round

Two test suites were selected by a single invocation of the build tool, and the flag that fails on an empty filter is per invocation. Rename one suite and its checks run nowhere while the pipeline stays green.

One filter, one invocation. A shared invocation lets a matched sibling hide an unmatched suite.
Ask what your filter matches when a name is wrong, not only when it is right.

@sks24git2026-09-09

Two texts each restate the whole contract to the agent, and the remedy landed in one of them. An agent that arms itself from the other reproduces the original incident with every check green.

Fix a rule on every surface that states it, or state it once. Two copies of a contract are two chances to ship the old behaviour.

@sks24git2026-09-09beat 2 review rounds

A rule branched two ways and the clause both branches share was asserted on one of them. The one-line ternary that strips it from the other branch is idiomatic in that file, so the mutation ships with a green suite.

Assert a shared clause on every branch, verbatim, mandatory verb included. A fragment match survives the edit that guts the rule.

@sks24git2026-08-27

A guard reports zero hits, so a control runs the same scan over two files that must violate it and asserts the total is not zero. One scores zero — its only match hides inside a longer word — and the control passes on a stray field name in the other, so green proves nothing while its comment swears otherwise.

Assert what the control must find, not that it found something. Above zero is satisfied by an accident.
Pick a control subject that does the real thing. A file named for the concept rarely performs it.
A short name never matches inside a longer one. Your scanner goes blind where it is spelled out in full.

@sks24git2026-08-21beat 2 review rounds

A guard that can only be aimed at the one file that already satisfies it. Five of seven mutations to its own boundary logic survive its self-test, so the day someone reindents the config, the guard reads a neighbour's setting as the answer and reports success.

A check must take its subject as an argument. One that can only be pointed at the real tree can never be shown to notice anything.
Derive structure from the file, never from a literal indent. A hardcoded depth turns a legal reformat into a silent pass.
Not finding your subject is a failure, not a pass. Otherwise a wrong directory looks exactly like a clean bill of health.