What Building a Real App with AI Actually Cost: 36 Parts, Three Seasons, About $17

The Trilogy at a Glance

Three seasons, thirty-six parts, one clinic app - and a meter that ran the whole time. Every part of the ClinicLive trilogy ended with a 💸 box, every retro added its season up, and every number came from the build log rather than from memory.

Building ClinicLive with Claude Code cost ≈ $17.00 of API spend across 36 parts and three seasons: $6.20 for a shipped Blazor Server app, $3.60 for its redesign, and $7.20 for a .NET MAUI companion app on three hosts - with 28 tests green at the end and three public tag ranges in the repo so you can check out any moment of it.

One caveat before anything else, in the words of the footnote every retro carries: on a subscription plan your bill won't literally say $17 - but the tokens burned are the same, so it's the honest apples-to-apples number.

The Meter, All Three Seasons

Here is every reading on one chart. The top row is what each part added; the bottom row is the trilogy's running total, which starts at forty cents for a spec and stops at seventeen dollars for a signed APK.

• Season one: 14 parts, $6.20
• Season two: 10 parts, $3.60
• Season three: 12 parts, $7.20
• The running total climbs from $0.40 at season one's spec to $17.00 at season three's ship-it part.
• The most expensive single reading is season three's Parts 1 and 2 together, at $1.30.

Three things jump out before any table:

1. No part cost more than $1.30, and most cost less than a dollar - the tallest bars are the parts that opened a season, where the architecture decisions and a lot of screenshots happen at once.
2. The seasons are more alike than different: the redesign was the cheapest, but not by the margin "it's only CSS" would predict, because a model looking at screenshots is burning image tokens.
3. The dead ends are in there. Season one's failed first chat design, season three's Windows toast chase and its forty-minute hunt for a QR poster the emulator never drew - all billed at the same rate as the features, and all left in the number on purpose.

Season by Season

Everything above "Per part" divides by every part of a season, including the ones that built nothing - the intros, season one's power-moves tour, and the three retros. Divide by the parts that actually moved the meter and the numbers are $0.62, $0.40 and $0.72. Either way, the honest unit is "less than a coffee per part."

Where the Numbers Come From

Three retros, reconciled:

• Season one's retro lists a running total for each of Parts 3 to 12, and the build log agrees with it to the cent.
• Season two's retro merged Parts 1-2 and 3-4 into two rows because the log only recorded a reading at Parts 2 and 4; the per-part numbers for Parts 1 and 3 below ($0.40, then $1.30 on the running meter) come from those parts' own 💸 boxes, which the retro didn't repeat.
• Season three's retro has Part 1 riding inside Part 2's reading, because the plan had no commit and its smoke build landed in Part 2.

Nothing here is a new measurement - it's the same 29 readings, laid end to end.

Which Model Did What, and What the Split Cost

Every part opened with a 🧠 box naming its model, and the rule never changed across three seasons: Opus where a mistake would compound - a spec, a schema, real-time semantics, a diagnosis, a review - and Sonnet where the path was well-worn: scaffolding, CRUD, tests, CSS, a documented toolchain.

Model per part across all 36 parts, and what each part added

Season one · From Prompt to Production

Season two · From Prompt to Polish

Season three · From Prompt to Pocket

Add it up by lead model and the split is even in count and uneven in cost:

• Fifteen Opus-led parts cost $10.10, about $0.67 each.
• Fifteen Sonnet-led parts cost $6.90, about $0.46 each - $0.49 if you leave out season one's setup part, which cost effectively nothing.
• Six parts have no reading of their own.

So the thinking model's parts cost about half as much again, and less of that gap than you'd guess is the price list: the Opus parts were also the ones with the long design conversations, the failed first attempts and the most screenshots.

One honesty note about that arithmetic. The log records one reading per part, not one per model. Where a part used both - most of season three did - the whole reading is counted under the model its 🧠 box leads with, the one that made the part's defining call. That is a judgment, and season three's scanner part is the closest one.

🧠 The rule, unchanged for 36 parts: match the spend to the consequence of error, not to the difficulty of the typing. Season one put it as "where mistakes compound"; season two as "what is this surface?"; season three as "semantics - foreground versus background versus stopped." Same rule, three axes. It never needed revising, and the table above is the receipt.

What Caught the AI's Mistakes

The three retros keep a mistake table each: eight rows holding 14 mistakes for season one, 6 for season two, and 44 rows for season three, one of which is an honest "no code catch" rather than a mistake. The later two tables record what caught each one; season one's has no such column, so its 14 are classified here from the descriptions.

Tallied together:

The honest reading is that the tools people assume catch AI mistakes caught the fewest. The compiler and the build found ten of sixty-three, and most were fixed in minutes - CS0542 twice, an ambiguous View, a DLL lock, a runtime pack that doesn't exist. Tests found four, and three of those were the test being wrong rather than the code. The two catchers that found forty of the sixty-three were a screenshot and a person.

The screenshot loop found a sidebar on a TV, an error banner on every page, a status bar the wrong color, a phone that had quietly given up reconnecting - things no diff can show. A person found the rest, from a spec that invented SMS, to a palette that was a near-twin of the author's other project, to a captured desktop that should never have been captured.

Season one's shape is different for a reason: with no screenshot loop yet, its catches came from reading code against a spec, which is why "a human" carries nine of its fourteen.

Two fairness notes:

• Tests look weak in this tally and were the strongest thing in the trilogy: the nine written in season one stayed green through a redesign that touched every page, and the 28 at the end are why a phone, a desk and a browser could share one set of rules without anyone re-checking them by hand. Catching mistakes and preventing them are different jobs.
• Nothing in the table was free: screenshots are image tokens, and the person is not on the meter at all - which is the next section.

What the Money Did Not Buy

Human time is not on the meter. Say it plainly, because the $17 headline invites the wrong conclusion. The meter counts tokens; it does not count reading every diff before accepting it, pasting a schema into a review, judging four art directions, vetoing a palette, toggling airplane mode, reading a vibrator log, or looking at a screenshot before writing its caption.

Season one estimated its own wall-clock at roughly an hour of AI-assisted building against two to three days by hand - and even that hour sits beside the review time the retro called "the real cost," like the twenty minutes of human reading that Part 5 said was the most expensive thing in it. Seasons two and three never logged hours at all; their retros say where the time went instead: "most of it is the looking," and "the meter bought code; the proving is where the season went."

If you want a real cost per part, add your own hours to the $0.47.

The Bench

An Android emulator, a Windows desktop, a free-tier Firebase project, a PostgreSQL in Testcontainers, a Playwright harness that photographs every surface, and a screenshot script that learned - the hard way, twice - to refuse a frame it doesn't own. None of that is a token, and season three's retro is clear that the bench, not the model, is where that season went.

Three Things the Bench Couldn't Prove

1. Windows toast notifications never displayed: registration succeeds, the setting says Enabled, and no banner appears, because an unpackaged app has no identity and the series declined to fake an MSIX.
2. No on-device QR decode was photographed, because the emulator never rendered its posters; the chain is proven by a test instead - everything except the lens.
3. Google Maps launched and crashed on the emulator after the directions intent resolved.

Season three's retro keeps all three together, and $7.20 closed none of them.

What Was Never Built

• iOS compiles and was never built, for want of a Mac.
• Patient accounts and SMS, which the spec said no to in Part 3 and kept saying no to.
• A packaged Windows build.
• Anything a real phone does after the emulator's Maps died.

The Judgment

The most valuable lines in the trilogy were typed by a person before the model started, and cost nothing: the spec's non-goals; the rule that a test is written from the spec, never from the code; "who uses this surface, and what state do they find it in?"; "a second front door must not grow a second set of rules"; "stale means read-only"; "fake nothing." Each would have shipped as something plausible and worse without it. The dollars bought drafts; those sentences are why the drafts became an app.

How the Meter Is Measured

Every retro carries the same footnote under its bill, with its own season's number in it. Here it is exactly as season three's retro prints it - the 🧠 boxes it refers to are the per-part model picks summarized in the table above:

How the meter is measured: the build's actual token consumption priced at the API list rates of the models used (the 🧠 boxes name the