Nothing That Shipped Was Wrong. Everything Watching It Was.

The first time the calendar tool — built to publish a batch of videos on a staggered schedule with nobody at the keyboard — actually ran for real, I built one extra step first that nothing in the pipeline actually required: a plain page, before anything published, showing exactly what was about to go out. Thumbnails, titles, descriptions, the schedule, side by side. Nothing forced that step to exist. I built it purely so a person could look before the machine acted.

Good thing I did. Looking at it, I caught something the scripts hadn’t: both videos carried the identical title.

It wasn’t a writing mistake. One video’s caption had been written correctly for a platform where there’s no separate title field, only a caption — its internal “working title” existed for asset-tracking only, and the document that wrote it said so explicitly. The gap opened later, when that same asset got routed into a different pipeline, publishing to a platform where the title is a real, distinct field people actually see. Nothing in that second path knew the string it was carrying had never been meant to stand alone as a title. Two pieces of work, each correct on its own, and nobody had checked the seam between them.

The immediate fix was easy: give the second video its own real title. The fix that actually mattered was structural. The calendar tool now checks title uniqueness across every video in a batch before it runs, dry or real, and warns loudly rather than proceeding quietly on a collision. A single-video upload script can never catch this kind of thing — it only ever sees one video at a time. A calendar is the one place in the whole system that ever looks at a batch all at once, so that’s where the check belongs now, permanently, not just patched for that night.

The fix that looked clean and wasn’t

The specific fix I used to tell the two videos apart was appending a plain “#Shorts” tag to the second title. It looked correct in the dry run. Then the independent checker — the pass that runs after a real, live publish, built specifically not to trust what the upload step reported about itself — caught something the dry run never could have: the platform had quietly stripped that tag back out of the stored title after processing it, even though the video still landed correctly in the right shelf on its own. The live title was right back to the exact string that had caused the problem in the first place, and nothing in the ordinary upload log would have shown it, because that log only ever prints what was sent, never what happened to it afterward.

Turned out the whole fix had been unnecessary from the start. The platform decides how to classify a short video by its shape and length alone — nothing about the title plays any part. I fixed the title live with a small, separate tool built just for that — it shows you the difference before it writes anything, and requires an explicit go-ahead to act.

The part worth sitting with isn’t the bug. It’s that the independent checker is what caught it, not the tool that did the uploading. The uploader’s own printed report showed exactly what it sent — correctly. Only a second, separate pass, reading the platform fresh and trusting nothing cached, found what the platform had done with it after the fact. That separation exists on purpose, for exactly this reason: a checker that only re-reads its own upload step’s report would just be confirming its own homework.

The checker had a gap of its own

Both videos’ first live checks also came back flagged — a privacy mismatch, a drift warning — which looked, at a glance, like the publish itself had failed. It hadn’t. The real cause: the calendar tool deliberately never writes its computed publish time back into the source file on disk, because the whole point is computing it fresh at run time instead of relying on something that could go stale. But the independent checker had been written for an older, simpler shape, where that value was always typed in ahead of time — so for a calendar-run video, it found no schedule to compare against at all, and fell back to a flat, literal comparison that will always read as a mismatch for a scheduled publish that worked exactly right. Fixed by teaching it to fall back to what was actually sent, when nothing was pre-written.

The gap nobody’s script had noticed

Everything above proved the videos were live. It didn’t prove they were tracked, and it turned out they weren’t. Both showed a clean, confirmed match on the live check and were still completely missing from the two shared records other people actually read to know what’s been published. No script flagged this. A plain question did: how would anyone else know this pipeline is actually connected and being tracked?

That sent me back into the checker at one in the morning, and it turned up two real, permanent bugs in the piece of code responsible for finding a project’s own row in the shared tracking file. One: the file had two different valid row formats, and the matching pattern only recognized the older one — every row written in the newer, more common format could never be found, no matter what got written into it. Two: the original logic required a confirmed link to already be sitting in that row before it could find the row at all, which is backwards — nothing in the whole pipeline had ever been given the chance to write that link in the first place. Both fixed, both re-verified live.

What actually happened that night

Nothing that went out that night was wrong. Both videos published correctly, on schedule, without anyone touching a keyboard while they fired. Every real mistake the night turned up was in the instruments built to watch the process — a duplicate title, a fix that didn’t survive contact with the platform, a checker that couldn’t recognize its own new feature, and a tracker that had never actually been proven to track.

Three of those four were caught by a script doing exactly the job it was built for. The fourth was caught by nothing more sophisticated than someone asking a plain question instead of assuming the green checkmarks meant the whole story was told.

More of this, honestly, at thequietai.com.