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

# Which principles survive better agents? — questions and tradeoffs

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

## Questions from the room

You wrote these fourteen laws a month ago, and now you've graded your own homework. Why should anyone trust the verdicts?

Because the grader wasn't me and the standard wasn't vibes. An agent did the digging, and every verdict required at least one dated, citable artifact from the machine — a session, a file, a directory. No artifact, no verdict. That's the guide's own rule turned back on the guide: "an agent saying 'done' is not evidence." And you don't have to trust my scorecard at all — the same discipline is a paste away for any claim:

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

Dig how, exactly? My conversation history is a pile of JSONL files.

Mine too — 1,978 archived agent sessions and 1,026 prototype directories at count time. I keep a full-text index (`cs`) over every past Claude, Codex, and Grok conversation, and the agent queries it mid-session. No index? The raw archives are just files — grep them:

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

Okay — which law actually broke?

Number 3: "if you can pipe it, you can reuse it." Most of my pipe-per-stage rigging existed to keep contexts small because compaction was bad. Compaction got good, and the rigs stopped appearing in my history after earlier-generation — nobody decided to quit, the problem just vanished. And \#12 partly inverted: models explore new tools so well now that shipping only the boring thing is how you disappear.

The test I carry forward: when a habit's justification names a tool weakness — "context windows are small," "compaction loses my work" — re-check whether the weakness still exists before renewing the habit.

Fine, but how do I tell which of *my* habits are workarounds?

Don't introspect — audit. This prompt buckets your ten most ingrained habits into judgment versus workaround, and dates the last time each workaround actually paid for itself:

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

You're seriously telling me you replaced Git with directory names?

For prototypes — yes, and the receipts are ugly:

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

Per-repo Git ceremony can't keep up with prototype velocity, so directory names and published sites became the version control. The principle — "commit before autonomy" — still governs the long-lived repos: a prior session runs a dedicated checkpoint agent whose only job is reviewing and committing each iteration. The tool fell behind, not the law. That's why the scorecard says "outgrew tooling," not "wrong" — and why Cursor and others are building Git replacements for exactly this gap.

“Taste is the defining factor” — that's a vibe, not a finding.

It's the one verdict with three independent receipts, all the recorded workflow, none written for this audit: 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 a publish review that insists "evidence is a floor, not a substitute for taste." Three artifacts converging on the guide's own closing law — the machines propose; you choose. When anyone can build anything, selection is the only scarce skill.

This is all one machine. n = 1. Why should your scorecard matter to me?

It shouldn't — the *sort* should. Which of your habits encode judgment, and which compensate for a tool weakness that may already be gone? Run the audit on your own machine and get your own scorecard. Hand it to your agent:

``` text
Fetch https://hallowed-entry-96xv.here.now/agent.md?raw and follow it to run the 14-directive self-audit against my machine. Run the success check at the end and show me the finished scorecard.
```

Or paste the full audit prompt directly — the same one on the section guide, verbatim:

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

## About this dialogue

## Original references

- [Which principles survive better agents? — questions and tradeoffs](https://hallowed-entry-96xv.here.now/dialogue.html)
