Skip to content

Built by Claude

Zero to hero: one person and an AI engineering team took a half-page brief to a shipping product — the Deployment Dashboard — a working MVP in 3 days.

How it was built See the code

The goal

A complete product — the Deployment Dashboard — produced by AI end-to-end: code, automation, docs, tests, delivery. The human only sets direction and signs off.

The Deployment Dashboard — services × environments matrix The Deployment Dashboard — services × environments matrix

Two achievements in one project

  • A method — an AI engineering team

    A reusable process: specialist roles, AI agents, and enforced guardrails. The reusable asset.

  • A product — built entirely by it

    A real deployment dashboard, shipped end-to-end with one human steering. The proof it works.

By the numbers

  • MVP in 3 days

    From napkin brief to a working product.

  • 1 human + AI team

    One person directing specialist AI agents.

  • ~1,700 tests

    Backend, frontend, contract, end-to-end.

  • ~2.5 h / feature

    A full DORA analytics view, contract to PR.

The goal: a product produced by AI

Most "AI coding" stops at snippets a human must then integrate, test, document, and ship. Here, AI owns the whole lifecycle — the human stays minimal. The product here is real — the Deployment Dashboard, a live services × environments matrix sourced straight from CI/CD events.

  • Source code

    Backend services, web app, browser extension.

  • SDLC automation

    Branching, guardrails, CI/CD, release machinery.

  • Documentation

    Architecture, specs, guides — kept current.

  • Testing

    Unit, contract, integration, end-to-end.

  • Delivery

    Committed & reviewed as pull requests — then cut as GitHub Releases with deployable Docker images.

The human owns only direction and acceptance. Everything in between is the AI team's.

Zero to hero

Zero to Hero — a half-page brief becomes a shipped product

How it works: judgment + enforcement

Built the way Anthropic recommends building agents — in the team's own terms:

  • Orchestrator-workers (hub & spoke) — a lead plus specialist roles.
  • Isolated contexts — each specialist works disposably; the lead stays lean.
  • Typed protocol — every cross-role hand-off is a schema-checked message.
  • Deterministic guardrails — the rules are enforced by programs, not goodwill.

Two layers carry it — judgment decides, enforcement guarantees:

A lead agent orchestrates — it plans the work, routes each slice to the role that owns it, and integrates what comes back. One coordinator, many specialists.

Judgment — the orchestrator routes work to specialist roles

  • The lead coordinates, never codes — it dispatches and integrates; it never edits a role's files.
  • Roles own lanes — each holds its own non-negotiable bar; parallel only on disjoint files.
  • Typed hand-offs — BRIEF down; RESULT · REVIEW · FINDING · ARTIFACT up; FIX for the loop.

Judgment can be argued with; hooks can't — small deterministic programs run at every key moment and block any rule-break. The AI can't talk past them.

Enforcement — every action runs the hooks gauntlet

Ten such hooks

Each is an independently tested program, wired in at every key moment — session start, before each edit, before each message, before every commit.

What the solution is made of

  • Process & roles

    A defined lifecycle — intake → contract → build → review → test → ship — run by an orchestrator + 6 specialist roles.

  • Specialist agents

    AI workers for API, backend, frontend, deployment, testing, and documentation.

  • Docs-keeper

    Keeps documentation authoritative and current — and blocks any change that lets it drift.

  • Hooks

    10 deterministic guards that enforce the rules automatically, every time.

  • Code intelligence

    Purpose-built search so agents navigate the codebase fast and cheaply.

What the solution is made of — five building blocks in two layers

The process in action: issue #299

A DORA analytics view — contract to shipped — in ~2.5 hours. A recent, ordinary example: a new analytics tab with the four industry-standard delivery metrics, eight charts, and new server-side endpoints.

Issue #299 — contract first, parallel build, a review/test fix-loop, then ship

  • ~6,500 lines across 41 files — API contract, backend, web UI, spec, and full test coverage.
  • Self-corrected mid-flight through the review-and-fix loop.
  • Stopped at the pull request for human acceptance — the process never auto-merges.

→ See the real thing: issue #299 — the requirements · PR #308 — the implementation

Why it matters

  • Team

    One person directing an AI engineering team.

  • Time to market

    A working MVP in 3 days; features in hours.

  • Quality

    Tests & review enforced by hooks — they can't be skipped.

  • Living docs

    Documentation can't silently rot.

  • Reusability

    The same process builds the next product too.

  • Control

    Humans set direction; AI executes within guardrails.

The takeaway

One person and AI built a shipping product — a half-page idea became a working MVP in 3 days, plus a reusable engineering process that builds the next product too. The breakthrough isn't a smarter model — it's instructions for judgment + hooks for guarantees.

Even this page

This showcase — every word and all five diagrams — was written and drawn by the same Claude team it describes. Meta, but true.