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

Home. Part 2's phone and browser frames beside Part 10's desk frame — dark because the desktop's OS theme is, and the tokens follow it. Same component; only the width and the host's answers change.

Phone

Desk

Browser

The capability-interface pattern, photographed: one Settings.razor asks IPlatformInfo where it is and prints the answer. The Windows frame is from Part 5 — the phone-layout-on-a-monitor era — and it shows.

Phone

Desk

Browser

The waiting room, Part 10: Ava C. being served, Noah B. next, on all three — the desk and the browser both wearing the rail that one 900-pixel media query hands to anything wide enough.

Phone

The wall TV

Part 3's moment: Maria checked in from a phone and appeared on the TV built two seasons earlier, because the app's check-in is literally the kiosk's method. That Refresh button died in Part 4.

Part 5

Part 7

Part 8

Permission in context, three times: notifications at check-in, location on "Use my location", the camera on "Scan my ticket". Never at launch. The dialogs are Android's; the timing is ours.

Before the fix

After

Part 4's evidence. Left: a full minute after the server came back, the default reconnect policy had given up for good. Right: the keep-trying policy — 2, 4, 8, 16 seconds, then every 30, never null. A browser tab gets refreshed; a phone in a car park doesn't.

The ticket

The scanner

Part 8: a QR on the ticket and a native ZXing page pushed over the Blazor WebView. The camera is looking at the emulator's virtual living room, not at a ticket — more on that below.

Offline

Back online

Part 9: a code in the keystore, a queue state cached with the time it was true. Stale means read-only — you can see the button but you can't press it.

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:

What each part of the companion app cost in API spend (cumulative)

💸 The meter, final reading: ≈ $7.20 for the whole companion app — nine capability interfaces, three hosts, real push, real haptics, a real scanner, offline, a signed build and CI. Season one's $6.20 built ClinicLive; season two's $3.60 designed it; $7.20 put it in a pocket. Seventeen dollars for the trilogy. The two big dead ends — Part 5's toast chase and Part 8's poster hunt — are in that number; everything else was proportionate.

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:

What the AI got wrong, part by part

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 got wrong, the season in one sentence: it knew the APIs and not the platform. It wrote NotificationCompat from memory and didn't know a force-stopped app never receives a push; it wired a ZXing camera view in an afternoon and didn't know the emulator couldn't show it a poster; it signed an APK and didn't know apksigner exits non-zero on success. Platform knowledge only comes from being bitten — and a bench, a log and a skeptic are how you get bitten on purpose, cheaply, before a patient does.

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.

🧠 Model pick, the season's rule: Opus wherever the question was about semantics — foreground versus background versus stopped, what "resumed" must mean for a socket, whether stale data is read-only, what not to fake; Sonnet wherever Essentials or a documented toolchain did the heavy lifting — geolocation, storage, CSS, signing, YAML. Same principle as the two seasons before, on a new axis: in a mobile app, the consequence of a cheap-model mistake is a notification that never arrives.

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

Two of the three, exactly as they happened. Left: the season's only full-screen Windows capture — taken with the app maximized so nothing else could be in frame — and the banner that isn't in it. Right: Maps, resolved and crashed. The third has no picture, which is rather the point.

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.

✅ Checkpoint, the last one: you've now shipped a companion app, not a demo of one — shared screens on three hosts, nine capabilities answered honestly, a live queue, push to a closed phone, haptics proven by the kernel, a QR pipeline proven by a test, offline that tells the truth about its age, a signed build and CI. And you know exactly which three things it can't yet prove. Here's what's next: pick one screen of an app you own, put its native needs behind a capability interface, and run it in a second host. You'll meet your first edge within the hour — write it down.

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. 📱

Originally published at coder000.com. Part of the series From Prompt to Pocket — read the whole series there.