Every fortnight we publish what actually shipped across the group.

295 commits in the fortnight to 19 September, counted from 6 September. The last edition was about gates that had started running and were mostly firing on things that were fine. This one is about three separate pieces of work that share a single instinct: stop trusting two systems to agree with each other by coincidence, and make the thing they need to agree on a file both of them read.

The finding: an assumption became a file

The clearest case of the fortnight involves a video frame specification — the exact pixel dimensions, safe margins and layout regions a rendered frame is supposed to follow.

Before this fortnight, that specification existed twice, independently. The renderer that produces the frame held its own understanding of the layout, written into its drawing code. The gate that checks the rendered output for defects held a separate understanding, written into its comparison logic. Nothing forced the two to describe the same thing. They had been written by the same team, at around the same time, against the same intent, and for a while that was enough to keep them in agreement by default.

Default agreement is not agreement. It is two independent descriptions of the same target that happen not to have drifted apart yet. The failure mode is not dramatic — nobody edits one and forgets the other in an obvious way. It is that the renderer changes for an unrelated reason, the gate’s separate description does not change with it, and the gate starts either passing frames it should not or failing frames that are actually correct, and there is no error anywhere that says “these two descriptions disagree,” because neither side knows the other exists.

The fix was to stop having two descriptions. The frame specification is now a single file. The renderer reads it to know what to draw. The gate reads the same file to know what to check the drawing against. There is exactly one place the specification can be wrong, and when it changes, both sides change with it because both sides are reading it, not remembering it.

This is a narrower and more useful statement than “keep your systems in sync.” Keeping two things in sync is an ongoing obligation that degrades the moment anyone forgets it. Making them read the same file removes the obligation by removing the second copy.

Substance gates for statistics scripts

The second thread of the fortnight is a new category of gate, built for a specific failure that generic checks do not catch: a script that states a number without anything behind it.

A grammar checker will not flag “conversions rose sharply this quarter” as a problem, and a link checker has nothing to check in a sentence with no link. But a statistic asserted with no source behind it is exactly the kind of claim that damages trust in Australian small-business content once a reader — or a client — asks where it came from.

Two pieces landed together to address this. The first is a data-block contract: a script destined for statistics content now has to carry its claims in a structured block that pairs every number with the source it came from, rather than the number living loose in prose with the source implied or absent. A script without a properly formed data block does not get past the gate, regardless of how well written the surrounding sentences are.

The second piece is a model-as-reviewer step sitting on top of the contract. A structured data block tells you a source is attached to a number. It does not tell you the source actually supports the specific claim made about it, or that the number has not been rounded, cherry-picked, or generalised past what the source says. That judgment call is not something a regex or a schema check can make. The reviewer step reads the claim against its attached source and gets to object before the script proceeds, which is a different job from the contract enforcing that a source exists at all — one checks the shape, the other checks the substance, and neither is a substitute for the other.

Wave 1 and wave 2

The two social publishing runs planned for the fortnight both shipped: wave 1, image-and-text content across five channels, and wave 2, gated video content across seven. Both were auto-scheduled only after passing the same two skill gates rather than on separate criteria per wave, which was a deliberate choice — a lighter-weight format does not earn a lighter bar for going out under the group’s name.

Also shipped

The claims-grounding gate that came out of the previous fortnight’s false-positive round — the one that had been treating every bare number as a statistic requiring a citation — is now the enforcement mechanism behind the data-block contract rather than a separate check running alongside it. One gate, doing the job that two overlapping ones were doing before.

A mutation probe was added for the new frame-specification file itself, on the same principle the last edition committed to for every gate: deliberately corrupt the shared file and confirm both the renderer and the gate notice, rather than assuming a single shared source of truth is automatically a correct one just because it is singular.

What went wrong

Consolidating the frame specification into one file surfaced a second, smaller version of the same problem we thought we had just fixed: the gate’s comparison logic held its own tolerance values — how many pixels of drift count as a genuine defect versus rendering noise — separately from the renderer’s own understanding of acceptable variation. Those tolerances are being folded into the same shared file next, because a specification that is authoritative about position and silent about tolerance is only half consolidated.

The thread

Two fortnights ago the finding was gates that did not run. Last fortnight it was gates that ran and fired on the wrong things. A month before that, it was optimisation written but never rendered — a specification that existed in one place and was read by nothing. This fortnight is neither of those — it is two systems that were each individually correct and had no way of knowing when they had quietly stopped agreeing with each other.

That is a different category of risk from a gate being missing or wrong, and it is easy to miss because both halves look fine in isolation. The renderer produces sensible output. The gate produces sensible pass and fail results. Nothing about watching either one on its own tells you their private descriptions of the same target have drifted apart, because drift between two independent descriptions has no error message of its own — only a growing gap between what one side assumes and what the other side assumes, discovered only when something downstream finally disagrees.

The practical version of the lesson: wherever two parts of a system each need to know the same fact, that fact should live in exactly one place, read by both, not written twice from a shared memory of what it used to be. A shared assumption is not a shared source of truth. A shared file is.

If your business runs any pipeline where a content step and a review step are meant to agree on a specification, and you have never checked whether they are reading the same definition or two independent copies of it, that is a specific and findable gap — and it is the kind of review we run for clients through Cloud Geeks as part of the wider group’s work.

Ganda Tech Services runs web, cloud, mobile and content operations for a group of Australian brands. These notes are published every fortnight, whatever they say.

Shipping Notes, 19 September 2026: The Fortnight the Frame Became a File