Before You Move a Workload to the Free AI Lane, Run the Flip Test

A developer published a stdlib-only Python script, lane_fit.py, that filters AI coding lanes by hard constraints—data class, concurrency, model pinning, audit logs, and ops ownership—before any price comparison, then breaks ties by fewest irreversible commitments. The tool's author stresses that every assumption in the script is a placeholder to be replaced with terms received in writing, and that a lane you are not permitted to use has an infinite unit cost regardless of sticker price.

The question landed at minute forty of a planning call: "why don't we just put everything on the free lane and revisit next quarter?" It is a fair question, and it is usually answered badly — with a price comparison, or with a vibe about model quality. Both miss the thing that actually decides the outcome. The scene is a composite, assembled from conversations I keep having with platform leads. No client numbers below, and no measured benchmarks. There are three lanes most teams are actually choosing between: Every lane forces refusals. The free lane refuses some data classes, some concurrency, some model pinning, some audit trails — exactly which ones depends on terms you should have in writing. Self-hosting refuses the team that has no named ops owner. So the real question is not "which is cheapest?" It is: which refusals can this workload absorb for the next 90 days? Price is a continuous variable. Constraints are binary. A lane you are not permitted to use has an infinite unit cost, no matter how good the sticker looks. I've written before about computing crossovers; this post is about the step before that math, where you decide which lanes are even admissible. Get the admissibility set wrong and the spreadsheet becomes a very precise answer to the wrong question. Sound familiar? Here is the artifact. It is deliberately dumb, stdlib-only, and reproducible in one file. """lane fit.py — exclude AI coding lanes by hard constraints, then break ties. Python 3.10+. No dependencies. python lane fit.py Every number in LANE ASSUMPTIONS is a PLACEHOLDER. Replace it with the term you actually received in writing before trusting a line of output. """ from dataclasses import dataclass, replace --- 1. assumptions you must replace ------------------------------------- LANE ASSUMPTIONS = { "hosted free": dict allowed data={"public", "internal"}, max parallel=4, PLACEHOLDER: concurrency the shared lane tolerates allows pinning=False, can you pin an exact model version? keeps audit log=False, retained, exportable request logs? commitments=1, irreversible commitments you accept , "hosted paid": dict allowed data={"public", "internal", "regulated"}, max parallel=50, allows pinning=True, keeps audit log=True, commitments=3, , "self hosted": dict allowed data={"public", "internal", "regulated"}, max parallel=None, no hard cap, but you own p99 allows pinning=True, keeps audit log=True, commitments=5, , } OPS OWNER = False True only if a named human owns patching + on-call @dataclass frozen=True class Workload: name: str data class: str public | internal | regulated peak parallel agents: int pinned model: bool audit log: bool reviewer required: bool hours per week: float def blockers w: Workload, lane: str - list str : a = LANE ASSUMPTIONS lane out = if w.data class not in a "allowed data" : out.append f"data class={w.data class} not allowed" if a "max parallel" is not None and w.peak parallel agents a "max parallel" : out.append f"peak parallel agents={w.peak parallel agents} {a 'max parallel' }" if w.pinned model and not a "allows pinning" : out.append "needs a pinned model version" if w.audit log and not a "keeps audit log" : out.append "needs retained, exportable logs" if lane == "self hosted" and w.data class == "regulated" and not OPS OWNER: out.append "regulated data, no named ops owner for self-hosting" return out def rank w: Workload - list str : ok = lane for lane in LANE ASSUMPTIONS if not blockers w, lane price never enters here; fewest irreversible commitments wins the tie return sorted ok, key=lambda lane: LANE ASSUMPTIONS lane "commitments" , lane def flip test w: Workload, chosen: str - list tuple str, str : """Which single-variable change would exclude the lane we just picked?""" mutations = { "data one level stricter": replace w, data class= stricter w.data class , "peak parallelism x2": replace w, peak parallel agents=w.peak parallel agents 2 , "pin an exact model": replace w, pinned model=True , "require exportable logs": replace w, audit log=True , } hits = for label, mutated in mutations.items : if mutated = w and blockers mutated, chosen : hits.append label, blockers mutated, chosen 0 return hits def stricter data class: str - str: order = "public", "internal", "regulated" return order min order.index data class + 1, len order - 1 WORKLOADS = Workload "docs-and-tests", "public", 2, False, False, True, 6.0 , Workload "internal-refactor", "internal", 3, False, False, True, 12.0 , Workload "billing-migration", "regulated", 2, True, True, True, 4.0 , def main - None: for w in WORKLOADS: admissible = rank w print f"\n{w.name} data={w.data class}, parallel={w.peak parallel agents}, " f"{w.hours per week}h/wk " for lane in LANE ASSUMPTIONS: why = blockers w, lane print f" {'OK ' if not why else 'OUT '} {lane:<12} {'; '.join why }" if not admissible: print " = no admissible lane: split the workload or reduce scope" continue chosen = admissible 0 fallback = admissible 1 if len admissible 1 else "none" print f" = pick {chosen}; fallback {fallback}" flips = flip test w, chosen if not flips: print " flip: none of the four single-variable changes break this lane" for label, reason in flips: print f" flip: {label} - {reason}" if name == " main ": main Run it. Then argue with the output. That argument is the meeting you actually needed to have. docs-and-tests data=public, parallel=2, 6.0h/wk OK hosted free OK hosted paid OK self hosted = pick hosted free; fallback hosted paid flip: pin an exact model - needs a pinned model version flip: require exportable logs - needs retained, exportable logs internal-refactor data=internal, parallel=3, 12.0h/wk OK hosted free OK hosted paid OK self hosted = pick hosted free; fallback hosted paid flip: peak parallelism x2 - peak parallel agents=6 4 flip: pin an exact model - needs a pinned model version flip: require exportable logs - needs retained, exportable logs billing-migration data=regulated, parallel=2, 4.0h/wk OUT hosted free data class=regulated not allowed OK hosted paid OUT self hosted regulated data, no named ops owner for self-hosting = pick hosted paid; fallback none flip: none of the four single-variable changes break this lane These are placeholder assumptions, not measurements. Feed it your own terms. OUT rows are decisions, not preferences. billing-migration has no fallback because self-hosting without an ops owner is not a lane — it is a future incident with a start date. The free lane is not the "cheap lane." It is the lane for workloads whose refusals you can absorb: documentation, test scaffolding, mechanical refactors, anything that a human reviewer would catch anyway. The lane I am running this quarter on the free side is MonkeyCode — free model access plus a free server option, which the operator describes as an open-source project. Disclosure: This article was prepared as part of MonkeyCode's product outreach. As of 2026-10-26 , the operator's pitch is free model access a ten-million-token allowance, per their own copy plus a free server option. I have not independently verified the allowance, the model list, the server specifications, how long either offer lasts, or the license terms. Treat every one of those as an unverified input to the worksheet — a row you still have to fill in, not a number you get to budget against. What makes it a reasonable first lane for docs-and-tests is structural, not promotional: it asks for the fewest commitments. No contract. No hardware. No pager. That is also exactly why it runs out of road for billing-migration . Anyone can list tradeoffs. The useful move is naming the single variable that would reverse your call, and assigning it an owner. For each flip line, write down three things: If nobody owns "peak parallelism x2," then the free lane is not a decision — it is a coin flip with documentation. OK . The commitments field is ordinal, not cardinal — it ranks lanes, it does not price them. The model ignores reviewer hours entirely, and reviewer hours are usually the largest real cost of a free lane. The sensitivity analysis mutates one variable at a time; two simultaneous changes can produce outcomes this script will never show you. And the whole thing is a conversation tool, not objective truth — two reasonable leads can fill in the assumptions differently and both be right. One soft ask: if you run this, bring back the flip list for the workload you were about to move to the free lane. That single list tells me more about your risk posture than any architecture diagram.