WAYS OF WORKING · DEMO 08 NINO CHAVEZ
Agents are strong inside a stage and unreliable at the boundaries — a confidently wrong artifact handed downstream gets amplified, not caught. Blueprint is a product-delivery methodology built on that observation: deterministic core, agentic shell. Eighty-eight revisions in, running fourteen registered initiatives.
→ or scroll to advance · ← to go back
02 THE SHAPE
"Research feeds BRD/PRD-class documents [...], the documents plan the prototype, the prototype validates the plan, and the validated package hands off to build." METHODOLOGY.md — the pipeline, verbatim
Inside a stage
Agents do the work — read the market, draft the strategy doc, build the prototype. Judgment calls escalate to the operator; production is delegated. Demo 01's split, at initiative scale.
At the boundary
The artifact is checked mechanically before the next stage consumes it: schema-validated metadata, derived state, reviewer checklists that are code, not vibes. A stage can't hand off what the gate can't verify.
Why the prototype validates the plan
Documents can agree with each other and still be wrong. A running prototype is the strategy doc's first contact with reality — cheap enough to throw away, real enough to falsify the plan.
03 CASE STUDY
May 2026: a migration sweep moved every prototype page into a live product's production routes. The prototype's page metadata had no field saying what each page was — so the sweep, reasonably, took everything.
What went live
Fictional pilot integrations. Unsigned partnership terms presented as real. Competitor-comparison claims — all on the production domain, fully SEO-indexable.
Why it happened
Not bad judgment — a missing declaration. Strategy surfaces and product surfaces lived in one prototype, distinguishable only in a human's head. The boundary existed; nothing carried it.
Why it's this deck's case
This is what an ungated agentic boundary looks like: the hand-off executed flawlessly and amplified the error. The sweep did exactly what it was told — that's the problem.
04 SCAR TISSUE
The fix wasn't "be more careful." It was a schema field plus an inverted check. Every prototype page now declares a destination — product / blueprint / noindex-only — and only product pages may ship to production routes.
/* DROPPED 2026-05-25: [three strategic surfaces] — these were catalogued as production capabilities but the surfaces are STRATEGIC POSITIONING, not product features. [...] If a future commit puts them back under src/routes/, an inverted convention check below catches it. */ { id: 'convention-no-strategic-surfaces-in-production', invert: true, // these files existing = the build goes NON-COMPLIANT }
The check is inverted — it greps for the strategic surfaces' return and fails when they exist. Gates are scar tissue: the incident is documented in the check that prevents its recurrence, the same move as demo 03's guards and demo 06's registry.
05 THE FEEDBACK LOOP
"Every change ships as a wave — a numbered batch of methodology changes released together [...]. Each initiative has caught gaps that became reviewer checks, schema fields, or logic in the stamper (the scaffolder that generates new initiatives) in subsequent waves." METHODOLOGY.md, verbatim
That's the loop: a consumer initiative breaks somewhere → the failure becomes a check or a schema field → the stamper installs it into every future initiative at birth. The destination gate above followed exactly this path. A methodology that doesn't version itself is a document; this one is a product with a changelog.
06 THE DETAILS THAT TELL
Three small design choices reveal the discipline more than any diagram:
A registry that knows it's a mirror
The consumer registry's own header declares the authoritative pin lives in each consumer, and that this file is a hand-maintained mirror that can go stale — so the fleet tool "reports drift-against-the-mirror, never authoritative drift." A document refusing to over-claim: demo 07 as file format.
Gates that degrade honestly
The gate-derivation package is substrate-degrading: with no project data sources configured it returns empty structures, and the portal builds green at tier zero. No data means "nothing to report" — never a fabricated status.
The public/private boundary, practiced
Two of the founding initiatives are real industry work — present in the public methodology docs, de-named because the repo is public. The same boundary this demo series holds for its own commerce case study.
07 THE FAMILY
Blueprint is the public face of a spec-driven family that grew in parallel — same conviction, different altitudes:
The methodology
Blueprint: initiative-level. Research through handoff, gated boundaries, waves, a stamper. This deck.
The implementation chain
A sibling tool at task-level: specs in, structured agents implement and verify, a capped remediation loop routes verifier findings back to implementers, and crash recovery makes the whole run resumable — agent work you can restart, not re-prompt.
The shipped case study
A commerce-platform initiative run this way end-to-end: dozens of decision records, machine-derived "what's actually built" state, and a synthesis ID carried from every decision into its commit. Its artifacts stay private; the method is what you're reading.
08 HONEST LIMITS
Scar tissue arrives after the wound
The sweep happened with the methodology in place. Gates encode failures already survived — they prevent recurrence, not novelty. Anyone selling a gate set that prevents unknown failures is selling the sentence, not the check.
Gates check the declarable
Whether the strategy is right, whether the design is tasteful, whether the initiative should exist — no schema field carries those. The gates free human attention for exactly those calls; they don't replace them.
The overhead is real
Eighty-eight waves of machinery is right-sized for product initiatives and absurd for a script. Fourteen consumers also means fourteen pinned versions that drift — the fleet tool reports it, but adoption of each wave is still work someone must do.
09 YOUR VERSION OF THIS
If you never touch code
When AI work moves between stages — draft to review, analysis to deck, plan to execution — ask what checks the hand-off. If the answer is "someone reads it," the boundary is where your next incident lives.
If you're technical
Make artifacts declare themselves: a schema field for what a thing is beats a convention for where it sits. Then write the inverted check — the one that fails when the incident tries to recur.
If you build systems
Version your process like a product: numbered releases, a changelog, a scaffolder that installs the hardening into every new project at birth. Process that doesn't ship isn't process — it's folklore.