Topic Guide
Verifying AI Output Before You Trust It
This is the largest cluster in the whole Build Log, and it took writing 170 uncovered posts to notice it: a huge amount of the actual work of running an AI-assisted shop is not building anything, it's refusing to believe a claim of done. A saved record, a green deploy, a passing dry run, a plausible-looking mockup, a status field that says LIVE, an AI result that looks finished. Every one of those can be wrong in the exact same way: something reported success without anyone checking that the real, observable state matches the report.
The posts below are grouped by what kind of claim got checked. Some are about AI output specifically: a mockup that missed a design token, a checkout button that grew four pixels, a plausible answer that dropped a whole class of information. Some are about backlog and status hygiene: an epic marked Not Started with six tickets already shipped under it, a priority label that quietly became a history marker instead of a fact. Some are about the review itself, a second model, a second person, a recorded dissent, because the fastest way to catch a wrong answer is to make a different mind check it before it ships.
None of this is abstract caution for its own sake. Every post here traces back to a real moment where trusting the report instead of the result cost something: a live mailer overwritten, a customer-facing bug hidden behind a stale label, a queue worker that was never actually built while the button said it was working. The fix is nearly always the same one line, reworded: go look at the actual thing, not the thing that claims to describe it.
40 posts in this guide, by DX
Start here
Separate Your Build Model From Your Review Model: Codex as Adversarial Reviewer
Build with one model, review with a different one at high effort. One adversarial Codex pass found 8 false-green paths in a production gate that showed all green.
Not done until someone watches it work
-
A Fix Is Not Finished Until Someone Sees It Work
An edited file can look convincing while the real behavior is unchanged.
-
A Process Is Not Finished Until the Result Is Verified
A status update can create confidence before the intended result has actually happened. Before calling work complete, make sure someone can check the outcome that matters.
-
I overwrote a live production mailer because I assumed an ID was free
My "idempotent" upsert assumed trial ID 14 was unused. It wasn't. It was a live "Staff Reminders" mailer, and at 15:58:09 EDT my update path overwrote its subject, from-address, and body with "Get ...
-
The \"queue worker drains it\" story was vapor: the create command said NOT YET IMPLEMENTED
The admin console had a clean button. Click it, and each domain got queued for Cloudflare custom-hostname registration.
-
Before You Automate a Process, Make Sure the Information Is Telling the Truth
A process can look broken when the real problem is a bad assumption about the information underneath it. A small diagnostic can prevent an automated fix from making the situation worse.
A plausible AI result still needs a human check
-
An AI Result Is Not Ready Just Because It Is Saved
When a tool must still analyze a submission, a fast confirmation can create a false promise.
-
AI Mutations Aren't Optimistic-UI Candidates: Make the 'Analyzing' State Honest
Why optimistic UI breaks when a write triggers model inference: show an honest Analyzing state and invalidate the cache instead of faking the result.
-
AI Will Happily Produce the Wrong Mockup
An AI-assisted UI rebuild looked plausible but missed design tokens, a title-alignment invariant, and a shell-level width constraint. Code review caught the gaps before release.
-
A Plausible Result Is Not the Same as the Right Result
An AI-assisted design can look finished while missing the exact details that make it work for real people.
-
The last 2 pixels still need a human
AI shipped the first 95 percent of a checkout UI fast. A senior dev caught four layout issues. Another caught a checkout button growing 4 pixels on activation. The fix was embarrassingly specific.
-
A Plausible Output Needs a Baseline
An output can look normal while quietly dropping an important class of information.
Second opinions, and recording what they found
-
Manus pushed back on six of seven archive decisions
Building a conversation archive across four provider repos is the easy part. The useful part was sending the spec to Manus and watching it find gaps in every assumption.
-
How I Run AI Peer-Agents on Each Other
An architecture-review AI claimed I was avoiding real work. I asked it to audit its own claim against my actual logs. It retracted, with data.
-
A Second Review Is Useful When You Record the Decision
A second review adds value when its scope, evidence, limitations, recommendations, dissent, risk acceptance, follow-up owners, and re-review triggers are explicit. AI can assist with bounded analysis, but it does not replace independent evidence or accountable human judgment.
-
A Second Opinion Helps When You Record the Decision
A second review is useful when it makes assumptions and disagreements visible, not when it creates the impression that another answer automatically wins.
-
All Seven Reviewers Passed. The Writing Was Worse. Here's What Went Wrong.
Automated reviewers can identify real risks while a sequence of locally reasonable edits harms the whole artifact. The answer is not to waive safety findings, but to use calibrated review, minimal changes, whole-artifact rereads, and-where appropriate-direct human input or non-publication.
-
More Review Does Not Always Make the Work Better
Several reasonable fixes can make a result worse when each one responds to a local concern without anyone rereading the whole thing.
Dry runs and previews that lie
-
A Dry Run Is Only Useful If It Tests the Real Path
A dry run can create false confidence when it exercises a cleaner or different path than the action it claims to preview.
-
A dry run is only useful when it checks the same things as apply
A preview that skips a real precondition can produce a reassuring number and still fail at the moment of change. The solution is to share all decision logic and separate only the final side effect.
Status and state can lie too
-
A Project Status Should Not Hide Work Already Finished
A status label can stay still while the work beneath it changes. That makes a simple summary misleading for everyone relying on it.
-
The epic said "Not started" while six tickets shipped under it: reading progress past a stale status table
"Where do we stand on the migration?" I opened the epic to answer that, and its own phase table said Not started across every phase. Phase 0, Phase A, all of it. Not started.
-
When Your Work List Stops Telling the Truth
A task list can create stress long after its labels stop reflecting what is actually happening. Before asking AI to prioritize work, make sure the underlying signals still mean what you think they mean.
-
A Warning Is Not a Guard Against Overwriting Work
A message can warn people about a conflict without preventing the conflict from damaging someone else’s work.
-
Uniform state is a clue, not a conclusion
When supposedly independent copies share the same incidental history, the pattern may reveal a shared origin. The safe response is to compare evidence, protect active work, and clean up only after the explanation is verified.
-
When You Keep Fixing the Same Thing by Hand
A repeated correction is not always quality control. It can be a quiet signal that the process or tool is producing an unreliable result.
Before you triage or automate, verify it still exists
-
Before You Sort Work, Check Whether It Still Exists
A backlog can look urgent even after the underlying issue has changed, been solved elsewhere, or needs a different kind of decision.
-
How to Triage an 880-Ticket Backlog Without Deleting Real Work
A triage tool queued a bug as fresh high-value work five days after the fix shipped under another ticket. One git log --grep would have caught it.
-
The Same Symptom Can Need a Different Repair
A familiar diagnosis can encourage people to reuse a prior fix before they have checked whether the current case actually has the same shape.
-
The most valuable line in an agent's ruleset: verify the fix in the browser before claiming it's fixed
One line in an agent ruleset beats any clever prompt: do not claim a fix until you reload the page and watch the behavior in a real browser.
A decision a system should not make silently
-
The Size of a Change Does Not Tell You How Carefully to Release It
A short change can affect many people, while a large internal change may be safe to test away from live work.
-
A New Request Should Not Quietly Undo Everyone Else’s Order
A simple request for something new to appear first can accidentally erase the order people already created through earlier decisions.
-
A New Feature Can Reveal an Old Assumption
A new request often exposes rules that were always present but never tested together in the old workflow.
-
Ask Before a System Makes a Choice for Someone
A system can save time by choosing automatically, but a wrong choice can make every later step more expensive or confusing.
-
When a Default Hides a Decision You Still Need to Make
A convenient default can quietly make a choice for people long after the situation has changed.
-
A Surface Complaint Can Hide a Destructive Path
A visible nuisance can distract from a deeper path that changes or removes work.
-
A Security Check Can Hurt Good Users When Its Signals Are Wrong
A protective rule can harm legitimate users when a signal that looks suspicious actually reflects a normal route, redirect, or work pattern.
-
An Auto-Approval Should Never Erase Curated Work
Automation can look efficient while quietly overwriting the choices people already made with care.
-
When a System Cannot Know Intent, Let People Decide
Some conflicts cannot be resolved from data alone because the correct result depends on what the people involved intend to do next.
-
A Screen Can Save and Still Lose the Work
A successful-looking screen can hide different rules behind what appears to be one action.
Hitting one of these walls in your own codebase or your own machine? Talk it through with us, or read the rest of the Build Log.