Tacit spec, and recursion as spec-compression
Parent: recursive-harness
The LLM supplies the unwritable part of the spec
The "common sense" that makes a decomposition complete is a tacit / unwritable form:
- Tacit knowledge (Polanyi): "we know more than we can tell."
- Computationally: a function whose shortest description is the model itself (not compressible to explicit rules); written by gradient descent, not by a human — "writable, but not human-writable."
- (Kripke's rule-following paradox: any finite explicit rule under-determines its own application; a tacit "going on the same way" is needed. The LLM is the first artifact to operationalize that tacit closure.)
This is why LLM-agents do what GOFAI/Cyc couldn't: Cyc tried to hand-write common sense and failed — because it isn't hand-writable, only learnable. The LLM's real role isn't "fill obvious gaps"; it's carry the part of the spec humans can't write.
Recursion compresses the infinite spec into a finite rule
You can't write "what to do in every situation" (infinite, tacit). But a recursive instruction is finite yet infinitely applicable: write the recursive step + base case once, and recursiveness covers all reachable states. So the human's burden is the finite recursive rule, not the infinite case table — that's why "the instruction applies in any situation: it's recursive." Recursion is a specification-compression device.
But tacit doesn't vanish — it concentrates at two points
| tacit point | where | failure cost |
|---|---|---|
| dispatch (which branch of the rule applies) | interior node | dangerous — mis-routes a whole subtree, and it's upstream of P×C (not contained) |
| leaf (the atomic base-case action) | bottom | tolerable — P×C stops here, so failure is already cheap-enough |
→ Strongest design: push all tacit load to the leaves, make dispatch writable/deterministic. Then structure is reliable, dispatch is reliable, and leaf tacit-risk is bounded by P×C. The real crux of how strong the harness can be = how writable the dispatch is (structured domains: yes; taste/context-laden: no — then dispatch needs a consistency gate).
The unverifiability tax
An unwritable spec can't be mechanically verified — so tacit steps only get a semantic gate (another LLM judging), which is fallible. Writable-spec levels → mechanical gate → reliable; unwritable-spec levels → semantic gate → fragile. This is "eval is the type system" at the seam: the type checker checks the writable, eval is the only thing that can check the unwritable, and eval can be wrong.
Revisited — under the theory layer
- "Push tacit to the leaves" now has a precise criterion: a leaf's tacit load is bounded iff its spec is learnable from its injection — the PAC leaf rule of coupling-to-the-learner (context window = sample budget
m; spec too complex form⟹ the model fills the gap with priors = exactly this note's tacit drift). - "Dispatch is dangerous" got its remedy: in root-protocol the split is an artifact — dispatch passes its own gate (with the largest budget share) before any child spawns, and no agent authors the spec it is judged by.
- The unverifiability tax is now measurable: a semantic gate's fallibility is a calibrated
α(mutation testing, operationalizing-tolerances), and understandability itself gets a mechanical-ish check (round-trip reconstruction). The tax didn't vanish — it acquired a meter.