Prompt library
Run the 14-directive self-audit
any coding agent with shell access
anywhere on your machine
a 14-row scorecard table with dated evidence and verdicts
Run the 14-directive self-audit of my agentic workflow against my own machine.
Background: "The Field Guide — Coding with Agents" (https://kindly-mirage-ejqd.here.now/) names 14 Prime Directives and calls them "the layer that doesn't rot." Audit that claim against MY machine: for each directive, find dated local evidence and give a verdict.
Evidence sources (adapt to what actually exists here):
1. My agent conversation history. Use a full-text index if I have one (e.g. `cs <terms> --recent -n 20`); otherwise grep the raw session archives (Claude Code: ~/.claude/projects/, Codex: ~/.codex/sessions/, plus any others you find).
2. My prototype directories: `ls -dt ~/dev/*/ | head -30` (or wherever my projects live). Count them; note naming patterns like repeated "-final" suffixes.
3. Any other session archives at scale — count them so we know the size of the well.
The 14 directives, with what to look for:
01 "If the agent can't see it, it doesn't exist." — do my agents find their own context, or do I hand-feed it?
02 "Research is loud. Contracts are quiet." — do I plan separately from executing? What enforces alignment?
03 "If you can pipe it, you can reuse it." — is my piping genuine composition, or leftover context management?
04 "Commit before autonomy." — is Git carrying my prototypes, or do directory names and published sites version things?
05 "Done is a claim. Green is a fact." — do finished tasks leave saved checks the next agent can run?
06 "The agent can't read your mind — only your artifacts." — how does intent enter: typing, dictation, files?
07 "Expose the decision space. Keep the decision." — do alternatives arrive as prose, code, or generated images?
08 "Bet small. Learn fast. Revert free." — how big is the prototype discard pile, and do I ever mine it?
09 "Reuse follows value — never precedes it." — how many capture tools do I run (instruction files, skills, memory dirs), and which have gone stale?
10 "No single switch makes autonomy safe." — what actually guards unsupervised runs: allowlists, backups, a secrets manager?
11 "You can launch more agents than you can review." — how many parallel agent tracks do I actually sustain?
12 "Boring code is a superpower." — what is the most novel tool stack in my recent sessions?
13 "A gate beats a plea." — who wrote my hooks and permission config: me, or an agent?
14 "The code is disposable. The contract is not." — where do my sessions show selection and taste as the real bottleneck?
Output: one table row per directive — # | law (quoted) | evidence from my machine (dated: session, file, or directory) | verdict. Verdict vocabulary: Held / Hardened / Partly inverted / Outgrew tooling.
Rules: every verdict needs at least one dated, citable artifact from this machine — no verdicts from vibes. If a source doesn't exist here, write that in the row instead of inventing evidence. Never include tokens, emails, or private identifiers in the output. Close with a 3-line summary: counts per verdict, and which of my habits are tool-shaped workarounds due for retirement.
Sort your habits: judgment or workaround
any coding agent with shell access
your home directory or main project
10 habits, each bucketed, with keep / retool / retire recommendations
Search my agent conversation history and my project instruction files (CLAUDE.md, AGENTS.md, hooks, saved prompts, skills) and list my 10 most ingrained agent-workflow habits — rules I repeat, ceremonies I enforce, rigs I keep rebuilding.
Sort each habit into exactly one bucket:
A. Encodes human judgment (verification, review limits, taste) — keep it; consider promoting it to a deterministic gate.
B. Compensates for a tool weakness — name the weakness explicitly (e.g. "context windows were small", "compaction lost my work").
For every bucket-B habit, check whether the named weakness still exists in my current tools, and find the last dated time it actually bit me. Recommend keep, retool, or retire for each. A habit I can't justify without naming a 2025-era tool limit is due for retirement.
Fact-check any claim against your own history
any coding agent with shell access
anywhere on your machine
a verdict with dated citations from your own sessions and files
Fact-check this claim against my own machine: "<paste any claim about how you work, e.g. 'I always commit before letting an agent run unsupervised'>".
Search my agent conversation history for dated sessions that support or contradict it, scan my project directories for matching artifacts, and return a verdict with citations (dates plus file, session, or directory names). If the evidence is thinner than the claim, say so — an agent saying "confirmed" is not evidence; the citations are.
What the guide promised wouldn't rot
The Field Guide distilled fifteen months of workshops (March 2025 → June 2026, across Cursor, Claude Code, and Codex) into fourteen Prime Directives and one rule above the rules: "An agent saying 'done' is not evidence." It called the directives "the layer that doesn't rot." This page audits that claim one month later, by the guide's own standard — saved, inspectable evidence instead of confident narration.
The method is itself the first verdict. An agent searched the author's full conversation history through a local full-text index (cs, covering every past Claude, Codex, and Grok session), scanned 1,026 prototype directories, and counted 1,978 archived agent sessions — all on 2026-07-16. Directive 01 said "if the agent can't see it, it doesn't exist," and made hand-curation the human's edge. The audit was performed by an agent finding its own evidence. The law's wording survives; the human's role in it didn't. Curation flipped from "feed the agent" to "make everything findable."
Piping was a compaction workaround
Directive 03 turned agents into Unix processes: print mode, JSON streams, one bounded agent per pipeline stage. The receipts say most of that rigging existed to keep contexts small because compaction was bad. July 2026 session logs across four projects show compaction firing mid-task under a standing "continue where you left off" directive — long multi-day sessions just keep going, and nobody thinks about it. The elaborate pipe-per-stage rigs appear in 2025 history and rarely since. Piping retreated to where it's genuine composition: CI stages and scripts. The test to carry forward: when a habit's justification names a tool weakness ("context windows are small"), re-check whether the weakness still exists before renewing the habit.
Git lost the short-lived majority
Directive 04 — "commit before autonomy" — made Git the recovery system and external memory. The principle held; the tool fell behind the volume. The prototype folder contains sibling directories named acorn-mcp, acorn-mcp-final, acorn-mcp-super-final: directory-name versioning, because per-repo Git ceremony can't keep up with prototype velocity. Many current demos are deliberately not Git repos at all; published sites act as the durable record. Cursor and others are building Git replacements for exactly this gap — approving code nobody reads, and exploring memories of what worked. Meanwhile the old discipline survives where it belongs: an April 2026 session runs a dedicated checkpoint agent whose only job is reviewing and committing each iteration in long-lived repos.
Directive 09 (the reuse ladder) hit the same wall from the other side. There's still no good tool for capturing success — the evidence log shows four competing capture mechanisms in active use on one machine within a single month: a friction-log skill, a workflow productizer, the conversation index, and per-agent memory directories. Four tools for one job means no tool has won. Worse, CLAUDE.md/AGENTS.md instruction files may be rotting into anti-patterns: stale rules that stop agents from making fixes or taking better directions. Audit your instruction files the way you audit dependencies.
The one law that inverted: boring code
Directive 12 said "boring code is a superpower" — familiar structures, mature CLIs, no novel protocols. Models got so much better at exploring new ideas and new tools that the advice partly flipped: pushing boundaries is now necessary to stand out, because everyone can ship the boring thing. The log includes a July 2026 project literally named pushing-boundaries, and recent sessions casually drive desktop-app automation, GPU UI frameworks, and multi-account model councils — stacks the old law would have flagged as risk. The inversion is scoped: boring still wins inside the implementation. The boundary-pushing lives in what you attempt, not how the code is structured.
The laws that hardened are the judgment ones
Three directives got stronger, and they're all about human judgment. Directive 05 ("done is a claim, green is a fact") extended past the diff — done now means leaving the codebase where the next agent can iterate, probe, and test; a July 2026 publish review states the mature position in seven words: "evidence is a floor, not a substitute for taste." Directive 11 was promoted from lesson to law of nature: a July 2026 retrospective quantifies the practical limit at one to two guided tracks even with manager-agent tooling, and token budgets are now first-class workflow parameters. You can build anything — so the binding question is what you will build.
Directive 14 is the audit's clearest winner. "The machines propose; you choose" — the guide called it where the other thirteen point. One month later the log converges on that sentence from three independent directions: a video project titled "taste-is-the-job," a workshop retrospective whose story spine reads "it turned out to be about taste, constraints, and verification," and the publish review above. When anyone can build anything, selection is the only scarce skill. The last law absorbed the other thirteen, exactly as the guide predicted.