WAYS OF WORKING · APPLIED NINO CHAVEZ
An AI agent is strong inside a task and weak at the seams between them. So you don't gate the middle — you put a deterministic check on every hand-off, and nothing advances until it passes.
Agents work inside the boxes. ◆ is a deterministic gate — non-AI, mechanical, and the only way across.
→ or scroll to advance · ← to go back
02 THE PROBLEM
Inside a single stage — writing the code, drafting the doc, building the prototype — an agent is genuinely good. The trouble is the hand-off: it passes work forward that looks finished, the next stage trusts it, and a small wrongness compounds into a shipped one. The seams are where confident output becomes confident error.
You can't fix that by making the agent more careful — carefulness doesn't survive a stage boundary any better than a correction survives a session. You fix it by putting a mechanical check between the stages that the agent cannot talk its way past.
03 THE SHAPE
The pattern names two jobs and keeps them apart: agents do the open-ended work inside each stage; deterministic code owns the boundaries. The creativity is in the boxes; the guarantees are in the gates between them.
Each ◆ is a check in code — an artifact is verified against source, a schema, a rule — before the next agent is allowed to start. A stage's position is derived from what's on disk, not asserted by the agent that just ran.
04 THE INCIDENT
A hand-off with no gate, in a real repo. A migration sweep moved every prototype page into production routes — because nothing on those pages declared where they were allowed to go.
⚠ unguarded hand-off
Production rendered fictional pilot integrations, unsigned partnership terms, and competitive claims — at full, SEO-indexable status. Each page was fine inside its prototyping stage; the boundary to production is where the fiction shipped, because the sweep had no mechanical way to tell a real page from a prototype.
No agent lied. The work was correct in context and catastrophic across the boundary — the exact failure the shell/core split exists to stop.
05 THE INVERTED CHECK
The fix wasn't "be more careful next sweep." It was to give every artifact a field it must declare, and a gate that reads it — so the boundary is enforced by data, not vigilance.
every prototype page declares: destination: product | blueprint | noindex-only # the gate, run on every derive + in CI: production route → maps to a blueprint-destination page NON-COMPLIANT — the catalog fails; the page can't ship to production
Only product pages reach the live routes. A gate born from the failure it now prevents — which is the honest way most good gates get built.
06 THE PATTERN
The load-bearing rule: the check at the boundary must be deterministic. A second agent reviewing the first is not a gate — it's another stage that can be confidently wrong. Real gates are dumb and mechanical, and that's their strength.
remote: Bypassed rule violations for refs/heads/main: remote: - Changes must be made through a pull request. 3d3ffe9..1e39642 main -> main # admin-bypass, solo phase — logged, not silent
Same family, every altitude: a pre-push design gate that fails on a raw color, a schema check between draft and publish, a required review before merge. Version the gates like a product — a changelog of what each boundary now enforces, so the process itself can't silently regress.
07 HONEST LIMITS
Gates cost something
Every check is friction, and friction on the wrong boundary slows work without protecting anything. The admin-bypass above is deliberate — a solo operator can override during early phases. A gate with no bypass gets disabled; a gate on every trivial step gets resented.
It must be genuinely deterministic
The moment the "gate" involves judgment, it's a stage wearing a gate's costume — and it fails the same way the work it's checking does. If you can't write the check as a test or a rule, you don't have a gate yet.
Boundaries, not brilliance
Gates make hand-offs safe; they do nothing for the quality of work inside a stage. A well-gated pipeline of mediocre stages ships reliable mediocrity. The shell still has to be good.Gate the seam the failure actually crosses.
08 USE IT
If you never touch code
Wherever work passes from one hand to the next — a draft to a signer, an analysis to a decision — add a small, boring check that has to pass first. Most process failures are unguarded hand-offs, not bad work.
If you're technical
Let agents run free inside a stage; gate the boundaries in code. Make each artifact declare what it is, derive the stage from disk rather than trusting the agent's word, and put the deterministic check in CI so the boundary holds without you.
If you build systems
Design the shell and the core as two different things. The agentic shell is allowed to be creative and occasionally wrong; the deterministic core makes the wrongness un-shippable. Version the gates, and treat a boundary with no check as a bug.