Agentic & future-proofingGuardrails, Agentic & Future-proofing5 min read

How this site was built: an AI agent, a vault, and a rulebook

This site is not hand-coded page by page. It is built by an AI agent working against a structured vault and a rulebook every change must pass, and the rulebook is the real product.

Answer first

laurelinlabs.com is not hand-coded page by page. It is built by an AI agent working against a structured knowledge vault that holds the strategy, the brand and the content, and a rulebook of four gates every change has to pass before it ships: one obvious home in the information architecture, a Non-Commodity Score that proves the page adds something, conformance to the 387-check AEO audit, and metadata and entity hygiene. The vault is the memory, the agent is the builder, and the rulebook is the real product, because it is what makes the output consistent when the builder is a model.

A while ago I wrote about the LLM-native wiki I use to run the business: a single structured vault that a language model can read and reason over, so scattered notes become one queryable source of truth. This site is what happens when you point that same idea at a product. The vault is the memory. An AI agent is the builder. And a rulebook decides what is allowed to ship.

The vault is the spec, not the notes

The way Andrej Karpathy frames it, the interesting shift is that you increasingly program software in English: you write the intent, the constraints and the examples, and an agent turns them into working output. For that to be more than a party trick, the intent has to live somewhere durable and structured. That is what the vault is. It holds the brand system, the frameworks, the entity definitions and the house rules, all cross-linked, so the agent is never guessing what good looks like. The site is a projection of that vault, not a separate hand-maintained artefact.

The rulebook is the real product

Letting an agent build freely is how you get a fast, confident mess. So the most important file in the repository is not a page, it is the rulebook: a set of gates every new page, tool or article has to clear before it goes live. There are four. It has to map to exactly one topic pillar, so nothing is homeless. It has to clear the Non-Commodity Score, so it carries a real unit of information gain rather than restating a definition. It has to satisfy the relevant checks in the 387-check AEO audit. And it has to carry correct metadata and structured data, so the entity graph stays coherent. The agent is fast. The rulebook is what makes it trustworthy.

This is the same logic as tests in software. You do not review every line an agent writes, you make the standard executable and let it fail loudly. The rulebook is that standard, written in English, applied before publish.

Everything here was shipped through those gates

The proof is the site itself. The topic-first information architecture was sized against live search demand and rebuilt around the Four Pillars. We then ran our own Non-Commodity audit on the site, published the honest 60 out of 100, and used the findings to harden the rulebook. Each of those changes went through the same four gates it now enforces on everything after it. The site is not a brochure about the method, it is the method running in public.

Why this is the future-proof bet

Search is moving from ranking links to citing sources, and the sites that win will be the ones a machine can read, trust and connect to a known entity. Building with an agent against a structured vault is how you keep a site coherent at that standard as it grows, because coherence is enforced by a spec rather than remembered by a person. The frameworks behind it live in the Agentic OS and the rest of the guardrails and future-proofing track.

Frequently asked questions about agentic website build

What is an agentic website build?

A build where an AI agent, not a developer, writes and changes the code and content, working from a written specification and a set of rules it must satisfy. The human sets intent and reviews diffs; the agent does the mechanical work and runs the checks.

Does the rulebook stop the AI making mistakes?

It catches the classes of mistake it encodes: pages with no home, commodity content, audit failures, broken metadata. Judgement calls still go to a human review of the diff, which is why every change is committed as a reviewable pull request.