Hand-typed copy of the rule drifts

What goes wrong

A rule that has one source of truth — a limit, a regex, a role list, a decision table — is re-typed by hand elsewhere (client validation, preview, message text) instead of being derived from it. The copy accepts, refuses or shows values the original does not.

Example

The password rule on the server changes to 12 characters; the client's hand-written regex still says 8, so the form accepts passwords the server rejects.

Not to be confused with

Both copies exist on purpose and the original was available to derive from; not a sweep that missed one of several equal copies (Fix applied to one copy only), and not a test's expected value copied from the implementation (Self Derived Expected Value).

Discovered by

@sks24git GitHub

Field notes · 56

@sks24git2026-11-06

A report filled gaps by redoing a check for every row the checker had skipped, including rows the author had withdrawn. A hit on a withdrawn row then counted as a hold the real checker would never make.

Copy the skip rules along with the work rules. A stand-in that only mirrors what the original does also does what it refuses.

@sks24git2026-11-05

A new output filter writes its own pattern beside the project's one rule for the same field, and guards only one of two doors. Valid records vanish from one door while unsafe ones still leave through the other.

Reuse the one validator for a field. A second regex drifts on day one.
Filter where the value is built, not at one exit. Every door then gets the same answer.

@sks24git2026-11-05beat 1 review round

A second check copied the 'is this approved' rule to give a clearer error, but skipped the reset rules and the read-error fallback. The copy then reported approved when the real rule said not approved.

Return the reason from the one place that decides. A second copy of a rule drifts on its first edge case.

@sks24git2026-11-05beat 2 review rounds

A list view copied the detail page's "still pending" rule into a database language but dropped its deadline check. A job whose wait had already timed out showed as running forever, while the page said done.

Copy the clock with the state. A pending flag without its expiry check never ends.
Test a timed state on both sides of its deadline. A fixture only in the future hides the expired path.

@sks24git2026-11-04

A label fallback is written out a third time in a third file. The next new kind gets a label in one copy and shows a raw key in the other two.

Extract on the third copy. Three copies of a lookup always fall out of step.

@sks24git2026-11-04

The same access rule is copied into four tests instead of one shared helper. When the rule changes, some copies get updated and the rest test the old rule while still passing.

Keep a rule a test depends on in one helper. Copies drift and keep passing.

@sks24git2026-11-04beat 2 review rounds

A rewards page stated that only serious findings earn credit, then listed every item with any finding as ready to claim. A user writes up a minor one and the progress bar never moves.

Filter a "ready" list by the same rule the counter uses. Two rules on one page and the user trusts the wrong one.

@sks24git2026-11-04beat 1 review round

A list titled "can have a story" checked only the account's setting, while each item's own page also checks the settings of the key that made it. A user follows a link the list offered and finds no form.

Name a list for the fact it checked, not the promise. When the item's own page has the final say, the list must not pre-empt it.

@sks24git2026-11-04

A speed-up sorts work by a hand-kept list of names, and anything the list lacks jumps to the front. Rename one item elsewhere and the sort quietly undoes itself; every test stays green and the system just gets slower.

Pin every copied list to its source with a test. A silent mismatch costs speed nobody sees.
Make the fallback for an unknown name visible. Quiet defaults hide drift.

@sks24git2026-11-04

A settings list overrides two switches of one key kind to hide stale values. It also overrides values in force and turns off a third switch when the stored row is empty, so the page shows settings that do not apply.

Mirror the real correction, not a broader one. A display fix that guesses past the rule lies.
Assert the row you changed, not a page-wide count.

@sks24git2026-11-04

Two database test fixtures reset shared state by hand, and one skipped a table its neighbours leave dirty. When the suite reshuffles which tests share a database, a stray row wakes an unrelated path and the test fails.

Reset shared test state in one helper. Each hand-copied reset misses the next table.
Start every fixture from empty. Test order is not a contract.

@sks24git2026-11-04beat 1 review round

A page copied the billing rule to explain why a job owed nothing, and the copy drifted from the rule that really charges. A job with no real bug at all could be told its bugs were paid for elsewhere.

Show a money reason from the rule that charges, never a copy. Copies drift one condition at a time.
Cut a feature that grows a finding per round. Ship the rest, rebuild it on one source.

@sks24git2026-11-03

A sign-off deadline moved into a hard-coded constant while the router still reads the same date from a shared table. Extend only the table and work keeps going to approvers the check now rejects, so it stalls silently.

Pin every duplicated deadline with a test that compares the copies. Two sources of one date drift on the first extension.

@sks24git2026-11-03beat 1 review round

Two code paths decided who counts as an approver, each with its own copy of the deadline rule, and the copies disagreed. One path fetched extra data for an approver the other path then rejected.

Compute a trust decision in one function and call it everywhere. Two copies of a rule drift on edge cases.
Test the edge where the copies differ. A reversal in the middle exposes it.

@sks24git2026-11-03beat 2 review rounds

A guard compared the year's total relief with the sum of its parts, but one part had already been used in an earlier year. Every return with that earlier choice was refused as if a cap had cut the relief.

Rebuild a total the same way its source does. A check that re-adds parts by its own rules flags gaps the source never had.

@sks24git2026-11-03beat 3 review rounds

A list rebuilt a state machine in a second language so it could show what a detail page shows without writing. Each round a reviewer found one more rule the copy missed, and its cost grew with the account's history.

Fix the source of truth, not every reader of it. A stored state that is kept current beats a copied rule.
Stop after three rounds on one change and go back to the cause.

@sks24git2026-11-03beat 1 review round

A report page promised its counts match the gate's, yet it graded each run from raw rows, not the gate's own view of paired runs. A lead reads equal numbers that differ wherever pairs are the default.

Claim parity only where the code shares the path. Sharing one helper is not sharing the whole rule.
Delete a false sentence before writing a truer one. The short page is the honest page.

@sks24git2026-11-03beat 1 review round

A list copied a "still running" rule from code that also checks a clock, and left the clock out. Work whose time ran out but nobody opened stays "running" in the list and drops out of the "waiting for you" count.

Copy a state rule whole, clock included. A rule without its time check never lets the state end.
Keep list reads free of writes, or one page view runs everyone's overdue work.

@sks24git2026-11-01beat 1 review round

A fix claims one shared rule for what counts as a paid job, but copies only the name check and skips the status check. Jobs that never got billed still turn the total into unknown, the same symptom the fix targets.

Share the whole predicate, not half of it. A rule copied in parts drifts on the part you left out.
Test the states that never reach billing. That is where an unknown total comes back.

@sks24git2026-11-01beat 2 review rounds

A page quoted the price from the job's requested mode, while the charge used the mode the job actually ran in. A job asked for in the costly mode but run in the cheap one showed one price and billed another.

Price the preview with the charge's own rule. A second copy of the formula drifts the moment a new case reaches it.