AI Debt #
Coined here
Accumulated framework overhead that starts serving itself instead of shipping the product.
Locked decision logs, sprawling architecture documents, scaffolding that the AI itself has to navigate before doing any useful work. Distinct from technical debt, which lives in the code shape. AI Debt is the prose, scaffolding, and meta-process around the code that the next agent has to absorb before doing anything useful. Compounds in proportion to how heavily AI is producing the artifacts.
Appears in AI Debt
B2A: Business to Agent #
Term in circulation; framing introduced here
The third distribution model after B2B and B2C: your customers are AI agents, finding and calling your product before a human ever sees your URL.
The term has surfaced in agent-marketing discussions and isn't unique here; what's introduced is the specific framing. An agent tasked by a human discovers your service via MCP, calls it on the human's behalf, and returns the result. The user never chose you, their agent did. MCP capability descriptions become the conversion funnel (the new SEO); that funnel has no homepage, no onboarding, no sign-up, just a JSON schema an agent reads. The asymmetric speed window: a solo dev ships an MCP server in an afternoon while enterprises take quarters.
Appears in B2A: Business to Agent
Boutique Gravity #
Coined here
The pull that quality work exerts on adjacent work, raising the bar until "done" becomes harder to declare.
Each improvement raises the bar for everything else. A high-quality feature makes adjacent features look unfinished by contrast; polishing one surface highlights every unpolished surface around it. Companion concept to economic gravity (the pressure to ship cheaply). Boutique gravity pulls the opposite direction. The mechanism behind shipping paralysis in projects with high taste and unbounded scope.
Appears in Shipping Paralysis & World Domination Scope
Cage and Constitution #
Coined here
Two different things the word "control" hides. A cage second-guesses the model's cognition; a constitution bounds its authority over shared state.
A cage is compensatory software written from distrust of the model: validators around validators, retry forests, frozen pipelines, code whose only job is to doubt the model's output. It grows with every failure and rots as the model improves. A constitution is the small set of boundaries that must hold no matter how capable the actor becomes: role-scoped tool exposure, admission gates at consequential side-effect boundaries, receipts for irreversible actions, a landing policy nobody including the operator can bypass. It does not grow with capability; it matters more because of it. The failure mode is treating both as the same thing and tearing out the constitution along with the cage. The sharper rule: a cage second-guesses intelligence at every step, a constitution defines the few truths that must stay mechanical. Maps onto Compiled Doctrine (the constitution compiles) and Privilege Separation (the side-effect boundary).
Coined in Cages and Constitutions
Cambrian Era #
Vocabulary of trade · VC metaphor
Established metaphor for technology category explosions and the early-form era preceding them.
Not coined here. Pre-Cambrian = the legacy era (open niches, no winners yet, most product forms unbuilt). Cambrian = the explosion (early body plans appearing, dominant winners not yet selected). Used here to describe the current state of dev-tool categories. Most are Pre-Cambrian; the Cambrian explosion of agent-shaped tooling is just beginning.
Appears in The Cambrian Explosion of Software and Humans Moving Upchain
Compiled Doctrine #
Coined here
Rules the runtime enforces structurally. Deterministic, testable, checked at the boundary before any action is admitted.
One half of the doctrine bifurcation. Compiled doctrine is the register where rules become structurally enforced gates: permissions scoped to an agent's role (a coordinator-tier agent cannot write code), checks that reject malformed work before an agent ever runs, a fixed order of execution the runtime controls rather than the model deciding, a cancellation that propagates through the entire work tree, every action carrying a traceable parent link. The model literally cannot violate these rules because the runtime does not expose the path to violate them. The enforcement is implicit: the role's rule-set loads when the agent starts, and its constraints become gates the agent runs inside. A visual editor (in development) surfaces this for the operator; the enforcement itself has existed for as long as the runtime has. Companion register: Interpretive Doctrine.
Coined in The Doctrine Bifurcation. Applied in Prompt Injection is a Privilege Problem and The Supervisor Tier.
Dark Factory #
Established term, applied here
An autonomous factory that operates without human attendance, applied here to the AI build/review/merge cycle running without humans in the implementation path.
Originates in industrial-era manufacturing (lights-out factories that run unattended). Widely used in the AI context for agent systems that ship work end-to-end without human intervention. Not coined here. Applied as the concrete metaphor for the L5 endpoint: a substrate-driven build/review/merge pipeline that runs the cycle on its own.
Appears in The Dark Factory
Doctrine Engineering #
Coined here
The discipline of authoring the rules that govern running many agents as a system. It covers both registers of doctrine: the rules a runtime enforces and the rules agents read and apply with judgment.
Prompt engineering helps you run one agent well by authoring the text a single model reads. Doctrine engineering is the broader discipline at fleet scale: authoring the full body of rules that govern how many agents operate together. It does not replace prompt-shaped rules, it contains them. Doctrine bifurcates into two registers and doctrine engineering authors both: compiled doctrine (rules the runtime structurally enforces, which no agent can violate) and interpretive doctrine (judgment-shaped rules agents read and apply in context). Deciding which rules can be enforced and which require an agent's judgment is itself part of the discipline. The concrete artifacts span both: permission policies scoped per agent role, pre-run checks, structural rules enforced across a task's whole lifetime, judgment-shaped recovery and altitude rules, automated tests on the enforced rules, and eventually visual surfaces where rules are authored as flow graphs. Where prompt engineering scales to one agent because a read-once instruction is enough, doctrine engineering scales to many because the enforced register holds the whole fleet to the same rules regardless of how any individual agent behaves on a given turn. Prompt engineering tunes one agent with text it reads. Doctrine engineering governs many agents with rules: some the runtime enforces, some the agents read and judge. See also: Compiled Doctrine, Interpretive Doctrine.
Coined in Doctrine Engineering
Five Levels of AI Programming #
Authored by Dan Shapiro
A framework describing the autonomy spectrum of AI-assisted programming, from L0 (manual coding) through L5 (full automation within a given spec).
Dan Shapiro's framework. L0 = manual coding. L1-L3 = increasing AI assistance. L4 = spec → software (one-shot agent execution under human supervision). L5 = full automation within a given spec (the dark factory: substrate ships its own work end-to-end repeatably). The framework as Shapiro authored it ends at L5; Level 6 is an extension introduced here.
Discussed in Five Levels of AI Programming and The Dark Factory
Interpretive Doctrine #
Coined here
Rules the agent reads. Judgment-shaped prose, applied contextually at decision time.
One half of the doctrine bifurcation. Interpretive doctrine lives in the written doctrine document and is read by the agent at decision time. The kind of rule that needs judgment: recovery procedures for when work partially completes, altitude rules about which tier of agent should do which work, judgment calls about whether an agent that is still running is actually making progress. These require weighing and context. They cannot be compiled into deterministic gates without losing their meaning. The agent is the enforcer of rules that genuinely require an enforcer with judgment; the runtime does not abdicate, it delegates only the rules whose nature is judgment-shaped. Companion register: Compiled Doctrine.
Coined in The Doctrine Bifurcation. Applied in Prompt Injection is a Privilege Problem and The Supervisor Tier.
Level 6 #
Articulation introduced here · extends Shapiro's L0-L5
Intent → software. The autonomy ceiling where the runtime authors its own spec from observed friction.
Beyond Dan Shapiro's L0-L5 framework. The term "Level 6" has surfaced in other discussions of AI-programming autonomy and isn't unique to here; what's introduced in these field notes is the specific articulation: intent → software, with the runtime authoring its own spec from observed friction. At L5 the human still writes the spec; at L6 the runtime observes its own friction, drafts the doctrine update, applies it, and validates against subsequent dispatches without the human writing the spec. Humans operate on intent ("salvage rate is too high") and high-risk review only. The runtime layer learns; the model executes; the human becomes policy-maker rather than spec-author. The cycle has been proven to close: doctrine updates drive correct behavior in the next dispatch (validated when a freshly-spawned agent honored a new doctrine amendment within seconds of authoring). The remaining engineering is removing the human from the observation and drafting steps; the validity of the loop itself is established.
Discussed across Field Notes; framework foundation in Five Levels of AI Programming
Model Context Protocol (MCP) #
Anthropic specification · interpreted and applied here
The permissioned bridge between probabilistic model reasoning and deterministic tool execution.
An open protocol authored by Anthropic. An MCP server exposes a defined set of tools, resources, and prompts that a model host can discover and call. The model does not directly execute code or read files; it calls a tool declared by the server, which runs it deterministically and returns the result. The model's probabilistic reasoning stays on one side; deterministic execution stays on the other. The server's tool manifest is the permission surface: what it exposes is what the model can reach, nothing more. This is where MCP connects directly to Privilege Separation and Compiled Doctrine: bounding the server's tool surface is how you bound the model's capability without touching the model itself. Applied here to describe each capability a server exposes as an ability, and the full set of abilities bundled with a role's context as the role. See also: B2A, where MCP capability descriptions become the conversion funnel for agent discovery.
Applied throughout Field Notes; central to B2A: Business to Agent
Oracle Capture #
Coined here
When the worker who produces the output also controls the criteria that judge it. The feedback loop collapses because no independent judge exists.
A worker captures the oracle when it defines the contract, produces the output, runs the evaluation, and declares the result correct, all from the same context and reasoning surface. The test cannot catch the worker's blind spots because they share the same latent space. A model that writes an eval, passes the eval, and explains why green proves correctness has not verified anything; it has confirmed its own prior. The fix is structural: the judge must be a different agent running from an independently committed spec as its contract, unable to see the builder's work history. Builder and judge cannot share model weights, session context, or system prompt. Oracle capture is the technical mechanism behind a broader principle: the real world must sign for it, because only a judge that is structurally isolated from the worker is a judge worth trusting. Related: Supervision Tree (the judgment tier that holds the independent judge role), Compiled Doctrine (the register where the contract lives outside the worker's reach).
Coined in The Real World Must Sign For It
The Pixel-Pushing Trap #
Coined here
Directing AI at cosmetic polish while the business engine sits unwritten. The factory is running; it's making the wrong thing.
A failure mode of frictionless implementation. When the cost of building drops to near-zero, the natural rate-limiter on polish disappears, and judgment about what to build loses the negotiation: polish is more visually rewarding than business logic, and AI cheerfully produces whatever it's pointed at. Distinct from Shipping Paralysis (scope expansion); pixel-pushing is wrong-task-direction, not endless-scope. The fix is structural discipline at the task-allocation layer: infrastructure first, a polish time budget, component libraries for solved problems, a per-task utility test.
Coined in The Pixel-Pushing Trap
Privilege Separation #
Established term, applied here
Bounding what each component of a system can do based on its role, so that compromise of one doesn't compromise all. Applied here to LLM agent runtimes: each role's tool surface is structurally bounded by what the runtime exposes to it.
Long-established in computer security: capability-based security (1960s onward, modern resurgence in Capsicum, gVisor, WebAssembly), the principle of least privilege (Saltzer and Schroeder, "The Protection of Information in Computer Systems," 1975), separation of duties. Not coined here. Applied here to LLM agents as the structural answer to capability-escalation prompt injection: the runtime exposes different tool surfaces to different agent roles, so a coordinator-tier agent processing untrusted web content cannot call the file-write tool because the path doesn't exist in its surface, regardless of what the model attempts. Maps directly onto Compiled Doctrine: privilege separation is what compiled doctrine implements for the agent layer.
Appears in Prompt Injection is a Privilege Problem
Prompt Sprawl #
Coined here
Rules accumulating across too many points in the prompt, none of which can actually enforce them, all competing for the model's attention at once.
The same shape as config sprawl or dependency sprawl, in a new domain. Every new failure mode adds another piece of prompt: a system-prompt rule, an in-context example, a tool-description hint, a re-injected memory. The rules pile up where nothing enforces them, because the model is asked to comply rather than required to. Compliance stays probabilistic no matter how the rules are phrased; better prompting moves it from 60% to 95%, but not to 100%, and the last few percent is where the expensive failures live. The fix is not more prompt. It is moving the rule out of the prompt and into the runtime, where it becomes Compiled Doctrine: a gate the runtime enforces rather than a request the model may ignore. Companion concept to AI Debt; both name an accumulation that ends up serving itself instead of the work.
Coined in Prompt Sprawl
Shipping Paralysis #
Coined here
When AI making code free didn't make shipping easier; it shifted the bottleneck to surfaces AI can't help with.
When the cost of writing code drops to near-zero, the constraints that used to be "writing code is hard, ship something simpler" disappear. What replaces them: scope expanding to fill available capacity (World Domination Scope), the quality bar rising past what the project can actually clear (Boutique Gravity), and the project becoming permanently local. The AI-era version of feature creep, with sharper teeth.
Appears in Shipping Paralysis & World Domination Scope
Supervision Tree #
Established term (Erlang/OTP 1986; EVE Online 2008), applied here
A tree of supervisor processes watching workers and restarting them on failure. Applied here to agent fleets: tiered specialists per failure domain, with judgment-tier agents only on rare escalation.
Established in Erlang/OTP (Joe Armstrong and the Ericsson telecom group, 1986); independently re-derived by EVE Online's fleet coordination structure for 1000-pilot battles around 2008. Not coined here. The pattern: every process has a supervisor; supervisors watch their children and restart them on crash according to a deterministic policy (one_for_one, rest_for_one, one_for_all); escalation to the parent supervisor happens only when the restart strategy is exhausted. "Let it crash" is the central philosophy: workers stay simple, supervisors handle recovery. Applied here to agent fleets via a three-tier split: autonomic supervisors (code-only, no LLM, watch a single failure domain), judgment supervisors (dispatch a small agent only on unknown patterns), command tier (human, only on true escalation). The tier split mirrors the doctrine bifurcation: autonomic is Compiled Doctrine, judgment is Interpretive Doctrine.
Appears in The Supervisor Tier
Upchain #
Coined here
The direction humans relocate as agents move into the implementation slot below them.
A vector, not a position. As AI capabilities take over the work humans previously did (writing code, debugging, reviewing), the humans don't disappear. They move up the chain to architecture, intent, judgment, and review. The substrate-level shift the entire AI moment is producing in every dev-tool category. Coined in public response to the question of what to call the AI era of software-building.
Appears in Humans Moving Upchain
World Domination Scope #
Coined here
The failure mode where a project's scope expands faster than its shipping cadence.
Genuinely good projects stay permanently local because every new capability makes the project harder to ship at all. Each addition pulls more surfaces into the "must be perfect before launch" frame, which extends scope, which pulls in more surfaces. Closely related to shipping paralysis and boutique gravity; names the specific failure shape where ambition outruns delivery.
Appears in Shipping Paralysis & World Domination Scope
