Commercial vs free models for coding assistants: reliability and exit strategy

Here's the rule: put both paths behind one adapter, throw the same failure list at each, and let whichever degrades safer become the default. Cost only breaks ties.

"Commercial versus free" hides three things: a paid API sells inference plus a service contract, a free hosted tier is that service with the meter turned down, and an open-weight model is an artifact, license aside, that someone still pays to run. Run it yourself and a token invoice becomes hardware, electricity, and maintenance hours nobody scheduled.

For a coding assistant the unit worth measuring is a reviewed change that clears the repo's own test suite, built from repo evidence, issue text, tool output, and diffs. The costly failure looks nothing like a refusal: a patch that compiles clean and quietly breaks a contract nothing in the prompt mentioned, and a pricier call that lands once beats a cheap one that fails validation.

the outage and the dead GPU are not the same risk

Reliability means dependency failure, model retirement, version drift, capacity, and recovery time, not what a pricing page implies. List price per token and tokens per second are diagnostic, not business outcomes: track cost per accepted task, p95 latency, failure severity, and human attention per route. Pit a local open-weight coder against a metered commercial API, real IDs and prices, then drop both from the permanent rule: catalogs reshuffle, allowances get pulled, and last year's weights have a better quant somewhere.

Feed both routes the same evidence and acceptance bar, let each keep its own prompt template and API, and count any integration one side gets for free. Then break each path on purpose: cut the provider, pull the host, hit the rate limit, retire the model, time the restore. Grade the result against tests and diff review, and label every failure, missing evidence, a bad instruction, broken structure, wrong reasoning, or a tool error, so you can route later. A local model can be flawless on routine work and fall apart only once ambiguity crosses a line you can now name.

"Free" and "commercial" are procurement labels; they don't tell you what breaks or when.

paying for uptime you can't build yourself

Commercial earns its place when the provider hands you availability and support you couldn't reproduce on your own budget, not because it topped a leaderboard. Put a cheaper commercial tier in the comparison and cap the reasoning effort first: capacity only pays off when it removes real work your team would otherwise do.

Free or open-weight earns its place when offline operation, pinned versions, and independence from someone else's account are real requirements, and the case strengthens with steady, narrow workloads. It weakens fast once the model barely fits, reloads constantly, or needs a runtime only one engineer understands, the same case for a local-first cascade, not one model alone. Spare hardware isn't free either, if another job loses its slot whenever you use it.

The mistake I see most is a silent fallback that quietly changes privacy, cost, or behavior mid-incident. Build the exit first: one adapter for provider handling, prompts and schemas in version control, job state outside any vendor's thread object, and contract tests for streaming and token accounting per route. If the commercial API goes dark, a local model as a degraded mode is fine if users are told; if local capacity runs out, quietly sending data to a remote provider is a breach with a good excuse, so privacy rules run before capability routing.

Re-run the comparison whenever traffic, prices, licenses, or review practice moves: a choice right at ten thousand tasks a month can be wrong at a hundred thousand, a model that failed last year might pass today on a better quant, and a free tier can vanish with no warning. What I accept on purpose is running a commercial route and a local model side by side for the workloads that need both: two adapters to maintain, two failure modes to keep straight, and no vendor left to blame when either breaks.