The Own the Code playbook. Six systems, one discipline.
Not a framework and not a template. A way of shipping client sites so that nothing bad goes out, on a stack you own outright, with an AI agent you govern yourself. Every system in it ran in production before it was written down.
A production discipline, not a framework.
A framework is code you install. A discipline is a set of rules you run, and the playbook is the second kind. It does not ask you to learn a new tool. It asks you to put six systems between your editor and your client’s domain, and to let the build refuse anything that fails one of the gate’s checks.
The stack underneath is deliberately ordinary: static files, a build command, hosting with a free tier. What makes it a playbook is what sits on top — the gate, the silos, the query rule, the verify loop and the agent — and the fact that each of them is enforced by a machine rather than remembered by a person.
Boring stack. Strict rules.
Six systems. Each with its own page.
The owned stack
Static builds on hosting with a free tier, behind a strict content-security policy, making zero third-party requests at runtime. A folder of files, portable by definition.
The release gate
Banned words, dead links, missing disclaimers, unsourced claims. A violation does not warn; it fails the build, and nothing goes out.
Content silos
The folder is the URL, and an unregistered folder fails the build. Information architecture becomes a rule the build enforces, not a diagram somebody drew once.
One query per page
Every page owns exactly one search query, collision-checked at build time. No two pages on the site compete for the same searcher.
Write, then verify
One agent writes; a second audits with the authority to correct and delete. Every correction is counted, and the count is published.
The governed agent
A schema-governed AI agent on infrastructure you control, with transcripts the browser cannot forge. The part no platform can sell you.
Each system is written up on its own page: the owned stack, the release gate, content silos, one query per page, write, then verify and the governed agent. Read them in that order. Each one assumes the one before it.
Who should read it. And who should keep the fee.
You carry a book of live client sites on Wix, Squarespace or Webflow, and the platform fee on each one has stopped looking like convenience and started looking like margin. Before the next renewal, read what a Wix site lets you take with you, what the Squarespace export carries, and what the Webflow ZIP leaves behind.
You can run a build command, and you would rather inspect a claim than take it on trust. The playbook shows its working for exactly that reader.
You want chapters on pricing, closing or paid acquisition. There are none. They get written when there are numbers to back them, and not before.
Or the builder margins genuinely work for your business. Some studios do fine on them. Keep the fee, with no hard feelings.
One production build. Publicly inspectable.
Nothing in the playbook is a proposal. It comes from a single real build of 100 articles, shipped and open to inspection. One agent wrote them; a second audited every one with the authority to correct and delete. Across that build it made 1,374 corrections and removed 308 claims that nobody could source.
Those figures are counts, not estimates. The number that matters most is the smallest: the finished site makes zero third-party requests at runtime. This page makes the same claim; the network panel is the way to check it.
Arrive sceptical. Then check.
The gate chapter is free. In full.
The sharpest chapter in the playbook is the one on the release gate, and it is the one we give away. It contains the six checks, the code that runs them, and the reasoning behind each: why a banned phrase fails the build instead of raising a warning, why a claim without a source is treated as a defect, and why the check for third-party requests is the one your client’s network panel will confirm.
It is a working gate, not an excerpt. Wire it into a static build and it runs on the next deploy.
Price, when there is one
There is no price yet. The playbook is being finished against the production build it describes, and it will not be sold until the last system is documented to the same standard as the first. When a price exists, the people on the free-chapter list hear it first, before it appears on this page.
Read the free chapter first. Decide afterwards.
Read the sharpest chapter first. It costs an email.
We’ll send the build-gate chapter in full: the checks, the code, and the reasoning. Read it. If it doesn’t change how you think about shipping client sites, you’ve lost ten minutes and kept a working release gate.
That did not send. Check the address and try again.