Which principles survive better agents? — prompts and exercises

Complete reusable prompts, setup recipes, success checks, and caveats for which principles survive better agents?.

Complete reusable prompts, setup recipes, success checks, and caveats for which principles survive better agents?.

Quick start

Size up your own evidence before the audit. Swap paths for wherever your history actually lives.

# search your past agent conversations (cs = any full-text index over your chats)
cs compaction --recent -n 20
# newest prototypes, and the depth of the well
ls -dt ~/dev/*/ | head -5
ls -d ~/dev/*/ | wc -l
# archived agent sessions available to mine
ls ~/.oracle/sessions | wc -l

Prompt library

Run the 14-directive self-audit

  • Agent: any coding agent with shell access
  • Working directory: anywhere on your machine
  • Expected result: 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

  • Agent: any coding agent with shell access
  • Working directory: your home directory or main project
  • Expected result: 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 earlier-generation tool limit is due for retirement.

Fact-check any claim against your own history

  • Agent: any coding agent with shell access
  • Working directory: anywhere on your machine
  • Expected result: 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.

Set it up (agent guide)

  1. Inventory your evidence sources. Run these and note what exists:

    command -v cs || echo "no conversation index — will grep raw archives"
    ls -d ~/.claude/projects ~/.codex/sessions ~/.oracle/sessions 2>/dev/null
    ls -d ~/dev 2>/dev/null || echo "adjust to your projects directory"
    
  2. Create the scorecard skeleton in your working directory:

    # 14-Directive Self-Audit — <date>
    
    Audited machine: <describe generically — never record private paths, tokens, or ids>
    Sources searched: <conversation index / session archives / prototype directory>
    
    | #  | Old law (quoted from the Field Guide) | Evidence from this machine (dated) | Verdict |
    |----|----|----|----|
    | 01 | "If the agent can't see it, it doesn't exist." | | |
    | 02 | "Research is loud. Contracts are quiet." | | |
    | 03 | "If you can pipe it, you can reuse it." | | |
    | 04 | "Commit before autonomy." | | |
    | 05 | "Done is a claim. Green is a fact." | | |
    | 06 | "The agent can't read your mind — only your artifacts." | | |
    | 07 | "Expose the decision space. Keep the decision." | | |
    | 08 | "Bet small. Learn fast. Revert free." | | |
    | 09 | "Reuse follows value — never precedes it." | | |
    | 10 | "No single switch makes autonomy safe." | | |
    | 11 | "You can launch more agents than you can review." | | |
    | 12 | "Boring code is a superpower." | | |
    | 13 | "A gate beats a plea." | | |
    | 14 | "The code is disposable. The contract is not." | | |
    
    ## Summary
    
    - Held or hardened: __ / 14
    - Partly inverted: __ / 14
    - Outgrew tooling: __ / 14
    - Tool-shaped habits due for retirement:
      -
    
  3. Fill every row: for each directive, search your history and record at least one dated artifact plus a verdict (Held / Hardened / Partly inverted / Outgrew tooling). With an index, use it; without one, grep the raw archives:

    cs "compaction" --recent -n 20
    grep -rl "compaction" ~/.claude/projects --include='*.jsonl' 2>/dev/null | head -5
    

Success check: the scorecard has exactly 14 directive rows, every Verdict cell is filled, and every Evidence cell contains a date. The count only includes rows with a non-empty Verdict cell, so an unfilled scorecard fails.

grep -cE '^\| (0[1-9]|1[0-4]) \|([^|]*\|){2} *[^ |]' agent-audit/scorecard.md
14

Complete reusable setup contract

How Agentic Work Is Evolving — agent setup guide

Following this file sets up: a 14-directive self-audit of your user's agentic workflow, run against their own machine, producing a filled-in scorecard file (agent-audit/scorecard.md).

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." Your job is to audit that claim against THIS machine: for each directive, find dated local evidence and assign a verdict.

Placeholders used below: <project-root> = the directory you are working in. All other paths are literal but may not exist on every machine — adapt per the Notes for agents.

Human presentation pages for this section (context for your user, not required for the audit): the section guide at index.html, a Session Replay of the audit session at replay.html, and a Socratic Dialogue at dialogue.html — all at this site's root. This file remains the canonical machine copy of the setup steps.

Prerequisites

Check each before starting:

command -v cs || echo "no conversation index — will grep raw archives"
ls -d ~/.claude/projects ~/.codex/sessions ~/.oracle/sessions 2>/dev/null
ls -d ~/dev 2>/dev/null || echo "adjust to your user's projects directory"

Expected: at least ONE source of agent history (a conversation index like cs, or a raw session archive directory) and one projects directory. If none exist, stop and tell your user there is no local history to audit — do not invent evidence.

Steps

  1. Create <project-root>/agent-audit/scorecard.md with exactly this content:

    # 14-Directive Self-Audit — <date>
    
    Audited machine: <describe generically — never record private paths, tokens, or ids>
    Sources searched: <conversation index / session archives / prototype directory>
    
    | #  | Old law (quoted from the Field Guide) | Evidence from this machine (dated) | Verdict |
    |----|----|----|----|
    | 01 | "If the agent can't see it, it doesn't exist." | | |
    | 02 | "Research is loud. Contracts are quiet." | | |
    | 03 | "If you can pipe it, you can reuse it." | | |
    | 04 | "Commit before autonomy." | | |
    | 05 | "Done is a claim. Green is a fact." | | |
    | 06 | "The agent can't read your mind — only your artifacts." | | |
    | 07 | "Expose the decision space. Keep the decision." | | |
    | 08 | "Bet small. Learn fast. Revert free." | | |
    | 09 | "Reuse follows value — never precedes it." | | |
    | 10 | "No single switch makes autonomy safe." | | |
    | 11 | "You can launch more agents than you can review." | | |
    | 12 | "Boring code is a superpower." | | |
    | 13 | "A gate beats a plea." | | |
    | 14 | "The code is disposable. The contract is not." | | |
    
    ## Summary
    
    - Held or hardened: __ / 14
    - Partly inverted: __ / 14
    - Outgrew tooling: __ / 14
    - Tool-shaped habits due for retirement:
      -
    
  2. Size up the evidence well and record the counts in the scorecard header area:

    ls -d ~/dev/*/ 2>/dev/null | wc -l
    ls ~/.oracle/sessions 2>/dev/null | wc -l
    ls -dt ~/dev/*/ 2>/dev/null | head -10
    
  3. Gather evidence for each of the 14 directives. What to look for, per row:

    • 01 — do the user's agents find their own context, or does the user hand-feed it? Search history for context-curation rituals vs agent-driven search.
    • 02 — is planning separated from execution? What (if anything) enforces alignment: task files, checkpoint agents, goal contracts?
    • 03 — is piping between agents genuine composition (CI, scripts), or leftover context management from when compaction was bad?
    • 04 — is Git carrying the prototypes, or do directory names (*-final, *-super-final) and published sites act as versioning?
    • 05 — do finished tasks leave saved checks the next agent can run?
    • 06 — how does intent enter: typing, dictation, artifacts? Search for dictation/brain-dump patterns.
    • 07 — do alternatives arrive as prose, code variants, or generated images?
    • 08 — how big is the prototype discard pile, and is it ever mined for ideas?
    • 09 — how many success-capture tools are in use (instruction files, skills, memory dirs), and which have gone stale?
    • 10 — what guards unsupervised runs: allowlists, backups, a secrets manager like the op CLI?
    • 11 — how many parallel agent tracks does the user actually sustain?
    • 12 — what is the most novel tool stack in recent sessions?
    • 13 — who wrote the hooks and permission config: the user, or an agent?
    • 14 — where do sessions show selection and taste as the real bottleneck?

    Search with the index if one exists, otherwise grep the raw archives:

    cs "compaction" --recent -n 20
    grep -rl "compaction" ~/.claude/projects --include='*.jsonl' 2>/dev/null | head -5
    
  4. Fill every row: at least one dated, citable artifact (session, file, or directory) in the Evidence column, and one verdict from the fixed vocabulary — Held, Hardened, Partly inverted, Outgrew tooling. Qualifiers are fine (e.g. "Held — mechanism moved"). Then fill in the Summary counts and list any tool-shaped habits due for retirement (habits that only made sense given a earlier-generation tool weakness that no longer exists).

Success check

Run:

grep -cE '^\| (0[1-9]|1[0-4]) \|([^|]*\|){2} *[^ |]' agent-audit/scorecard.md

Expected observable result: 14. Only directive rows with a non-empty Verdict cell count, so an unfilled or half-filled scorecard fails this check. Also confirm by inspection that every Evidence cell contains a date (or an explicit "no local evidence found" note).

Report to your user: the finished scorecard table, the summary counts, which habits look due for retirement, and anything you had to adapt (missing sources, substituted paths).

Notes for agents

  • cs is a personal full-text conversation index on the original author's machine. If it is missing, grep the raw session archives instead (Claude Code stores JSONL under ~/.claude/projects/; other CLIs have their own directories). Any searchable history works.
  • ~/dev and ~/.oracle/sessions are the original author's layout. Substitute wherever your user keeps projects and session archives; ask the user if you cannot find them.
  • Evidence discipline: a verdict without a dated, citable artifact is a vibe, not a verdict. Write "no local evidence found" in the row rather than inventing something.
  • Privacy: the scorecard may be shared later. Never write tokens, emails, session IDs, or private absolute paths into it — describe artifacts generically ("a the recorded workflow session", "a project directory named <name>-final").
  • If the machine has very little history (new machine, fresh install), report that the audit is not meaningful here instead of forcing 14 verdicts.

Source references