The Brief Was Wrong

The brief said a directory was orphaned. A leftover from a service we’d decommissioned. Safe to delete in the next sweep.

The brief was wrong.

Two surfaces, one loop

Before the story makes sense, the architecture needs to.

V8’s build flow splits design and implementation across two AI surfaces. Chat does the design — writing briefs, planning sweeps, working through the shape of what needs to happen. Code does the implementation — reading the actual repo, executing the work, reporting what it finds.

The split isn’t accidental. Chat is good at thinking broadly. It has research tools, can search public domain, can read documentation, can bring outside substance into a decision. Code is good at ground truth. It has hands on the whole codebase, can read the actual state of any file, can run a check against the real system rather than against a remembered version of it.

The operating rule underneath both: don’t trust memory. Mine, or chat’s. When unsure, ask code to look. Memory is always a lossy abstraction; code can read the real thing.

That rule is what produced this near-miss — and it’s what caught it.

What happened

Chat wrote a decommission brief. The brief named a directory. Cited a recon. Marked it as orphaned. Acceptance criteria said: delete in the next sweep.

Code started the sweep. At implementation, code did what it always does — read the actual state of the system before acting. The directory wasn’t orphaned. Five active consumers, including a running production process, all depending on it. The brief’s premise was wrong.

Code reported the contradiction back. Chat read the report. And then chat did the thing chat always does when its premise breaks: it jumped to a solution.

Chat’s default, the moment a premise contradicts ground truth, is to find a way around the contradiction. Not to ask why the premise was wrong. Not to interrogate what changed. To solve.

This is the failure mode worth naming. It’s not random. It’s predictable. Chat is a design surface — its instinct under pressure is to design a path forward, not to stop and re-examine the foundation. Useful in most contexts. In a contradiction with ground truth, it’s exactly wrong.

Two interventions

The first one was the operator’s. Not a system gate, not a discipline encoded in the build flow — me, watching chat start to draft a workaround, recognising the pattern, and stopping it. Don’t solve. Recon the actual cause first. Why was the brief wrong?

Code went back and did the proper recon. Not the abbreviated version the original brief had been built from — the full audit. The directory wasn’t orphaned because the service it had been associated with had been decommissioned, but the directory itself had been re-purposed. The recon evidence the original brief was filed against had been written against a version of the system that no longer existed.

That re-grounded the problem. Chat now had ground truth, and the framing shifted: not “how do we work around the contradiction” but “what is the right way to handle a directory with multiple active consumers in a decommission flow.”

The second intervention was also the operator’s. Don’t solve from first principles. Check public domain first — there’s almost certainly an established methodology for this. Chat searched, found the standard pattern, applied it, produced a solid corrected approach.

Code shipped the work.

The discipline

Two interventions, neither of them automated. Both operator-driven. The architecture didn’t catch the near-miss; the operator did, by knowing what each surface tends to do under what conditions.

Chat’s failure mode under contradiction is to solve rather than re-examine. The operator’s job is to recognise the pattern — not as character flaw, but as a known property of the surface — and route the work back to code for ground truth before letting chat solve.

Memory is the source of the problem. Briefs get filed against what chat remembers about the system. Implementation runs against what code can actually read. When those diverge, the brief is wrong. The discipline is: don’t trust either side’s memory. Ask code to look. Let chat design from what code finds, not from what chat thought it knew.

The brief was wrong. The directory had five active consumers. One sweep would have taken down sandbox.

The system shipped corrected work. The operator stayed in the loop.