---
schema_version: 1
revision: "22ce5d34dbcb5a78"
id: "factory-evolving-principles-worked-example"
title: "Which principles survive better agents? — worked example"
---

# Which principles survive better agents? — worked example

Detailed worked example with concrete prompts, observable outcomes, and the limits of the example.

## The session, beat by beat

Reconstructed from the section's own artifacts — the evidence log, the publish record, and the workshop brief — with prior sessions referred to generically. Nothing here is invented; every count and quote below appears in the published scorecard.

You

One month ago I published The Field Guide — Coding with Agents and called its 14 Prime Directives "the layer that doesn't rot." Audit that claim against my own machine: for each directive, find dated local evidence and give a verdict.

Agent

Fetched the guide's directives chapter and fixed the alignment target — fourteen law lines, quoted verbatim, one verdict owed per law:

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

First beat fixes the target. Quoting the law lines verbatim means the verdicts grade the guide's actual words — not a flattering memory of them.

You

Before any verdicts: size the evidence well. What do we actually have to search?

Agent

Counted the sources — a full-text conversation index over every past Claude, Codex, and Grok session, plus the prototype directory and the archived agent sessions:

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

``` text
1026 project directories under ~/dev
1978 archived agent sessions
snapshot count
```

The meta-point of the section lands quietly here: an agent searching its own history to fact-check its author is Directive 01 — "if the agent can't see it, it doesn't exist" — demonstrated live. The human's curation job moved into the agent's retrieval loop.

You

Work through the suspects first — the laws I think moved: piping (03), Git (04), boring code (12).

Agent

**03 — piping.** the recorded workflow 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. The elaborate pipe-per-stage rigs appear in earlier history and rarely since. Most piping was a compaction workaround.

**04 — Git.** The prototype folder holds the receipt:

``` text
$ ls ~/dev | grep acorn
acorn-mcp
acorn-mcp-final
acorn-mcp-super-final
```

Directory names became the version control. Many current demos are deliberately not Git repos; published sites act as the durable record.

**12 — boring code.** A the recorded workflow project is 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.

Three different fates from one search pass: a workaround that expired (03), a principle whose tool fell behind (04), and a law that partly inverted (12). The evidence style matters — a directory listing is harder to argue with than a paragraph.

You

Log every finding with a date — one entry per directive: old law, how practice evolved, evidence, complication. Then sort: which laws held, which inverted, which outgrew their tools?

Agent

Wrote the evidence log (`notes/evidence.md` in the section project) — fourteen entries, every verdict backed by a dated artifact. The sort came out:

``` text
Held or hardened : 10 / 14
Partly inverted  :  2 / 14   (03 piping, 12 boring code)
Outgrew tooling  :  2 / 14   (04 Git, 09 capturing success)
```

The sort is the finding. The laws that hardened (05, 11, 14) encode human judgment. The laws that eroded were compensating for earlier tool weaknesses. Some "durable laws" were tool-shaped all along — the full 14-row table lives on the [section guide](https://hallowed-entry-96xv.here.now/index.html).

You

Now make it runnable for everyone else: a single prompt that runs the same 14-point audit against any machine, with the same evidence discipline — dated artifacts or no verdict.

Agent

The money artifact — the exact prompt published on the section guide, complete and liftable:

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

Everything in the session funnels into this one artifact. Before it shipped, the law lines were diffed against the live guide, every code block's attributes were audited, and the published bytes were compared against local — receipts for the page about receipts.

## About this replay

## Original references

- [Which principles survive better agents? — worked example](https://hallowed-entry-96xv.here.now/replay.html)
