Ziaz Digital Ziaz Digital

Delivery Team Schematic

Not a fixed sequence — a routing map. What actually happens depends on the change: whether it touches a screen, whether a challenge changes the requirement or just the approach.

SCOPE — design & feasibility, no code
STATUS — framework, not yet built

Built to answer one bind: cut delivery cost and risk without cutting the team. Seven zones, not a fixed sequence. Each zone can branch — a diamond marks a real decision point, not a formality. Colour still means the same thing throughout: teal is the human, copper is an automated trigger, ink is the core pipeline; solid borders run in shared context, dashed borders are isolated subagents. The pill next to each zone's title names the actual Claude Code primitive doing the work. Zones A–E move a request through the team; F and G are the two layers underneath — who's allowed to change the agents themselves, and what stops the automation from running away. For the plain-language version of all of this, see The Bulletproof Delivery Team; for the reasoning behind each decision, see Under the Hood.

A

Requirement routing

HooksSkill

BA drafts the requirement first — this isn't a paired loop by default. Whether UX gets involved is a real decision, not automatic: no screen or journey impact → straight to the Architect. Contained UX impact → BA hands to UX, UX hands it back, BA finalizes. Genuinely complex or ambiguous → BA, UX and the Architect work it as a trio. All three routes land on the same place: a finalized requirement, ready for approval.

Product Owner states vision vision/ Hooks watches vision/ Business Analyst drafts the requirement UX impact? screens / journey complex — trio BA + UX + Architect trio — complex cases UX needed UX Architect designs the journey no UX impact capabilities/ · pending-approval
B

PO + Architect approve

Human gateHooks — fires next stage

Not called "Solution Architect" here on purpose — this is whichever architect the change actually needs, solution-level, technical-level, or both. Same mechanism as always: this isn't a pause, it's a state transition. Approve flips the field to approved, reject flips it to rejected; a Hook watches for either and fires the matching next step, even days later with nobody watching.

capabilities/ · pending-approval PO + Architect review & approve capabilities/ · approved Hooks → fires Zone C capabilities/ · rejected Hooks → reopens Zone A
C

Design, then review in parallel

SkillAgent — isolated

The Architect designs; then QA, Risk and Data all fire at once off that one design — not staged one after another. QA's check is concrete: it reads the design against use-cases/ and test-scenarios/, the actual existing scope, not an abstract regression pass.

capabilities/ · approved Architect solution / technical · designs technical-design/ · ready QA checks vs use-cases / tests parallel qa-review/ Risk Architect isolated · threats risk-findings/ Data Architect canonical model data-model/
+

Addendum — shared-standard writes

HooksAgent — isolated scanconditional

Runs alongside Zone C, independent of it. Only when the Architect's design touches a shared standarddesign-system/ or data-model/, not just this capability's own files — a folder-watching Hook fires an isolated Retrofit Scan, which finds every artifact still referencing the old standard and writes a backlog that surfaces at Zone E alongside everything else.

design-system/button.md Hooks watches those folders Retrofit Scan isolated · scans old refs retrofit-backlog/ · created → Zone E
D

Findings route to the Architect

Architect decides

Not straight to BA, not straight to the PO. Every QA or Risk finding lands with the Architect first. If it's resolvable with a different implementation approach — the requirement itself doesn't change — the Architect just decides and redesigns; QA, Risk and Data re-check the revision back in Zone C, no one else involved. Only if the fix actually changes what was asked for does it go further: back to BA to revise the requirement, then back through Zone B for PO re-approval.

qa-review/ or risk-findings/: flagged Architect assesses the finding changes the requirement? no — Architect resolves alone, redesigns → back to Zone C yes capabilities/ · pending-approval → BA revises → Zone B re-approves
E

PO decides, logs, remembers

PushNotificationMemory

Whatever survives Zone D — a clean pass, a resolved-in-Zone-C revision, or a genuine requirement change — lands here. If you're watching, you just see it; if you've stepped away, PushNotification is what pulls you back for a decision worth interrupting you for. Every decision writes to decisions/, append-only. Baseline resets and Memory updates are separate, deliberate, ongoing — never triggered automatically by any of the above.

Product Owner decides decisions/ · appended always Memory durable fact — no Hook scope-baseline.md · v2 deliberate — PO + BA/SA, occasional scope-baseline.md.v1 · archived
F

Skill governance — the headcount answer

Human owner

Every skill file has exactly one owner, and this is also where the "what happens to my team" question resolves: the person who used to do this work full-time now owns the skill that represents it — reviewing its output, rewriting it when it's wrong. Edit rights stay with the owner; suggestion rights are open to any role. Same pattern for all six skills, shown here for one.

any role · suggests QA owns · edits qa-regression skill.md owned by QA validated before it's live Product Owner validates, manual review Same for all six skills Versioning: every update is a full, clean rewrite of the live file — never an appended patch. The previous version is archived intact, never deleted, never left inline diluting current scope. Maturity model: human-gated today — broad suggestion rights, narrow edit rights, PO as backstop. Fully decentralized peer validation is the eventual goal, deliberately not built yet.
G

Reliability gates

HooksEvaluation

Every write from any zone above passes through these gates before anything fires — schema, duplication, and runaway-loop checks, in that order. This is what makes it safe to let Hooks act on real artifacts unattended: nothing here is a live pause, each is a deterministic check on the write itself.

write: technical-design/CAP-04 schema valid? invalid — no Hook fires already done for this ID? exit — already satisfied ≥3 cycles, unresolved? flag to PO — stuck Hooks fires the next stage logged either way — groundedness · relevance · completeness · latency/cost · schema accuracy
Border colour — layer
Human
Event / trigger
Core pipeline & state
Shape
Real decision point
Isolated subagent
Arrow colour — flow
Artifact / data flow
Automated trigger
Each primitive's job in this system, and whether it's worth wiring up now.
PrimitiveRole in the delivery teamPhase
CLAUDE.mdProtocol only — roles, folder conventions, definitions of done. Almost never changes.now
HooksFires on artifact writes and status transitions — vision intake, approval gates, shared-standard changes.now
SkillBA, UX and Architect run in shared context — persona-driven, not isolated.now
Agent (isolated)QA and Risk run isolated, reading only artifacts — no memory of how the pitch went.now
MemoryCross-session facts about the PO, feedback, and decisions — never the artifacts themselves.now
PushNotificationPulls PO's attention back only when they've actually stepped away.now
RemoteTrigger (webhooks)External event — a GitHub PR touching design-system/ — fires a routine with nobody present.later
Artifact capabilities (db / comments)A chat-only front end: PO reviews and comments on a published page instead of a CLI.later