Agent Governance Mechanisms

Generative AI is shifting software engineering from a practice built around scarce implementation toward one built around abundant, low-cost code. The hard part stops being writing code and becomes governing the conditions under which fast code can be trusted. That means keeping it inspectable, correctable, and maintainable at speed.

QUICK START: Install the skills for Claude →

Between two schools of thought

Two common ways to build with agents sit at opposite ends of a spectrum. This site is about the midway.

← all velocity   •   all oversight →

Both ends of the spectrum pay the pet tax. Each spends per-change human attention, whether you're coaxing the output at one end or inspecting it at the other, and that attention grows with the size of the fleet until it becomes the bottleneck. The midway is cattle, not pets: build the fences and chutes once, and the guardrails ride every change instead of a person.

The midway is a discipline: establishing and maintaining a governed engineering environment. It works in two directions at once.

1. Up front, you specify what you can: the architecture that makes a class of error impossible, the model the fleet reasons through (more on that below), the templates and checklists that put a change on rails before it's written.
2. In flight, you let velocity surface the failures you couldn't foresee, and convert each recurring one into a durable guardrail.

This site describes both halves. The first is the guidance on what to fix in advance; the second is the machinery for responding when something slips through. It packages both as three Claude skills with a quick-start. The catalogue itself is 69 governance mechanisms across three roles, each written like a design pattern — the recurring failure it kills, and why it is not just the cheaper thing everyone already does.

Documentation, taken to its limit

Start with the up-front half. Anyone who has built with agents has found the first move on their own: give them good documentation and tests, then point them at it. Agents write and maintain those artifacts as fast as they write code, so the cost that always made thorough docs a fantasy is gone. The step the training data won't suggest is the next one. Documentation has a hierarchy, and its top is not prose. It is a typed model.

A context-bounded agent working on a context-exceeding system needs a typed, queryable, drift-checked model of that system to reason through, the blueprint for a structure too large to hold in one view. That is model-based software engineering, and it is the bridge between the agent and the codebase it cannot fit in its head. Two things make it more than a tidier README:

Because agents build and maintain the model the way they maintain docs and tests, pointing them at it costs almost nothing, and it pays back in higher code quality, fewer tokens spent rederiving what the model already states, and fewer mistakes. The catalogue's models-bridge role is this bridge, made concrete.

Governance has two mechanisms

A guardrail is one of two kinds: prevent the error, or catch it.

A control works like a sensor: it detects a mistake and surfaces it after the fact. Architecture works like a wall: it makes the whole class of mistake impossible to make. Reach for the wall first, because a sensor still lets the mistake happen. But a wall built across the only exit blocks the people trying to leave — an over-constrained design stops legitimate work as surely as it stops the error, so the wall belongs around the class you can name, not across the whole floor.

The way of thinking

Three stances that make the midway work, distilled from the AI-First Engineering Method (architecture, controls, and the stance that wields them); the full set ships in the starter CLAUDE.md.

The three skills — govern, operate, communicate

The catalogue ships as three partner Claude skills (one plugin). Two are one substrate seen from opposite ends (self-governance designs the controls, self-operations runs them), and self-communicate makes what they produce legible: the docs, and the operator's own reports to the human.

Govern and operate are one substrate seen two ways; communicate is the craft that keeps their output legible. The loop closes across all three: operate surfaces a recurring break, govern mints the control, communicate writes it up in the shared register. Install all three →

Walking through the loop

Governance conversion is a non-terminating loop: higher velocity keeps surfacing failure classes that earlier governance didn't address.

Explore the catalogue

69 governance mechanisms — the repertoire this loop produced in one real production system.