The Pocket Retro: What a Companion App Really Costs

Eleven parts ago, ClinicLive lived on a kiosk and a wall. This season made the trilogy's third promise: put it in the patient's pocket with AI assistance and hide nothing — every prompt verbatim, every native feature behind an interface each host answers honestly, every screenshot from a real emulator or a real desktop, every dead end kept in. The meter has stopped. Time to look at what we made, and at what we couldn't prove.

The gallery

This is the payoff post, so the pictures go first. The season's claim was one set of screens, three hosts, so wherever the bench allowed it, a row is the same Razor component photographed on a phone, on a desk and in a browser.

Phone

Desk

Browser

Phone

Desk

Browser

Phone

Desk

Browser

Phone

The wall TV

Part 5

Part 7

Part 8

Before the fix

After

The ticket

The scanner

Offline

Back online

The bill, honestly

Same rules as season one's retro and season two's: cumulative API spend from the build log as each part landed. Part 1 was the plan, with no commit, so it rides inside Part 2's reading:

How the meter is measured: the build's actual token consumption priced at the API list rates of the models used (the 🧠 boxes name them). On a subscription plan your bill won't literally say $7.20 — but the tokens burned are the same, so it's the honest apples-to-apples number.

And the caveat, one last time, because it was truer this season than either before: the dollars are not the real cost. The real cost was the bench — a GPS fix to fake, airplane mode to toggle, a vibrator log to read, a Firebase console to watch, a desktop to photograph without photographing anything else. The meter bought code; the proving is where the season went.

The complete mistake log

Every 🤖 from eleven parts in one table, including two that were about the process, not the code:

Read the right-hand column and a third pattern appears. Season one's mistakes were about context — your rules, your timezone — and were caught by reading code against a spec. Season two's were about looking, and the screenshot loop caught them. This season's were about the platform underneath the code: insets, stopped states, package visibility, MAX_PATH, restore semantics, exit codes. Almost none are visible in a diff, and a screenshot alone often wasn't enough either — the catch needed a screenshot plus a skeptic: a gray frame that was only a dimmed emulator, a "1 delivered" that meant nothing, an exit code that lied in both directions. The two process rows cost no tokens and taught the most: a screenshot harness needs a privacy guard, not just a crop, and it must never touch a window it didn't open.

What the AI never caught alone

The table undersells the human half again, because the biggest contributions were decisions, and this season they lived in the prompts. Two verbs of haptics, because an app that vibrates for everything gets muted. Permission at check-in, never at launch. "A second front door must not grow a second set of rules." "The code is the credential." "Stale means read-only." "Prove as much as the bench allows" and its twin, "fake nothing." Each was a sentence a person wrote before the model started, and each would have shipped as something plausible and worse without it. The two process incidents were human catches too: the model doesn't know what else is on your desktop, or whose Notepad that is. And Part 7's wrong "known distance" was caught by a test the model wrote but decided by a human working the numbers by hand — a failing test is a question, not an order.

What the AI was brilliant at

Fairness cuts both ways, and this season's wins were the biggest of the three:

• The capability-interface pattern, nine times over. From IPlatformInfo to IAppStorage, each a small interface in the shared project, answered by MAUI next to the platform it talks to and by the web host honestly — null, false, "not here". Introduced once in Part 2, never bent, so the screens never learned which host they were on.
• Diagnoses that would have cost a person a day. Safe-area insets reading zero inside a WebView. A 270-character path killing a Windows build. Android 11's package visibility. The AndroidX version dance. Each named from a screenshot or a build log of the symptom.
• Proof by other means. When the emulator couldn't be shown a QR, it proposed the test that decodes the server's PNG back through the parser — the whole chain except the lens. When no screenshot can show a vibration, it went to the OS's vibrator log: 182 ms, 102 ms, 403 ms. It looked for evidence instead of settling for a claim.
• Honest no-ops. "iOS: not built here." "Windows: no push." "Browser: not a scanner." The season's least glamorous code and its most trustworthy.
• The runbook. docs/pocket.md, written in the same session as the code it describes — the only time anyone ever writes one.

The three things the bench couldn't prove

Every part photographed what it claimed, and three claims could not be photographed. They belong together, so nobody has to hunt for them:

1. Windows toast notifications never displayed. Not in Part 5, not in Part 10, not from Part 11's published build. Registration succeeds, the OS setting says Enabled, Show() returns, and no banner appears. The cause is app identity — the unpackaged build has none — and the fix is MSIX packaging or an installer-made shortcut with an explicit AppUserModelID, neither of which this series demonstrates, because sideloading an MSIX means trusting a home-made certificate. The Windows app says "Allowed" and shows nothing. That's the honest state.
2. No on-device QR decode was photographed. The emulator never rendered its virtual-scene posters, so the scanner was only ever pointed at a virtual living room. The chain — the server's PNG, read by ZXing back to cliniclive://visit/CODE, through the parser — is proven by TicketQrTests, which runs in CI. Everything except the lens.
3. Google Maps crashed on the emulator. After the package-visibility fix the directions intent resolved and Maps launched — then died, the emulator's stale Maps build without a Play sign-in. What we control worked; what a real phone does next was not shown.

Windows: Allowed, nothing shown

The emulator's Maps

Was Blazor Hybrid the right bet?

Part 1 made the case before any code existed: for a companion to an existing Blazor product, the screens would be the cheap part and the platform edges the whole cost, so sharing the screens would pay for itself. The retro gets to check it.

The screens were cheaper than cheap. Five pages written once; the Settings triplet above is the proof they never learned where they were. Season two's tokens carried straight over, dark mode included. The waiting-room page was forty lines because the live plumbing already existed. And the party trick paid off exactly where it mattered: a native camera page pushed over the WebView, because the WebView is just one page in a native app.

The edges cost what edges cost, and the table above is that bill: insets CSS can't see, a status bar the tokens can't reach, a cold start three and a half seconds slower with the SignalR client, a 33.8 MB APK and a 235 MB Windows folder, the AndroidX version dance, toasts that need an identity, iOS compiling but never built for want of a Mac. None of that is Blazor's fault — and, the honest point, none of it would have been avoided by going native. A Kotlin app meets package visibility and the stopped state too; a WinUI app meets the same identity rule. Native would have paid the same edge bill and rebuilt the screens, three times.

So: yes, for this app — a small team, an existing Blazor product, screens that are forms, cards and one big number. Where the bet goes the other way: an app whose product is the camera, or gesture-heavy motion, or platform idioms polished enough to sell a store listing. There the WebView is the wrong stage and shared screens the wrong savings. Know which app you have before you place it.

The tests postscript

The number that grew all season: 9 tests from season one, 13 after Part 3's API tests against a real Postgres, 15 after Part 6's push test with a fake sender, 20 after Part 7's haversine, 28 after Part 8's QR round-trip and parser — and 28 green through Parts 9, 10 and 11, which changed nothing the tests can see. Two of them caught the AI red-handed: the wrong "known distance" and the regex that let a banned letter back in. The harness built in season one is now what lets a phone, a desk and a browser share one set of rules without anyone re-checking them by hand. Three seasons in, the compounding return on those first nine tests is the least surprising and most useful fact in the trilogy.

Where next 🎉

Twelve parts, one companion app, $7.20. The whole three-season arc — every prompt, every tag, every honest screenshot — lives in the ClinicLive repo; the README's season-three table maps pocket-02 through pocket-11 to their parts, and docs/pocket.md takes you from a fresh clone to a signed APK.

If you arrived through the pocket door, the story starts two seasons earlier: From Prompt to Production, Part 1 builds ClinicLive from a spec to a VPS, and From Prompt to Polish, Part 1 makes it something people would want to use. The full catalog of everything on this site is on the series page.

And that's the trilogy complete. Season one proved AI can build software with you. Season two proved it can design with you, steered. This season proved it can reach the parts of a product that live on someone else's operating system — and that the steering matters more there, not less, because the mistakes are no longer in the code where a diff can show them. A prompt that says what not to fake. A bench that toggles airplane mode. A log that keeps the dead ends next to the wins. A skeptic reading the exit codes. The tools got the app onto the phone; the honesty is what makes it worth trusting there.

Thanks for coming all the way — three seasons, thirty-six parts, one clinic. If any of it helped you ship something, or you hit an edge this series didn't, the contact page is open and I'd genuinely like to hear about it. Now go put something of yours in someone's pocket. 📱