The model drifts toward plausible. You hold the line on correct.

The machine executes. I own the intent, the context, and the judgment that makes it right.

Name the drift, and the human stops being a disclaimer.

A vague warning to "stay in control" reads like every other note on AI. What makes control real is recognizing the exact way the work wanders. Drift is not one failure. It is seven, and each has a tell you can learn to see. Once it has a name, you can build a guard for it, and the human becomes the fixed point the whole system turns around.

Six rules everything else descends from.

1. Intent is the artifact you own. The prompt is just its serialization. If the intent is fuzzy, no amount of prompting saves the output.
2. Context is the work. A plain instruction only produces on system results when the environment around it was built for that. You build the environment.
3. The model proposes, you dispose. Generation explores width. Selection is the leverage. Choosing well is the job.
4. Verify before you trust. Fluency is not evidence. Every generated artifact clears a gate before it counts as done.
5. Keep a human legible trail. Document the reasoning, not only the output, so the next reader, human or agent, can follow the why.
6. Taste does not transfer. The model can match a standard once you set it. It cannot originate the standard. That part stays with you.

I do not prompt from a blank box. I brief from a system.

The difference between a clever one off and a repeatable practice is the context layer. Before the work starts, the machine is handed three things. This is what turns "make me a case study page" into output that already knows my conventions, my voice, and my bar.

• Role specific system prompts. A library of personas, one per discipline: architecture, full stack build, content, growth, discovery. Each one carries the standards of that craft so the model starts inside the role, not outside it.
• A project operating standard. A portable document that travels in the repo root. It sets the git hygiene, the directory shape, the backup discipline, and the session handoff rules, so any machine, mine or the model's, resumes cleanly.
• A precise brief. The one line problem, the constraints that are not negotiable, and the definition of done. Short, but exact. The brief is where intent gets pinned before a single token is generated.

From a vague request to a live, growing product, eight phases.

This is the complete arc, not a slice of it. The front end frames raw intent. The back end measures what shipped. At every phase the split is the same: what I own, what the machine does, the drift that bites hardest here, and the guard that catches it. The other playbooks plug in where named.

• Discover and Define run on my Discovery to Scope playbook: Jobs to be Done to find the real job, the Double Diamond to widen then narrow.
• Design runs inside my Figma Operating System: the agent generates in the file, the naming, tokens, and status keep it on system.
• Build applies the Interface Content System to every string the machine writes, so the copy stays in the customer's voice.

The gate the machine never gets past.

This is where "final decision maker" stops being a sentiment and becomes a mechanism. Nothing the model produces reaches the live site until it clears this. The gate is run, not vibed. When it is green, I sign. When it is not, the work goes back, not out.

• Dash sweep. Zero em dashes, en dashes, or dash as punctuation, including HTML entities that render as a dash. Prose hyphen check runs on the stripped visible text.
• Structure scan. Duplicate id check, tag balance across div, section, article, and nav, and every in page anchor resolves.
• Machine readability. The JSON-LD parses, and node checks every inline script block for syntax.
• Render proof. A jsdom smoke test with the right polyfills boots the page, and the rendered output is inspected by eye.
• Contrast proof. Color pairs are measured with exact oklab math and confirmed at WCAG AA before any color change ships.

Reach for judgment, not generation.

An operating model is also a set of edges. There are places the machine should not be in the loop at all, and naming them is part of the discipline.

• When being subtly wrong is unbounded. Legal, medical, financial, and security calls carry a cost that plausible cannot be allowed to touch. The human decides, with a qualified human.
• When you cannot specify the intent yet. If the thinking is the point, do the thinking. A model handed a vague intent returns a confident average, and the average is the thing you were trying to escape.
• When the work is the relationship. A hard conversation or a judgment about a person is not a generation task. Outsourcing it is the cost, not the saving.
• When you would ship what you cannot verify. If there is no gate for it, there is no green for it. Do not ship on faith.

The whole thing, at a glance.

Drop this in and you are running the model.

A minimal version of the briefing layer and the gate, written so you can adapt it to your own stack. The persona sets the role. The pre ship checklist is the gate in plain text.

# brief.md  (pin intent before any generation)
Problem (one line): ____________________________________
Definition of done: ___________________________________
Hard constraints:   ___________________________________
Out of scope:       ___________________________________

# persona.md  (the role the model starts inside)
You are a [discipline] specialist. You hold the standards of
that craft. You propose, the human disposes. You cite real
sources only. You never present a guess in the voice of a fact.

# preship.md  (the gate, run not vibed)
[ ] dash sweep clean  (entities included)
[ ] no duplicate ids, tags balanced, anchors resolve
[ ] JSON-LD parses, inline scripts pass a syntax check
[ ] page boots in a smoke test, render checked by eye
[ ] color pairs measured, WCAG AA confirmed
[ ] whole reviewed against original intent, then signed