Thirty years shipping product.
Ten weeks shipping code.

I grew up less than a mile from the Boys & Girls Club in Royal Oak, Michigan. I started going at six and spent most of my childhood there. The club shaped me. The coaches, the programs, the structure, the simple fact of somewhere to be. I owe a lot of who I am to that incredible organization and the adults in it.

A couple of years after I started, a Commodore VIC-20 showed up. I never knew where it came from. I’ve always assumed it was a board member who bought it out of pocket and donated it, hoping a machine like that might do something good for the kids who came through the door. It ran about $300 at the time, close to a thousand dollars now. The staff set it up in the game room, left it turned on, and let anyone who was curious sit down at it.

Almost no one in the country was computer literate then. Not the staff, not our parents, not our teachers. There was no one to teach us because there was barely anyone who knew. What the club had was the instinct to put the machine where kids could reach it, and the patience to let us make a mess of it.

So a handful of us taught ourselves, entirely by trial and error, which at that age is indistinguishable from play. Ten lines of BASIC to make your name scroll down the screen forever. Then we got ambitious and built a choose-your-own-adventure game. Pure text, if/then logic, maybe forty lines. I remember it feeling impossibly sophisticated. It felt like magic, and more than that, it felt like something I had made. I was eight years old and I had just become a builder.

I think about that room constantly right now.

I’ve spent thirty years in product. I was a political science major. I have no computer science background and never wrote production code in my career. And for the last stretch I’ve been building real software with Claude Code, in English, at a speed that would have been a fantasy two years ago.

A lot of what comes back at me is still a foreign language. I don’t always know what I’m looking at. But I’m learning exactly the way I learned on that VIC-20. Try it, break it, read the error, try it again. I have not enjoyed work this much in a very long time.

Almost nobody is fluent in this yet. That’s not a gap to be embarrassed about, it’s just what the front edge of a technology feels like, and it doesn’t last long.

I don’t know who bought that VIC-20. They couldn’t have known what it would turn into, and they almost certainly never found out. They just thought it might be good for some kids in Royal Oak.

If you’re waiting until you understand it before you start, you have it backwards. I never understood any of it at first. I just kept typing.

Read the post on LinkedIn ↗

Every AI feature carries a marginal cost on every single interaction. It scales with conversation shape rather than user count, it is dominated by what you send rather than what the model says back, and it is invisible until you instrument it. I deferred measuring MotorAdvisor’s until the product had enough shape to be worth optimizing. This is what I found.

The unit. One complete demo transaction, four user turns: symptom, book a leak inspection ($90), add an HVAC diagnosis ($180total), quote a compressor. Every figure below is the API’s own usage accounting, captured in the production agent loop against live data, 18–19 August 2026. Pricing at list.

Baseline: $0.715, and no caching at all

Four user questions became twelve model calls, because an agentic loop re-sends its growing context on every internal step. Input was 98% of tokens and 91% of cost; all output together came to $0.066. Roughly 6,900 tokens of identical tool schemas and system prompt were re-billed at full price twelve times, about 83k of the 130k input tokens. cache_read_input_tokens was zero on every call.

Optimization 1 — prompt caching: $0.270, −62%

Two cache_controlbreakpoints per request: one on the system block, which caches tools plus system prompt, and one on the final message’s last content block, so each loop iteration and each following turn reads the conversation from cache. About 30 lines behind a pure request-builder, plus six tests.

Full-price input tokens fell from 129,936 to 20. Normalizing for path variance between runs, the like-for-like reduction is 52%. Responses ran roughly 27% faster as a side effect. No quality trade of any kind.

Optimization 2 — AI Gateway: $0.265, flat

Routing the same calls through an AI Gateway saved nothing, and it should not have. Cost-based provider routing ranks providers serving the same model, and Anthropic-family providers price Claude within a rounding error of each other. Cross-provider price arbitrage is real for open-weight models and close to nil for frontier proprietary ones.

What the gateway does buy is a failover surface, per-app spend tracing, and an answer to what happens during a provider outage. It runs with the app’s own provider key on each request, so inference bills the existing account at zero markup. Prompt caching passed through byte-identically. One sample showed a latency premium; a single sample is an anecdote, not a finding.

I am documenting a flat result because the alternative is crediting infrastructure with savings it did not produce.

Optimization 3 — model-tier routing, quality-gated: $0.168 shipped

Switching to a cheaper model is the most common cost lever and the least examined one. “It scores 95% of the frontier model on a public benchmark” is a hope, not a decision. So the gate came first.

Hard gates, binary, on structured tool traffic, any failure disqualifying: turn 1 yields the two-inspection menu with no total; turn 2 maps the booking phrase to exactly one application id and returns $90.00; turn 3 carries two ids and returns $180.00; turn 4 re-calls in quote stage and surfaces compressor candidates. The model never computes money — the upstream data service does — so accuracy for a model swap means does the cheaper model drive the tools identically.

Soft gates covered style. Latency was measured as medians and ranges across five runs per arm, with time-to-first-token tracked separately from wall time.

Time to first token was statistically identical: Opus 2,274ms median (n=32) against Sonnet 2,262ms (n=37). Wall time improved about 16%. Every money-critical behavior held in every arm, including the hybrid’s $90 and $180 bookings, which were Sonnet turns.

The gate caught exactly one real deviation, and it was style: Sonnet ended booking turns with an invitation rather than the specified next-step question. One added prompt line fixed it. Re-gating through the shipped code across three runs: hard gates 3/3, router placement exact in every run, question-form endings recovered to 8 of 9 booking-adjacent turns from 2 of 10 before the fix. One residual slip in nine, reported rather than rounded away. Median cost $0.168.

What shipped: a deterministic modelForTurn() router in application code. Three mechanical booking-message forms route to Sonnet 5, everything else to Opus 5. Unit-tested, environment-overridable, one model per turn, because a mid-turn switch would thrash the model-scoped cache.

What did not ship:all-Sonnet routing, worth another 20%, until the gate covers ambiguous vehicles, tool-error recovery, and off-script questions — where the more capable model is likeliest to earn its premium. The savings envelope is known. The license to take it is not yet earned.

Where the model decision actually lives

The most useful thing I learned has nothing to do with cost. Nothing in the stack picks your model for you. The API runs whatever you name. The gateway selects a provider for the model you already named and can substitute a pre-authorized fallback, but only on failure — never because a turn looked easy or expensive. Per-turn model choice is product logic. It belongs in application code where it is deterministic, testable, and visible in a trace.

Cumulative

$0.715 → $0.168 median, a 76% reduction, with zero measured quality given up because every step was gated. Against a $180diagnostic ticket that is under 0.1% of ticket value. Each loop — instrument, measure, change one variable, re-measure, document — took an afternoon or less.

Read the essay on LinkedIn ↗