I build autonomous AI systems.Then I audit my own claims about them.

The method

Constraints, not keystrokes

I run a pipeline where I write the specification and the acceptance criteria, and agents do the typing. The part that matters is not that agents write code — it is that nothing reaches production without an audit stage that can fail the build, and that stage never accepts an agent’s word for anything.

How I run agents

Nine days, one datable change

On 18 August 2026 I audited my own work and found forty-one things I had called “passed” with nothing behind them. A test script pointed at a file that did not exist. Every “10 of 10 tests passed” report I had filed was not produced by that script. I stopped building that day and built the controls instead.

Version control, a numbered ticket protocol, and a rule that every figure carries a grade — MEASURED, CALCULATED or NOT VERIFIED — all enter the record on the same day. They are one change, not three. Nine days later the same method was running in three unrelated codebases. I am not going to call this a month of practice. It is nine days with a start date and a cause, and you can check both.

On VOLTHAVEN 64 that is 39 work orders, 5,103 files of working record and 48 reports. Two other projects run their own series, numbered independently. I am not going to add them together and call it one number.

Three rules I paid for

Where it caught something

What it costs, and what is still missing

The largest single waste in the record is mine. I sent an agent to reconcile two line counts without giving it either script or telling it where they had run. It swept two hundred thousand configurations for thirty minutes looking for a difference that was not in any of them. The answer was that one script had counted my own tooling directories. The ticket was the defect, not the agent.

Across eighty-eight reports, “where I wasted effort” appears once. No template requires a cost section, so the cost is systematically under-reported — including in the four catches above. 28.4 percent of my commits are documentation. There is still no CI, no linter and no formatter, eight days after my own audit said there should be.

The same method, applied to teaching

Every Academy class used to carry its own hand-written interactive exercise. Now there is one engine and nine modules — decider, hunt, ledger, instrument, gate, anatomy, forge, promptdiff and setupcheck — in 1,104 lines, generalised out of code originally written for a single class. 136 exercises are deployed from it across 72 pages.

Every module’s CSS sits behind its own conditional, so a page carrying one decider ships none of the other eight modules’ rules. The engine gets more capable without taxing the seventy pages already using it — which is the usual way a shared component library dies, and it was designed against at the start rather than patched later. The grammar fails closed: one malformed row renders zero bytes, no markup and no error, so a broken exercise cannot ship half-working. The cost is that a missing module looks exactly like an absent one, which is the first thing the runbook tells you to check.

Around it sits a twelve-stage class pipeline with the interactive standard as a mandatory gate, and seven numbered promote gates whose comments each name the incident that created them.

VOLTHAVEN 64

I had never built an N64-style game. Thirty-nine work orders later there is one: nineteen rendering techniques, a synthesised soundtrack, gamepad support, and a first-load payload measured at 424,557 bytes — which models to $48.93 per million loads at CDN egress rates.

Eighteen months

February 2025 to here

The earliest retrievable artifact anywhere is a t-shirt design uploader, dated 27 February 2025. Eight independent sources agree on it, including the filesystem. 26,779 older files were examined and rejected — all browser-extension and game-cache assets stamped with an invalid 1979 epoch. So this is eighteen months, not the vaguer “two years” this page used to claim. The compressed timeline is the whole story.

Build density — dated artifacts per month

What this measures, precisely: the count of artifacts carrying a verifiable date in that month — application records, first commits, conversation timestamps and operating-system file stamps, across eight sources. It is not a record of hours worked, and no hours figure is claimed anywhere on this page, because no time-tracking data exists to support one. The three empty months in 2025 are real: nothing dated survives from them.

Tool adoption — ten rungs, nine of them timestamped

Each date below comes from an operating-system file stamp or a platform record, not from memory. The one exception is marked, because it should be.

Firebase Studio is the honest weak link and it stays labelled as such. I adopted it in its launch month; no artifact from it survives, so the claim is ASSERTED, not measured. What is externally checkable is the product itself: Firebase Studio entered preview on 9 April 2025, was renamed from Project IDX on 15 April 2025, and Google announced its retirement in March 2026 with a final shutdown date of 22 March 2027. That is why it is no longer in the stack.

The record — 38 dated events

.rfx-rail{ overflow-x:auto; scroll-snap-type:x mandatory; }
.rfx-rung{ scroll-snap-align:start; flex:0 0 auto; }

The systems

Six AI systems in production

Working, audited, multi-agent systems. The headline figure this page used to carry — “51,000+ lines across all builds” — was understated by roughly eleven times. One system alone exceeds it.

Every project, plotted by date

Horizontal axis is time, February 2025 to now. Node size is measured lines of code. Connecting lines are lineage — where one build became the next. Hover or tab to a node for its record.

Node detail appears here on hover or focus. Every project below is also listed in the timeline above, so nothing here depends on JavaScript to be discoverable.

Where the July 2026 measurement found the lines

Tile area is proportional to measured lines. A total with no exclusion list is worth less than a smaller one with a reproducible command behind it, so the exclusions are stated below the map, not buried.

The first version of this measurement returned 6,491,299 lines. It was wrong, and it was wrong in a specific and instructive way: 83 percent of it was Liquid, because the same Shopify theme sat in five working directories and every copy got counted. The tell was two byte-identical base.css files at different paths. Content hashing removed 2.36 million lines in one pass. A big number with no exclusion list is worth less than a smaller one with a reproducible command behind it — and that applies to my own output first.

<div class="rfx-tile" style="flex:' }} 1 150px">

Live and purchasable

Two commercial desktop apps — and how they got there

Not prototypes. Both ship today, both bring-your-own-key with a serverless licence gate, so inference cost sits with the user and there is no subscription. The part worth showing is not that they exist — it is the dated path from a browser prototype to a paid product.

Free and live

Three games, a web app, and two civic tools

All shipped, all free, none monetised. The game count on this page said two; three are live. Three further game builds exist and are deliberately not counted here, because they are demos and counting them would be padding.

Hard-won

Engineering judgment, from real incidents

The work that does not fit in a feature list. Each entry is an actual production failure — symptom, root cause, fix, and the rule it locked in. This is the difference between writing code and operating systems. Two of them are my own mistakes from the last 24 hours.

.rfx-conwrap:has(#rfx-f-css:checked) .rfx-inc:not([data-cat~="css"]){ display:none; }

The part that took the longest

I used to publish numbers I could not defend

Most “AI-assisted developer” claims are unfalsifiable, and mine were too. What follows is a dated, documented reversal toward a stricter evidence standard — made against my own commercial interest, because it cost me every impressive number I had. Nobody asked me to do it.

A big number with no exclusion list is worth less than a smaller one with a reproducible command behind it. The rule I now apply to my own output first

If you are hiring an AI systems architect, the core competence is not prompting. It is knowing which outputs to trust and having a method for deciding. The most direct way I can demonstrate that is on my own claims, in public, including the ones that did not survive.

Both directions

What the audit changed

Every figure on the previous version of this page was re-derived from source on 27 July 2026. The corrections run in both directions, which is what an honest audit looks like — a padded one only ever corrects downward, and a defensive one never corrects at all.

14 of these were understated, and that is the part worth pausing on. The class count was 59 and is 81. The blog count was 25 and is 62. The code figure was 51,000 lines against 556,586 measured. This portfolio was not padded — it was unaudited. Those are different failures with different fixes.

.rfx-diffwrap:has(#rfx-onlywrong:checked) .rfx-drow[data-dir="up"]{ display:none; }

Always on

An autonomous operations fleet

Beyond the headline systems, scheduled agents run the day to day with the human out of the loop — research, publishing, video and engagement — reporting in rather than waiting for instructions.

Teaching the method

The DDS Vibe Academy — 86 free classes

I teach the method openly. The Academy is a free curriculum on intent-based AI coding, built with the very workflow it documents. Nothing is paywalled and nothing is gated: no signup, no email capture, no certificate. This page said 59 classes. It reached 78 on 25 July and is 81 today.

The storefront

A production Shopify store, engineered solo

Design Delight Studio is itself proof of work: a full sustainable-apparel catalogue on Shopify Basic, built and tuned by one architect, and the environment every constraint on this page was learned in.

Measured, not claimed

What this page actually scores

Every previous version of this portfolio published performance figures that were never re-measured after the rebuild. So this page is audited before the numbers are written — three runs per configuration, median reported, spread disclosed. It was re-audited on 3 August 2026, after this page gained a live WebGL section, because publishing the old numbers next to new code is the precise failure this section exists to prevent.

Median of three runs per row, 3 August 2026, PageSpeed Insights — Lighthouse 13.4.1, emulated Moto G Power on slow 4G for mobile, single page session, initial page load. Spread across the three runs: mobile Performance 82–87, LCP 3.5–3.8 s, Speed Index 2.6–4.7 s, CLS 0–0.019; desktop Performance 100–100, LCP 0.7–0.7 s, Speed Index 0.6–0.7 s. Lighthouse is noisy, so a single sample would not have been worth publishing — the mobile Speed Index alone moved 2.1 s between identical runs.

Warm rows have been removed rather than carried forward. The earlier audit ran Lighthouse from Node with disableStorageReset to measure a repeat visit; PageSpeed Insights only performs a cold single page session and cannot reproduce that. Leaving the old warm numbers in a table dated today would have implied they were re-measured. They were not, so they are gone.

Why Total Blocking Time is zero — and why that is not a trick

A 0 ms TBT on a 194 KB page under mobile CPU throttling deserves suspicion, so here is the actual mechanism rather than a flattering one. It held at 0 ms across all six runs on 3 August, mobile and desktop, after the page gained a WebGL section.

That last line is the one worth checking rather than trusting. Held at the top of the page for eight seconds on a cold load, the network log shows 12 requests and no three.module.js; the engine has not mounted and the project map has not been built. Both are gated behind IntersectionObserver, so a visitor pays for them only if they scroll far enough to see them.

This does not contradict the earlier finding that Shopify imposes a Total Blocking Time floor. That floor is real — on pages that render through theme.liquid, which is most of the store. This template opts out of the theme layer entirely, so it never pays that cost. Two true findings about two different page types, which is worth stating precisely rather than collapsing into one flattering claim.

Two honest caveats. The accessibility 99 is Lighthouse's automated score, which checks what a machine can check — it is not a WCAG conformance statement, and the manual keyboard and screen-reader passes are separate work. Best Practices sits at 92 because of a console 404 from a Shopify app embed that this template does not load and cannot remove.

const r = await psi(url, strategy);              // strategy: mobile | desktop
const c = r.lighthouseResult.categories, a = r.lighthouseResult.audits;
runs.push({ perf: c.performance.score * 100,
            lcp:  a['largest-contentful-paint'].numericValue,
            tbt:  a['total-blocking-time'].numericValue,
            cls:  a['cumulative-layout-shift'].numericValue });
report(median(runs), spread(runs));              // never a single sample

The stack

Skills, mapped to proof

A skills list is a claim. Each row below names the artifact that backs it, so the claim is checkable.

• Multi-agent system architectureSovereign Orchestrator Pro — 20 agent modules, 86 services, 54,886 lines measured
• Agent skill authoring & portabilityshopify-dds-mastery — installed into two agents, blind-tested 10 of 10 first attempt
• Autonomous pipeline operationsMorning Brief — 62 of 62 weekdays, verified by platform count
• Release engineering~100-script toolchain, preflight gating, staging-to-production parity, three hard ABORT guards
• Shopify Liquid architecture229,493 live lines; one snippet dataset driving ~16 rendered surfaces
• Structured data & technical SEO10–13 JSON-LD schemas per page; FAQ-to-schema parity enforced at build
• Accessibility engineeringWCAG 2.2 AA; contrast measured 3.4:1 → 8.56:1 by pixel sampling
• Test & audit engineering22 invariant tests; 40-gate and 38-gate audits at zero failures
• React + TypeScriptcase-study dashboard under TS strict, clean; bilingual client site
• Compliance automationclaims-compliance-sweep — 4-class classifier, reversible, 561 live URLs
• Hybrid local / cloud inferenceGemini plus local qwen2.5-coder:14b on an RTX 3060; telemetry-enforced budget gate
• Cloud deploymentTwo independent GCP Cloud Run deployments
• Evidence governanceThis page. Valuations stripped from my own schema at commercial cost.

Experience

Founder & Architect — Design Delight Studio

Boston, MA · February 2025 – present · AI Systems Architect

• Designed and operate an AI development pipeline in which agents write, audit and deploy production code under written constraints, with zero human keystrokes in the production pipeline and an audit stage that can fail the build.
• Shipped 772,119 authored lines of code across six production AI systems, two commercial desktop apps, three browser games and a live web app — solo, measured with declared exclusions.
• Built and operate a fleet of scheduled autonomous agents; the publishing agent has shipped 62 consecutive weekday issues with zero misses, verified by platform count.
• Built and run a 619-product Shopify Basic storefront across 129 pages and 229,493 lines of live Liquid, rebuilt to WCAG 2.2 AA.
• Created the free 86-class DDS Vibe Academy and a 5,529-line portable agent skill validated by blind build test.
• Authored a compliance classifier that swept 561 live URLs for unsupported claims, and applied it to my own marketing copy first.
• Manage four supply-chain certifications plus Fair Wear Foundation membership across a made-to-order catalogue.

The brand

Four certifications, plus one membership

The distinction matters and this page used to get it wrong. Four are third-party certifications. Fair Wear Foundation is a multi-stakeholder membership covering factory labour conditions, held through our supplier — not a certification, and it should never be described as one.

Design Delight Studio is not OEKO-TEX certified. See the certifications page →

Questions

FAQ

In one screen

Key takeaways

• 772,119 authored lines measured with declared exclusions on 2026-07-27 — six AI systems, two commercial desktop apps, three games and a live web app.
• Eighteen months, self-taught, from a first Shopify conversation on 2025-02-27 to a ten-tool agent stack, with every adoption date but one established by an OS or platform timestamp.
• 62 consecutive weekday publications with zero misses, and 86 free classes — both verified against the platform, not asserted.
• Corrections in both directions: of 30 figures re-derived from source, 14 were understated and 7 overstated. The portfolio was not padded, it was unaudited.
• Published my own worst numbers — 2,360,839 duplicated lines and 3 of 23 repositories under version control — because a page arguing for evidence standards that hid its own gaps would not be worth reading.
• Every number here is clickable and returns its grade, method, date and exclusions.

One architect, directing AI agents under tight constraints, shipping and operating production software at the scale of a small company — and holding the output to a standard that costs him claims. If that is the kind of builder you need, let’s talk.