Should Your EM Graduate Off a Free AI Coding Lane? Use This 5-Gate Switching Card

If you cannot point to a kill date, you are not piloting a free AI coding lane. You are running a shadow default.

Picture a capacity review, not a model bake-off. Finance froze headcount. Platform dropped a self-host doc in the shared drive. The squad already pastes stack traces into whichever chatbot loaded first this morning. Sound familiar?

I do not start with which model is smarter. I start with which constraint would reverse the choice this quarter. Would you still keep the free lane if the kill date were next Friday?

This meeting is about switching cost

Seat licenses feel precise. They are not.

A paid seat you can turn off is often cheaper than a "free" lane nobody is allowed to kill. Self-hosting feels like control. It is also an idle bill: someone patches, watches the box, and answers "is it up?" at 6pm.

I use a 5-gate switching card. It is a conversation tool, not objective truth. If your team cannot argue with the inputs, do not trust the output.

The 5 gates

I score three destinations with the same five questions: keep a sanctioned free lane, buy a vendor lane, or self-host.

1. Boundary. Do prompts ever include non-public code, secrets, or customer data?
2. Idle. What do you pay when nobody is typing?
3. Switch. How many hours to leave without losing working context?
4. Skill-retention. Can the squad still ship if the lane dies on Friday?
5. Owner-expiry. Named owner, calendar kill date, written exit?

If gate 1 fails for a hosted free lane, I stop. Cash does not get a vote.

Variable definitions

Replace every number. The names are the method.

• B — boundary class: public_only, internal_ok, or customer_data
• H_idle — hours per week to keep a self-hosted lane healthy at zero use
• C_hour — loaded cost of the person who does that idle work
• P_seat — monthly vendor seat quote you actually have in writing
• N — people who would get a seat
• H_switch — hours to migrate prompts, policies, and "how we do this here"
• S — 1 if a named teammate can narrate and land a typical change with the lane offline
• O — 1 if there is a named owner
• E — 1 if expiry sits on a real calendar

Monthly idle drag of self-host, in cash terms:

IDLE = H_idle * C_hour * 4.3

Monthly paid cash:

PAID = P_seat * N

I do not convert skill-retention into a fake ROI. I treat S = 0 as a hard stop on expanding any lane, free or not.

Copy-paste policy, then a scorer

Write the exception down before anyone pastes a repo. YAML is enough. Put it next to the other platform policies, not in a chat thread.

# ai_lane_exception.yaml — worked example, not a standard
ai_coding_lane:
  status: exception
  destination_candidates:
    - sanctioned_free
    - vendor_paid
    - self_hosted
  owner: "platform-em"
  expires_on: "2026-10-18"
  boundary: public_only
  idle:
    max_hours_per_week: 2
    pager: "platform-em"
  exit:
    revoke_keys: true
    archive_prompts: true
    freeze_new_repos: true
  kill_triggers:
    - customer_data_in_prompt
    - owner_vacant_7d
    - expiry_with_no_renewal_note

Then run the numbers in the open, on a laptop, in the review. No dashboard required.

# switching_card.py
# Labeled example. Conversation tool, not a truth machine.

from dataclasses import dataclass

@dataclass
class Inputs:
    boundary: str          # public_only | internal_ok | customer_data
    h_idle: float          # hours/week to keep self-host healthy at zero use
    c_hour: float          # loaded $/hour for that work
    p_seat: float          # monthly vendor quote — replace with yours
    n: int                 # seats
    h_switch: float        # hours to leave the current lane
    skill_ok: bool         # can ship if the lane dies Friday
    owner: bool
    expiry: bool

def hard_stops(x: Inputs):
    stops = []
    if not x.skill_ok:
        stops.append("skill-retention: do not expand any lane")
    if not x.owner:
        stops.append("no owner: do not start or keep a lane")
    if not x.expiry:
        stops.append("no kill date: this is a shadow default")
    if x.boundary == "customer_data":
        stops.append("customer data: hosted free lane is out")
    return stops

def monthly(x: Inputs):
    idle = x.h_idle * x.c_hour * 4.3
    paid = x.p_seat * x.n
    return {"self_host_idle": idle, "vendor_paid": paid, "switch_hours": x.h_switch}

def suggest(x: Inputs):
    stops = hard_stops(x)
    if stops:
        return {"stops": stops, "call": "do_not_switch_yet"}
    m = monthly(x)
    # Heuristic, not a law. Move the 0.6 if your ops reality is different.
    if x.boundary == "public_only" and x.h_switch < 8:
        return {"call": "keep_sanctioned_free_as_exception", "math": m}
    if m["self_host_idle"] < m["vendor_paid"] * 0.6 and x.boundary != "public_only":
        return {"call": "self_host", "math": m}
    return {"call": "vendor_paid", "math": m}

if __name__ == "__main__":
    example = Inputs(
        boundary="public_only",
        h_idle=6.0,
        c_hour=95.0,
        p_seat=40.0,   # ILLUSTRATIVE — paste your quote
        n=8,
        h_switch=12.0,
        skill_ok=True,
        owner=True,
        expiry=True,
    )
    print(hard_stops(example))
    print(monthly(example))
    print(suggest(example))

Run it like this:

python3 switching_card.py
# then put expires_on on a calendar the owner actually sees

If you cannot run that in five minutes, you do not have inputs. You have opinions.

Worked example (composite, not a client)

Eight engineers. B2B product. The monorepo holds customer code. Finance wants "the free thing." Platform wants a box in the VPC. The squad wants whatever answers first.

I fill the card in the room:

Field	Value on the whiteboard	Why it is not a vibe
B	customer_data for the monorepo, public_only for a sample sandbox	Mixed boundaries are two lanes, not one
H_idle	6 hours/week	Patch, queue, "is it up?"
C_hour	$95 loaded	Staff-engineer time, not a cloud list price
P_seat	$40	Illustrative. Replace with the quote in your inbox
N	8	People who would actually get seats
H_switch	12	Prompt library, review rules, onboarding doc
S	unknown until a Friday drill	I do not assume yes
O	platform EM	If this is blank, stop
E	2026-10-18	Four weeks, then renew or kill

Do the arithmetic.

Self-host idle ≈ 6 × 95 × 4.3 = $2,451 / month before any model bill. Vendor cash ≈ 40 × 8 = $320 / month at the illustrative rate. The free hosted lane is $0 cash. It is also out for the monorepo under gate 1, because B = customer_data.

So the real choice is not "free vs paid vs self-host" as a slogan. It is a public_only sandbox on a sanctioned free lane, and a different destination for the monorepo. Would you still self-host if idle is six hours a week and paid seats are a few hundred dollars? I would not. Not this quarter.

Change one input. If they already operate a box and H_idle drops to 1, idle ≈ $408. Self-host starts to talk. That is the point of sensitivity. One field should be allowed to reverse you.

Hard gates, owner, expiry, exit

I write these as rules, not culture.

Hard gates

• Customer data or secrets in prompts → hosted free lane is out. No exception by enthusiasm.
• S = 0 after a Friday drill → freeze expansion on every lane.
• Vacant owner for 7 days → revoke.
• No expires_on → do not start.

Owner. One human. Not "platform." A calendar they look at.

Expiry. A date. Renewal needs a written note: which field changed, and which destination you are switching to.

Exit. Revoke keys. Archive prompts. Freeze new repos. Say out loud what you will forget — that is the switching cost you underpriced last time.

A scorecard that cannot kill the lane is a poster.

Where a sandbox free lane actually fits

I want a place to practice the card on sample code before anyone touches the monorepo. That is a different job from production coding.

Disclosure: This article was prepared as part of MonkeyCode's product outreach.

MonkeyCode is an open-source project with free model access and a free server option. I treat that combination as exception infrastructure: public or synthetic repos, a named owner, a kill date. It is one way to keep the sandbox off the customer boundary while you learn whether S is even true. It is not a reason to skip gate 1.

If the sandbox cannot expire, it is not a sandbox.

Who should not use this

Skip the card if you are shopping for a model leaderboard. Skip it if you need a permanent free production agent. Skip it if you cannot instrument idle hours, even roughly.

Regulated shops with a written data-residency rule already know gate 1. Do not dilute that rule with a spreadsheet. Tiny teams of two who share one laptop may not need three destinations. Name an owner and a date anyway. The meeting is still the same meeting.

Limitations

I did not benchmark models. I did not measure your token bill. The $40 seat and $95 hour are labeled placeholders, not market facts.

The heuristic that self-host "wins" below 60% of paid cash is an argument starter. Move it. If your ops hours are unpaid heroics, C_hour is a lie and the card will flatter self-hosting. This article will rot if you treat the worked numbers as research.

What would reverse you?

I end reviews with one question. Not "would you buy." Not "is free good."

Which single field — boundary, idle hours, switching hours, skill-retention, or expiry — would reverse your destination this quarter?

If you cannot name it, you are not deciding. You are hoping the shadow default holds.