DEV Community: bestbee

Should Your Platform Lead Default New Hires Onto a Free AI Lane? Use This Fit-or-Exit Card

bestbee — Wed, 23 Sep 2026 15:56:51 +0000

Two new hires start Monday. Paid AI seats are still stuck in procurement. The wiki already links a free coding lane.

Do you default them onto it?

I would not. Not without a fit-or-exit card. Free access looks like a gift to a joiner. It often shows up later as mentor overtime and a habit the squad never voted on.

The scene I keep replaying

Composite scene, not a named-client story. Six-person squad. Two joiners. One staff engineer who already reviews too much.

The joiners are not slow. They are fast in the wrong unit. Pull requests appear before they can name the invariant they touched. Mentors go quiet because the tests are green. Have you watched that happen in week one?

That is not onboarding. That is a cost transfer.

Here is the reversing constraint. If mentor hours are the scarce resource, a free lane that multiplies unverified diffs is more expensive than a paid seat that sits idle for two weeks.

Three placements, not two slogans

I score three placements. I do not score "AI versus no AI."

Free hosted lane. Fastest thing you can put in a new hire's hands. Cash near zero. Your data-boundary and uptime story now belong to someone else's product.
Self-hosted lane. Weights and logs stay inside a boundary you own. You also own the pager, the queue, and the "who restarts this" question.
Paid seat. Procurement, vendor terms, usually clearer retention. You pay even while the joiner is still reading the runbook.

An open-source coding assistant with free model access and a free server option sits in bucket one. Sometimes it is a bridge into bucket two if you later self-host.

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

MonkeyCode fits that first bucket: free model access, plus a free server option, which is useful when you need a bounded measurement lane before procurement moves. Useful is not the same as "make it the default." Strip the name out. The card still has to work.

Variable dictionary

Write these on a whiteboard before anyone debates vendors.

B — data-boundary allow. 0 or 1. Security or platform owns it.
M — extra mentor hours spent unsticking AI output, per joiner, per week.
N — share of the joiner's PRs they can narrate without the model. 0 to 1.
T — calendar days to the first change they own without AI as the author of record.
H — loaded hourly cost of a mentor.
P — paid-seat monthly cost. Finance replaces the placeholder.
S — self-host monthly cost, box plus toil.
E — expiry of the exception. A date, not a vibe.

If B is 0, stop. The rest of the math is entertainment.

A scorecard is a conversation tool, not objective truth. If your security lead disagrees on B, you do not average the disagreement. You halt the default.

The fit-or-exit card

Four questions. Each one can kill a placement on its own.

1. Boundary: can this joiner's work leave the trust zone?

Private source, customer records, unreleased schema: free hosted is ineligible. Public docs and secret-free internal tools: a pilot is allowed. Mixed work? Split the work. Do not split the policy.

I want this in the first-week checklist. Ugly. Readable.

# Labeled checklist. Not a security audit.
rg -n "AKIA|BEGIN PRIVATE KEY|api_key|SECRET" --glob '!.git' || true
echo "If this joiner's repo can trip the above, B=0 for any free hosted lane."

Policy PDFs do not catch a .env in a generated commit. This does, if someone runs it.

2. Narration: by day 10, can they walk a diff they shipped?

If N stays under 0.5, the free lane is teaching speed, not the system. Paid will not fix that. Self-host will not fix that. Freeze expansion. Pair.

PR template I want in the repo:

## Narration (required if an AI lane touched this PR)
- Invariant I changed:
- Failure I would have caused without this change:
- Test that would fail if I reverted the wrong hunk:
- What I did *not* let the model write:

If they cannot fill it, the PR is not late. The onboarding is.

3. Mentor-hour break-even: who actually pays?

Monthly transferred cost of a "free" joiner:

M * H * 4.3

Compare that to P per paid seat, and to S divided by people who actually hit the box.

Worked example. Labeled assumptions. Replace every number before you quote it.

Two joiners.
M = 3 extra mentor hours per joiner per week.
H = $90 loaded.
P = $40 per seat per month (placeholder; use your contract).
S = $400 box + 2 hours of platform toil at $90.

Free hosted cash: about $0.

Transferred cost: 3 * 90 * 4.3 * 2 ≈ $2,322 / month.

Paid seats: 2 * 40 = $80 cash. I do not assume M falls. Measure M either way.

Self-host: 400 + 180 = $580 total. Per-user only if six people truly share the box.

See the inversion? Free can win the cash column and still tax your best reviewers. Paid can look spendy and still be cheaper than three hours of a staff engineer explaining a generated layout.

Sensitivity is the whole point. If M drops to 0.5, free hosted can be rational on money. If M stays at 3, free hosted is a stealth cost center. Which one is your squad this month?

I run it as a script so nobody hand-waves the 4.3.

# Worked example only. Not a benchmark. Not vendor ROI.
M = 3.0          # extra mentor hours / joiner / week
H = 90.0         # loaded $ / hour
joiners = 2
P = 40.0         # $ / seat / month — replace with your contract
S_box = 400.0    # $ / month
S_toil_hours = 2.0
users_on_box = 6

free_transfer = M * H * 4.3 * joiners
paid_cash = P * joiners
self_host = S_box + S_toil_hours * H
self_per_user = self_host / users_on_box

print(f"free transferred $/mo: {free_transfer:.0f}")
print(f"paid cash $/mo:        {paid_cash:.0f}")
print(f"self-host total $/mo:  {self_host:.0f}")
print(f"self-host per user:    {self_per_user:.0f}")

m_star = paid_cash / (H * 4.3 * joiners)
print(f"break-even M* vs paid (hours/week/joiner): {m_star:.2f}")

If real M sits above M, "free" is a slogan. In the placeholder above, **M** is tiny. That is the point. Staff-engineer time is the expensive input, not the token sticker.

4. Owner, expiry, exit: no owner, no lane

I do not care how open source the stack is.

Owner: a named EM or platform lead. Not "the squad."
Expiry: 30 days for a new-hire default. Not "until it feels fine."
Exit: if N < 0.5, or M > M*, or a secret hits the lane, the unsupervised default dies. Joiners keep their editors.

Decision log, in the repo, not in a slide deck:

# decision-log/ai-onboarding-2026-09-23.yaml
decision: default_new_hires_free_hosted
owner: "platform-lead-name"
opened: 2026-09-23
expires: 2026-10-23
B: 1
M_hours_per_week: 3.0
N_day10_target: 0.5
exit:
  - "B drops to 0"
  - "N < 0.5 at day 10"
  - "M > break-even M*"
review_after: 2026-10-23

Thirty days. Renew with new numbers or stop. Expiring exceptions beat evergreen "we are still piloting."

Day-one workflow

I do not survey feelings. I pick one joiner, one service, one week.

Set B with security in the room. Fifteen minutes.
Put N in the PR template. Zero extra tools.
Ask the staff engineer for M. If they say "not much" and their calendar is review, believe the calendar.
Run the script with finance's H and P. Refuse invented ROI.
Commit the YAML. Drop the expiry on the EM's calendar.

Boring on purpose. Adoption theater is expensive. Measurement is not.

Who should not use this approach

Do not default new hires onto a free hosted lane when any of these are true.

The repo can see production secrets, health data, or uncleared customer dumps.
You have no spare mentor hours. A free lane without review slack is how green tests become production archaeology.
You need a vendor DPA more than you need a cheap token path.
You were about to treat a free server as an SRE team. It is a pilot instrument. It is not a capacity plan.

Self-host is the wrong first move when nobody can name who patches the box. Paid is the wrong first move when procurement will strand joiners for a month with no measurement plan either. Sometimes the honest answer is delayed AI. Not a free default.

Limitations

I have not run a multi-company trial of this card. The worked numbers are placeholders. Your H and P will move the break-even more than any model slide.

Free model access and a free server option change cash timing. They do not change B. They do not narrate the diff. They do not create an owner.

Open source matters for exit: you can leave. That is real. It is not a license to skip day-10 narration.

If any vendor quotes adoption percentages without your M and N, ignore the quote.

What would reverse you?

Forget whether the tool is likable.

Which variable flips your default?

If M is really 0.4, I would let joiners start on a bounded free lane and revisit at day 30. If B is 0, I would not. If N is stuck at 0.2, I would spend the week pairing, not shopping seats.

So. What is your M this week, and who owns the expiry?

Should Your EM Mix a Free AI Lane With Self-Host? Use This 3-Bucket Routing Card

bestbee — Tue, 22 Sep 2026 14:14:42 +0000

A $0 invoice can still be the expensive default.

I keep landing in the same Monday planning room. Finance is calm. The AI line is blank. Then two seniors wait fourteen minutes on one shared free lane while a docs rewrite and a billing patch sit in the same queue. Security asks the question that should have been on the card already. Did customer code leave the boundary because we treated “free” as “fine for everything”?

That is not a model problem. It is a mix problem.

Most teams still run a binary. Keep the free lane, or stand up something private. Binary feels clean. It also dumps three jobs into one pipe. Commodity text. Boundary code. Deadline bursts. They do not share a cost unit, and they do not share a failure mode.

So here is the card I want an EM to fill. Not buy-or-don't. Which work stays on a free hosted lane, which work must stay in-boundary, and which work needs reserved capacity — with an owner and an expiry date.

Disclosure, and where a free lane actually fits

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

I am not crowning a stack. I am trying to stop a blank invoice from posing as a strategy. If you need a free hosted option for the commodity bucket, MonkeyCode is an open-source project that currently offers free model access and a free server option. I am not treating any posted quota, box size, or duration as durable. Check the project on the day you write the policy.

Strip that name out and the routing card still has to work. That is the bar.

The constraint that reverses “just use free”

Zero dollars is a price. It is not a capacity plan.

Shared free capacity has a queue. Self-hosted capacity has an ops tax. Reserved capacity has a sticker. Your job is to put work on the lane whose failure mode you can live with. Not the lane whose invoice is quiet.

Ask it this way. If the free lane vanished for ten days, which PRs would you still ship by hand, which PRs would you pause, and which PRs should never have been on that lane at all?

If that takes a meeting, you do not have a mix. You have a habit.

Look at the incentives, because they will write the mix if you do not. Finance is paid to keep the line at zero. Security is paid to assume nothing left the building. You are paid to show throughput. Seniors are paid to stop waiting behind docs. An unwritten default lets finance win the meeting and security lose the incident.

Variable definitions — write these first

A scorecard is a conversation tool, not objective truth. Fill the variables before you score a vendor.

Queue minutes (Q): wall-clock wait from “I submitted” to “the lane started useful work,” sampled over a week, not a lucky hour.
People stacked (P): how many engineers are blocked on that wait. Idle seniors are not free.
Fully loaded rate (R): your finance number per engineer-hour, including benefits. Not a blog number.
Ops hours (H): platform hours per week to keep a private lane alive: upgrades, auth, disks, “why is it 500.”
Ops rate (S): fully loaded cost of the person who actually gets paged.
Boundary (B): can this diff include customer code, secrets, or production config? Yes or no. No maybes.
Blast radius (Z): if the model is wrong, is the miss a typo in docs or a payment path?
Expiry (E): the date the mix dies unless a named human renews it. No open-ended exceptions.

Queue tax for a bucket, dollars per week:

queue_tax = (Q / 60) * P * PRs_per_week * R

Ops tax:

ops_tax = H * S

Reserved sticker is whatever finance is actually billed for that burst lane. Do not convert it into seats. Seats hide contention.

The 3-bucket routing card

Put every recurring work type into one bucket. If a type fits two, it goes to the stricter one. Argue the row, not the brand.

Bucket A — commodity, public-shaped

Think internal docs, test scaffolding on fake data, changelog drafts, “explain this open module.”

Fit: B is no. Z is low. Q can get ugly before the dollar tax beats a private box.

Default lane: free hosted.

Exit: if a commodity PR starts carrying production config, it is no longer commodity. Move it the same day. “Just this once” is how Bucket B leaks.

Bucket B — boundary or high blast radius

Think billing, auth, migrations, customer payloads, anything you would page on.

Fit: B is yes, or Z is high. Cost is not the decider. The boundary is.

Default lane: self-hosted in-boundary, or no AI on that path.

Exit: if you cannot staff H, you do not self-host. You restrict the work. A free shared lane is not a compliance control.

Bucket C — deadline bursts

Think a freeze window, an incident patch, a launch week when three squads collide on one pipe.

Fit: Q times P spikes, even if B is no.

Default lane: reserved capacity, or a hard cap on who may touch the free lane during the window.

Exit: the freeze ends, the reserved lane expires. Burst is not a lifestyle.

Worked example (labeled hypothetical)

This is a filled card, not a customer case. Do not quote it as evidence. Squad of eight. Planning week of 2026-09-22. Rates are placeholders so you can replace them.

Bucket	PRs/week	Q (min)	P	R	B	Z	Weekly queue tax
A docs/tools	10	8	1.0	$120	no	low	$160
B billing/auth	4	8	1.5	$120	yes	high	$96, plus an unacceptable boundary miss
C launch burst	6	18	3.0	$120	no	med	$648

Self-host ops: H = 5 hours/week, S = $160, so ops_tax = $800.

Read it slowly.

Bucket A is cheap to leave on free. The tax is real and still smaller than standing up a private box for docs. Bucket B should never have been on the shared free lane, even though its queue tax looks small. The failure mode is not money. Bucket C is where the blank invoice lies. Three people waiting eighteen minutes, six times a week, is already most of a private lane’s ops tax — and that is before review time.

Break-even for moving only Bucket C off free: if queue_tax_C stays above the reserved sticker (or above the share of ops_tax you would actually staff for C) for three weeks, C leaves the free lane. If Q drops to four minutes, C can return. The mix is allowed to move. The card is not.

Sensitivity, same sheet:

If R is $80, C’s tax falls to $432. Free looks better. The boundary rule for B does not move.
If Q for C is 4 minutes, tax falls to $144. Do not self-host for pride.
If H is 12 hours because nobody automated upgrades, self-host loses even when Q is ugly. Buy reserved, or cut AI off that path.
If B flips to yes on a “docs” PR, the whole row jumps to Bucket B. Cost stops mattering.

Which variable would reverse your call this month? Q, H, or B? Pick one. Write it under the table.

Run the numbers. Do not argue the vibe.

Label this as unexecuted example code. Point it at your samples, not at a vendor dashboard.

# Hypothetical worksheet. Not a benchmark. Not a product result.

from dataclasses import dataclass

@dataclass
class Bucket:
    name: str
    prs_per_week: float
    queue_min: float
    people_stacked: float
    engineer_rate: float
    boundary: bool
    blast_high: bool

def queue_tax(b: Bucket) -> float:
    hours = b.prs_per_week * b.people_stacked * (b.queue_min / 60.0)
    return hours * b.engineer_rate

buckets = [
    Bucket("A_commodity", 10, 8, 1.0, 120, False, False),
    Bucket("B_boundary", 4, 8, 1.5, 120, True, True),
    Bucket("C_burst", 6, 18, 3.0, 120, False, False),
]

ops_tax = 5 * 160  # H * S

for b in buckets:
    tax = queue_tax(b)
    if b.boundary or b.blast_high:
        route = "self_host_or_none"
    elif tax > ops_tax:
        route = "reserved_or_self_host"
    else:
        route = "free_hosted"
    print(f"{b.name:12} tax=${tax:7.0f}  route={route}")

print(f"ops_tax=${ops_tax:.0f}")

Want a queue sample you actually own? Pull wait from your logs. Adjust the pattern. This is a sketch.

# Proposal only. Replace the file and field with your lane's logs.
# Do not pretend a missing log is a zero wait.

awk '
  /queue_wait_ms/ {
    n++
    sum += $2
  }
  END {
    if (n < 20) {
      print "not enough samples; do not route on this"
      exit 2
    }
    print n, "samples, avg_min=", sum / n / 60000
  }
' /var/log/ai-lane/queue.log

If you do not have logs, you do not have Q. You have folklore. Folklore always says the free lane is fine.

Need a rough split of work types before you fill PRs/week? Use your own tree. This is not a quality metric. It is a mix input.

# Proposal: last week's path hits, not a productivity score.
git log --since='2026-09-15' --name-only --pretty=format: |
  grep -E '^(docs|internal|billing|auth)/' |
  sed 's#/.*##' |
  sort | uniq -c

A tiny routing policy beats a wiki paragraph. Expire it.

# Proposal: commit next to the architecture decision record.
# Owner: platform EM. Expires: 2026-10-22.

mix:
  owner: "platform-em"
  expires: "2026-10-22"
  review_channel: "#ai-mix"

buckets:
  commodity:
    examples: ["docs", "internal-tools", "fake-data-tests"]
    lane: free_hosted
    boundary: false
  boundary:
    examples: ["billing", "auth", "migrations", "customer-payloads"]
    lane: self_hosted_or_none
    boundary: true
  burst:
    examples: ["launch-week", "incident-window"]
    lane: reserved
    expire_with: "the freeze calendar"

hard_gates:
  - "no customer code on a shared free lane"
  - "no mix without a named owner"
  - "no open-ended burst exceptions"

Hard gates, owner, expiry, exit

Gates are yes/no. Scores are for debate.

Boundary gate. If B is yes, the free shared lane is illegal for that work. Do not average it with queue tax.
Sample gate. If you have fewer than 20 wait samples in a week, you may pilot. You may not declare the mix “working.”
Owner gate. One named human renews the YAML. A rotation is fine. “The platform team” is not a name.
Expiry gate. Thirty days, then the exception archives. Burst lanes die with the freeze, not with “we will revisit.”
Exit gate. To leave a bucket on free, queue tax must stay below the next alternative for three weeks, and B stays no. To leave self-host, H must stay staffed. If H disappears, AI on Bucket B disappears with it.

Archive rule: when you change a route, keep the old YAML in git. Future-you will ask why billing ever sat on the free lane. Show them the date, not a Slack myth.

Pilot rule: run the card for one planning cycle on two work types only. Commodity plus one boundary path. If you cannot keep the YAML honest for that, you will not keep it honest for a company-wide rollout.

Who should not use this card

Do not run a three-bucket mix if you are a two-person shop with no customer data and no queue. You will spend more hours on the card than on the product. Stay on a free lane and write a one-line boundary rule.

Do not self-host because the invoice is $0 and that feels suspicious. Idle ops hours are a real cost. If nobody can own H, you are buying a second incident surface.

Do not use this if legal already mandated a private cluster. The mix collapsed to Bucket B. Fill the YAML anyway so people stop sneaking commodity work onto the expensive box.

And do not treat my placeholder rates as your rates. If R and S are guesses, the table is theater.

Limitations

This card ignores model quality. A free lane that is empty and wrong is still wrong. It ignores token stickers on purpose. Stickers do not capture stacked seniors. It ignores hiring effects. If juniors only ship from a lane nobody can review, you have a different problem, and a routing table will not save you.

I also cannot certify any vendor’s uptime, quota, or hardware from this chair. Free hosted options change. That is why expiry exists.

The question that actually matters

Would you still keep docs and billing on the same free lane if Q for bursts doubled next week?

If yes, your binding constraint is not money. It is probably H, or a boundary rule you have not written down.

If no, write the three buckets this afternoon. Put an expiry on the YAML. Name an owner. Then decide whether the commodity bucket rides a free hosted option.

Which variable would reverse your mix this month — queue minutes, ops hours, or the boundary flag? Write that variable under the table before you change a lane.

Price Free AI Capacity With Incident-Adjacent Share, Not Seat Count

bestbee — Mon, 21 Sep 2026 12:15:52 +0000

Seat count called it free. In this labeled scene, 4 of 11 merged AI-assisted diffs last week touched a production path.

That share is the number I want on the table. Not the token sticker. Not the seat. Once that share climbs, a free coding lane stops being a cheap experiment. It becomes an unpriced exception sitting on the incident path.

Can your squad still defend that exception next Friday?

The scene that should reverse the call

Labeled example, not a customer claim: a 12-person platform squad, public APIs in production, a free AI coding lane still on because nobody opened a purchase order.

Friday, 4:40 p.m. On-call opens a 400-line diff. Tests are green. The author cannot narrate why the retry budget changed. The box that generated half the patch has no owner and no SLA.

Would you keep that lane as a standing default? Or would you put a clock on it?

I keep putting clocks on it. Seat count does not move incidents. Incident-adjacent share does.

Seat count is the wrong proxy

Seats are easy to count. They do not tell you where prompts live, which paths diffs touch, who pays in review hours, or what breaks when the lane disappears mid-freeze.

A free model and a free server can be the right exception. They are a poor standing budget line once the work is incident-adjacent.

This ledger is a conversation tool. It is not objective truth. Move one threshold and the call can flip. That is the point. Write the reverse number before you argue about vendors.

Variable definitions

Five fields. Fill them weekly. Expire the card.

Variable	Meaning	Unit	Owner
`S`	Incident-adjacent share	AI-assisted PRs that touch a production path / all merged AI-assisted PRs, trailing 14 days	EM
`D`	Fattest prompt class this week	`public` / `internal` / `restricted`	Security + EM
`N`	Net review hours	Reviewer hours on AI diffs minus hours you honestly think authors would have spent without the lane	Review lead
`B`	Blocked hours if the lane is gone	Hours of change-freeze or incident work that cannot proceed	On-call
`E`	Exception expiry	A calendar date, never "until it feels fine"	EM

Starting gates I use as conversation numbers, not laws:

If D = restricted → a shared free lane is the wrong fit. Stop. Do not convert later as a workaround.
If S >= 0.30 → the lane is on the incident path. Convert or kill. Do not quiet-keep.
If N > 0 → review is costing more than the lane returns. Do not upgrade. Kill or retrain.
If B >= 4 and there is no SLA → free shared capacity is the wrong fit for that window.

Which of those four would reverse your call if I moved it?

The 4-clock ledger

Four clocks. Each one is GREEN (keep the exception), AMBER (shorten E), or RED (convert or kill).

Clock 1 — Data

GREEN if every prompt this week is public. AMBER if anything is internal. RED if anything is restricted or you cannot classify it.

Cannot classify is not AMBER. It is RED. Ambiguity is how exceptions become standing lines.

Clock 2 — Path

S is the clock. Production path means: auth, payments, data stores, deploy tooling, on-call runbooks, or anything that pages a human.

Proposed measurement, unexecuted. Tag PRs. Then count.

# Proposed, not a run I am claiming.
# Requires: gh auth, labels ai-assisted and prod-path on merged PRs.

SINCE=$(date -u -d '14 days ago' +%Y-%m-%dT%H:%M:%SZ)

AI=$(gh pr list --state merged --search "merged:>=${SINCE} label:ai-assisted" --limit 200 --json number --jq 'length')
PROD=$(gh pr list --state merged --search "merged:>=${SINCE} label:ai-assisted label:prod-path" --limit 200 --json number --jq 'length')

python3 - <<'PY'
import os
ai = int(os.environ.get("AI", "0") or 0)
prod = int(os.environ.get("PROD", "0") or 0)
s = (prod / ai) if ai else None
print({"ai": ai, "prod": prod, "S": None if s is None else round(s, 2)})
PY

Export AI and PROD from those gh calls, or paste the counts. If you cannot label, you cannot compute S. Then Clock 2 is RED until you can.

GREEN if S < 0.15. AMBER if 0.15 <= S < 0.30. RED if S >= 0.30 or unlabeled.

Clock 3 — Review net

N is messy. Say that out loud. Still write a number.

I treat N as reviewer_hours_on_ai_diffs - avoided_author_hours. Both sides are estimates. Label them est.

GREEN if N <= -2 (the lane returns at least two hours). AMBER if -2 < N <= 0. RED if N > 0.

Do not convert a RED review clock into a paid seat. Paying does not fix a workflow that reviewers already cannot narrate.

Clock 4 — Uptime / blast

B is "hours we cannot move if this lane is dark during a freeze or a page."

GREEN if B < 1. AMBER if 1 <= B < 4. RED if B >= 4.

A free server with no named owner is not GREEN just because it answered yesterday. Yesterday is not an SLA.

Policy file the squad can argue with

Hang this next to the CODEOWNERS file. If it is not in the repo, it is not a policy.

# exception-clock.yml — conversation tool, not a control plane
exception:
  owner: platform-em
  expires_on: 2026-10-05
  lane: free-shared
variables:
  S: 0.36          # 4 / 11 in the filled example below
  D: internal
  N_hours: 3.5     # est; review heavier than avoided author time
  B_hours: 6
gates:
  S_red: 0.30
  N_red: 0.0
  B_red: 4.0
  D_red: [restricted, unknown]
exit:
  kill_if:
    - S above gate two trailing windows
    - D upgrades to restricted
    - author cannot narrate a prod-path diff during a page
  convert_if:
    - S red and D is internal and N is green or amber
    - B red and the squad still wants the lane
  keep_exception_if:
    - no clock red
    - owner named
    - expires_on in the future

Scorer you can run locally

Proposed script. Not a benchmark. Not production telemetry.

from datetime import date

GATES = {"S_red": 0.30, "N_red": 0.0, "B_red": 4.0}
D_RED = {"restricted", "unknown"}

def clock_data(d):
    if d in D_RED:
        return "RED"
    if d == "internal":
        return "AMBER"
    if d == "public":
        return "GREEN"
    return "RED"

def clock_path(s):
    if s is None or s >= GATES["S_red"]:
        return "RED"
    if s >= 0.15:
        return "AMBER"
    return "GREEN"

def clock_review(n):
    if n > GATES["N_red"]:
        return "RED"
    if n > -2:
        return "AMBER"
    return "GREEN"

def clock_blast(b):
    if b >= GATES["B_red"]:
        return "RED"
    if b >= 1:
        return "AMBER"
    return "GREEN"

def decide(row):
    clocks = {
        "data": clock_data(row["D"]),
        "path": clock_path(row["S"]),
        "review": clock_review(row["N"]),
        "blast": clock_blast(row["B"]),
    }
    reds = [k for k, v in clocks.items() if v == "RED"]
    expired = date.fromisoformat(row["E"]) < date.today()
    if expired or "data" in reds or "review" in reds:
        action = "KILL"
    elif reds:
        action = "CONVERT"  # path or blast red, data/review not blocking
    else:
        action = "KEEP_EXCEPTION"
    return {"clocks": clocks, "reds": reds, "action": action}

example = {"S": 4 / 11, "D": "internal", "N": 3.5, "B": 6, "E": "2026-10-05"}
print(decide(example))

On that filled row the path clock is RED, review is RED, blast is RED, data is AMBER. Action: KILL. Paying does not repair a positive N. Self-hosting does not repair an author who cannot narrate the diff.

Filled example, then sensitivity

All numbers below are illustrative. They are not a measured customer result and not a model benchmark.

Squad P, 12 people, platform APIs. Trailing 14 days: 11 AI-assisted merges, 4 tagged prod-path. S = 0.36. D = internal. N = +3.5 hours. B = 6 hours on the Friday deploy train. E = 2026-10-05. Owner: the platform EM.

Call: kill the standing free lane, or shrink it to non-prod paths with a new expiry. Do not convert first. Conversion is for a lane that is already net-negative on N and still needed on the path.

Now flip three knobs.

If S drops to 2/11 ≈ 0.18, N flips to -4, and B is 1 → clocks land AMBER / AMBER / GREEN / AMBER. Action: KEEP_EXCEPTION until E. Re-score on the expiry date, not in Slack.
If S stays 0.36 but N flips to -5 and D stays internal → review is no longer the blocker. Path and blast still RED. Action: CONVERT if the squad still wants the lane on prod paths.
If D becomes restricted → KILL on any other combination. Do not bargain with Clock 1.

Break-even on S: I start the conversion talk at 0.30. If your on-call density is low and prod-path means "touches a helm chart once a quarter," your reverse number might be 0.50. Write it. If you will not write a reverse number, you are not using a gate. You are using a mood.

Free vs paid vs self-host: fit, not vibes

Same five variables. Three homes. Pick with the clocks, not with a catalog page.

Fit question	Keep a free shared lane as an exception	Convert to a paid lane	Self-host
`D`	public, maybe internal with a short `E`	internal, vendor DPA you actually read	restricted, or you already cannot leave the boundary
`S`	under your red gate	at or above the gate, and you still want AI on those paths	at or above the gate, and blast must stay inside your network
`N`	must be green or you kill, you do not buy	green or amber, with a named review ritual	same; hosting does not teach narration
`B`	under 4 hours, owner named	you are buying an SLA, so write the SLA hours into `B`	you are buying ops load; add on-call hours into `N`
`E`	14–28 days, written	standing line with a quarterly kill review	standing line with a capacity review

Free is not cheaper. Price the exception in review hours and blocked hours. Paid is not safer. It is a different invoice plus whatever SLA you actually negotiate. Self-host is not automatically the grown-up move. It is the move when D or B cannot leave your boundary, and you already know who gets paged when the box dies.

Hard rule I use: never convert a KILL review clock into spend. Spend hides the mismatch. It does not close it.

Where a free-model, free-server option actually belongs

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

If the honest call is KEEP_EXCEPTION, you still need a lane that does not wait on a purchase order while the clocks run. An open-source coding assistant with free model access and a free server option is useful as the exception under test. MonkeyCode is one such project. I would still hang exception-clock.yml on the repo. I would still refuse restricted prompts. I would still expire E. I would not treat the free server as an SLA.

That is the whole product-shaped sentence. The ledger still decides.

Owner, expiry, exit, archive

Owner. The EM or platform lead who can kill the lane without a committee. If kill needs three directors, you do not have an exception. You have a zombie.
Expiry. 14 or 28 days, written in the YAML. No silent renewals.
Exit. Two trailing windows with S above gate, or D upgrades, or N stays positive, or one page where the author cannot narrate a prod-path diff.
Archive. If you convert, keep the ledger and reset E to the next quarter. If you kill, write one paragraph on why so the next squad does not reopen "but it's free" as a strategy.

Who should not use this

Do not run this ledger if you have no production path, no merge labels, and no on-call. Individuals tinkering on throwaway branches do not need four clocks. Orgs that already banned AI on prod paths do not need a conversion talk. Security reviews are not replaced by a Python dict. If your real constraint is a legal hold, stop scoring and call counsel.

Limitations

N is mushy. S is only as good as your prod-path label. The 0.30 gate is a conversation number I can defend in a staff meeting, not a measured industry constant. I am not sourcing model names, token quotas, hardware, uptime, or permanence I cannot point at. A free server can vanish. That fact is why Clock 4 exists.

The scorer will happily emit KEEP_EXCEPTION if you feed it wishful inputs. Garbage N in, confident action out. Treat the printout as minutes for a fight, not as proof.

If I moved S from 0.30 to 0.50, would you keep the free lane as a standing default? If the answer changes, write your reverse number before the next Friday 4:40. That number, not the seat count, is the decision.

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

bestbee — Sun, 20 Sep 2026 10:27:19 +0000

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.

Boundary. Do prompts ever include non-public code, secrets, or customer data?
Idle. What do you pay when nobody is typing?
Switch. How many hours to leave without losing working context?
Skill-retention. Can the squad still ship if the lane dies on Friday?
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.

Should Your Squad Keep a Free AI Lane When Green Tests Stop Meaning Done? Use This False-Done Gate

bestbee — Sat, 19 Sep 2026 08:46:38 +0000

Nine of the last twelve AI-touched pull requests on the board were green. Two of them still shipped a path no test executed. That ratio can reverse a spend decision faster than any token invoice.

I'm treating this as a composite squad, not a war story. If your numbers differ, the card still works. Would you keep the free lane, isolate the sensitive work, or exit generation on that surface entirely?

Most teams start in the wrong meeting. They argue free versus paid, or free versus self-hosted, before they can say what "done" meant last week. I don't. I want a field that can fail.

The standup that should have been a stop

Picture Tuesday. A service owner pastes a diff that reads complete. CI is green. The reviewer asks one question: which test hits the new branch?

Silence. Then a follow-up commit. Then another. The original PR was not unfinished in the Git sense. It was unfinished in the evidence sense. That is the leak I score.

Throughput looked fine. Review comments looked polite. The team still could not reproduce the claim without the author in the room. If that is your week, buying a bigger lane will not fix it. It will only make false-done cheaper.

Stop pricing the lane before you define false-done

A free coding lane is a capacity choice. It is also a governance choice. Mixing those two debates is how platform leads buy isolation they did not need, or keep a shared lane they cannot defend.

I use four outcomes, not two:

Keep the free lane for that surface.
Split: free for scratch, isolated for anything with data, secrets, or production blast radius.
Exit generation on that surface until evidence holds.
Park the decision with an expiry, not a vibe.

Paid and self-hosted sit inside Split or Exit. They are not a personality. They are a response to a gate you can fail.

This scorecard is a conversation tool, not objective truth. If nobody on the squad can name the variable that would reverse Keep, you are not deciding. You are decorating a preference.

Define the variables before anyone scores

I will not score a lane with undefined nouns. Write these on the wiki first.

False-done rate (FDR). Share of AI-touched PRs in the sample that merged or were marked ready, then needed a follow-up because a generated path was untested, unreproducible, or unexplained. Count the PR, not the commit spam.
Evidence lag (EL). Hours from "looks done" until a named owner can reproduce the claim without the author. If the owner is "the team," EL is infinite.
Boundedness (B). Share of generated branches, handlers, or jobs that a test, a recorded manual reproduction, or a failing fixture actually hits.
Isolation need (I). Binary for the surface: does policy forbid prompts, code, or tool output on a shared free server? If yes, Keep is already illegal. Do not score taste.
Switch cost (SC). Hours to stand up an isolated lane (vendor or self-host) and move the evidence template with it. Exclude catalogue shopping. Include review, secrets, and rollback notes.
Sample window (W). Consecutive calendar days, not "busy week." I default to 14. Shorter windows lie. Longer windows hide the fire.

Tag AI-touched PRs in the description or a label. If you cannot tag them, you cannot compute FDR. That is a process bug, not a model bug.

The 4-gate false-done card

Copy this. Fill it in a doc, not in Slack.

# false-done-gate.v1.yaml
# Conversation tool. Not a procurement score.
surface: payments-webhooks  # one surface per card
owner: em-payments          # named human, not a rotation
window_days: 14
expiry: 2026-10-17          # 28 days from decision, not "next quarter"
sample:
  ai_touched_prs: 12
  false_done_prs: 2
  fdr: 0.167                # 2 / 12
  evidence_lag_hours_p50: 6
  boundedness: 0.75         # 9 / 12 had a hit on the new path
  isolation_need: false     # policy check, not preference
  switch_cost_hours: 16
gates:
  fdr_max: 0.20             # fail closed if FDR > 20%
  el_max_hours: 8           # fail if p50 evidence lag > 8h
  boundedness_min: 0.70     # fail if < 70% of generated paths are hit
  isolation_must_pass: true
outcome: keep               # keep | split | exit | park
exit_criteria:
  - "FDR > 0.20 in any completed window"
  - "EL p50 > 8h for two windows"
  - "isolation_need flips to true"
reversal_question: "Which single field, if it flipped, would kill Keep?"

Hard reading order. Do not average the fields.

Isolation gate. If I is true, Keep is forbidden. Split or Exit. Stop scoring FDR as a way to smuggle a policy exception.
FDR gate. If FDR is above your max, you do not have a capacity problem. You have an evidence problem. Exit generation on that surface, or Split so the messy work cannot hide in the same queue as production.
Boundedness + lag gate. If B is below the floor or EL blows the cap, Keep only if the owner can name a two-week fix. Otherwise Park with expiry.
Switch-cost gate. Buy or self-host only when gates 1–3 already demand isolation and SC is lower than the evidence debt you are already paying. Evidence debt, roughly: false_done_prs * (EL hours + re-review hours).

Would a cheaper token price reverse Exit? It should not. Price does not create a test hit.

Worked example, then I break it

Illustrative numbers. Not a benchmark. Not a customer.

A payments-webhooks squad, 14-day window, 12 AI-touched PRs, 2 false-done. FDR = 16.7%. Evidence lag p50 = 6 hours. Boundedness = 75%. Isolation need = false. Switch cost to an isolated lane = 16 hours. Re-review on each false-done ≈ 3 hours.

Evidence debt in the window: 2 * (6 + 3) = 18 hours. Switch cost is 16 hours. Close, right? Not yet. Isolation need is false, FDR is under 20%, lag is under 8, boundedness is over 70%. Keep. The 16-hour migrate would buy a feeling, not a gate.

Now flip one field. Same squad, isolation need becomes true because webhook payloads include customer identifiers that cannot sit on a shared free server. Outcome is Split on the same afternoon. FDR did not move. Policy did.

Flip a different field. Isolation stays false, but false-done PRs are 4 of 12. FDR = 33%. Evidence debt: 4 * 9 = 36 hours. Exit generation on that surface until boundedness recovers. Do not "upgrade" the lane so people can miss tests faster.

Sensitivity I actually walk:

Knob you change	Keep still holds?	What I ask next
FDR 17% → 25%	No	Which paths were unhit? Exit or Split, not spend.
EL 6h → 12h	No	Name an owner. If you cannot, Park.
B 75% → 60%	No	Add reproduction notes before any vendor talk.
I false → true	No	Split today. Free scratch can remain.
SC 16h → 40h	Yes, if I is false	Do not migrate to soothe anxiety.
W 14d → 5d	Invalid	Refuse the card. Sample is too short.

If FDR is the field that reverses you, you were never in a build-versus-buy meeting. You were in a test-design meeting wearing a procurement hat.

Commands to count false-done without inventing dashboards

I want the sample in git, not in memory. Label this as a method you can copy. It is not production telemetry, and it will lie if you skip labels.

# Last 14 days of merged PRs that someone tagged as AI-touched.
# Requires GitHub CLI. Adjust the label to whatever you actually use.
gh pr list --state merged --search "label:ai-touched merged:>=2026-09-05" \
  --json number,title,mergedAt,url,labels > /tmp/ai-prs.json

# Follow-up commits on the same paths in 72h often signal false-done.
# This is a heuristic. Read the PR. Do not let the script merge for you.
git log --since='14 days ago' --pretty=format:'%h %ad %s' --date=short -- '*.py' '*.ts'

A tiny scorer you can run after you classify each PR by hand. Classification is the work. The script only refuses a missing denominator.

# proposal: score a window you already classified
# fdr = false_done / ai_touched; fail closed on empty sample

def false_done_rate(ai_touched: int, false_done: int) -> float:
    if ai_touched <= 0:
        raise ValueError("empty sample; do not score")
    if false_done < 0 or false_done > ai_touched:
        raise ValueError("false_done must sit inside ai_touched")
    return false_done / ai_touched

def gate(fdr: float, fdr_max: float = 0.20) -> str:
    return "fail" if fdr > fdr_max else "pass"

if __name__ == "__main__":
    fdr = false_done_rate(ai_touched=12, false_done=2)
    print({"fdr": round(fdr, 3), "gate": gate(fdr)})

If you will not classify PRs by hand for two weeks, do not run a free lane at production blast radius. You cannot see FDR. You are guessing.

A PR template that makes boundedness visible

I want the evidence in the PR, not in a hallway. Paste this under the diff.

## Evidence (AI-touched)
- [ ] Generated paths listed (file + function / job name)
- [ ] Test or fixture that hits each path, *or* a recorded reproduction
- [ ] Named owner who can re-run that claim without the author
- [ ] Data / secrets in the prompt: none | redacted | blocked (isolation)
- [ ] Follow-up PR expected? no | yes, ticket id

If the checklist is empty and CI is green, that is a false-done candidate. Green is not done. Green is "the tests you already had did not scream."

Where a free model lane still earns Keep

Some squads need a scratch lane to measure FDR before they pay for isolation. That is a real job. It is not a brand preference.

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

MonkeyCode is an open-source coding tool with free model access and a free server option. I treat those as availability facts, not as a bake-off. I will not invent model names, quotas, hardware, or permanence. If a free shared server cannot hold your prompts, Isolation need is already true. The product does not get a vote.

Use a free lane when all of this is true:

Isolation need is false for that surface.
You will tag AI-touched PRs and run the 14-day window.
The owner can fail Keep.
Scratch work and production work are not one queue.

If you want a place to run the card without buying capacity first, that free model access and free server option are one way to do the measurement. The card still owns the decision.

Owner, expiry, exit

Owner. Engineering manager or platform lead for the surface. Not "AI champions." Champions do not revoke lanes.
Expiry. 28 days, written on the YAML. If the card is not re-scored, the lane Parks. Park is not Keep with worse lighting.
Exit. Any completed window with FDR above max, EL above cap for two windows, or Isolation need flipping to true. Exit means generation stops on that surface until boundedness recovers. It does not mean a angry all-hands.
Archive. Keep the YAML. Future you will try to remember why you Split. Future you is a liar.

Who should not use this approach

Do not run a free shared lane, including a free server, if legal already forbids prompts or code leaving your boundary. Do not use this card to launder that exception.

Do not use it if you refuse to label AI-touched PRs. The math needs a denominator.

Do not use it as a model beauty contest. There are no latency tables here on purpose. If your question is "which weights are hottest this week," you are in a different article.

Do not use it for a two-person hobby repo with no reviewer. FDR collapses into self-grade. Be honest and skip the theater.

Limitations, said plainly

FDR depends on how strict you are when you classify follow-ups. Two reviewers will disagree on the edge. Write the rule: unhit path, unreproducible claim, or missing owner. Not "I did not like the style."

A 14-day window can miss a rare surface. A 90-day window can hide a bad week under a good month. If the blast radius is high, shorten the decision loop, not the sample until it flatters you.

Switch cost is local. My 16-hour example is illustrative. Your procurement, your SSO, your secret broker. Fill the number. Do not borrow mine.

Free lanes change. Availability is not a contract I can sign for you. Re-score when the lane you measured is not the lane you have.

And tests can be as outdated as the generation they fail to bound. If AI output routinely steps around the assertions you still worship, FDR will look fine while production will not. Boundedness is about hitting the new path, not collecting more of the old green.

The question that actually closes the meeting

I do not care whether you "believe in" a free lane. Belief does not reverse.

Which field on your card, if it flipped this week, would kill Keep: FDR, evidence lag, boundedness, or isolation need? If you cannot name it, you are not choosing. You are hoping the next green build means done. It might not.

Should Your Squad Keep a Free AI Lane When Nobody Can Narrate the Diff? Use This Ownership Half-Life Gate

bestbee — Fri, 18 Sep 2026 06:51:32 +0000

The standup looked calm. Then I asked the only question that matters for a free AI coding lane.

"Can you narrate this diff without the chat log?"

Nobody could. Twelve minutes to generate. Forty minutes of shrugs. If that ratio holds, the free server is already more expensive than a quieter paid lane. Would you keep it anyway?

This is a composite from platform reviews, not a customer case. I still use it because the constraint is real. Generation got cheap. Ownership did not.

The decision this gate is for

You are not choosing a mascot. You are choosing one of four moves for a squad that already touches a free AI coding path:

Keep the free hosted models and free server.
Move to self-hosted or paid, but only if ownership actually improves.
Pilot a tighter lane with an expiry date.
Stop the lane and return the work to human-owned slices.

The 2026 argument around "vibe coding" keeps collapsing into a culture war. I care about a narrower product question. When does unowned generation become a P&L leak?

Why free-server uptime is the wrong unit

Uptime is a vanity metric here. A box that is "always on" can still ship diffs that die in review, or land and then cannot be explained on a Sev-2 call.

Ask yourself: if the author left tomorrow, how many days until the squad can still reconstruct why the change exists?

I call that ownership half-life. It is a conversation tool, not a law of physics. Treat every number below as a proposal you should replace with your own logs.

Variable definitions

G — generation minutes for a change, from first prompt to a mergeable diff.
E — explanation minutes: time for the author to teach the change to a teammate who was not in the session, with the chat log closed.
H — ownership half-life in days: how long until a typical teammate can no longer reconstruct intent without the original thread.
R — rehearsal success: 1 if the author can re-derive the change from the ticket and the diff alone, else 0.
B — blast radius: count of production services or data classes the diff can break.
X — unexplained-diff budget remaining this sprint.

Derived:

Explanation ratio Q = E / G. If Q > 1, generation is not the bottleneck. Teaching is.
There is no magic weighted score. Hard gates beat averages that hide one ugly PR.

The ownership half-life gate

Run this on five merged PRs, not on a demo. If you only sample the pretty one, you already decided to keep the lane.

Field	Keep the free lane	Move, split, or stop
Q = E/G	Q ≤ 1.5 on at least 4/5 PRs	Q > 1.5 on 2+ PRs
R	Rehearsal succeeds on 4/5	Two failures in five
H	Half-life ≥ 10 calendar days	Half-life < one sprint
B	B ≤ 1, or B ≥ 2 only with a written owner	B ≥ 2 with no named owner
X	Unexplained diffs still inside budget	Budget already spent

If any hard gate fails, you do not "optimize prompts." You change the lane. Paid and self-hosted options only win if they change Q, R, or H. Faster tokens that raise Q are a loss.

Which threshold would reverse your call? If you cannot name it, you are shopping, not deciding.

A filled example (labeled, not measured in your shop)

Squad: four backend engineers, two-week sprint, one shared free coding server for non-prod work. I filled the rows so we can argue about thresholds, not vibes.

PR	G (min)	E (min)	Q	R	B	Notes
auth retry	18	14	0.78	1	1	Ticket was clear
cache stampede	9	31	3.44	0	2	Author could not re-derive
CSV export	22	12	0.55	1	1	Fine
feature flag default	7	28	4.00	0	2	"The model suggested it"
log sampling	15	16	1.07	1	1	Borderline

Two PRs already fail Q and R. Blast radius is 2 with no extra owner. I would freeze the free lane for anything that can touch auth, cache, or flags. I would keep it for export and logging only if X still has room.

That is the opposite of a seat-based upgrade. You might stay on free models and a free server for low-B work. You might still buy or self-host a governed lane for high-B work. Or you stop generation on high-B work entirely.

Sensitivity, not a vendor story

If E on the cache PR drops from 31 to 12 because the author wrote a 15-line narrative in the PR body, Q falls under 1.5 and R may flip to 1. The same free server suddenly passes. The product change was documentation discipline, not a new contract.

If E stays high even after a narrative template, the lane is the problem. Exit. Do not add more headroom.

Break-even in this model is not dollars per seat. It is the Q at which explanation time eats the generation "win." For the cache row, any G under 9 still loses while E sits at 31. You cannot prompt your way out of a teaching bottleneck you refuse to measure.

Free vs self-hosted vs paid vs stop

Compare moves against ownership, not against brochure speed.

Move	Can win when	Loses when
Keep free models + free server	Q stays ≤ 1.5, R is boring, B is 1, you need a pilot without procurement	You use "it's free" to skip a named owner
Self-host	You have operators, and persistent context or policy actually raises H	You only lift G, so Q gets worse
Paid / governed	Audit, tenancy, or review hooks you will operate, with a bet on Q or H	You buy status after two ugly PRs and never re-measure
Stop	High-B diffs fail rehearsal twice	You stop everything, including B = 1 chores the squad can already narrate

Self-hosted is not morally serious. Paid is not automatically safer. Both are more expensive ways to hide the same leak if authors still cannot close the chat log and teach the diff.

One question for a buyer's call: will this option change H, or only G?

How I would instrument this in a week

Do not wait for a platform program. Steal five PRs and a spreadsheet.

Proposed log schema. Unexecuted example, not a production collector:

pr_id,merged_at,g_min,e_min,rehearsal,blast_radius,chat_log_used,owner,expiry
auth-retry,2026-09-18,18,14,1,1,0,em-backend,2026-10-02
cache-stampede,2026-09-18,9,31,0,2,1,em-backend,2026-10-02

A tiny checker you can run locally after the fifth PR. Proposal only. Replace the thresholds before you argue with finance.

# proposal: ownership_gate.py
prs = [
    {"id": "auth", "g": 18, "e": 14, "r": 1, "b": 1},
    {"id": "cache", "g": 9, "e": 31, "r": 0, "b": 2},
    {"id": "export", "g": 22, "e": 12, "r": 1, "b": 1},
    {"id": "flag", "g": 7, "e": 28, "r": 0, "b": 2},
    {"id": "logs", "g": 15, "e": 16, "r": 1, "b": 1},
]

Q_MAX = 1.5
fail_q = sum(1 for p in prs if p["e"] / p["g"] > Q_MAX)
fail_r = sum(1 for p in prs if p["r"] == 0)
fail_b = sum(1 for p in prs if p["b"] >= 2)

print(f"q_failures={fail_q} rehearsal_failures={fail_r} high_blast={fail_b}")
if fail_q >= 2 or fail_r >= 2:
    print("GATE: freeze or split the lane")
else:
    print("GATE: keep, expiry 14 days")

Put the human check in the PR template, not in a wiki nobody opens:

## Ownership check
- [ ] Chat log closed while explaining to a reviewer
- [ ] Rehearsal: I can re-derive this from the ticket
- [ ] Blast radius and named owner
- [ ] If Q > 1.5, this class of change does not use the free lane next time

If you cannot get authors to close the chat log during explanation, you do not have a measurement problem. You have an incentive problem. The free lane is rewarding speed theater.

Where a free model path belongs in this gate

I only reach for a zero-cost coding environment when I need to price the measurement, not when I need to declare a platform winner.

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

MonkeyCode is an open-source project that currently offers free model access and a free server option. I am not attaching model names, token ceilings, hardware SKUs, or uptime promises here. Those claims go stale, and I will not invent them. Use whatever is on the project page the day you run the gate.

The fit is narrow. A free server is useful when:

You need a pilot with an expiry, not a permanent estate.
You want authors to log G and E without a procurement cycle.
The work is low blast radius, so a failed rehearsal is cheap.

It is the wrong default when you already fail Q or R on production-shaped diffs, when you need audit or tenancy the free lane does not claim to give you, or when "it's free" is how the squad avoids naming an owner.

Hard gates, owner, expiry, exit

Copy these into the decision record. If you skip owner and expiry, you did not decide. You postponed.

Hard gates (any fail = no keep for high-B work)

Two or more of five sampled PRs with Q > 1.5.
Two rehearsal failures.
Any B ≥ 2 change with no named human owner overnight.
Unexplained-diff budget X already spent.

Owner: the engineering manager of the squad, not the vendor champion. Platform can advise. They do not hold the pager narrative.

Expiry: 14 days after the fifth sampled PR, or the next sprint boundary, whichever is sooner. No silent renewals.

Exit criteria

Split the lane: free path for B = 1 chores; governed or human-only for the rest.
Move to self-hosted or paid only with a written bet that Q or H will improve, reviewed at expiry.
Stop generation on the failing class of diffs. Tickets go back to smaller human slices.

Archive the five-PR table. If you cannot find it next month, the gate never happened.

Who should not use this

Skip the gate if you are a solo hobbyist with no reviewer and no incident channel. You are not hiding cost from a squad.

Skip it if your team already forbids AI on anything that can page. You already made the call.

Skip it if you will not close the chat log during explanation. The numbers will be fan fiction.

This is a poor tool for ranking vendors. It will not tell you a free open-source path is "better" than a paid IDE. It will tell you whether your free lane is producing unowned work.

Limitations

Half-life is a judgment, not a stopwatch. Two reviewers will disagree on whether a narrative counts. That disagreement is data.

Five PRs is a small n. It is enough to freeze a lane. It is not enough to publish a benchmark.

I have not run these exact rows in your shop. The table is a filled example so you can argue with the thresholds instead of the mood in Slack.

Essays this month keep asking whether models outgrew our tests, or whether we started calling autocomplete "engineering." I will not launder secondary recaps as proof. The operational test is still local: can the author narrate the diff?

If the answer is no, the cheapest tokens you will ever get are still too expensive.

What would reverse it?

If your Q stays under 1.0 and rehearsal is boringly successful, keep the free lane. Do not upgrade for status.

If Q is ugly but a 12-line PR narrative flips R to 1, fix the template before you buy anything.

If high-B work keeps failing rehearsal even after you add narrative and a named owner, freeze that class. Then, and only then, compare a governed or self-hosted option against stopping.

I would rather a squad keep a free server for the work they can still explain than buy a louder lane they cannot.

So: which variable would reverse your keep-or-kill call this sprint — Q, R, H, or B? If you cannot pick one, you are not ready to spend, and you are not ready to keep the free lane on trust.

Should Your Squad Expand AI Capacity When Reviewers Go Quiet? Use This Question-Rate Gate

bestbee — Thu, 17 Sep 2026 04:56:44 +0000

Eleven of twenty-four AI-assisted pull requests merged last week with zero review comments. Median time-to-approve: nine minutes. Tests green. That number should reverse a buy. It should also reverse a self-host.

Why would you add capacity to a lane that already stopped being engineering?

Picture Tuesday standup. Maya, an EM on a payments squad, is proud. Cycle time dropped. Then a rollback lands at 4 p.m. because an AI-authored retry loop double-charged a webhook. Nobody in review asked how idempotency worked. The tool was not the failure. The silent approve was.

Names here are composite. The numbers below are a worked example, not a customer case. I still use this filter because the incentive is the same every time: a free or paid lane that makes diffs look finished will get expanded for the wrong reason.

The unit is question rate, not cycle time

Cycle time is a bad proxy. It moves in the same direction as both real engineering and pretend engineering. Question rate does not.

Question rate is review comments plus blocking questions per AI-assisted PR, counted after the first bot noise is stripped. Silent-approve rate is the share of those PRs merged with zero human comments and a sub-15-minute approve. If those two signals invert while cycle time “improves,” you do not have an adoption win. You have a trust unit going to zero.

Would you buy more seats for a queue nobody interrogates? I would not. Would you stand up a GPU box for the same queue? Also no.

This gate is a conversation tool. It is not objective truth. Game it and it will lie. Use it anyway, because token stickers and seat counts lie faster.

Four options, one bottleneck

You are not choosing a model brand. You are choosing blast radius.

Keep a bounded free lane. Capacity stays small on purpose. You measure trust before you spend.
Buy a paid lane. You pay for context, SLA, or vendor features. You also scale whatever habit you already have.
Self-host. You pay in ops time for data control. Same habit risk. Different invoice.
Stop or shrink. The lane is producing silent approves plus rollbacks. Extra capacity is malpractice.

A free model-access path and a free server option only matter in option 1. They are a blast-radius cap, not a trophy. If your reviewers already went quiet, paid and self-hosted are the same mistake with better hardware.

Variable definitions

Write these on a wiki page before you argue in Slack.

AI_PR_WEEK: PRs in the last 7 days labeled AI-assisted by the author or your bot.
Q: human review comments + blocking questions on those PRs. Strip linter bots.
QR = Q / AI_PR_WEEK.
QR_HUMAN: same ratio on PRs with no AI label, same week.
QR_RATIO = QR / QR_HUMAN.
SA: silent approves. Zero human comments, merge under 15 minutes, tests green.
SA_RATE = SA / AI_PR_WEEK.
RB_H: hours spent rolling back or hotfixing AI-assisted changes in the last 30 days. Include the meeting.
TEST_DELTA: new or changed tests per AI-assisted PR. 0.0 means the model wrote product code and nobody added proof.
EXPLAIN_OWNER: named human who can defend the change without re-reading the model transcript.

If you cannot fill those fields from git and review data, you do not have a buy/self-host decision. You have a vibe.

A 30-minute ledger, labeled unexecuted

Do not trust memory. Export one week.

# Unexecuted example. Adjust labels to match your process.
gh pr list --state merged --search "merged:>=2026-09-10" --limit 50 \
  --json number,title,author,mergedAt,reviews,comments,labels \
  > /tmp/pr-week.json

Then score it. This script is a proposal, not a benchmark I ran on your repo.

# Unexecuted example: question-rate ledger from a simplified CSV.
# columns: pr, ai, human_comments, merge_minutes, rollback_hours, tests_changed
import csv
from collections import Counter

rows = list(csv.DictReader(open("ai_review_week.csv")))
ai = [r for r in rows if r["ai"] == "1"]
human = [r for r in rows if r["ai"] == "0"]

def mean_comments(group):
    return sum(int(r["human_comments"]) for r in group) / max(len(group), 1)

qr_ai = mean_comments(ai)
qr_human = mean_comments(human)
sa = sum(1 for r in ai if int(r["human_comments"]) == 0 and float(r["merge_minutes"]) < 15)
rb = sum(float(r["rollback_hours"]) for r in ai)
td = sum(int(r["tests_changed"]) for r in ai) / max(len(ai), 1)

print({
    "ai_pr_week": len(ai),
    "qr": round(qr_ai, 2),
    "qr_ratio": round(qr_ai / qr_human, 2) if qr_human else None,
    "sa_rate": round(sa / len(ai), 2) if ai else None,
    "rb_h": rb,
    "test_delta": round(td, 2),
})

If QR_RATIO is missing because you never labeled AI PRs, stop. Label for two weeks. Then decide. Expanding first is how you buy a mess.

Worked example: Northwind payments, 8 engineers

Hypothetical week. I am not claiming this is a real team.

Field	Human PRs	AI-assisted PRs
Count	10	24
Mean human comments (`QR`)	1.80	0.42
Silent approves	1	11
`SA_RATE`	10%	46%
`TEST_DELTA`	1.4	0.3
`RB_H` (30-day, AI only)	—	14

QR_RATIO = 0.42 / 1.80 = 0.23.

Maya’s cycle time looks great. The ledger does not. Eleven silent approves is not “the model got better.” It is reviewers treating green CI as a personality.

Decision under this gate: do not expand. Do not buy. Do not self-host for “more speed.” Keep a bounded free lane only if you still need the tool for drafts, and freeze it to files the squad already owns. If RB_H stays above the rollback gate below, shrink further.

Hard gates (any one fails → no expand)

These are stop signs, not vibes.

SA_RATE > 30% on AI-assisted PRs. Reviewers went quiet. Extra capacity scales silence.
QR_RATIO < 0.35. AI diffs get less than about one-third the interrogation of human diffs.
RB_H > 8 hours / 30 days. The lane is already costing review-adjacent labor you will not see on a token invoice.
TEST_DELTA < 0.5. The model is writing product code without proof. Buying context will not grow a test habit you refused to require.
No EXPLAIN_OWNER. If the author cannot defend the change without the chat log, it is not a PR. It is a paste.

If gate 1 and gate 3 both fire, the call is stop or shrink, not “try a better model.” A better model with the same review policy is a faster webhook double-charge.

Sensitivity: which number reverses the call?

Hold Northwind constant and move one field.

If SA_RATE drops from 46% to 18% and QR_RATIO rises to 0.70, buy becomes discussable — but only if the bottleneck is context or vendor workflow, not GPU envy.
If RB_H falls from 14 to 3 and TEST_DELTA hits 1.0, self-host becomes discussable — but only if data residency or air-gap is a real constraint, not a status purchase.
If AI_PR_WEEK doubles while QR stays at 0.42, the decision gets worse. Volume is not evidence.
If human QR also collapses to 0.42, you do not have an AI problem. You have a review-culture problem. No lane, free or paid, will save you.

Ask the squad this out loud: which single threshold would reverse your expand vote? If nobody can name one, you are shopping.

Free vs paid vs self-host under a quiet review queue

Fit is not “which model is smart.” Fit is whether capacity is the constraint.

If this is true	Keep bounded free	Buy	Self-host
Reviewers still ask hard questions	Maybe	Maybe	Maybe
`SA_RATE` already > 30%	Cap, don’t market it	No	No
Context across repos is the actual bottleneck	Weak fit	Stronger fit	Only if you will staff the box
Data cannot leave the building	Weak fit	Usually no	Only after trust gates pass
You cannot name an `EXPLAIN_OWNER`	Shrink	No	No
You want a trophy for “AI adoption”	No	No	No

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 am not using that as a bake-off win. I am using it as an example of a bounded lane: useful while you run the ledger, dangerous if you treat free capacity as a reason to skip gates. The article still works if you never touch that project. Substitute any free lane you already have.

Paid and self-hosted fail the same way free fails. They fail faster when the invoice or the rack implies you must “get value.” Incentives leak into review. Quiet reviewers plus a larger context window is how pretend-engineering gets a budget line.

Owner, expiry, archive

Owner: the EM plus one staff reviewer who is not the vendor champion. The champion can collect data. They cannot grade their own expansion.
Expiry: 14 days for the first ledger, 30 days after that. An expired exception is a no.
Exit: if gate 1 and gate 3 both fire in a window, disable AI labels from merge, or cut the lane back to draft-only on non-production paths. Write the rollback in the same doc as the adoption note.
Archive rule: keep the CSV. Do not keep screenshots of cycle-time dashboards as proof.

Put the expiry on a calendar. Verbal “we’ll watch it” is how silent approves become culture.

Who should not use this gate

Teams with no review data and no will to label AI PRs. You cannot price trust from anecdotes.
Security or compliance work that needs a legal review of any tool, free or not. A decision card is not a SOC report.
Solo hackers optimizing for learning speed. Question rate is a team unit.
Anyone hunting a promotional build-versus-buy conclusion. If you already picked a vendor, this ledger will feel hostile. Good.

Limitations

Small, boring diffs can be silent and still correct. A 4-line typo fix should not inflate SA_RATE the way a 400-line retry loop should. Split trivial PRs out, or you will punish good hygiene.

Comment count can be gamed. “LGTM” is not a question. Count blocking questions if your tool allows it. If it does not, sample 10 PRs by hand once a week. Hand samples beat vanity metrics.

I have not run these commands on your repository. There is no benchmark hiding in this post. There is a policy you can fill, argue with, and expire.

The question that actually matters

Not “would you try the tool?” Not “is free cheaper than a rack?”

If silent-approve rate stayed at 46%, what extra capacity would you still purchase? If the answer is none, keep the lane bounded or kill it. If the answer is “we’d buy anyway because leadership wants AI,” you do not have a model problem. You have a P&L that is rewarding pretend work.

Run the ledger on last week’s merges. Fill QR_RATIO, SA_RATE, and RB_H. Then pick keep-bounded, buy, self-host, or stop. If you need a cap while you measure, a free-model plus free-server lane is one way to keep capacity from becoming the decision. The gate still comes first.

Should a Platform Lead Self-Host an AI Coding Lane or Keep a Free One? Use This 6-Field Fit Card

bestbee — Wed, 16 Sep 2026 03:13:45 +0000

Monday, 9:40 a.m. An AI-assisted change is already in production. The invoice is still zero. The on-call thread is not.

Can you replay the exact lane that wrote the diff? If the answer is a shrug, the “free” column is already charging you — just not on a card statement. This piece is a fit card for that moment. It is not a vendor bake-off, and it is not a claim that any one runtime is “better at coding.”

I treat the numbers below as a labeled hypothetical. Fill your own. A scorecard is a conversation tool, not objective truth. Which single threshold would reverse your keep-free decision?

The constraint that can flip the call

A free hosted lane is cheap until three things collide: you cannot pin the model and runtime, review happens beside the PR instead of in it, and people hide usage so the lane stays free. Self-hosting is expensive until those three things are the job.

Paid SaaS sits in the middle only if the contract actually buys pin, boundary, and an exit. Seat stickers do not buy those. Neither do token stickers.

So the question is not “is free good?” It is: where should this squad’s coding lane live for the next 45 days — free hosted, paid hosted, or self-hosted — given replay, data, incentives, and exit?

Define the variables before you score

Write these on a wiki page. If a field has no owner, it is not a field. It is a vibe.

Variable	Meaning	Unit	Owner
`R`	Can we re-run the same model + runtime + prompt pack against the same SHA?	`yes` / `partial` / `no`	Platform
`B`	What leaves the building, and is that allowed in writing?	`ok` / `exception` / `blocked`	Security
`W`	Does the lane sit in the PR path, or in a side chat that reviewers never see?	`in-band` / `side`	EM
`I`	Are people hiding prompts, pasting secrets, or dual-running a shadow tool?	`clean` / `leak`	EM
`H`	Extra human hours the lane creates: review, rollback, incident archaeology	hours / week	EM
`X`	Hours to leave: export, re-onboard, rewrite rules, kill the exception	hours	Platform
`C_h`	Fully loaded cost of an engineering hour	currency / hour	Finance partner
`C_run`	Invoice or infra for the lane itself	currency / 45 days	Platform

H is the expensive number. C_run is the loud one. Do not let the loud one win by default.

Three columns, not two slogans

Score the same squad three ways. Do not skip a column because it feels unfashionable.

Keep a free hosted lane. Invoice near zero. You accept whatever pin, quota, and region the operator gives you this month.
Buy a hosted lane. You are paying for a contract: pin, logs, DPA language, support, and a kill switch you can actually pull.
Self-host. You buy replay and boundary with owner hours. The GPU bill is not the whole bill.

Some teams park column 1 on a product that currently offers free model access and a free server option. Disclosure: This article was prepared as part of MonkeyCode's product outreach. I am not treating those offers as permanent, unlimited, named-model, or benchmarked. They are a perishable input to column 1. If they change next week, the card should still work.

Hard gates (these are not scores)

If any gate fails, stop scoring and pick the column that clears the gate. Scores do not override law, paging, or a lying incentive.

Pin gate. The next Sev-2 needs a model id, runtime id, and prompt-pack hash on the PR. If the lane cannot emit those, column 1 is closed for that repo.
Boundary gate. Customer data, secrets, or production configs cannot ride a lane with no written exception. B = blocked kills hosted-free for that surface.
Incentive gate. If people dual-run a shadow tool to “protect” the free lane, you do not have adoption. You have a leak. Freeze expansion.
In-band gate. If reviewers cannot see the prompt, the file list, and the rejection path in the PR, W = side. Side channels do not get to touch auth, payments, or migrations.

Who should not use this card? A solo hobby repo with no pager and no customer data. You do not need a six-field ledger to autocomplete a side project. Also skip it if nobody will own R and X. An orphaned self-host is just a future incident with extra YAML.

Worked example (hypothetical, 8-person squad)

Assume C_h = 95 currency units per hour. Forty-five day window. One platform owner at 0.25 FTE on the lane. No invented vendor list prices — C_run is what you were quoted or what your cloud bill actually did.

Column 1, free hosted

R = no (no pin you control)
B = exception (public tickets only; prod configs banned)
W = side for two engineers who live in chat
I = leak starting in week three (paste of a staging URL)
H = 5.5 extra review/archaeology hours per week
C_run = 0
X = 6 hours to leave

Loaded 45-day human cost: 5.5 * 6.4 weeks * 95 ≈ 3,344. Exit is cheap. Replay is not.

Column 2, paid hosted

R = partial (vendor pin, not your binary)
B = ok on the paper you actually signed
W = in-band after you force the PR check
I = clean if the paid seat is the only blessed path
H = 2.0 hours / week
C_run = your quote
X = 20 hours if the export is clumsy

Human cost: 2.0 * 6.4 * 95 ≈ 1,216 plus C_run plus a slower exit.

Column 3, self-host

R = yes if you freeze image digest + model artifact + prompt pack
B = ok on your network
W = in-band only if you build the PR check; the box does not do that for you
I = leak if the server is up and the workflow is annoying
H = 1.5 hours / week once the workflow exists, plus 0.25 FTE owner (0.25 * 36 hours * 95 ≈ 855 in 45 days)
C_run = power, box, storage, backups — your bill, not a blog benchmark
X = 40 hours if you are the only person who knows the runbook

Self-host wins on pin and boundary. It loses if the owner is fictional.

Would you still keep column 1 if H is 5.5 and R is no? Only if this squad never pages, never handles customer data, and you have already scheduled the expiry.

Sensitivity: the one slider that reverses the call

Hold everything else still. Move one variable.

If H drops under ~2 hours/week because the free lane is in-band and boring, column 1 can survive a 45-day exception. The invoice was never the point.
If R stays no and you have had one unreplayable incident, column 1 is done for that repo. Do not “try one more sprint.”
If C_run for paid hosted exceeds the H savings, you are buying a brand, not a pin. Demand the pin in writing or stop.
If self-host X is 40 hours and the owner takes leave, you do not have a platform. You have a pet.

Break-even against staying free, in words: column 2 or 3 is cheaper when (H_free - H_alt) * weeks * C_h + incident_risk_you_will_actually_write_down > C_run_alt + owner_hours_alt * C_h + (X_alt - X_free) amortized. If you will not write the incident risk down, set it to zero and admit you are gambling.

The 6-field fit card (copy this)

Score each field 0, 1, or 2. Higher means “this column fits this squad for 45 days.” Cap any column at 0 if a hard gate failed.

# fit-card.45d.yaml — conversation tool, not truth
squad: payments-api-8
window_days: 45
owner: platform-lead
expiry: 2026-10-31
hard_gates:
  pin: fail-closed
  boundary: fail-closed
  incentive_leak: freeze-expansion
  in_band_for_sensitive_paths: required
columns:
  free_hosted:
    R: 0   # no pin we control
    B: 1   # exception, public tickets only
    W: 0   # side chat still exists
    I: 0   # leak observed
    H: 0   # 5.5h/week extra
    X: 2   # cheap to leave
  paid_hosted:
    R: 1
    B: 2
    W: 2
    I: 2
    H: 1
    X: 1
  self_host:
    R: 2
    B: 2
    W: 1   # only if the PR check ships
    I: 1
    H: 1
    X: 0   # expensive pet risk
gates_failed:
  free_hosted: [pin, incentive_leak]
recommendation: "Do not expand free_hosted. Pick paid_hosted or self_host after pin is evidenced."

Run a dumb scorer so the meeting cannot hide in adjectives:

# fit_card.py — labeled example, not a benchmark
COLUMNS = {
    "free_hosted": {"R": 0, "B": 1, "W": 0, "I": 0, "H": 0, "X": 2},
    "paid_hosted": {"R": 1, "B": 2, "W": 2, "I": 2, "H": 1, "X": 1},
    "self_host": {"R": 2, "B": 2, "W": 1, "I": 1, "H": 1, "X": 0},
}
GATES_FAILED = {"free_hosted": ["pin", "incentive_leak"]}
WEIGHT = {"R": 3, "B": 3, "W": 2, "I": 2, "H": 2, "X": 1}  # pin/boundary dominate

for name, scores in COLUMNS.items():
    if GATES_FAILED.get(name):
        print(f"{name}: GATE FAIL {GATES_FAILED[name]} -> 0 (do not rank)")
        continue
    total = sum(WEIGHT[k] * scores[k] for k in WEIGHT)
    print(f"{name}: weighted {total} / {sum(WEIGHT.values()) * 2}")

That script will print a zero for the free column. Good. The meeting should argue the inputs, not the printout.

Make replay a merge rule, not a slide

If you cannot pin, you cannot choose column 1 for a paged repo. Put the evidence on the PR. Something this boring:

# required labels on every AI-touched PR (policy, not a product pitch)
echo "lane=$LANE"
echo "model_id=$MODEL_ID"          # empty => fail closed
echo "runtime_digest=$DIGEST"      # empty => fail closed
echo "prompt_pack=$PACK_SHA"
echo "files=$(git diff --name-only origin/main)"

Empty model_id is a failed pin gate. Do not negotiate it in Slack after the page.

Owner, expiry, exit

Owner: the platform lead who can turn the lane off. Not “the squad.” Not “AI champions.”
Expiry: 45 days, on a calendar invite, with the six fields filled again. Exceptions expire. They do not mellow.
Exit criteria for column 1: pin gate fail, one unreplayable incident, I = leak, or H still above the number you wrote down on day 0.
Exit criteria for column 3: owner drops below 0.15 FTE, backups untested, or W slides back to side chat.
Archive rule: keep the YAML, the PR labels, and the incident note. Delete the exception ticket so it cannot be copy-pasted as policy.

Limitations

This card will not tell you which model writes prettier React. It will not rank vendors. It will not invent an ROI from tokens. It under-weights rare, huge incidents unless you write that risk as a number you are willing to defend. It over-weights process if your company never pages.

Do not use it to justify a self-host vanity cluster. Do not use it to keep a free lane alive after a leak because the invoice is flattering.

What would reverse it?

I would keep a free hosted lane for 45 days if R becomes partial or better, W is in-band, I stays clean, and H is under two hours a week on a non-sensitive repo. I would self-host the day B is blocked and we still need a lane. I would pay the day pin and logs are in the contract and owner hours for self-host would exceed the quote.

Your turn. Which variable — R, H, or I — would reverse the column you are defending this week? Write that number next to an expiry date. Then run the card again before the exception quietly becomes the architecture.

Should Your Team Stay on a Free AI Coding Tier? Run This Three-Lane Break-Even Model First

bestbee — Tue, 15 Sep 2026 03:04:34 +0000

The capability fight is over. The invoice fight hasn't started.

Two DEV posts landed within three days of each other this month. On 10 September 2026, one asked whether AI is already better at coding than most software developers, and collected 213 reactions and 181 comments (link). On 8 September, "Most 'AI Agents' Are Just If-Statements in a Trench Coat" gathered 105 reactions and 125 comments (link). Then, on 13 September, a third thread argued the problem is not vibe coding but calling it engineering (link).

All three are good reads. None of them answers the question that actually reaches a budget review: which lane should your team pay for, and at what volume does the answer flip?

So let me do the unglamorous part. Here is the model I use to compare a free hosted tier, a self-hosted box, and a metered paid API — plus a script you can run before your next planning meeting.

Three lanes, one unit

Every team I talk to evaluates these three options on sticker price. That's the first mistake.

Lane A — free hosted access. Someone else's servers, someone else's terms.
Lane B — self-hosted. Hardware you own or rent, on your network, with your uptime.
Lane C — metered paid API. You pay per unit of consumption and control nothing about capacity.

Seats lie. Price per million tokens lies harder, because tokens are usually a rounding error next to the line item nobody counts: human review time.

So pick a unit that survives contact with your P&L.

Unit: fully loaded cost per accepted change. An accepted change is an AI-assisted change that passes review and is still in the codebase two weeks later.

Why two weeks? Because a change reverted on day three was never a win, and rollback labor is real labor. If you cannot measure survival yet, use "merged and not reverted in 14 days" as a first proxy — but write down that it is a proxy, not a measurement.

What Lane A refers to in this article

The operator-supplied claims I am working from: MonkeyCode is an open-source project that offers free model access and a free server option, and the operator advertises 10M free tokens for people evaluating it.

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

I have not independently verified the current quota, the model list, the server specification, or the expiry date. Free allocations change, and that is not a scandal — it is a fact you should plan around. Treat Lane A below as "free until the operator says otherwise" and attach a real expiry date to your own assumption before you build a quarter on it.

The eight inputs you actually need

Most cost models fail because they use four inputs and infer the rest. Use these eight, and label the source of each one.

Attempts per month. Every AI-assisted change that reached review, including the ones you threw away.
Accept rate per lane. Accepted changes ÷ attempts. This differs per lane and people usually assume it doesn't.
Review minutes per attempt, per lane. Your reviewer reads differently when the tool differs. Measure it.
Loaded hourly cost of the reviewer. Salary plus overhead, not salary.
Variable cost per attempt. Tokens, API calls, power draw.
Fixed monthly cost. Reserved capacity, amortized hardware, licenses — things you pay for whether you use them or not.
Ops hours per month. Upgrades, key rotation, incidents, model swaps, backup.
Cost per hour of whoever owns the infrastructure. If nobody owns it, that is Lane B's hidden failure mode.

Inputs 3 and 5 are the ones people guess. Pull 30 recent pull requests and time the reviews with a stopwatch. It takes an afternoon and it will change your conclusion.

A script you can run in twenty minutes

The script below is a proposal, not a measured result. I have not attached a run log, and every number in LANES is an assumption you are expected to overwrite with your own invoice and calendar data.

#!/usr/bin/env python3
"""Compare three AI coding lanes on cost per accepted change.

STATUS: proposal. Every number in LANES is an ASSUMPTION.
Usage:
    python3 lane_breakeven.py --attempts 900 --loaded-hourly 78 --ops-hourly 95
"""

import argparse
from dataclasses import dataclass


@dataclass(frozen=True)
class Lane:
    name: str
    fixed_monthly: float       # paid whether you use it or not
    per_attempt: float         # tokens, API calls, power, per attempt
    review_minutes: float      # human review per attempt
    ops_hours_monthly: float   # upgrades, incidents, key rotation
    accept_rate: float         # fraction of attempts that survive review


LANES = [
    Lane("A free hosted",  0.0,   0.00, 24.0, 0.0, 0.58),
    Lane("B self-hosted", 1450.0, 0.02, 27.0, 9.0, 0.57),
    Lane("C paid metered",  0.0,  0.41, 23.0, 1.0, 0.61),
]


def cost_per_accepted(lane, attempts, loaded_hourly, ops_hourly):
    accepted = attempts * lane.accept_rate
    if accepted <= 0:
        return float("inf"), 0.0
    tokens = attempts * lane.per_attempt
    review = attempts * (lane.review_minutes / 60.0) * loaded_hourly
    ops = lane.ops_hours_monthly * ops_hourly
    total = lane.fixed_monthly + tokens + review + ops
    return total / accepted, total


def self_host_breakeven(self_lane, paid_lane, ops_hourly):
    """Attempts/month where self-hosting ties the metered lane.

    Review cost is treated as lane-independent, which holds only when
    accept_rate and review_minutes match. Change the inputs rather than
    trusting this number if they don't.
    """
    fixed_gap = (self_lane.fixed_monthly
                 + self_lane.ops_hours_monthly * ops_hourly
                 - paid_lane.fixed_monthly)
    per_attempt_gap = paid_lane.per_attempt - self_lane.per_attempt
    if per_attempt_gap <= 0:
        return None
    return max(fixed_gap, 0.0) / per_attempt_gap


def main():
    p = argparse.ArgumentParser()
    p.add_argument("--attempts", type=float, default=900.0)
    p.add_argument("--loaded-hourly", type=float, default=78.0)
    p.add_argument("--ops-hourly", type=float, default=95.0)
    args = p.parse_args()

    print(f"attempts/month={args.attempts:.0f}  loaded=${args.loaded_hourly:.0f}/h")
    print(f"{'lane':<16}{'total/mo':>12}{'accepted':>10}{'per accepted':>14}")
    for lane in LANES:
        per, total = cost_per_accepted(
            lane, args.attempts, args.loaded_hourly, args.ops_hourly)
        accepted = args.attempts * lane.accept_rate
        print(f"{lane.name:<16}{total:>12,.0f}{accepted:>10.0f}{per:>14,.2f}")

    be = self_host_breakeven(LANES[1], LANES[2], args.ops_hourly)
    print()
    if be is None:
        print("self-host ties the metered lane at any volume for these inputs")
    else:
        print(f"self-host ties the metered lane at ~{be:,.0f} attempts/month "
              f"(~{be / 5.0:,.0f} per engineer at 5 engineers)")

    minute_cost = (args.attempts / 60.0) * args.loaded_hourly
    print(f"one extra review minute per attempt costs ~${minute_cost:,.0f}/month")


if __name__ == "__main__":
    main()

A filled example (hypothetical, fully specified)

Picture a five-engineer squad. 900 attempts a month, $78 loaded hourly, $95 hourly for the one person who owns infrastructure. Lane A has no fixed cost and no metered cost because it is free today. Lane B carries a $1,450/month amortized hardware and power line, plus nine ops hours. Lane C meters at $0.41 per attempt plus one ops hour.

python3 lane_breakeven.py --attempts 900 --loaded-hourly 78 --ops-hourly 95

These outputs are arithmetic from the assumptions above — not measurements of any product.

attempts/month=900  loaded=$78/h
lane                 total/mo  accepted  per accepted
A free hosted          28,080       522         53.79
B self-hosted          33,913       513         66.11
C paid metered         27,374       549         49.86

self-host ties the metered lane at ~5,910 attempts/month (~1,182 per engineer at 5 engineers)
one extra review minute per attempt costs ~$1,170/month

Look at the shape of that table. The entire metered token bill for Lane C is $369/month. The review line for the same lane is $26,910/month. The model choice is roughly 1.4% of the total.

That is the finding most teams miss while they argue about which model is smarter.

Sensitivity: three variables, three different answers

A single point estimate is not a decision. Move these three and watch the ranking change.

Review minutes. Here, one extra minute per attempt costs about $1,170/month. Lane B's review is four minutes slower than Lane C's, which is worth roughly $4,680/month — more than three times Lane B's entire hardware line. That single assumption decides the answer.
Accept rate. Drop Lane C's accept rate from 0.61 to 0.55 and its cost per accepted change moves from $49.86 to about $55.30, which makes the free lane the cheapest option again. Accept rate is not a detail; it is a ranking variable.
Ops hours. Self-hosting only ties the metered lane at roughly 5,910 attempts/month for these inputs. Cut ops to two hours and hardware to $700 and the crossover falls to about 2,282 attempts — still around 456 attempts per engineer per month.

And if Lane A quietly throttles or queues, adding three minutes of waiting per attempt costs about $3,510/month. "Free" becomes the second-most-expensive lane without anyone changing a price.

Fit criteria: five questions, one table

Answer these before you pick a lane. The scorecard is a conversation tool, not objective truth — its job is to surface disagreement, not to settle it.

Can your source code leave your network at all? If no, Lane A and Lane C are disqualified and the real choice is Lane B versus not adopting.
Does one named person spend at least four hours a week owning infrastructure? If no, do not choose Lane B.
What is your attempts per month? Below ~1,500, fixed costs dominate and self-hosting almost never amortizes.
How spiky is demand? Steady load favors self-hosting; bursty load favors metered billing.
How much review headroom do you have? The model shows review dominates, so adding a lane without adding review capacity just relocates the queue.

Signal	Free hosted	Self-hosted	Paid metered
Code can leave your network	no → disqualified	yes	no → disqualified
Named infra owner ≥4h/week	not needed	required	not needed
Attempts per month	low to mid	high enough to amortize	any, but cap the spend
Demand shape	steady, low stakes	steady, sensitive data	spiky bursts
Cost of leaving	low	high, hardware is sunk	low

Hard gates, an owner, an expiry

A model without an enforcement clause is a slide. Write these down.

Lane A gate: re-approve every 30 days. Free allocations change; a decision made against today's terms should expire with them.
Lane B gate: kill it if ops hours exceed your stated ceiling for two consecutive months. Name the owner and the ceiling.
Lane C gate: alert at 80% of the monthly cap, and require a second approval above it.
Expiry: every lane decision expires in 90 days or when any input moves more than 25%. Whichever comes first.
Exit criteria: if review minutes per accepted change rise 25% for two consecutive weeks, stop adding seats or lanes and fix the review path first.

One owner per lane. An expiry date. A written exit condition. That is the whole governance cost.

Limitations, and who should skip this

The model above ignores switching costs, quality differences beyond accept rate, and queueing delays when a hosted tier throttles. It treats review cost as lane-independent in the crossover formula, which is wrong whenever review minutes actually differ — and in the example, they do.

Skip this approach if you are a solo developer with fewer than 50 attempts a month; noise will dominate every number and you will spend more time modeling than coding. Skip it if your code cannot leave your network and you have no infra owner — your answer is "none of these lanes," and that is a legitimate answer. And do not build a roadmap on a free allocation you have not dated.

What I would ask you

Before you switch lanes, answer one question: which variable would have to move — review minutes, attempts per month, or ops hours — before your current lane stops being the right choice?

If the honest answer is "review minutes," then the cheapest experiment is a bounded pilot on a free lane, because you are not testing the model. You are testing one number with a stopwatch. MonkeyCode's free model access and free server option exist for exactly that kind of bounded test, and the operator's terms — including the advertised 10M free tokens — are theirs to set and worth reading before you plan a quarter around them.

Measure the review minutes first. Everything else is cheaper than guessing wrong about those.

Price AI Coding Lanes With Rollback Hours, Not Token Stickers

bestbee — Sun, 13 Sep 2026 19:10:20 +0000

A platform lead told a room the AI coding bill was zero. Then someone opened the revert log. Fourteen reverts in eleven working days. That is not a free path. That is an unpriced one.

I keep seeing the same inversion. Finance scores seats and token stickers. Incident review scores hours you cannot get back. Which unit should actually assign the work?

This is a routing guide, not a vendor sermon. I will price three lanes with one equation, fill a labeled example, and show which variable flips the call. The scorecard is a conversation tool. It is not objective truth.

The bad proxy hiding in the standup

Teams still ask, "Is the model free?" That question is incomplete. Free of invoice is not free of review, revert, or context setup.

A token sticker also lies in the other direction. A paid seat can look expensive while it quietly deletes two rollback hours a week. Self-host can look virtuous while it burns a platform engineer on GPU babysitting that never shows up on the AI budget line.

So I stopped asking which tool is cheaper. I ask which workstream belongs on which lane.

Three lanes, one workstream at a time

Do not make a team-wide license call. Route tickets.

Free lane: zero invoice, shared or hosted-for-you runtime, weakest guarantee that the path will still look the same next quarter.
Paid lane: invoice you can forecast, vendor on the hook for uptime and policy knobs, still not your metal.
Self-host lane: you own the runtime, the logs, and the failure. You also own the idle capacity.

A changelog draft and an authz middleware change should not share a lane just because they share a repo. Why would they?

Variable definitions

Write these on the top of the sheet before anyone argues about brands.

Symbol	Meaning	Unit
`R`	Fully loaded cost of one rollback hour (author + reviewer + wait)	currency / hour
`H`	Extra rollback hours this workstream is expected to create per week on that lane	hours / week
`I`	Invoice for that lane, allocated to this workstream	currency / week
`C`	Amortized context and policy setup (rules, allowlists, eval fixtures)	currency / week
`G`	Governance drag (legal, security, procurement) that actually fires	currency / week
`K`	Hard kill switch. If true, cost math does not get a vote	boolean

Weekly lane cost:

LaneCost = I + R * H + C + G

If K is true, you do not pick the cheapest number. You leave the lane. Secrets, production-adjacent writes without an owner, and unauditable training-data questions are K events in most orgs I advise. Your legal team may add more. They should write them down.

The rollback-hour router

I score each workstream against all three lanes. Lowest LaneCost wins unless a kill switch fires.

Copy this YAML and fill it in the staff meeting, not after the vendor demo.

# proposal: conversation tool, not a benchmark
workstream: billing-api-tests
owner: platform-lead
expires_on: 2026-10-14
r_rollback_hour: 180   # labeled assumption, fully loaded
lanes:
  free:
    I: 0
    H: 3.5
    C: 40
    G: 0
    K: false
  paid:
    I: 220
    H: 1.2
    C: 25
    G: 30
    K: false
  self_host:
    I: 90    # allocated idle capacity, not cash if already owned
    H: 1.0
    C: 70
    G: 15
    K: false
exit:
  freeze_free_if: "H_free > 2.0 for 2 consecutive weeks"
  rescore_after_tickets: 20

Then run the arithmetic so the argument has a denominator.

# unlabeled brands on purpose. plug in your numbers.
from dataclasses import dataclass

@dataclass
class Lane:
    name: str
    invoice: float
    extra_rollback_h: float
    setup: float
    governance: float
    kill: bool

R = 180.0  # labeled assumption: $/rollback-hour

lanes = [
    Lane("free", 0, 3.5, 40, 0, False),
    Lane("paid", 220, 1.2, 25, 30, False),
    Lane("self_host", 90, 1.0, 70, 15, False),
]

for lane in lanes:
    cost = lane.invoice + R * lane.extra_rollback_h + lane.setup + lane.governance
    status = "BLOCKED" if lane.kill else f"{cost:.0f}"
    print(f"{lane.name:10} LaneCost={status}")

Expected print for the labeled example:

free       LaneCost=670
paid       LaneCost=491
self_host  LaneCost=355

Self-host wins on this sheet. Change R or H and it may not. That is the point.

A filled squad example (labeled, not a customer claim)

Take an eight-person platform squad. Three workstreams. I am not citing a named company. These are working numbers so you can disagree with a digit instead of a vibe.

Assumptions I want challenged: R = $180. Reviewer time is in the number. Calendar time waiting on a broken deploy is not, unless you add it.

Release notes and internal runbooks. H_free = 0.3, I_free = 0, K = false. Free lane cost ≈ $54 + setup. Paid cannot win unless setup on free is chaotic. Keep it free. Put a human on the merge.
Billing API tests that touch fixtures, not secrets. H_free = 3.5, H_paid = 1.2, I_paid = $220 / week allocated. From the script above, paid beats free (491 vs 670). Self-host beats both if you already have idle capacity. If you do not, set I_self_host to the real weekly carry and re-run.
Authz middleware. K = true on any path you cannot log, restrict, or turn off. Cost math is commentary. Self-host or a paid tenant with a written data path. Not a shared free box.

Notice what I did not do. I did not average the three workstreams into one "AI ROI." Averages hide the kill switch.

Sensitivity: which number reverses you?

Hold everything else still and move one lever.

Lever	Direction	What flips
`R` falls from 180 to 50	rollback is cheap	billing tests fall back to free (`0 + 503.5 + 40 = 215` vs paid `220 + 501.2 + 55 = 335`)
`H_free` falls from 3.5 to 1.0	reviewers actually catch the mess	free wins on billing tests even at `R = 180`
`I_paid` jumps because you allocated the whole invoice to one squad	paid looks toxic	you are doing allocation theater; split `I` by tickets, not by pride
Idle GPUs already exist	`I_self_host` near zero	self-host wins more often, until on-call hours leak into `C`
Legal says prompts leave the tenant	`K = true`	free lane dies regardless of `LaneCost`

If no lever can reverse you, you are not running a model. You are defending a purchase.

Crude telemetry helps you stop guessing H. This is a proxy, not science.

# last 14 days, revert-shaped commits on one service
git log --since="14 days ago" --grep="revert" --oneline -- services/billing-api | wc -l

# optional: minutes between bad merge and revert, if your messages are disciplined
git log --since="14 days ago" --grep="revert" --format="%ct %s" -- services/billing-api

Count is not hours. Multiply by your median revert duration from the incident doc, then divide by two weeks. If you do not have that median, you are not ready to claim the free lane is "working."

Hard gates, owner, expiry, exit

Gates that skip the equation:

Secrets or customer PII in prompt, repo context, or traces. No free shared runtime.
Production-adjacent write tools without a named blast-radius owner. No lane at all until the owner exists.
No merge human. If the path can open a PR, a person still ships it. Automation without a neck is not a lane. It is a leak.

Owner: the platform lead who can freeze a lane without a steering committee. If that person does not exist, you do not have a router. You have a Slack poll.

Expiry: 30 days or 20 tickets, whichever comes first. Write the date in the YAML. An expired score with last quarter's H is fan fiction.

Exit: freeze the free lane for that workstream when H_free beats your break-even for two consecutive weeks, or when a K event fires once. Unfreezing needs a new sheet, not a vibe that "the model got better."

Break-even extra rollback hours for free versus paid:

H_free_break_even = H_paid + (I_paid + C_paid + G_paid - C_free - G_free) / R

Plug the labeled billing-test numbers:

H_free_break_even = 1.2 + (220 + 25 + 30 - 40 - 0) / 180
                  = 1.2 + 235 / 180
                  = 2.51 hours/week

If free is adding more than ~2.5 rollback hours a week on that stream, the sticker price of zero has already lost. That threshold moves the moment R moves. Put the formula next to the YAML so people argue the input, not the brand.

Where a free model path still belongs

I do not route every spike to a credit card. Internal docs, throwaway probes, and new-hire sandboxes often lose when you force a paid tenant before anyone knows whether the workflow sticks.

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. That pair maps to the free lane in this router: useful when K is false and H is still a guess. It does not map to authz middleware, and I will not pretend a free runtime is a production owner. If you try it, score the workstream in the YAML first. Then look at revert hours, not at whether the chat felt fast.

A free server also fails a different way than a free chat box. Someone still has to patch it, restrict network egress, and decide who can paste logs into the prompt. If that someone is "whoever found the link," C and G are lying on your sheet.

Who should not use this router

Skip it if you are a solo hobbyist. Your R is weekend mood, not payroll.

Skip it if a regulator or a customer contract already names the runtime. The equation will only decorate a decision you are not allowed to make.

Skip it if you cannot name a median revert duration. You would be stuffing H with optimism. That is how "free" paths become silent headcount taxes.

And skip any scorecard that outputs a single company-wide winner. Workstreams do not consent to that average.

What I would challenge on your sheet

Would a 30-point drop in R send billing tests back to free? If yes, your paid lane is a rollback hedge, not a quality religion. Price it that way.

Would one K event — a secret in a prompt, a prod write with no owner — wipe the free lane even when LaneCost looks pretty? It should.

I want the argument on those two questions. Not on whether the token sticker was zero.

Should a Squad Graduate a Free Coding Path When Review Time Inverts? Use This 5-Field Gate

bestbee — Sat, 12 Sep 2026 17:04:00 +0000

Forty extra review minutes can erase a zero invoice. I keep seeing that inversion in platform reviews, and it almost never shows up on a pricing page.

Last quarter I sat with an EM who was proud the coding path had no bill. The review queue was two days deep. Agent-shaped PRs were landing faster. Humans were not. So I asked the only question that can reverse a “keep it, it’s free” call: what happens if review minutes per merged change stay inverted for two more sprints?

This is not a buy-the-tool essay. It is a graduation gate. Free hosted models and a free server can be a rational row in the table. They can also become a shadow platform with no owner, no expiry, and a switch cost you will hate later.

The wrong unit is still “free”

Invoice line is a terrible proxy for coding-path cost. A zero invoice hides three cash-like drains: extra review minutes, dual-workflow tax, and the day you must move.

Paid seats can be the wrong unit too. Self-hosting can be the wrong unit if you price hardware and ignore the human who now owns uptime. I want one question on the whiteboard: should this squad keep, graduate, or kill the free coding path?

Keep means the free path stays default for a named scope. Graduate means you move that scope to paid or self-hosted on a date. Kill means you archive the path and write down what you will not do again. Which of those three is actually on your calendar today?

Define five fields before anyone argues

Treat this scorecard as a conversation tool, not objective truth. Fill it with your numbers. If a field is blank, you do not have a decision. You have a vibe.

Field	Definition	Unit	Who measures
Review-minute inversion (RMI)	Extra human review minutes per merged PR vs the squad’s baseline for similar diffs	minutes / merged PR	EM + a rotating reviewer
Secret surface (SS)	Whether prompts, repo context, or secrets leave the team’s control boundary	inside / mixed / leaves	Security + platform
Switch cost (SC)	Calendar days to move the same workflow to paid or self-hosted without freezing shipping	days	Tech lead
Dual-path tax (DPT)	Hours per week lost to two coding paths, two prompt styles, two “how we do agents” docs	hours / week	EM
Owner + expiry (OE)	Named human plus a date when keep/graduate/kill is re-decided	name + ISO date	Director or platform lead

Hard rule: if OE is empty, the path is not free. It is unowned infrastructure.

I score keep vs graduate vs kill with gates, not with a weighted average that pretends precision. Averages hide a single red gate. You already know that from incident reviews. Why would a coding path be different?

Proposed measurement, not a benchmark

Do not invent velocity theater. Pull a small, boring sample. Thirty merged PRs. Two weeks. Label the method as a proposal until you actually run it.

# Proposed measurement — run on YOUR repo; this is not a result set.
# Baseline: human-authored PRs. Treatment: PRs that used the free coding path.
gh pr list --state merged --limit 30 \
  --json number,title,author,createdAt,mergedAt,reviews,labels \
  > /tmp/pr-sample.json

# Then tag each row in a sheet: baseline | free_path
# RMI = median(review_minutes_free) - median(review_minutes_baseline)

Review minutes are not “time to first comment.” Use time from ready-for-review to first approving review, minus known blockers. If you cannot get that from your tool, sit with two reviewers for one standup and reconstruct ten PRs. Ugly beats fake precision.

A tiny ledger keeps the argument honest:

# decision_record.yaml — proposal, unexecuted
question: graduate_free_coding_path
scope: squad_orion_service_repo
baseline_window: 2026-08-25/2026-09-12
fields:
  rmi_minutes: null          # fill from sample
  secret_surface: mixed      # inside | mixed | leaves
  switch_cost_days: 10       # paid vs self-host may differ; pick the real alternative
  dual_path_tax_hours: 3
  owner: "A. Chen, EM"
  expiry: "2026-10-10"
gates:
  secrets_must_stay_inside: true
  named_owner_required: true
  rmi_kill_threshold_minutes: 40
  rmi_streak_sprints: 2

If rmi_minutes stays null, stop the meeting. You are bargaining about a feeling.

Hypothetical: Squad Orion, not a case study

I am not claiming this squad exists. I am filling the tool so you can see the arithmetic. Copy the structure. Replace every number.

Squad Orion: eight engineers, one service repo, one “no invoice” coding path for boilerplate and tests. Baseline review for a similar PR: 25 minutes. Free-path PRs: 70 minutes, because the diffs are wide, the tests are shallow, and reviewers do not trust the agent loop. RMI = 45. Secret surface = mixed (prompts leave the laptop, secrets are supposed to stay). Switch cost to a paid path = 6 days of policy and seat work. Switch cost to self-host = 18 days including on-call. Dual-path tax = 4 hours/week of “which path did you use?” Slack. Owner exists. Expiry is blank.

What does the gate say?

OE fails. No expiry means keep-by-inertia. That is a stop, not a keep.
RMI is 45 against a 40-minute kill line. One sprint is a smell. Two sprints is a graduation trigger.
SS is mixed. If the next SOC questionnaire asks where repo context went, “it was free” is not an answer.
SC is the real comparison. Six days to a paid path vs eighteen to self-host. Free vs paid is not the same decision as free vs self-host. Write both.

Weekly human cost of the inversion, labeled as arithmetic on the hypothetical:

12 merged free-path PRs / week × 45 extra minutes = 9 hours of senior review.
Plus 4 hours of dual-path tax = 13 hours / week.
At a fully loaded $120/hour (your finance number, not mine), that is $1,560 / week of “free.”

Would you still call it free if the invoice arrived as review load? I wouldn’t. Not past expiry. Not with mixed secret surface.

Sensitivity: which number flips you?

Hold every field still and move one. That is the whole point of a gate.

If RMI drops to 12 minutes after you ban agent loops from auth and migrations, keep can survive — with an expiry.
If RMI stays at 45 for two sprints, graduate the default path even if the invoice is still zero.
If SS becomes “leaves” for a regulated repo, free hosted is out regardless of RMI. That is a hard gate, not a score.
If SC to paid is 6 days and SC to self-host is 18, do not let a hardware enthusiast skip the cheaper graduation. Self-host is a product choice, not a moral one.
If DPT hits 8 hours/week, you already have two platforms. Pick one default. The second path becomes an expiring exception, not a culture.

Break-even on the hypothetical: extra review minutes × PRs per week = the “free” surplus. At 12 PRs/week, a 40-minute RMI is 8 hours. If your paid alternative’s true add-on (seats, admin, extra process) is less than those 8 hours, graduation wins on P&L even before secrets. If the paid add-on is 15 hours/week of ceremony, keep the free path and fix the review protocol instead. See how fast the answer moves? That is why a single vendor narrative is useless.

Where a free hosted row belongs

You still need a concrete row for “stay on a free hosted path.” Empty rows get filled by whoever is loudest.

Disclosure: This article was prepared as part of MonkeyCode's product outreach. MonkeyCode is an open-source project that currently offers free model access and a free server option. I am using those two availability claims as operator-supplied inputs to the table — not as a TCO conclusion, a benchmark, or a promise about models, quotas, hardware, or how long the offer lasts.

Put that row next to “paid hosted” and “self-host.” Then run SS and SC. A free hosted path is a fit when secret surface can stay inside policy, RMI is measured, a named owner exists, and expiry is on a calendar. It is a poor fit when the squad is already using the path as default infra for anything that can page production.

If you want a free hosted row to score against your own review sample, try MonkeyCode and then fill RMI from your last thirty PRs — not from a landing page.

Hard gates, owner, expiry, exit

Gates are binary. Miss one and you do not “average it out.”

Keep is allowed only if all of these are true:

Named owner on the decision record.
Expiry ≤ 45 days from today (pick your number; write it).
SS is inside, or mixed with a written exception that names the repos that are in and out.
RMI is below your kill line, or above it for at most one sprint with a dated fix.
Default path is scoped (for example: tests and docs, not auth).

Graduate when:

RMI ≥ kill line for two consecutive sprints, or
DPT ≥ 6 hours/week, or
a paid path’s switch cost is lower than the next two sprints of inverted review.

Kill when:

SS is “leaves” on a repo that cannot leave, or
no owner will put their name on OE, or
the path is the only way anyone knows how to change the service.

Exit criteria should be boring. Archive the prompts. Close the free-path default in the team README. Move the exception list to a gist or an internal RFC with an expiry. Say out loud what happens to in-flight agent sessions on the expiry date. If you cannot describe the Tuesday after expiry, you do not have an exit. You have hope.

Owner is not “platform.” Owner is a person who can stop the path. Expiry is not “when we know more.” Expiry is an ISO date that creates a meeting even if nobody wants it.

Who should not use this approach

Skip this gate if you do not merge through review. There is no RMI without a reviewer. Also skip it if legal already forbids any hosted prompt path; you already have the answer, and a scorecard would be theater.

Do not use a free hosted path as a stealth self-host delay for teams that need an on-call owner tomorrow. Do not use self-host as a purity move when your actual pain is review protocol. And do not run this as a founder-only spreadsheet while the EM who eats the queue is out of the room. The queue is the P&L.

Limitations

This model ignores model quality as a single number because I will not invent win rates. Quality shows up as RMI and as rollback rate. If you have a rollback delta, add a sixth field. If you do not, do not fake one.

The 40-minute kill line is a conversation starter. Finance might want dollars. Security might want a binary SS and nothing else. Good. Bring them into the same document. The failure mode I care about is a squad that keeps a free path because the invoice is quiet while seniors drown in wide diffs.

I also cannot tell you that free model access or a free server will still be there on your expiry date. Price switch cost as if the row can vanish. That is just TCO hygiene.

So here is the question I actually want back: which field would reverse your keep — RMI, secret surface, or switch cost — and what number did you write next to it? If you cannot name the number, you are not deciding. You are hoping the invoice stays zero long enough that the queue feels like someone else’s problem.

Should a Squad Promote a Free Coding Path to Shared Context? Use This 4-Gate Test

bestbee — Fri, 11 Sep 2026 14:59:58 +0000

I still start these reviews the same way. Not with a model leaderboard. With the merge queue.

A twelve-person squad can mint more unreviewed AI answers in one week than staff engineers can reconcile in a month. That ratio can reverse a “make the free path the default” decision overnight. A viral thread claiming AI already codes better than most developers does not pay the review tax. You do.

Picture Tuesday standup. The EM drops a screenshot. Three people solved the same auth-boundary question in three private chats. Three answers. Three slightly different error contracts. Zero shared constraints in the repo. Cheap generation. Expensive divergence. Sound familiar?

The wrong question

“Is the model good enough?” is a product-marketing question. It is not an adoption question.

The adoption question is uglier. Should this free coding path stay a personal scratchpad, or should you promote it into shared context the team is allowed to trust?

Those are different products wearing the same chat UI. Mix them up and you get shadow standards, unowned incidents, and a prompt folklore nobody can exit.

I use four gates. They are a conversation tool, not objective truth. If one variable below would flip your call, write it down before anyone “standardizes” a server.

Scratchpad vs shared context

A scratchpad is private, disposable, and easy to abandon. A shared context path is a workflow. It has owners, reuse, and a blast radius when it is wrong.

Mode	What you are actually buying	Failure mode
Personal scratchpad	Speed on a single task	Divergent patterns, duplicated wrong answers
Shared context	Reused constraints, fewer repeated questions	Unowned “the agent said so” merges
Paid team workspace	Vendor workflow, seats, support path	Seat proxies hiding unused licenses
Self-host	Control of data path and teardown	You inherited an internal SaaS

Free model access and a free server option sit in the first two rows until you promote them. Promotion is the decision. Not the signup.

Disclosure: This article was prepared as part of MonkeyCode's product outreach. MonkeyCode is one open-source coding product that currently offers free model access and a free server option. I am not treating those as a quality ranking, a quota promise, or a permanent SKU. I am treating them as a cheap way to run the gates below before you pay, self-host, or freeze a standard.

Would you promote a wiki that nobody edits? Then do not promote a chat log either.

The 4-gate ownership test

Define the variables first. Then score. Then argue.

Context reuse rate (CRR). Share of AI answers that get pasted, linked, or encoded into repo artifacts another human can find in 90 seconds. Unit: percent of AI-touched tasks in a 14-day window.
Review hours per AI-touched merged PR (RH-PR). Staff time spent on first review plus re-review, including “please undo the clever bit.” Unit: hours / merged PR.
Named revert authority (NRA). One human who can revoke the path, revert the pattern, and say no without a committee. Unit: named role, not a Slack channel.
Folklore exit days (FED). Calendar days to recapture prompts, rules, and “we always do it this way” into files in git if the free path vanishes. Unit: days.

Score each gate 0, 1, or 2. Total 0–8. This is not a personality test. It is a promotion test.

Scoring rubric

CRR

0: reuse under 15%. Private chats die in the thread.
1: 15–40%. A few snippets land in PRs, still not searchable.
2: over 40%. Constraints live in repo docs, fixtures, or policy files.

RH-PR

0: review hours up more than 25% vs the prior 14 days on comparable PRs.
1: flat within ±25%.
2: down more than 25%, with the same review bar. No silent rubber-stamping.

NRA

0: “the team” owns it. Nobody can kill it on Friday.
1: an EM owns it, but only after a sync.
2: a named owner can revoke access the same day, in writing.

FED

0: exit would take more than 14 days or depends on one person’s head.
1: 8–14 days, with a documented prompt dump.
2: 7 days or fewer, because rules already live in the repo.

Hard promotion rule I use: do not promote to shared context unless CRR ≥ 1, NRA = 2, and total ≥ 5. A pretty model demo cannot override a missing owner. Should it?

Filled example (hypothetical squad, labeled as such)

Squad Helios. 12 engineers. 14-day window. Labeled unmeasured proposal, not a customer case.

They want to promote a free coding server from “try it” to “how we answer architecture questions.”

Observed in the worksheet (hypothetical):

40 AI-touched tasks
8 produced a repo artifact another person reused → CRR = 20% → score 1
Mean RH-PR moved from 1.6h to 2.1h → +31% → score 0
Owner is “platform, kind of” → NRA score 0
Prompts live in four Notion pages and one engineer’s local snippets → FED ≈ 15 days → score 0

Total: 1 / 8. Keep it a scratchpad. Do not put it on the onboarding doc. Do not imply the answers are team canon.

Same squad, different 14 days, after they force one rule: every reused answer must land in /docs/ai-constraints/ or it does not count as shared.

CRR 45% → 2
RH-PR 1.4h vs 1.6h baseline → 2
Staff engineer Maya is revert authority, written in the README → 2
Constraints already in git, FED = 3 days → 2

Total: 8 / 8. Now you may discuss promotion. You still set an expiry. A scorecard is not a marriage certificate.

Sensitivity that should change your mind

Hold three variables still. Move one.

Lever you change	If it moves this way	Decision flip
CRR	Falls under 15%	Demote to personal scratchpad
RH-PR	Rises over 25%	Freeze promotion, inspect review bar
NRA	Owner goes on PTO with no deputy	Suspend shared use the same day
FED	Exit estimate exceeds 14 days	Stop writing new shared prompts
Incident	One production miss tied to an unreviewed answer	Exit the shared path; scratchpad may remain

Break-even I actually argue about: hours saved in repeated questions versus hours added in review.

Weekly question load Q. Minutes saved per reused answer S. Reuse rate CRR. Extra review minutes per AI-touched PR R. AI-touched PRs per week P.

Net hours ≈ (Q * CRR * S) / 60 - (P * R) / 60

If net hours go negative, the free path is a cost center even when the invoice is zero. Invoice-zero is not P&L-zero. You knew that, right?

Worked numbers for Helios, still hypothetical: Q = 30, S = 12, CRR = 0.20, P = 10, R = 30.

Net ≈ (30 * 0.20 * 12)/60 - (10 * 30)/60 = 1.2 - 5.0 = -3.8 hours/week.

That is the whole case against promotion. Not model quality. Not a tweet. Review tax larger than reuse.

Raise CRR to 0.50 and drop R to 10 minutes because constraints are in git: net ≈ (30 * 0.50 * 12)/60 - (10 * 10)/60 = 3.0 - 1.7 = +1.3 hours/week. Only then is shared context even in the conversation.

Measurement you can run without a vendor dashboard

Label this as unexecuted template. Do not pretend it is telemetry you already have.

# Last 14 days of merged PRs, titles only. Adjust the date.
git log --merges --since='2026-08-28' --pretty=format:'%h %ad %s' --date=short

Keep a boring CSV. If it is not boring, people will stop filling it.

date,task_id,ai_touched,reused_in_repo,review_hours,merged,owner
2026-09-01,PAY-118,yes,yes,1.2,yes,maya
2026-09-02,PAY-121,yes,no,2.4,yes,lee
2026-09-03,PAY-126,no,no,0.8,yes,maya

Proposed scorer. Hypothetical. Run it on your sheet, not on my claims.

# proposal only: score promotion gates from a local csv
import csv
from statistics import mean

BASELINE_RH = 1.6  # hours; set from YOUR prior window

rows = list(csv.DictReader(open("ai_context_gate.csv")))
ai = [r for r in rows if r["ai_touched"] == "yes"]
crr = sum(r["reused_in_repo"] == "yes" for r in ai) / max(len(ai), 1)
rh = mean(float(r["review_hours"]) for r in ai) if ai else BASELINE_RH

def bucket_crr(x):
    return 2 if x > 0.40 else 1 if x >= 0.15 else 0

def bucket_rh(x, base):
    delta = (x - base) / base
    return 0 if delta > 0.25 else 2 if delta < -0.25 else 1

print({"crr": round(crr, 2), "crr_score": bucket_crr(crr),
       "rh_pr": round(rh, 2), "rh_score": bucket_rh(rh, BASELINE_RH)})

NRA and FED still need a human. Scripts do not name owners. Scripts do not recapture folklore. If your “owner” is a distribution list, you already scored a zero.

Hard gates, owner, expiry, exit

Write these in the same README you were about to stuff with tool cheerleading.

Owner: one staff engineer or EM. Deputy named. Not “platform.”
Expiry: 14 days after promotion, auto-demote unless the four scores are re-recorded.
Stop gates: CRR < 15%, RH-PR +25%, missing owner, or one production incident tied to an unreviewed answer.
Exit: prompts and constraints already in git, or FED work starts the day you promote, not the day the free server hiccups.
Non-goals: do not use seats, token headlines, or “it feels faster” as proxies.

If you cannot name the exit, you are not buying leverage. You are buying a habit.

Where free models and a free server actually fit

Use a free-model, free-server path when you are still in measurement mode. You need enough usage to fill the CSV. You do not yet need a seat contract or a self-hosted internal SaaS.

Stay on personal scratchpad if CRR is low and RH-PR is rising. That is most squads in week one. It is not a moral failure. It is a workflow mismatch.

Consider paid or self-host only after promotion passes twice in a row. Paid does not fix missing ownership. Self-host does not fix a review bar you were afraid to keep. Build-versus-buy is downstream of this test. Reverse that order and you will decorate a bad habit with invoices or with YAML.

MonkeyCode is a reasonable place to run the first 14-day measurement if a free model path plus a free server is what you need to get the worksheet. Run the gates first. If the score stays a 1, do not “standardize” anything. Just close the tab.

Who should not use this approach

Do not promote a third-party free server into shared context if you cannot put that code or that prompt traffic on someone else’s machine. Regulated data, unpaid legal review, or “we will anonymize later” is a stop, not a yellow flag.

Do not use the scorecard if you will treat a 6 as a mandate. It is a conversation tool. Two senior engineers can weight RH-PR differently. Good. Put the disagreement on the page.

Do not use it to launder a quality claim. I am not saying any model is better than your developers. I am saying unowned generation does not become knowledge because the chat was fluent.

Skip the whole promotion idea if the squad already has a working design-review ritual and AI is only used for local boilerplate. You do not need a shared context program to rename variables.

Limitations

I did not benchmark models. I did not invent a quota, a GPU SKU, or a durability promise. Token headlines change behavior; they are still a bad unit for this decision. Review hours and reuse are slower to collect and harder to fake. That is the point.

Fourteen days is an arbitrary window. If your merge cadence is weekly, extend the window or you will overfit two PRs. If your cadence is many merges per day, 14 days may hide a bad week. Say the window out loud.

And if the only artifact you can produce is a vibe, you are not ready to promote. You are ready to keep a scratchpad.

So which variable would reverse your call? CRR, RH-PR, the named owner, or the exit clock? If you cannot pick one, you are not deciding. You are hoping the free path stays free and the review queue stays quiet. Hope is not a gate.