verification without tests

automated tests are unwanted overhead for this project. verification is the live exercise of the changed boundary with recorded evidence — never a test suite, never an unverified completion claim.

upstream Superpowers prescribes TDD for every change; this catalog supersedes it with an owner decision: no automated tests. the discipline transfers, the artifact does not. what TDD buys — a failing state observed before the fix, a passing state after — is bought with probes, smoke checks, and recorded status and payload evidence.

verification is contact with reality at the boundary that actually behaves differently — not an artifact that says so. a test suite proves shape and mocks; a live probe proves the deployed route, query, or workflow changed what users experience. the avoided risk: the credible but false completion claim — code that compiles, typechecks, and still executes the old path behind a fallback nobody removed. the before/after evidence pair is the only artifact that keeps the claim checkable later.

TDD's value is forcing contact with reality before claiming completion. that contact is mandatory; the test suite is optional. the equivalent loop:

a probe is a curl, a script, a page load, or a query whose exact command and output are recorded in the slice or change ledger — evidence kept with the change that produced it.

probe the narrowest boundary that can prove the change; escalate only when a narrower boundary cannot show the defect.

• add a test framework, test files, or test scripts to compensate for missing verification — the gap is closed with recorded probes, not a suite.
• claim completion from typecheck or build alone. types prove shape, not behavior.
• discard failing evidence once the fix works — the before/after pair is the claim's proof.
• let a slow probe widen into a smoke of everything. scope probes to the changed boundary.

bad

$ pnpm typecheck
# clean. agent declares the authorization fix verified and deploys.

$ curl -i https://api.example.com/admin/settings \
    -H "Authorization: Bearer user-token"
# (never run — no probe was recorded)

# next day, a real unauthorized request arrives and returns 200 OK.
# the guard sits behind a try-catch that falls through to the legacy
# unguarded handler nobody removed.

an agent adds an isAdmin guard to an authorization route. it compiles, typecheck passes, the agent claims the fix and deploys. but the route still calls the legacy unguarded handler inside a never-removed try-catch fallback, so unauthorized requests still return 200. a real unauthorized request succeeds the next day; nobody knows when the breach started because no before/after boundary proof exists to show the fix never took effect.

good

before the change, the agent records a curl probe for an unauthorized request:

curl -i https://api.example.com/admin/settings \
  -H "Authorization: Bearer user-token"
# response: 200 OK — unauthorized request succeeds (BEFORE fix)

after the change, reruns the same command:

curl -i https://api.example.com/admin/settings \
  -H "Authorization: Bearer user-token"
# response: 401 Unauthorized — authorization guard now enforced (AFTER fix)

the before/after pair proves the boundary changed; the correlation ID is recorded alongside. a fallback to the old handler would have been caught by the before proof. the claim stays checkable after the fact — anyone can rerun the exact recorded probe and observe the same behavior. probes are cheap to repeat, so every risky refactor gets the same loop, and the recorded evidence corpus becomes the audit trail for when and how each boundary changed.

before any completion claim: list the probes run, their exact commands, and their outputs. each probe must exercise the changed boundary, not a neighbor. a before/after evidence pair must exist for any change that fixed a defect. absent evidence means the work is not done, no matter how correct the code reads.

verification evidence · diagnostic errors · live boundary evidence · deployment and UAT · superpowers · no git worktrees