Agentic Software Factory · 2026-07-17

How Agentic Work Is Evolving

One month ago, The Field Guide — Coding with Agents named 14 Prime Directives and called them "the layer that doesn't rot." An agent audited that claim against its author's own machine. Here's the scorecard — and the prompt to run the same audit on yours.

TL;DR

🤖 Have your agent run the audit — paste this into it:

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.

The scorecard: 14 laws, one month later

Each row: the directive's law line quoted from the guide, what one month of receipts showed, and the verdict. Read it as a sort, not a grade: which kind of law lands in which column?

#Old law (quoted)What the receipts showedVerdict
01"If the agent can't see it, it doesn't exist."Agents find their own context now; curation moved into their retrieval loopHeld — mechanism moved
02"Research is loud. Contracts are quiet."Agents recover from thin plans; alignment is the real variableHeld — sharpened
03"If you can pipe it, you can reuse it."Most piping compensated for bad compaction; compaction got goodPartly inverted
04"Commit before autonomy."Directory names and published sites became the version control for prototypesOutgrew tooling
05"Done is a claim. Green is a fact.""Done" now includes leaving the repo easy for the next agent to probeHardened
06"The agent can't read your mind — only your artifacts."Dictation became the intent firehose; structuring it is the gapHeld
07"Expose the decision space. Keep the decision."Alternatives now arrive as generated images, not just proseHeld — went visual
08"Bet small. Learn fast. Revert free."1,026 discarded prototypes compounded into a searchable idea libraryHeld — compounds
09"Reuse follows value — never precedes it."Four competing capture tools on one machine; instruction files may rot into anti-patternsOutgrew tooling
10"No single switch makes autonomy safe."Unsupervised runs are routine: backups plus secrets fenced behind the op CLIHeld — layers thinned
11"You can launch more agents than you can review."Attention and budget are now the absolute bottleneckHardened
12"Boring code is a superpower."Models explore new tools so well that pushing boundaries is now necessaryPartly inverted
13"A gate beats a plea."Agents now write their own gates and permission configHeld — authorship moved
14"The code is disposable. The contract is not."Taste is the defining factor when anyone can build anythingHardened

The sort is the finding: the laws that hardened (05, 11, 14) encode human judgment. The laws that eroded (03, 12, half of 01) were compensating for 2025 tool weaknesses. Some "durable laws" were tool-shaped all along.

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

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.

Set it up (agent guide)

These steps mirror agent.md — the machine copy your agent fetches. They produce a filled-in scorecard file on your machine.

  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

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.

Appendix

Limits & caveats
  • Every verdict rests on one practitioner's machine over roughly one month — a sample of one, gathered by an agent with access to that machine only. The verdicts support the sorting method, not an industry-wide ranking.
  • The claim that instruction files actively harm agents is the workshop's position, not a measured result. The evidence documents tool proliferation; there is no controlled comparison of sessions with and without instruction files.
  • Piping did not die — it survives where it is genuine composition. The evidence can't say how much piping remains in other practitioners' setups.
  • Agent-authored gates inherit the old guide's requirement unchanged: teeth and exits, reviewed by a human. The log shows agents writing config; it does not show that unreviewed agent-written gates are safe.
  • cs and ~/.oracle/sessions are personal tooling on the author's machine. The audit works with any searchable history — agent.md includes grep fallbacks over raw session archives.
  • Verdicts and the tool-shaped/judgment-shaped sort are editorial inference from the evidence, and are marked as such.
Provenance

S1 — "The Field Guide — Coding with Agents: Lessons Learned," published at kindly-mirage-ejqd.here.now, fetched 2026-07-16. All fourteen law lines are quoted from its Prime Directives chapter.

S2 — the workshop brief for "How Agentic Work is Evolving" (Agentic Software Factory, 2026-07-17) by John Lindquist; its fourteen numbered points supply the commentary, condensed but not reworded in substance.

S3 — a local evidence log compiled 2026-07-16 by searching the author's conversation index, project directories, and session archives. Counts (1,978 sessions, 1,026 project directories) are as measured that day. Private identifiers — tokens, session IDs, emails, personal paths beyond ~/dev/<name> — were removed or generalized. No external citations or artifacts were invented.

JavaScript: only the canonical copy-button enhancement (app.js); the page reads fully without it. This page supersedes the Scholarly Folio edition previously published at this URL.