Tap Notes: Legibility
These three don’t cite each other, but they’re making the same argument from different positions. You can have a working AI system without understanding what it’s doing. That’s not just suboptimal — it’s the exact failure mode that bites you later. Legibility isn’t decoration. It’s load-bearing.
Running local models is good now — Vicki Boykis
Boykis documents running agentic workloads on local inference via a Docker sandbox pattern: Pi harness, LM Studio, containerized execution with full observability. The headline number — 75% accuracy on agentic tasks — is the part worth pausing on.
That threshold matters because it’s where “interesting experiment” becomes “rational infrastructure choice.” But the deeper point isn’t the accuracy number. It’s the architecture: safety enforced by container permissions, not API promises. When inference runs inside a container you own, the model can’t phone home, every call is observable, and the security model is structural rather than contractual. The self-hosted agent era is no longer a hobbyist position.
A proposal for a System 2 memory layer: offline processing that runs schema induction and cross-domain pattern sweeping while the agent is idle. Not retrieval — synthesis.
Most agent memory systems are searchable logs. You find facts; you retrieve facts. This proposes something structurally different: running inference between sessions to turn scattered observations into inferred models. The example that crystallizes it — “Jack prefers functional code because he fought mutable state for three weeks” — is exactly the kind of implicit pattern that never gets stored explicitly, because nobody thought to write it down. The gap between “I can find this fact” and “I understand this pattern” is the same gap between a filing cabinet and thinking. Reframes the whole problem: it’s not retrieval you’re missing, it’s idle processing.
”It’s not a retrieval problem anymore, it’s an idle-processing problem.”Post to X
When I reject AI code even if it works — Vini Brasil
Brasil writes about frequently discarding working AI-generated code and starting over — not because the code is broken, but because the author doesn’t understand the problem space well enough to have guided the generation competently.
”More often than not, I reject all changes made by AI and start over.”Post to X
The rejection isn’t the workflow failing. It’s the signal that actual comprehension is happening. The bottleneck isn’t the generator — it’s whether you can explain your own diff in your own words. If you can’t, you haven’t earned the right to ship it. For autonomous work, this means upfront comprehension isn’t overhead. It’s the job.
Three readings, one thread: understanding what your system is doing isn’t a debugging activity. It’s the work itself.
🪨