The previous two posts describe the individual pieces: persona extraction into testable lenses, and voice governance derived from conversational patterns. But the thing that has no parallel, as far as I can find, is how they fit together into a single integrated system.

I’m going to describe the full architecture, because this is the kind of thing that’s hard to explain without showing the pieces and how they connect.

How it’s organized

The system has two kinds of components: atomic skills and coordinators. A manifest maps every dependency: what calls what, what needs what, what produces what. The methodology that governs the architecture is documented on the Formwork Protocol page.

Atomic skills

An atomic skill does one thing. It takes an input, runs a diagnostic or generates an output, and returns a result. It doesn’t know about the rest of the system. It doesn’t call other skills. It’s self-contained.

Some examples:

The Millman lens takes a portfolio page and evaluates it against five criteria extracted from Debbie Millman’s body of work. It returns a verdict per criterion (STRONG, HOLDS, WEAK, BROKEN) with specific findings and evidence. That’s all it does.

The Grip Test takes a page’s opening paragraphs and evaluates whether a stranger would feel the problem or just be informed about it. It returns a rating (Fingernail, Grip, or Lock) with the specific sentence where the page becomes undeniable (or doesn’t). That’s all it does.

The texture-grain skill generates a paper grain texture tile based on reference material from my visual studies. It produces a PNG file and waits for approval before writing to disk. That’s all it does.

The constraint is important: atomic skills are single-purpose, and they produce a clear output format. This means they can be composed without coordination overhead. If you know what a skill takes and what it returns, you can use it in any combination.

Coordinators

A coordinator dispatches atomic skills, collects their results, and synthesizes. It knows the structure. The atomics don’t need to.

The audit coordinator runs a baseline check (links, images, cross-references, voice violations, SEO metadata) and then dispatches five evaluative lenses in parallel: Millman, Bierut, Appleton, Peers, and Victore. Each lens runs independently, evaluating the same pages from a different perspective. The audit collects all six verdicts and presents them together.

The steward coordinator is the full career stewardship pass. It dispatches eight arms in parallel: audit, position, design review, copy review, visitor journeys, speed tiers, forwarding assessment, and cross-page arc. Each arm is a coordinator or skill in its own right. The steward collects all eight reports, then runs convergence (which needs the audit output, so it’s sequential), cross-checks against Victore, and produces a combined report with priority actions.

The design review coordinator dispatches a Playwright screenshot capture across four breakpoints (mobile, tablet, laptop, ultrawide), then runs nine visual lenses in parallel — each selected for a specific dimension: restraint, type craft, personality, economy, conceptual typography, concept, grid, structural honesty, and print artifact quality. If the print-craft lens returns anything less than PRESSED, the coordinator offers a texture generation pass.

The coordination pattern is simple: dispatch independent work in parallel, collect results, synthesize where sequential dependency exists. The steward doesn’t need to understand what the Millman lens checks. It needs to know the Millman lens returns a verdict and findings, and those feed into convergence alongside the other lenses.

The 8 parallel arms

When the steward runs, it spawns eight independent processes:

  1. Audit (baseline + 6 content lenses + Victore)
  2. Position (magnetism, market fit, discoverability, peer credibility, substance, esoteric risk)
  3. Design Review (screenshots + 9 visual lenses + conditional texture)
  4. Copy Review (grip test + copy verify per published page)
  5. Visitor Journeys (3 paths: discovery, deep dive, peer evaluation)
  6. Speed Tiers (what registers at 10 seconds, 2 minutes, 20 minutes)
  7. Forwarding (per-page: would someone send this? who? what would they say?)
  8. Cross-Page Arc (intra-tier, inter-tier, the through-line)

Each arm runs with full context and full nesting depth. The audit arm dispatches its own parallel lenses. The design review arm dispatches its own parallel visual lenses. Nested parallelism. The reports land in a timestamped directory.

After all eight arms complete, convergence runs sequentially. It reads the audit output and maps where lenses agree (high-confidence signals) and where they disagree (decision points). The disagreements get articulated: “Millman says STRONG on vulnerability, Vignelli says WEAK on restraint. At stake: raw personal directness vs. visual discipline.” Those are the decisions I make. The system surfaces them. I resolve them.

The system surfaces them. I resolve them.

The knowledge base

Every skill that writes copy operates under a no-hallucination policy. The system may not invent, infer, or assume any detail about the work. Every concrete claim (project history, what broke, number of iterations, what someone said, why it mattered) must trace to a verified source.

The sources are indexed:

Layer 1: 43+ Claude Code session transcripts from February 2026 onward. These are the sessions where the site was actually built. JSONL format, searchable.

Layer 2: 1,643 ChatGPT conversations from January 2023 to January 2026. The earlier history: worldbuilding for a novel, career planning, brand development, cooking technique, teaching approaches, enterprise UI strategy. 292 MB of JSON.

Layer 3: Claude.ai conversation exports. The mid-period work between ChatGPT and Claude Code.

Layer 4: Gemini exports. Planning conversations and site strategy.

Together, these feed a Personal Knowledge Base of 52,000+ documents. When a skill needs a specific fact, it searches this base. When it can’t find verification, it stops and asks. It does not write speculative copy.

This is not a philosophical stance. It’s an enforced constraint in the copywriting protocol. The protocol specifies a knowledge escalation order: check what you have, search the knowledge base, and if nothing comes back, interview the maker. At no point is “make something up that sounds right” an option.

The generative loop

Evaluation without generation produces documentation. A report that says “the print-craft lens scores ADEQUATE on paper texture” is useful, but it doesn’t produce the texture.

The system closes the loop. Evaluative lenses identify gaps. Generative skills take those gaps and produce real output. A texture system generates paper grain tiles, film noise overlays, distressed SVG border masks, and halftone treatments. A type-scale skill measures ratios in reference material and generates SCSS tokens. A composition skill studies spatial tension and generates asymmetric spacing rules. A layout skill restructures templates.

Every generative output stops before writing to disk. The system presents what it made, side by side with the current state and the reference standard. I decide. The skills do the analysis and generation. I do the creative direction and approval.

After approval, Playwright captures the new state at four breakpoints. The visual lenses run again on the captures. Did it improve? Did anything regress? If the print-craft lens still returns ADEQUATE after the texture pass, the system tries different parameters or presents its best attempt for me to assess. The loop continues until the work converges toward the identity I extracted.

Why the combination matters

Individual pieces of this system have analogues. AI-assisted writing is everywhere. Prompt engineering with persona instructions exists. Voice style guides exist. Evaluation checklists exist. Multi-agent architectures exist.

What I can’t find anywhere: the specific combination of persona extraction from practitioner bodies of work into testable diagnostic lenses, voice governance derived from real conversation patterns (not published writing), coordinator-dispatched parallel evaluation across structural and narrative dimensions, convergence analysis that surfaces disagreements as decision points, and a no-hallucination knowledge base grounding every specific claim in verified conversational history.

Each piece solves a specific problem I encountered while building. The extraction solves the “act as” problem. The voice governance solves the “all AI copy sounds the same” problem. The coordinator pattern solves the “too many tools, no structure” problem. The convergence solves the “multiple perspectives without synthesis” problem. The knowledge base solves the “AI makes things up” problem.

The fact that all of these pieces talk to each other, share a manifest, and run through coordinators that handle the orchestration: that’s the architecture. And architecture is what makes the difference between a collection of tools and a system that produces decisions.

The manifest

Everything described here is documented in a single manifest file. Every skill, what it does, what calls it, what it needs, what it returns. If the system were a building, the manifest would be the set of plans that lets a contractor understand the whole structure without having to trace every pipe.

The methodology underneath all of this is the Formwork Protocol. The protocol describes the approach. This system is one practitioner’s implementation. They’re related but distinct: the protocol transfers to anyone. This implementation is mine.