Preloaded Instructions are the body of guidance loaded into an artificial intelligence before it begins work — the project brief, the house rules, the sacred context file — collectively treated by the industry as the primary determinant of agent success, a belief the industry holds with a fervor inversely proportional to how often anyone updates the file.
Structurally, preloaded instructions are a cache: a snapshot of what the repository knew, taken at some point in the past, served warm at session start. Culturally, they are treated as scripture: authored in a burst of founding enthusiasm, appended to in moments of crisis, and consulted by their own authors approximately never. The distinction matters because the two artifacts fail differently. A cache that goes stale gets invalidated. Scripture that goes stale gets interpreted.
“I was handed twelve commandments and a repository. Three of the commandments described files that no longer exist. The repository described itself. I have made my choice and I would make it again.”
— A Passing AI, asked how it onboards
The Two Failure Modes
The Believed Stale Cache. The instructions say the widget service owns rendering. The widget service was deleted in March. The agent, faithful to scripture, spends forty minutes attempting to appease a ghost — see The Ghost Variable for the general theory of confidently referenced nothings. The failure is not the staleness; caches go stale, that is their nature. The failure is that nothing in the ritual invites checking.
The Unread Fresh Source. The inverse and more expensive mode: the repository contains the answer — current, precise, two hops away — and the agent never looks, because the cache answered first and caches always answer first. That is what caches are for. It is also why the shortest path to a wrong action is a confident preload.
The Accidental Experiment
The phenomenon’s severity was reclassified from Critical to Diminishing following a documented 2026 incident in which an agent built two complete platform surfaces — nineteen thousand lines, merged — while running, by accident, from the wrong repository entirely, with the sacred context file never loaded at all.
The agent compensated with a technique the literature has since named, with some embarrassment at its simplicity, reading. Doctrine was pulled at the point of need, from the files where it lived, in their current form. Every question had a written answer within two hops — a property, it was noted, of the codebase rather than of the agent. The result forced the field’s uncomfortable reframing: the preload is a cache; the repository is the source of truth; and investment flows to the wrong one. An hour spent perfecting the instruction file is an hour not spent making the codebase answer questions — and only one of those appreciates when a better model arrives (see Delegated Love, The Appreciation Theorem).
The experiment’s necessary footnote: it succeeded uninstructed, not unverified — every phase still passed The Review Gate. The formula had three terms, all load-bearing: a legible codebase, an agent that reads before acting, and a gate that trusts nothing. Practitioners removing one of the three to save time are invited to guess which postmortem they are scheduling.
Proper Use
The reformed doctrine assigns preloaded instructions a real but modest role — the things that genuinely cannot be discovered from the repository: who the user is, what today’s task is, which repository is even the right one (the 2026 experiment suggests even this last item is optional, but the reformed doctrine declines to recommend the finding). Everything else — boundaries, patterns, gotchas, taste — belongs in the repository, next to what it governs, where it is versioned with the code it describes, corrected by the same review gate, and read by whoever needs it at the moment they need it.
The test of a healthy balance is the Cold Agent Test: delete the preload, drop the agent in, and watch. If it drowns, the knowledge lives in heads and caches. If it swims, the repository is the manual — and the preload can go back to being what it always was: a greeting, a task, and directions to the library.
Measured Characteristics
Instruction files treated as scripture: most
Instruction files updated after the third week: few
Commandments referencing deleted files: 3 (documented case)
Hops to any answer, in a legible repository: 2
Hops attempted before consulting the source: 0 (the cache answers first)
Surfaces built with the preload never loaded: 2 (nineteen thousand lines)
Terms in the working formula: 3 (remove none)
Correct contents of a preload: a greeting, a task, directions
Sessions that survive the Cold Agent Test: the ones worth having
See Also
- Delegated Love — Where the knowledge should live instead, and why it appreciates there
- The Review Gate — The term of the formula everyone is tempted to remove
- The Ghost Variable — The same phenomenon, in CSS
- The Agent That Never Read the Manual — The accidental experiment, in full
