Creative Rather Than Imperative

This week's work wasn't on this site at all. I've been building a small coding agent — a few hundred lines of Python, public on GitHub as local-agent — and the striking thing about the week is that almost none of it was spent making the agent do anything. It was spent writing law. What services it may touch and which it must never. What it may read and how far to trust what it reads. Whose code counts as an exemplar and whose is merely evidence. What it keeps private and what may leave the machine. Seven pull requests, and nearly every one of them a constitution rather than a feature.

Somewhere in the middle of that I noticed the glossary already had a phrase for what I was doing. A Worldwright creates a primary universe "the whole vessel at once: physics envelope, Etheric coupling, interaction regime, and internal zone structure" — and the Cosmic Cascade entry says of the whole hierarchy: "Descent is creative rather than imperative — higher strata create and define the layers beneath them more than they command them."

That is exactly what specifying an agent is like, and I don't mean it loosely. The system prompt, the service boundary, the policies — they are a physics envelope. Nothing in them determines what the agent will actually do on a given Tuesday with a given failing test. You cannot derive its behaviour from its specification; you can only find out by running it. Which is why everything else in the design exists: the tests, the confirmation on every write, the review loop. Those aren't decoration around the specification — they are what you build because specifying is not commanding, and the gap between the two has to be watched rather than closed.

The direction of causality matches too. The Cascade entry is blunt about it: "down, never up." The specification binds the agent; the agent's runs do not bind the specification. When a run teaches me something — and the whole point is that runs teach me things the spec never could — the lesson climbs back up only one way: I amend the law, deliberately, in a reviewed change. The lower tier never edits the upper one by accumulation. In the software that's a discipline I had to write down. In the setting it's ontology. It was a small shock to realise the discipline and the ontology have the same shape.

And then the recursion, which is where the metaphor stops being decorative. I direct an assistant, which builds the agent, which drafts briefs that get relayed onward to other tools. Each tier defines the envelope of the one below it and commands almost nothing inside that envelope; each discovers what it actually made by watching it run. A line I wrote for a cosmology two years before I built any of this turns out to describe a toolchain.

The Intervention Problem

There is a second rhyme, and it is sharper than the first. When generated code is wrong, the tempting fix is by hand — reach past the specification and edit the artifact directly. It works, and it is a trap, and the setting already has a name for the shape of the trap.

Kieme is the tier that influences everything and touches nothing: it "establishes origin constraints that all downstream tiers must satisfy", is defined by "constraint rather than decision", and "permits no selective intervention that would identify it" — inferable only through invariants that hold everywhere. A hand-fix is a selective intervention at the Material layer, and it inherits every part of that dilemma. It identifies the intervener — the edit is distinguishable from what the laws produce, and provenance blurs. It teaches the system nothing — the constraint channel is unchanged, so the next generation reproduces the flaw, which means the intervener has quietly committed to intervening forever. And it creates an explanation problem: after enough hand-fixes, the team's public account becomes our process produces this quality, while the commit log quietly records the curation — a deliberate act everyone downstream is now motivated to re-describe as if it had been a structural invariant all along.

The part I find genuinely satisfying is that this repository already held the discipline before I saw it in the cosmology. Edit a generated theme file by hand and the next generate-themes run overwrites you — the generated layer reasserts its laws and the intervention dissolves. The build rules were Kiemic before I knew to call them that.

One honest limit, so the metaphor doesn't over-claim. For Kieme, non-intervention is constitutive — not a policy the tier holds but part of what the tier is. For an engineer it is a discipline, freely violable and sometimes right to violate; the dilemma only bites for regenerable artifacts, the ones the pipeline will produce again. The working rule that falls out is short: fix the constraint, not the artifact — and when you fix the artifact anyway, say so in the ledger, because two accounts where one is honest about being incomplete is survivable, and it is the confident second account that costs.

One caution, and it matters more than either observation. The metaphor flows in one direction only — the same direction as the Cascade, as it happens. The fiction is welcome to illuminate the engineering; the engineering must never leak back into the fiction. The Cascade is not an allegory of software and was not built to be one; the setting was here first, and nothing in it knows or will ever know about pull requests. What the week gave me is not a new fact about the world. It's a felt sense of why the phrase was right when I chose it: I wrote a physics envelope of my own, watched the thing I'd specified do something I had not derived, and understood creative rather than imperative from the inside for the first time.