A bug is a signal about the generator — fix the workflow that produced it so the class of error becomes impossible, not just this instance.

Principle

Fix the System Not the Issue

The asymmetry

One fix pays once. The other pays forward.

Individual fix

patch the file

Agent produced a phantom edit. You manually touch the files and move on. The generator is unchanged. Tomorrow's invocation can ship the same error.

same class keeps recurring

System fix

add the contract

Implement filesExpected + a Stop hook. Phantom edits become impossible by default — for this agent and every future one.

class is closed, once

Individual fixes cost you every occurrence. System fixes pay forward across every future invocation.

The trajectory

tac-2 → tac-6 is this principle, applied to itself.

Each iteration diagnosed what problem class the system was still capable of producing — and structurally eliminated it.

tac-2

Class

no ADW pipeline at all

Fix

built the pipeline

→

tac-4

Class

ADWs aren't isolated

Fix

worktree isolation

→

tac-5

Class

no hook enforcement

Fix

the hook system

→

tac-6

Class

starting from scratch every project

Fix

the primer repo

Not rewrites — structural eliminations of the next problem class in line.

The diagnostic

Before you fix anything, answer one question.

Can I imagine this happening again with a different agent, a different task, or a different input?

No — one-time

It's an incident.

Genuinely unique context. Won't recur across agents or runs. Rare.

→ patch it and move on

Yes — class

It's a generator defect.

The system is still capable of producing this. Every future invocation is exposed.

→ fix the class, not the case

Most "one-time" bugs are classes in disguise — treat them as classes until proven incidents.

How this principle dies

The moves that leave the system capable.

If you catch yourself doing any of these, the generator is still broken.

• ✗Patch a specific file without updating the ADW script or command that generated it.output-only
• ✗Fix a failing test without asking why the builder agent produced incorrect code.symptom
• ✗Workarounds that bypass root cause — --no-verify, skipped hooks, manual overrides.bypass
• ✗Treat a recurring error as a one-time incident — every time it appears.amnesia
• ✗Fix the output instead of fixing the generator that produced the output.downstream

Every bypass is a promise that the class will come back.

What a system fix looks like

Problem class → structural closure.

Each row: the class of error, and the primitive that closes it at the generator.

agents shipping phantom edits

↦

closes withHook-Enforced Contract

verification fires on wrong signal

↦

closes withHook Event Selection

two agents racing the same task

↦

closes withWork Claim

abandoned worktrees piling up

↦

closes withOrphan Reaper

failure with no prescribed recovery

↦

closes withCorrection Task

Every primitive in the harness is a closed class — a defect that can no longer happen by default.

The discipline

A bug is a signal about the generator, not about the output.

The system is only as reliable as its lowest-enforcement boundary. Individual fixes leave gaps; system fixes close them. If it can happen once, it will happen again — unless you change what can happen.