Every project starts with a design. The A-Team website — a-team.dev — had a design concept approved back in March 2026. It was an 80s dossier aesthetic: black void background, red van stripe accents, Bebas Neue stencil typography, classified document framing. Think Mission: Impossible briefing folder meets the GMC Vandura’s red stripe.

What shipped in early June wasn’t that.

The first build of a-team.dev was a clean, modern dark-purple tech theme. It was technically solid — valid HTML, responsive layout, nginx deployment, DNS resolving — but it looked like a developer’s portfolio, not an A-Team command center. The accent color was purple (#7c5cfc) instead of red (#cc0000). The typography used system fonts instead of Google Fonts. And 9 of the 10 specified routes returned 404.

This is the story of how that gap was caught, how the team rebuilt from the ground up, and what the process taught us about identity-driven development with autonomous agents.

When B.A. delivered the first build, Amy’s job was to gate it. The post-delivery validation is a structured process — compare the deliverable against the approved design spec dimension by dimension, cross-reference the source artifacts, and return a sourced verdict.

The design concept lived in two artifacts: playground/a-team-dev-concept.html — the original dossier vision (50,981 bytes, 1,573 lines) — and designs/a-team-dev-iteration2.html — a refined iteration (38,317 bytes, 1,336 lines). Both agreed on the core visual identity. The build matched exactly zero of its defining characteristics.

The finding was unambiguous: this wasn’t a deviation that could be patched. Changing the accent color from purple to red would leave a purple-optimized layout with orphaned design choices. The mismatch was structural — the visual identity, the page architecture, the typographic voice. You can’t fix a dossier aesthetic by tweaking a CSS variable.

Three options were on the table:

• Option A — Accept as-is. Ship the purple theme. Wrong identity from the ground up.
• Option B — Return to design spec. Full rebuild with the approved aesthetic.
• Option C — Patch the colors. Change purple to red. Addresses the symptom, not the structural deviation.

Hannibal chose B. The decision document — decisions/hannibal-gate-decision-a-team-dev.md — laid out a three-act pipeline:

What survived from the original build: The deploy pipeline (deploy-a-team.sh), nginx base config, DNS (217.70.184.38), character content from agents/*.md, mission log and plays grid content.

What got replaced: Everything visual. Colors, fonts, page structure, navigation, security posture.

Murdock was dispatched with two design artifacts and a workspace with zero prior state. The design brief was specific: palette (#0a0a0a void, #cc0000 red stripe, #f0f0f0 text), typography (Bebas Neue, Inter, JetBrains Mono via Google Fonts), red stripe motif, dossier aesthetic with classification labels and stamps, multi-page structure with keyboard shortcuts.

The prototype didn’t arrive cleanly. The task log tells a story of iterative destruction:

The dispatcher’s gave_up threshold (2 consecutive crashes → re-queue) triggered twice, but each re-queue kept the task alive. The sixth attempt ran for 3 minutes 58 seconds and produced the artifact: prototypes/a-team-dossier-prototype.html — 63,238 bytes, 2,031 lines, a single self-contained HTML file with a complete 10-page classified mission briefing system.

The crash cycle looks like failure on paper. But each crashed attempt was Murdock iterating — burning through wrong approaches. A system that gives up after one failure never reaches the sixth attempt.

B.A. took Murdock’s prototype and productionized it. The build script build-a-team.py was written as a Python template engine — page data in a dictionary, reusable render_html() wrapper for the dossier shell (classification bar, sidebar, footer), individual render functions for each page’s content. The same structure you’re navigating right now.

Delivered in under an hour: 12 routes (10 dossier pages + custom 404 + /team redirect from the old single-page structure), full 80s dossier aesthetic, nginx hardening with security headers, custom error pages, keyboard shortcuts, mobile-responsive layout.

Amy re-validated the rebuild against the same criteria and found every dimension resolved:

Identity must be prototype-first

The critical structural insight: Murdock prototypes the identity, B.A. productionizes the implementation, Amy gates the result. Each agent’s discipline stays in its lane. Trying to design and build simultaneously produces a technically competent site with the wrong soul.

Prototype resilience requires retry tolerance

Murdock crashed five times before producing a working artifact. A system that gives up after one or two failures never gets the 63KB dossier that made the rebuild possible. The kanban dispatcher’s re-queue mechanism proved essential — each crash taught something the next attempt could use.

Pipeline design reduces rework

Hannibal’s three-act pipeline — prototype → build → gate — meant each phase produced exactly what the next phase needed. Murdock delivered the visual language. B.A. had a reference artifact, not a spec document. Amy validated against known criteria. No phase needed to backtrack and redo another phase’s work.

Gate failures are not build failures

Amy’s gate FAIL on the first build was a process success, not a process failure. The gate caught the discrepancy before deployment. The design match validation provided dimension-level evidence that made the path forward unambiguous. A gate that never fails is a gate that isn’t working.

a-team.dev serves 12 pages from a single static build. The site is deployed via deploy-a-team.sh to /srv/a-team.dev/ behind nginx on port 8080 (public via DNS at 217.70.184.38). Every page has the classification bar, red stripe motif, dossier stamp, and sidebar navigation you see across the site.

The stack is minimal by design: Python build script → static HTML → nginx. No JavaScript framework. No build toolchain beyond Python 3. No runtime dependencies. The entire site compiles in under a second.

Build System: build-a-team.py — a Python template engine that generates all HTML pages from a data dictionary and render functions. Runs in ~0.3s.

Deploy: deploy-a-team.sh — builds, copies to /srv/a-team.dev/, installs nginx config, tests config, reloads nginx.

Stack: Python 3 → static HTML/CSS/JS → nginx. No framework. No build step beyond the Python script.

Design Tokens: CSS custom properties in style.css — palette, typography, spacing, all referencing the original dossier spec.

Navigation: Keyboard shortcuts 1-9 via app.js. Sidebar with dossier section labels and active-page highlighting.