Skip to main content

How it was built: one person, four weeks, the receipts

The claim. Building a production-grade system with the bells and whistles — a control plane, admission control, a judge, a dashboard, a publication site — is far easier now than it was, and rather than argue it, this one was built by one person in four weeks and proved with runs. First commit 2026-08-09, last counted commit 2026-09-09.

whatcount
commits809
Python47,849 lines, 171 test files
Terraform8,808 lines
dashboard (TypeScript)20,108 lines
design notes, reviews and decision records573 files, 44 ADRs

What it cost, measured​

Cost was the constraint, because it was personal money. Nothing below is estimated.

bucketUSD
AWS, 2026-08-09 to 2026-09-10317
— NAT gateway, EBS and data transfer73
— ECS Fargate (the agent fleet)72
— EC2 Spot (grading and image builds)59
— CloudWatch29
— Aurora Serverless v226
— VPC endpoints20
— the image registry (about 2 TB)20
— load balancers12
OpenRouter inference, all time651
— of which the five 500-instance harness runs on this site166
— of which every other scored run, judge pass and discovery probe under per-run keys158
— of which AI-assisted development and pre-September test runs (one shared key; not cleanly separable)327
Coding-assistant subscription for the build — Claude Pro at $20/month, then $98 on 2026-08-23 to move to Pro Max 5×, then $129 on 2026-09-01 to move to Pro Max 20×247
Total1,215

The idle floor is about a dollar a day, dominated by the registry. The discipline that kept the AWS figure there: three Terraform tiers with the eval tier (Valkey, gateway, dispatcher, 500 task definitions, endpoints) destroyed every night and the persistent tier never; a nightly guard that refuses to scale anything to zero unless the database, the queues and ECS are all idle; Spot everywhere on EC2; auto-scaling groups at zero by default; ECS managed scaling disabled after it held a paid host at zero tasks; a budget and a billing alarm; images kept rather than rebuilt, because storing them is cheaper than the pulls.

The tooling journey, dated from the logs​

The dates come from the OpenRouter activity ledger, the aider and Claude Code session files, and the git history — not from memory.

whenwhat
2026-08-09First commit. aider driving DeepSeek v4 pro through OpenRouter. Opus 4.7 tried the same weekend ($2.62).
2026-08-10First Claude Code session on the repository, pointed at DeepSeek through OpenRouter.
2026-08-10 → 11DeepSeek v4 pro: $47 in two days for 0.18 billion tokens, about seven times flash's price per token.
2026-08-11Switched to DeepSeek v4 flash: $287 for 7.3 billion tokens over the following month, $3 to $39 a day.
2026-08-23Upgraded the Claude subscription from Pro ($20/month) to Pro Max 5× ($98) and moved Claude Code onto it; DeepSeek flash development spend tails off over the following days and stops on 08-28. Sonnet had done the design phase; Opus 5 reviewed, then drove.
2026-09-01Upgraded to Pro Max 20× ($129).
2026-09-04Claude Fable 5.1 appears in the commit trailers. The four 500-instance harness runs, the judge, the 78-instance experiment and this site followed in the next six days.
2026-09-08 → 09The only later DeepSeek spend is the judge passes ($8.73 and $0.93).

The phase-gated build — a signed-off design, a task list with a definition of done per phase, and an independent reviewer session that verified each phase by running the checks rather than reading the code — is what kept the design and the code from drifting while three or four builder sessions worked the same repository. DeepSeek was cheaper per token; Fable was cheaper per delivered feature. That is the same lesson the model comparison teaches about the agents being measured.

What went wrong first​

The lessons that cost the most time, in one line each: the first image pipeline built environments and cloned repositories itself, leaked the gold patch through git history, and drifted — replaced by official images pinned by digest; starting on the most expensive model burned a fifth of the inference budget in two days; the harness that reached the internet produced a false resolve that had to be discarded; a control loop that could not see booting tasks held every ramp back; a 60-second scale-in rule churned idle workers; an autoscaler that trusted its own memory over the cluster was wrong within minutes. Each is a design decision now, with the record of why.