Standards That Are Code | Verial<br>← Systems

Contents<br>In my experience working with coding agents, there are many patterns I have to re-explain over and over. Even though it can be frustrating and important details may slip through, it's understandable because every agent session starts fresh unless it has context. A rule of thumb I've heard for this is the Third Time Rule: if you have explained the same thing to an agent three times, turn it into a reusable skill.

It is a good rule, and it captures the reusable workflows you lean on regularly. But from an engineering perspective, reusability is only half the story. If we want to scale, performance matters too. We want the most out of the hardware we are paying for.

A reusable skill helps, since many agents can run the same pattern in parallel. But it still runs on inference, and inference is expensive.

So what if we could turn a repeatable workflow into a deterministic script?

The slide and the Galton board#

The mood right now is "AI can do it, just prompt it." For genuinely new work, that is the right instinct. Inference is the first tool we have ever had for the parts of software that used to require a human to sit and think.

But inference has a shape. Picture a Galton board, the pegboard you may know as Plinko. Drop a coin at the top, it clatters through the pins, and it lands somewhere in a bell curve. Same input, different output. That is inference, stochastic by design. And every bounce is a little piece of work: the more the coin ricochets, the longer it takes to settle. In a real machine that maps to compute, and compute is time and watts.

Now picture a slide. In at the top, out at the bottom, one path, every time. That is deterministic code. A Rust binary, a script. The oldest guarantee in computing, and once we got excited about inference we half forgot we still had determinism. One path means less work: less time, fewer watts.

Most of what we ask agents to do all day is not new. Validate this file. Generate that scaffold. Check the config against the contract. We keep sending those coins through the pegboard, paying in watts, tokens and trust for a probabilistic answer to a question that usually has a deterministic one.

The Agent Paradise Standards System is our bet on the deterministic path. APSS, for short. The one-line version: standards that are code.

Smart standards#

A standard in APSS is built around an artifact with a shape. You pin that shape down as a schema, a protobuf contract, and that schema becomes the single source of truth. The standard itself is a Rust crate, chosen for determinism and speed.

Two kinds of code hang off that one definition: a generator that produces the artifact, and a validator that proves a given artifact conforms. And because everything hangs off the artifact, a substandard can add its own generator that reads it and produces something new, a view or a report, without touching the standard that created it.

Generation and validation from one definition reinforce each other: the standard produces things in the correct shape and proves things are in it, from the same source of truth. That is why I call it smart. The standard is not a description of the rule, it is the rule, executable in both directions.

The meta-standard#

If standards are code, then the rules for writing a standard should be code too. So APSS has a meta-standard: the standard that defines how every other standard is structured, and validates them itself. A convention only humans enforce tends towards degradation if continuous attention is not paid. A convention the tooling enforces cannot, because nonconformance is a failing build, not a forgotten guideline.

Standards are versioned like software. All of V1 stays backwards compatible, and if you need to break that contract you owe the ecosystem a V2. A standard can also have substandards: smaller standards built on the parent's artifact, versioned on their own timeline.

CodeCity is a good example of how that layers. The Code Topology standard analyzes your codebase into a topology artifact, a language-agnostic snapshot of structure, complexity, and coupling. A visualization substandard then consumes that artifact and renders it. CodeCity, the 3D-skyline view I wrote about earlier, is one of those renderings. So the parent generates the artifact, and the substandard generates a view from it.

Each standard also carries its rationale, the why and not just the rule. That turns a standard into an argument you can agree with or challenge, and it turns the whole system into a lab: an idea starts as an experiment and gets promoted to an official standard only once it has earned it.

The payoff is speed, watts, and confidence#

Put it together and you get something like procedural memory for agents. The practices we would otherwise re-explain every session become executable, reusable across codebases, and wired straight into CI. Humans define the standard, agents execute it. And a green...