Fourteen parts ago, this series made a promise: build a real app with AI and hide nothing — every prompt shown, every mistake kept, every dollar counted. ClinicLive is live behind nginx, its commit messages are the prompt log, and the meter has stopped. Time to count.
The bill, honestly
These numbers come straight from the build log — cumulative API spend as each part of the app landed:
| Part | What we built | Running total |
|---|---|---|
| 3 | The spec (plus 9 clarifying questions) | ≈ $0.40 |
| 4 | PostgreSQL schema | ≈ $0.60 |
| 5 | Blazor Server skeleton, entities, migration, seeder | ≈ $1.10 |
| 6 | The booking flow | ≈ $1.80 |
| 7 | Live queue: kiosk, board, SignalR hub | ≈ $2.70 |
| 8 | Staff chat, presence, typing | ≈ $3.40 |
| 9 | Test suite vs a real PostgreSQL | ≈ $4.10 |
| 10 | Two real bug hunts | ≈ $4.90 |
| 11 | The hardening pass | ≈ $5.60 |
| 12 | Deploy runbook, nginx, systemd, CI | ≈ $6.20 |
The meter, final reading: ≈ $6.20 of API spend and roughly one hour of wall-clock AI-assisted building — for a Blazor Server app with PostgreSQL, two SignalR surfaces, auth, a nine-test suite against a real database, CI, and deploy artifacts. An honest estimate for hand-building the same thing: two to three days.
Now the honesty that belongs next to that callout: the $6.20 is not the real cost. The real cost is the human time steering and reviewing — reading every diff, pasting the schema into a review before accepting it, saying no to SMS, noticing that "Test G" isn't "Test G." That time doesn't appear on any meter, and it is precisely the part you must not skip — because every mistake in the next table was caught by exactly that time, and the one that wasn't caught early (open self-registration) sat in the codebase for six parts. The dollars buy drafts. The review is where the app became correct.
The complete mistake log
Every 🤖 from fourteen parts, in one table:
| Part | What the AI got wrong |
|---|---|
| 3 — spec | Invented an SMS notification feature nobody asked for; wanted patient accounts until the non-goal was stated explicitly. Scope creep is a habit, not an accident. |
| 4 — schema | timestamp without a timezone; no index on the
appointment.patient_id foreign key; a plain UNIQUE on the slot
that would have blocked re-booking a cancelled appointment. The
partial-index requirement had to come from us. |
| 5 — skeleton | Left the SQLite package in the csproj "for tests"; didn't flag that the template's confirmed-account default would lock out every seeded staff login until we asked "why can't I log in?" |
| 6 — booking | Treated clinic hours as UTC — wrong "today" for any clinic east of UTC, slot labels shifted by the offset. Compiled, demoed fine, quietly wrong about time. Fixed in Part 10. |
| 7 — queue | CS0542: injected a QueueService Queue member into
Queue.razor — a component can't have a member named after its
own class. |
| 8 — chat | Proposed an [Authorize] hub that a server-side component can
never reach (the connection carries no browser cookie — 401 forever). And
CS0542 again, Chat in Chat.razor. |
| 9 — tests | Wrote the queue-order test by reading the code instead of the spec — a tautological test that passed against a bug. Also asserted "Test G" where the board masks to "Test G." |
| 11 — hardening | The template's open self-registration had shipped unquestioned in Part 5: anyone on the network could create an account and walk into the staff area. Found only when we made the AI attack its own app. |
Sort that table by kind and a pattern jumps out. Syntax barely features — two CS0542s across fourteen parts, both fixed in seconds, is the entire compiler-error tally. Where the AI actually failed was your context: business rules (the queue order lived in the spec, not the code), time (whose "today"?), auth reality (which connection carries which cookie), scope (what "version 1" means). The training data taught it the world's code; nothing taught it your clinic. And notice the repeats — the same CS0542 twice, the same confident tone before and after every mistake. It doesn't learn your lessons between sessions. You have to carry them.
What the AI got wrong: this whole post, condensed — almost never the syntax, reliably the context. Every mistake worth logging was about our rules, our timezone, our auth, our scope. That's not a flaw to wait out with better models; it's the permanent shape of the division of labor. The context is your job.
What the AI was brilliant at
Fairness cuts both ways, and the wins were not small:
- The scaffold. A complete Blazor Server solution with Identity, wired and running, in minutes. Nobody types that faster.
- The translation work. Spec to DDL, schema doc to EF Core entities, requirements to EditForms — mapping one precise representation onto another is its native gear.
- The test harness. The whole Testcontainers rig, and when told "no
mocking library", a hand-written 30-line no-op
IHubContext— a genuinely tasteful choice. - The runbook. Part 12's DEPLOY.md, 2am checklist included, is better deployment documentation than most funded products ship.
- Explaining every error instantly. CS0542, "pending model changes", the 401 loop — each diagnosed and explained in seconds. As a tutor sitting inside your terminal, it has no precedent.
Model pick, the series rule: Opus-class where mistakes compound — the spec, the schema, the real-time design; Sonnet-class where the path is well-worn — the scaffold, CRUD, tests; cheap models for the mechanical. Fourteen parts never needed the rule revised: match spend to the consequence of error.
Saying "I built it with AI" in an interview
Done wrong, it sounds like a confession. Done right, it's a hiring signal — and the difference is entirely in the story you can tell. Here's the ClinicLive version: the spec came first, and the AI interviewed me before writing it. Every prompt is recorded in a commit message, so the process is reviewable end to end. The tests were written from the spec, not from the code — and I can explain the tautological-test trap that rule prevents. A hostile review pass caught open self-registration before it shipped. I read every diff.
That story demonstrates spec thinking, review discipline, testing judgment and security awareness — the things interviews are trying to detect. The fear behind the question was always "can this person function without the tool?", and a story about directing the tool answers it better than pretending you don't use one. If interviews are on your horizon, the interview prep hub is built for this, and the AI interview series' prompting part turns this series' habits into answers you can give under pressure.
Keeping sharp
The whole series' discipline, compressed to four lines worth pinning above your desk:
- Read every diff. No exceptions, no "it's probably fine".
- Hand-write something weekly. The day you can't write it is the day you can't review it.
- Own the spec. Deciding what "correct" means is never delegated.
- Never ship what you can't explain. If you can't explain it, it isn't yours yet.
Checkpoint, the last one: you've shipped a real app with AI — spec to schema to SignalR to a VPS, tested against a real database, hardened, deployed, and honestly accounted for. That's not a tutorial completed; that's a capability. Here's what to build next: something of yours, same discipline, prompts in the commits.
Where next 🎉
Fourteen parts, one app, $6.20. If this series left you wanting to go deeper rather than wider: the Blazor series builds the UI-side fundamentals this series moved fast over, and the PostgreSQL series gives the database the attention it deserved here. And if the commit-messages-as-prompt-log trick appealed to you, that only works when git is second nature — the Git & GitHub workshop starts from the very beginning.
Got a war story — an app you built this way, a mistake your AI made that belongs in somebody's table? Tell me through the contact page. I read every message, and the best stories become posts.
The models in this series will be museum pieces in three years. The discipline won't: own the spec, read the diff, define correct, explain what you ship. The tools multiply judgment — so grow the judgment, and let them multiply it.
Thanks for building all fourteen parts with me. Now go build something of your own. 🤖