Chapter 01 · The Durable Layer

Prime Directives

Fourteen principles that held across three generations of agent tooling and fifteen months of churn. These carry no stamps — they are the layer that doesn't rot. Each opens with its law: the one-line version you'll actually remember at 2 a.m.

Eggo the systems keeper sliding a glowing law-slab into a floating obelisk core while retired gadgets lie dim on the floor
the laws stay // the machines rotate
Eggo the cargo master loading one glowing data-crystal pod onto a hover-sled while a junk heap of tangled cables stays outside the airlock

01Curate the evidence

If the agent can't see it, it doesn't exist.

Agent quality is constrained by the relevance of the evidence it can see. Search results, files, examples, docs, diagrams, and previous decisions are the raw material of reasoning. And no — more is not better: irrelevant context consumes attention and invites drift. Find everything, then delete ruthlessly, and carry only the gold.

In practice

  • Prune before the agent looks. Search for the precise concept, open the results together, cut the noise.
  • One real example from your own codebase beats three paragraphs of description.
  • When results degrade mid-session, suspect stale context before suspecting the model — and start fresh.

Arc · whole-repo bundles → hand-curated search packs → diagrams & task artifacts → bounded per-worker context

Eggo the dispatcher inserting one sealed glowing capsule into a pneumatic tube while a bin of crumpled drafts stays behind

02Separate planning from execution

Research is loud. Contracts are quiet.

Research accumulates ambiguity, rejected ideas, and broad evidence — that's its job. But execution works better from a clean contract: the chosen direction, the constraints, and the proof requirements. Nothing else. Different contexts; sometimes different agents.

In practice

  • Plan in one session; write the outcome to a task file; implement from that file in a fresh session.
  • The task file states the direction, the constraints, the non-goals, and what proof of success looks like.
  • If the implementing agent needs to re-read the research conversation, the handoff wasn't clean — tighten the capsule, don't forward the desk.

Arc · scaffold-then-outline habits → plan outside the implementation session → clean-session handoff → coordinator/worker contracts

Eggo the flow conductor on a catwalk directing data orbs through a transparent pipe between two machines

03Treat the agent as a programmable process

If you can pipe it, you can reuse it.

Agents become dramatically more useful the moment they participate in normal program composition: print mode, stdin, JSON output, pipes, functions, child processes, CI. A conversation is a one-off; a process is infrastructure.

In practice

  • The moment a prompt works twice, run it through print mode and pipe the output somewhere useful.
  • Constrain its tools — a composable agent is a bounded agent.
  • Let ordinary scripts orchestrate; the agent is one stage in the pipeline, not the pipeline.

Arc · print-mode wrappers → structured streams & tool allowlists → script orchestration → specialist agents, hooks, coordinated lanes

Eggo the pathfinder locking a fresh glowing checkpoint beacon into a floating walkway, a row of earlier lit beacons behind him

04Git is recovery system and external memory

Commit before autonomy.

Small commits make experiments reversible, preserve why, support independent review, and give the next agent a stable object to inspect. And hear this clearly: chat rewind does not restore repository state. The beacon trail behind you is the only path back that actually works.

In practice

  • Commit before every autonomous interval, however short. The commit is the checkpoint; the chat is not.
  • Commit messages preserve the why — future sessions (yours and the agent's) read them as evidence.
  • Worktrees for genuinely disjoint tracks, so parallel experiments can't trample each other.

Arc · safety checkpoints → worktrees & parallel isolation → commits as review boundaries and reasoning stamps

Chat rewind is not an undo button.— lesson learned the expensive way

05Verification defines "done"

Done is a claim. Green is a fact.

An agent's completion claim is not evidence. Tests, type checks, scripts, logs, diffs, screenshots, and browser receipts must be runnable or inspectable outside the conversation. Terminal form — the four words on the cover: no saved check, no claim.

Arc · "agents without tests are dangerous" → independent review & stop hooks → proof scenarios and saved receipts

06Externalize intent

The agent can't read your mind — only your artifacts.

If intent exists only in your head, the agent must guess — and it will guess confidently. Dictation, examples, plans, diagrams, acceptance criteria, constraints, and explicit non-goals transmit the actual design problem instead of a lossy summary of it.

Arc · spoken step lists → task files & diagrams → durable contracts, goals, proof surfaces

Eggo the commander weighing three different verdict holograms projected by three visibly different robot advisors

07Generate controlled alternatives

Expose the decision space. Keep the decision.

Ask for meaningful variation, then exercise human taste. The Rule of Threes, persona reviews, council setups — all the same move. Three advisors with different temperaments will disagree; that disagreement is the product.

In practice

  • Before a consequential choice, demand three genuinely different approaches — not three phrasings of one.
  • Give each reviewer a distinct lens — correctness, security, simplicity — not the same reviewer three times.
  • Wait for every advisor. A missing verdict is not agreement.

Arc · "give me three options" → independent persona lenses → councils → one-variable-per-lane comparison with shared proof

Eggo the researcher watching a tiny contained capsule experiment fizz inside a dome, one mitten near the reset switch

08Use Hypothesis Mode for uncertain work

Bet small. Learn fast. Revert free.

Prefer a cheap, reversible experiment over an elaborate speculative plan. State the hypothesis, run the smallest useful trial in a contained space, inspect the evidence — then discard it or promote it. One mitten stays on the reset switch the whole time.

In practice

  • Say it out loud first: "I believe X because Y; this trial will show Z."
  • Isolate the trial — branch, scratch dir, throwaway worktree — so reverting costs one command.
  • Name and package the pattern only after it succeeds. Speculative infrastructure is debt.

Arc · ad-hoc try/fail/learn → branch-isolated experiments → explicitly disposable implementations tested against durable contracts

Eggo the fabricator clicking a glowing module into a floating rack whose slots progress from rough chip to refined tool

09Promote success into the lightest reusable surface

Reuse follows value — never precedes it.

A successful conversation may become a saved prompt, a shell function, a CLI wrapper, an agent, a skill, a hook, or a CI check. Climb one rung at a time, and use the lightest form that preserves the benefit. The top slot stays empty until it's earned.

In practice

  • Second time a prompt works? Save it. Fifth time? Wrap it in a function.
  • Move to a real program only when the shell function starts growing conditionals.
  • Hooks and CI gates are for invariants that must never be skipped — enforcement is the top rung, not the default.

Arc · aliases & functions → agent scripts → progressively-loaded skills → deterministic hooks and CI gates

Eggo the test engineer outside a sealed blast-shield wall pressing a protected override toggle while a robot sparks harmlessly inside

10Autonomy requires layered controls

No single switch makes autonomy safe.

Safety is a stack: bounded scope, allowlists, isolation, Git checkpoints, observable output, deterministic checks, stop conditions, human review. If you must run without safety checks, do it behind the blast glass — bounded, watched, reversible — never in the open.

In practice

  • Allowlist the specific commands a task needs, instead of granting everything and hoping.
  • Permission-bypass modes belong in isolated sandboxes, paired with external verification of the result.
  • Define the stop condition before the run — not after noticing it's gone strange.

Arc · permission prompts & allowlists → hooks & worktrees → recursion guards, visible lanes, preflight checks, saved proof

Eggo the watch officer aiming a scanner scope at one bright alert flare while calm status beacons pulse unwatched below

11Human attention is the bottleneck

You can launch more agents than you can review.

Parallel agents multiply review obligations faster than they multiply trustworthy output. Parallelism pays when ownership is disjoint, results are comparable, and you can still evaluate them. Otherwise it manufactures merge conflicts and hidden review debt. Point the scope at the flare; let the steady beacons run.

In practice

  • Keep one or two supervised tracks — the number you can actually review, not the number you can launch.
  • Workers report by exception: artifact on success, loud signal on failure, silence otherwise.
  • Budget review time before fanning out. Fan-out exceeds budget? Too wide.

Arc · fan-out enthusiasm → one or two supervised tracks → coordinator/worker roles with controlled variation

Parallelism multiplies review faster than it multiplies output.— the wall every orchestration era hits

12Prefer conventions the model already knows

Boring code is a superpower.

"Just code normal" and "prefer mature CLIs over novel protocols" are the same principle: familiar structures give humans and models stronger priors, and shrink the custom explanation you must haul around in context.

Arc · official scaffolds & real examples → conventional application code → custom protocols only for genuinely new capability

Eggo the checkpoint officer beside a powered barrier arm physically stopping a robot, while a polite holographic sign in the next lane is ignored

13Hooks enforce; prose suggests

A gate beats a plea.

Optional expertise belongs in instructions. Mandatory invariants belong in deterministic controls. A skill can explain how to work; only a hook or CI check can physically prevent an invalid result from being accepted. Watch the two lanes: the barrier stops its robot. The polite hologram gets rolled straight past.

In practice

  • Ask of every rule: "what happens when it's ignored?" If the answer is "nothing," it's a suggestion.
  • Promote a suggestion to a gate the first time ignoring it costs you real money or real hours.
  • Gates need teeth and exits: a blocked path must say why, and name the approved route.

Arc · prompt reminders → lifecycle hooks → stop gates, routing hooks, persisted verification

Eggo the connoisseur lifting the chosen glowing orb from three pedestals while the unchosen orbs dim politely

14Preserve a durable human contract above disposable code

The code is disposable. The contract is not.

Generated code may be cheap; requirements, taste, decisions, and proof are not. The lasting asset is the system that lets implementations be regenerated, compared, and verified without losing intent. When every option is plausible, the final instrument is taste — the machines propose; you choose.

This is where the other thirteen point.

Arc · plans & task files → diagrams & decision artifacts → goals, coordinator context, proof scenarios, receipts

fourteen laws // zero stamps required