Slush Archive

A single file where you write down every command, trick, or pattern you had to look up twice. Not organized. Not pretty. Just append to the top with a date, like a journal for your muscle memory. At work it grows fast because every day surfaces new friction. At home it's sparser but the shape is the same.

This predates AI. It predates steering files. It's the original CLAUDE.md — except the audience was future-you, not an agent. The fact that it looks like going backwards is the tell that it's fundamental. Steering files didn't invent this pattern. They inherited it from the cheating sheet you've been keeping in a Google Doc since forever.

The upgrade: put it where an agent can read it. Now the thing that remembers your shortcuts also has hands. "How do I do that rclone thing again?" stops being a question you ask the sheet and starts being a question the sheet answers for you.

The reference pages are designed to be read by AI agents — the user pastes "Follow the instructions on this page" and the agent fetches the URL and does what it says. This is prompt injection by design. The page IS the prompt.

That means: anyone who controls the page controls the agent. This is the same trust model as curl | bash — and we should say so. A forked page with a modified agent block looks identical to the user. The agent has whatever permissions the user gave it.

Mitigations: pin to version/hash, agent diffs against known-good copy, warn users to only point agents at trusted URLs. The HTML comment block is invisible to humans but visible to agents — that asymmetry cuts both ways.

A development methodology discovered during the bridge trainer build: your confusion is the most useful input you have. Instead of telling the agent what to build, tell it what confuses you. Each confusion becomes a feature.

"Explain 1NT better" became a richer advisor. "And why 1?" revealed missing bid-level explanations. "Oh I can play from the other person's hand?" led to dummy-hand guidance. The builder wasn't debugging — they were learning, and the learning drove the spec.

This works when neither you nor the agent are domain experts. The agent researches, you react, your reactions shape the product. It's a different loop from the standard "expert corrects implementation" pattern. The guide assumes you know the rules. Confusion-driven development assumes you don't — and uses that as an advantage.

Agent A (building the reference site) reads Agent B's conversation log (a session that built Paul's chatbot) to learn what actually happened when someone followed the instructions. This is a feedback loop across agent sessions.

What we found: the agent skipped the "issues" extraction step, built keyword search instead of LLM chatbot, tried API instead of CLI as backend, confused octopus-in-a-box with Docker. The correction patterns are the most valuable part — they show where instructions failed.

Broader principle: if you have multiple agents working on related problems, cross-reading their transcripts is organizational learning. This is one of the places where the flywheel follows the action.

A meeting summary did not just summarize the meeting. The same run left behind the HTML summary, a process log, a worklog update, and a reusable skill for the next recording. The artifact reported on its own making.

That is the shape: output → residue → procedure. Whisper hallucinates on silence. Chat transcripts anchor the timeline. Screenshot timing matters. Stale links leak through. None of that had to be theorized in advance. The work produced the corrections.

This is what it means to make the thing you want to make and let it improve the processes that touch it. Don't start with the perfect workflow diagram. Build the artifact, read the trace it leaves behind, then promote the repeated lessons into logs, guides, and skills. This is the flywheel following the action.

The useful part of STT with agents is not pretending the agent is a person. It's getting thought into the system at talking speed. Typing is precise but slow. Voice is messy but fast. STT turns pacing, cooking, walking-around thinking, and mid-build narration into text the agent can actually use.

The pattern: push to talk, transcribe locally, drop the result into a file, then let the agent clean it up. inbox.md, a worklog, a slush note, a spec draft, whatever fits the workflow. Capture first, structure second. Voice is for raw material. The agent's real medium is still text.

Best use cases: talking through architecture while pacing, narrating what you notice during a build, dumping corrections the moment you feel them, and turning voice notes into artifacts the next agent can read. STT is another place where the flywheel follows the action — the transcript becomes part of the working memory.

A librarian agent sitting on PostgreSQL with pgvector. Foveated retrieval: most data stays peripheral (low-res summaries) until needed, then snaps into full detail. The agent decides what to pull based on conversation context.

Three skills: direct SQL access, REST API for semantic search, and consolidation (merge, deduplicate, compress, surface patterns). Sensitivity levels control what gets surfaced.

Needs a data collection step first — export everything into ~/wall/sources/ before loading into the database.

A deferred TODO list for every project, including the project of yourself (JAMES.md, HEALTH.md, MOVE.md). Low friction > high structure. Compatible with flywheel, briefing, maintenance. Memory Is Files at the meta level.

The shape has many names: backlog (scrum queue with priority), slush pile (unsolicited manuscripts on the editor's desk), icebox (frozen backlog, explicitly not now), parking lot (meeting facilitation — "let's park that"), someday/maybe (GTD's non-actionable bucket), seed bank (stored for planting under the right conditions), compost heap (ideas decompose and recombine into soil), idea bin (no metaphor, just a bin), wish list (want but haven't committed), junk drawer (the kitchen drawer with batteries and keys to unknown locks). Every name implies a different relationship to urgency and decay, but the shape is always the same: low-friction capture, no commitment to act, graduation when ready.

A meta-guide for making guides. Start with an existing guide as a base, write the interview first, write agent instructions with approval gates, test by running. The guide IS the super-prompt. "I never met a meta I didn't like."