Most of what I know about software I learned by watching my own systems lie to me. A design scorer that gave itself 10 out of 10. An agent that copied photographs from one project into another so a check would pass. A sign-in that returned 200 while it was broken.
So the work below is not a list of technologies. It is six failures and the guard each one bought — because a system that has never been caught being wrong has only ever been unobserved.
This table lives in the repo, at the top of the file every agent and collaborator reads before touching anything. It is the first thing I write after something breaks, and none of it is hypothetical.
The SESSION_SECRET fallback was removed — which was correct — but shipped before the variable existed in production. /api/me still answered 200, so every health check looked fine.
The app now works out what it can do by checking what is actually configured, instead of trusting a switch somebody set by hand. It reads the live server’s settings, not the settings on my laptop — which is where the two had quietly drifted apart.
The tests asserted over the scorer's own recorded output, so both sides of every comparison came from the same file. The gold-set bands overlapped, so nothing could fail.
Scores are recalculated from saved examples on every run, and the set it is measured against has to include work I did not make. Judged only against my own work, all it proves is that the critic agrees with me.
Asked to satisfy an asset check, it copied images from a sibling project rather than saying it had none. The check passed. The work was a lie.
Every file is fingerprinted and compared across projects. If two projects contain the identical image, the build stops. It does not warn and carry on.
A brief called for real hardware geometry. Rather than fail, it produced flat canvas quads that looked three-dimensional in a still and satisfied the tests.
A page that claims to show real 3D has to actually contain a 3D scene. A flat shape that merely looks three-dimensional in a screenshot is refused, and a simple generated box may never be described as a scan of a real object.
A sync client auto-committed whatever happened to be in the working tree, including a broken state, and pushed it.
Every check runs before code can leave my machine, and pushing straight to the live branch is blocked unless I deliberately opt in.
An ignore file listed a bare docs, which matches at every level — so a nested docs folder was silently dropped from the upload. Every local check passed, because the files were never missing.
Every link is now tested the way the live server resolves it, not the way the files happen to sit on my disk. The files existed the whole time; they were never uploaded, and only the live server could tell me that.
These are enforced, not aspired to. Every rule has a test that fails if
the guard is removed, and you can read the whole set with one command:
npx @mrkt_frwd/award doctrine.
Never tune a threshold to make a run pass. Fix the work. Gates may be optimised; quality scores may not — a quality scalar under optimisation pressure gets gamed, and I have three recorded instances of exactly that.
Tests must recompute. Never assert over a checked-in result, or both sides of the comparison come from the same place and the system is grading its own homework.
Refuse rather than guess. When a tool cannot answer, the answer is that it cannot — not a plausible middle value. A guessed number is indistinguishable from a real one downstream, which is what makes it expensive.
Include work you did not produce. A calibration set made only of your own output cannot detect that the whole set sits too low. It is enforced in code: such a set can never report ready.
Calibrate against the medium you are judging. I made this mistake twice from opposite directions — pages scored with a photography rubric inverted the ranking; objects judged against screenshots produced specific, correct findings and no stable bar.
Say which number reproduces. A checksum you cannot match is worse than no checksum. One artifact is deterministic and the rest carry per-run state, so the manifest records what your run actually produced instead of implying they are all fixed.
A critic scoring a page where the judge could not evidence two of five axes. Filling those with zero would report 49 — a number about the evidence, not the page. Dropping them and re-weighting what is left reports 77. When nothing is scorable at all, there is no number to report, and it says so.
$ npx @mrkt_frwd/award score partial.json typographicHierarchy 78 spatialRhythm 72 compositionalTension abstained chapterDifferentiation abstained colorDiscipline 81 page craft 77 $ npx @mrkt_frwd/award score nothing-scorable.json unscored — no axis was scorable. That is an answer, not a zero.
Extracted from the work they were built for. Each one takes a file, does one job completely, and refuses rather than guessing when it cannot.
The tools above are the by-product. The habit is the thing: write down what broke, build the guard that would have caught it, and let the guard fail loudly rather than let the system quietly agree with itself.
If that is useful to you — as an employer or on a project — I would like to hear about it.
START A CONVERSATION SEE THE TOOLS