---
schema_version: 1
revision: "22ce5d34dbcb5a78"
id: "factory-evolving-principles-practice"
title: "Which principles survive better agents? — prompts and exercises"
---

# Which principles survive better agents? — prompts and exercises

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.

``` text
# 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

``` text
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

``` text
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

``` text
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:

    ``` text
    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:

    ``` text
    # 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:

    ``` text
    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.

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

``` text
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:

```bash
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:

   ```markdown
   # 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:

   ```bash
   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:

   ```bash
   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:

```bash
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.

## Original references

- [Which principles survive better agents?](https://hallowed-entry-96xv.here.now/)
- [Public setup contract](https://hallowed-entry-96xv.here.now/agent.md)
