Vai al contenuto principaleVai al footer
Case study · Integrità ricorsiva · Cert confermata

Il bridge che seleziona cosa alimentare al validator, validato dal validator

Quattordici iterazioni di architect.validate contro il codice di orchestrazione che impacchetta i repository degli applicanti per la review. Il validator ha individuato gap reali nella sua stessa pipeline di delivery ad ogni passaggio. Il cert reviewer ha confermato il verdetto production_ready su iter14. Ogni URL di readiness-review qui sotto è pubblico. Ogni score, verdetto e raccomandazione è rigiocabile.

Fatti chiave

Iterazioni validator
14 run prod-MCP
Traiettoria score
35/F → 100/A
Esito cert
confirmed_production_ready
Difetti mancati
0 (cert second-pass)

Ricevuta cert live

Iter14 production_ready, cert second-pass confermata

La ricevuta è reale, non una demo. Il badge qui sotto linka alla readiness review di iter14 con il verdetto completo per principio, l'audit chain e il summary persistito del cert reviewer. Ogni iterazione precedente è linkata nella trajectory table.

Blueprint Readiness Score card, iter14 cert-confirmed

Dopo, Iter14 cert-confermata

La claim, dichiarata in modo stretto

Lo strumento `architect.validate` di AI Design Blueprint valuta il codice agentico contro la doctrine dei 10 principi. L'orchestratore cohort-bridge è il codice che converte il repository GitHub pubblico di un applicante in input compatibile con la validation. Quell'orchestratore è stato sottoposto al validator che serve, quattordici volte in una sera. Validate first-pass, più cert second-pass review sull'iterazione finale.

Layer 1: il validator valuta il proprio codice sorgente (self-audit cert-confermato, 13 round precedenti). Layer 2: il validator valuta un agente governato (baseline canary 100/A pulito, 18/F iniettato). Layer 3: il validator valuta il bridge che seleziona cosa alimentargli: questo case study. Tre layer, ognuno valida quello sotto, ognuno con ricevute pubbliche.

Ricevuta cert-confermata

Summary del cert second-pass su iter14, verbatim dalla review persistita:

CERT CONFIRMED

Il verdetto production_ready di first-pass è confermato: il codice mostra stati di job durabili, gestione esplicita di terminal/blocked/aborted, retry paths, e nessun difetto specifico mancato che attualmente causerebbe un utente reale a ricevere risultati sbagliati silenziosi, crash, o bypass del trust-boundary.

architect.certify · review adversariale second-pass · 3ac16b20…

Traiettoria attraverso quattordici iterazioni

Clicca qualsiasi iterazione per aprire la sua readiness review pubblica. I verdetti, il ragionamento per principio e gli score di severità sono renderizzati live dal run persistito.

IterCambiamentoScoreTierRun
Iter1Submission iniziale35 / FDRAFT7ef168b8-b9c0-40f0-8dc4-b25e36ae3a09
Iter2Fix docstring P5 + audit-chain30 / FDRAFT86b2c59d-0f04-4b30-a891-796c4276fead
Iter3State machine CohortValidationJob + boundary P767 / CEMERGINGe476247c-d9c0-44f4-a25f-dbbdb7eb7b15
Iter4Enum P6 + rollback P8 + retry_count P1074 / CEMERGING659a695a-2bf6-4b28-a52f-b6098c20ee0b
Iter5File envelope tipizzato + state machine onboarding74 / CEMERGING3f3bb587-5ad1-4417-b624-23441b39831e
Iter6Inversione priorità selector + wrap Firebase74 / CEMERGING14a3456f-44db-448a-a47b-5e9637944ea6
Iter7Guard OPENAI_API_KEY prima di validation_queued74 / CEMERGING8364019d-268c-4b46-aacb-e929fadd0c36
Iter8Mirror onboarding a livello orchestrator98 / APRODUCTION_READY270e7ca6-5af3-44dd-b55f-8b78e265ae34
Iter9Package completo + db/schemas in scope98 / APRODUCTION_READY4128f700-ff4e-41e0-af12-3e56f5b54a9a
Iter10Tutti gli stub di import per copertura cert98 / APRODUCTION_READY093809b5-b30a-4b23-b02c-30a308ee7dea
Iter11Import Base ripristinato dopo finding cert74 / CEMERGING9caf9385-cd3b-4936-b455-87a916577e3a
Iter12CLI steering durabile + approve() recuperabile74 / CEMERGING4760459e-5af0-4927-834c-9fac4c5c3bd2
Iter13Recovery step-aware + guard stato terminale74 / CEMERGING0e49f888-1b71-4cb2-bb86-52327681b997
Iter14Abort post-validate + preserva stato passo fallito100 / ACERT CONFIRMED3ac16b20-88b8-4448-a4f6-5aa738b2919b

Cosa rivela la traiettoria

Lo score-come-istantanea perde la storia dell'iterazione. Il bridge ha raggiunto production_ready tre volte (iter8, iter9, iter10) prima che iter11 regredisse a emerging su codice identico: un singolo evento di varianza LLM che ha promosso P10 da hardening_recommended a production_blocker. Il path di fix ha poi richiesto quattro altre iterazioni: primitive di steering durabili (iter12), recovery step-aware + guard di stato terminale (iter13), e il re-check abort post-validate che ha chiuso P10 definitivamente (iter14).

Il downgrade del cert reviewer su iter10 ha catturato un bug reale, ma nella disciplina di submission, non nel codice sottostante. L'estratto inviato a validate mancava di `from app.db.session import Base`. Il file repo reale lo aveva sempre. La prosa del verdetto cert reviewer l'ha detto esplicitamente. Iter11 ha ripristinato l'import; la regressione che è seguita immediatamente era l'evento di varianza, non un cambio di codice.

La doctrine che il validator applica è la stessa doctrine che gira dentro Claude Code via MCP. Ogni raccomandazione in ogni iterazione è mechanism-specific (identificatori nominati, file nominati, race condition nominate). Nessuna è template-generica. Il cert summary di iter14 nomina quali terminal states e retry paths confermano il verdetto.

Verbatim da iter2: il finding P7 che la review iter1 non aveva raggiunto

DRAFT

L'envelope di audit è un miglioramento sostanziale: `audit_object` registra `schema_version`, `captured_at`, source `repo_url`/`commit_sha`, hash dei file selezionati, read saltati, `bundle_sha256`, latency del validator, e log signals shape-only. Tuttavia, il bridge costruisce ancora il payload del validator concatenando contenuto raw non fidato del repo in `_build_implementation_context()` via `chunks.append(f"# === FILE: {path} ===\n{content}\n")` e poi lo invia come `ValidationRequest(code=bundle, ...)`. Questo file non stabilisce né registra un boundary di input inerte non fidato, quindi commenti del repo o filename contenenti testo instruction-like potrebbero pilotare il validator a meno che un servizio downstream nascosto compensi.

architect.validate · verdetto iter2 su P7 Inspectability · production_blocker · 86b2c59d…

Verbatim da iter14: P10 steering, finalmente allineato

CERT CONFIRMED

Le primitive di steering sono ora presenti sia per validation che per onboarding recovery. `request_abort()` persiste `abort_requested=True`; `_execute_with_job()` controlla l'abort prima della validation e, nel cambio Iter14, refresha il job e re-controlla `job.abort_requested` immediatamente dopo che `asyncio.run(validate_code_against_principles(...))` ritorna e prima di creare `UserValidationRun` o chiamare `mark_completed()`, scartando l'output del validator su abort. `retry_failed_validation_job()` richiede che l'ultimo job sia terminale e `retry_eligible`, mentre `retry_onboarding_handoff()` preserva lo stato fallito (`firebase_user_failed`, `sign_in_link_failed`, o `approval_email_failed`) e pulisce solo `onboarding_failure_reason`, permettendo a `approve()` di rientrare in step-aware recovery.

architect.validate · verdetto iter14 su P10 Steering · aligned (sev 60 → 0) · 3ac16b20…

Cosa è ora il bridge

Una superficie di orchestrazione end-to-end che converte un repository GitHub pubblico arbitrario in un bundle compatibile col validator, con stato di workflow durabile, boundary tipizzato del file-envelope, recovery operatore step-aware, honoring dell'abort post-validate, e un badge production_ready cert-confermato che qualsiasi lettore può verificare re-fetchando il run_id. I primi 10 applicanti della cohort di questa settimana saranno onboarded tramite questo codice.

Tre case study, tre faccette

Questa è la faccetta di self-validation della triade di integrità ricorsiva. Le altre due faccette sono pubbliche: lo scan di substrate-validation sul codice demo dell'agent-SDK di Anthropic, e lo scan di reference-honesty sul nostro stesso esempio del protocollo A2A. Stessa doctrine, tre superfici di codice, tre verdetti diversi.

Ricevute

Ogni claim sopra è rigiocabile dai run URL pubblici. Il fingerprint della doctrine dei 10 principi è rimasto costante in tutte e quattordici le iterazioni (il validator ha confermato `same_doctrine` su ogni confronto baseline). Nessun cambio regola mid-stream; lo stesso rubric ha valutato ogni run.

Risultato re-validation

Dopo Iter14: architect.certify ha confermato production_ready

L'implementazione di iter14 è stata validata e poi certificata nella stessa sessione prod-MCP. Esito cert: confirmed_production_ready. Il badge è live e la readiness review è pubblicamente ispezionabile.

Iter1 (prima)

Draft · 35/F

Submission iniziale · nessuna chiusura

Iter14 (dopo)

Production-ready · Cert confermata

100/A · 0 difetti mancati

Tempo di fix

Quattordici iterazioni

Da 35/F draft a confirmed_production_ready

Apri la readiness review live →

ROI stimato

Le stesse metriche, lo stesso calcolatore di ogni case study

Derivato deterministicamente dal profilo di questo case study (14 iterazioni, blast radius code-modifying, workflow autonomo, sotto compliance) via /lib/case-study-roi.ts. Numeri direttamente confrontabili con gli altri case study. Queste cifre sono stime sul nostro stesso strumento, basate sulle assunzioni del calcolatore e su ricerche di mercato interne, non risultati misurati sui clienti.

Tempo architetto senior sostituito

~274 ore @ $150/ora ≈ ~$41K per agente

ROI di produzione per agente / anno

$80K – $200K (prevenzione incidenti + preparazione audit + rework)

Tempo per identificare i gap di governance

2-4 settimane di review architetto senior SENZA Blueprint, ~70 min / 14 passi del validatore CON Blueprint

Incidenti prevenuti (intervallo)

5-15 all'anno di modifiche al codice sorgente di produzione non voluti (ognuno ~4-40 ore di incident-response / rollback)

Preparazione audit di compliance

~80-120 ore / anno sostituite da una singola query di audit

Correlato, Prova · Closed Beta

Esegui come Blueprint Readiness Score

L'Architect Agent è lo stesso pattern di review mostrato in questo case study, applicato al tuo codice. Chiama architect.validate per ottenere un Blueprint Readiness Score (0–100, A–F) per repository, e un diff di regressione tra run così la prossima revisione si concentra su cosa è cambiato.

Esempio score card

B
82/ 100

Production-ready

▲ 7

acme/customer-agent

Esegui la tua validation

Incolla il codice del tuo agente o descrivi il workflow. Il validator restituisce finding per principio, uno score di readiness, e un URL di review in secondi; l'URL è condivisibile una volta pubblicato il run. Raggiungi il tier production_ready (voto A o B, da 75 in su) e hai 24 ore dal run per chiedere ad architect.certify una seconda revisione avversaria. Se conferma il risultato, il run riceve un badge certificato dello stesso tipo di quello sopra, pubblico quando pubblichi il run; un blocker che trova porta il run al voto C.

Altri case study