DEV Community: bestbee

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

bestbee — Mon, 26 Oct 2026 11:08:20 +0000

The question landed at minute forty of a planning call: "why don't we just put everything on the free lane and revisit next quarter?"

It is a fair question, and it is usually answered badly — with a price comparison, or with a vibe about model quality. Both miss the thing that actually decides the outcome.

The scene is a composite, assembled from conversations I keep having with platform leads. No client numbers below, and no measured benchmarks.

The lane you pick is a statement about what you can refuse

There are three lanes most teams are actually choosing between:

Hosted free allowance — zero contract, zero ops, shared infrastructure, terms you don't control.
Hosted paid — a contract, per-unit billing, stronger retention and version guarantees.
Self-hosted — your hardware, your patching, your pager.

Every lane forces refusals. The free lane refuses some data classes, some concurrency, some model pinning, some audit trails — exactly which ones depends on terms you should have in writing. Self-hosting refuses the team that has no named ops owner.

So the real question is not "which is cheapest?" It is: which refusals can this workload absorb for the next 90 days?

Why price goes last

Price is a continuous variable. Constraints are binary.

A lane you are not permitted to use has an infinite unit cost, no matter how good the sticker looks. I've written before about computing crossovers; this post is about the step before that math, where you decide which lanes are even admissible.

Get the admissibility set wrong and the spreadsheet becomes a very precise answer to the wrong question. Sound familiar?

The worksheet: exclude first, tie-break second

Here is the artifact. It is deliberately dumb, stdlib-only, and reproducible in one file.

"""lane_fit.py — exclude AI coding lanes by hard constraints, then break ties.

Python 3.10+. No dependencies.

    python lane_fit.py

Every number in LANE_ASSUMPTIONS is a PLACEHOLDER. Replace it with the
term you actually received in writing before trusting a line of output.
"""
from dataclasses import dataclass, replace

# --- 1. assumptions you must replace -------------------------------------
LANE_ASSUMPTIONS = {
    "hosted_free": dict(
        allowed_data={"public", "internal"},
        max_parallel=4,          # PLACEHOLDER: concurrency the shared lane tolerates
        allows_pinning=False,    # can you pin an exact model version?
        keeps_audit_log=False,   # retained, exportable request logs?
        commitments=1,           # irreversible commitments you accept
    ),
    "hosted_paid": dict(
        allowed_data={"public", "internal", "regulated"},
        max_parallel=50,
        allows_pinning=True,
        keeps_audit_log=True,
        commitments=3,
    ),
    "self_hosted": dict(
        allowed_data={"public", "internal", "regulated"},
        max_parallel=None,       # no hard cap, but you own p99
        allows_pinning=True,
        keeps_audit_log=True,
        commitments=5,
    ),
}

OPS_OWNER = False  # True only if a named human owns patching + on-call


@dataclass(frozen=True)
class Workload:
    name: str
    data_class: str              # public | internal | regulated
    peak_parallel_agents: int
    pinned_model: bool
    audit_log: bool
    reviewer_required: bool
    hours_per_week: float


def blockers(w: Workload, lane: str) -> list[str]:
    a = LANE_ASSUMPTIONS[lane]
    out = []
    if w.data_class not in a["allowed_data"]:
        out.append(f"data_class={w.data_class} not allowed")
    if a["max_parallel"] is not None and w.peak_parallel_agents > a["max_parallel"]:
        out.append(f"peak_parallel_agents={w.peak_parallel_agents} > {a['max_parallel']}")
    if w.pinned_model and not a["allows_pinning"]:
        out.append("needs a pinned model version")
    if w.audit_log and not a["keeps_audit_log"]:
        out.append("needs retained, exportable logs")
    if lane == "self_hosted" and w.data_class == "regulated" and not OPS_OWNER:
        out.append("regulated data, no named ops owner for self-hosting")
    return out


def rank(w: Workload) -> list[str]:
    ok = [lane for lane in LANE_ASSUMPTIONS if not blockers(w, lane)]
    # price never enters here; fewest irreversible commitments wins the tie
    return sorted(ok, key=lambda lane: (LANE_ASSUMPTIONS[lane]["commitments"], lane))


def flip_test(w: Workload, chosen: str) -> list[tuple[str, str]]:
    """Which single-variable change would exclude the lane we just picked?"""
    mutations = {
        "data one level stricter": replace(w, data_class=_stricter(w.data_class)),
        "peak parallelism x2": replace(w, peak_parallel_agents=w.peak_parallel_agents * 2),
        "pin an exact model": replace(w, pinned_model=True),
        "require exportable logs": replace(w, audit_log=True),
    }
    hits = []
    for label, mutated in mutations.items():
        if mutated != w and blockers(mutated, chosen):
            hits.append((label, blockers(mutated, chosen)[0]))
    return hits


def _stricter(data_class: str) -> str:
    order = ["public", "internal", "regulated"]
    return order[min(order.index(data_class) + 1, len(order) - 1)]


WORKLOADS = [
    Workload("docs-and-tests", "public", 2, False, False, True, 6.0),
    Workload("internal-refactor", "internal", 3, False, False, True, 12.0),
    Workload("billing-migration", "regulated", 2, True, True, True, 4.0),
]


def main() -> None:
    for w in WORKLOADS:
        admissible = rank(w)
        print(f"\n{w.name}  (data={w.data_class}, parallel={w.peak_parallel_agents}, "
              f"{w.hours_per_week}h/wk)")
        for lane in LANE_ASSUMPTIONS:
            why = blockers(w, lane)
            print(f"  {'OK  ' if not why else 'OUT '} {lane:<12} {'; '.join(why)}")
        if not admissible:
            print("  => no admissible lane: split the workload or reduce scope")
            continue
        chosen = admissible[0]
        fallback = admissible[1] if len(admissible) > 1 else "none"
        print(f"  => pick {chosen}; fallback {fallback}")
        flips = flip_test(w, chosen)
        if not flips:
            print("     flip: none of the four single-variable changes break this lane")
        for label, reason in flips:
            print(f"     flip: {label} -> {reason}")


if __name__ == "__main__":
    main()

Run it. Then argue with the output. That argument is the meeting you actually needed to have.

What it prints (illustrative, from the placeholders above)

docs-and-tests  (data=public, parallel=2, 6.0h/wk)
  OK   hosted_free
  OK   hosted_paid
  OK   self_hosted
  => pick hosted_free; fallback hosted_paid
     flip: pin an exact model -> needs a pinned model version
     flip: require exportable logs -> needs retained, exportable logs

internal-refactor  (data=internal, parallel=3, 12.0h/wk)
  OK   hosted_free
  OK   hosted_paid
  OK   self_hosted
  => pick hosted_free; fallback hosted_paid
     flip: peak parallelism x2 -> peak_parallel_agents=6 > 4
     flip: pin an exact model -> needs a pinned model version
     flip: require exportable logs -> needs retained, exportable logs

billing-migration  (data=regulated, parallel=2, 4.0h/wk)
  OUT  hosted_free    data_class=regulated not allowed
  OK   hosted_paid
  OUT  self_hosted    regulated data, no named ops owner for self-hosting
  => pick hosted_paid; fallback none
     flip: none of the four single-variable changes break this lane

These are placeholder assumptions, not measurements. Feed it your own terms.

Read the output like a lead, not like a spreadsheet

OUT rows are decisions, not preferences. If the free lane is out on data class, stop negotiating with it and move on.
"No admissible lane" is a finding, not a failure. billing-migration has no fallback because self-hosting without an ops owner is not a lane — it is a future incident with a start date.
A fallback is not a plan. It is the name of the person you call when the primary breaks.
The flip list is the actual deliverable. It tells you what you are one decision away from losing.

Where the free lane genuinely earns its place

The free lane is not the "cheap lane." It is the lane for workloads whose refusals you can absorb: documentation, test scaffolding, mechanical refactors, anything that a human reviewer would catch anyway.

The lane I am running this quarter on the free side is MonkeyCode — free model access plus a free server option, which the operator describes as an open-source project. Disclosure: This article was prepared as part of MonkeyCode's product outreach.

As of 2026-10-26, the operator's pitch is free model access (a ten-million-token allowance, per their own copy) plus a free server option. I have not independently verified the allowance, the model list, the server specifications, how long either offer lasts, or the license terms. Treat every one of those as an unverified input to the worksheet — a row you still have to fill in, not a number you get to budget against.

What makes it a reasonable first lane for docs-and-tests is structural, not promotional: it asks for the fewest commitments. No contract. No hardware. No pager. That is also exactly why it runs out of road for billing-migration.

The flip test is the part people skip

Anyone can list tradeoffs. The useful move is naming the single variable that would reverse your call, and assigning it an owner.

For each flip line, write down three things:

Who watches that variable.
What threshold triggers a re-run of the worksheet.
What the team does in the first hour after the trigger.

If nobody owns "peak parallelism x2," then the free lane is not a decision — it is a coin flip with documentation.

Who should not use this

Teams without a data classification scheme. Fix that first; this script will happily launder your ambiguity into a tidy OK.
Regulated workloads with no ops owner. Self-hosting is not available to you yet, and pretending otherwise wastes the meeting.
Anyone who needs a score to justify a decision already made. This worksheet excludes lanes. It does not bless one.
Teams expecting measured numbers. Every value above is a placeholder until you replace it.

Limitations I want on the record

The commitments field is ordinal, not cardinal — it ranks lanes, it does not price them. The model ignores reviewer hours entirely, and reviewer hours are usually the largest real cost of a free lane. The sensitivity analysis mutates one variable at a time; two simultaneous changes can produce outcomes this script will never show you. And the whole thing is a conversation tool, not objective truth — two reasonable leads can fill in the assumptions differently and both be right.

Owner, expiry, exit

Owner: platform lead.
Expires: 2026-11-25. Re-run or archive, do not silently inherit.
Exit criteria: either every workload has a named lane plus an owned flip trigger, or the team writes down which workload it is deliberately parking.

One soft ask: if you run this, bring back the flip list for the workload you were about to move to the free lane. That single list tells me more about your risk posture than any architecture diagram.

Two Free Offers, Two Failure Modes: Route AI Work by Blast Radius, Not by Lane

bestbee — Tue, 20 Oct 2026 09:09:58 +0000

Two tabs open. Both say free. One is a token allowance on a hosted model endpoint; the other is a server you can run somewhere. My platform lead looked at them and asked the reasonable question: "So which one do we take?"

It took me a week to notice that the question was malformed. They are not two versions of the same offer. They fail in completely different ways, on different timelines, against different budgets. Choosing between them like flavors is how teams end up with a free model quota nobody trusts and a box nobody patches.

Here is the reframe that actually helped: stop picking a lane for the team. Route individual change sets, and let the two offers absorb the classes of work they are genuinely good at.

Why this keeps going wrong

Look at what developers were writing on DEV last week. On 2026-10-13, a post titled "AI Fatigue? Yea I know." collected 164 reactions and 101 comments. Two days later, "I Vibe-Coded My Way Out of Angular Upgrades" picked up 88 reactions and 56 comments about shipping model-authored diffs into a real codebase. Different moods, same underlying constraint.

Neither thread is about generation speed. Both are about the cost that lands after generation — reading, verifying, and owning the diff. That cost does not care which lane produced the code. It only cares how big and how dangerous the change was.

So ask yourself: if your reviewers are the bottleneck, does a faster or cheaper generator change your throughput at all?

The two offers fail differently

	Free model access	Free server option
Primary currency	Tokens / requests	CPU, memory, disk, egress
Failure mode	Review debt — output arrives faster than it can be verified	Ops debt — patching, upgrades, restarts, who is on call
Shows up as	Rising review latency, rubber-stamped approvals	Silent drift, surprise downtime, config archaeology
Detected by	Reviewer queue depth	Uptime and patch-lag tracking
Reverses when	Review latency exceeds one business day	Nobody owns the box for two consecutive weeks

Read that table again. The left column is a people constraint. The right column is an ownership constraint. A team can be perfectly staffed for one and completely unstaffed for the other, which is exactly why a single "free tier yes/no" decision keeps producing bad outcomes.

Workload fission: route the change, not the team

Borrow the idea from fault-tolerant systems. You do not ask "is this system safe?" You ask what a failure would cost, and you place controls accordingly. Do the same with AI-authored diffs.

Two axes decide the route:

Reversibility — can this be reverted in one commit, with no data migration, no customer notification, no third-party side effect?
Blast radius — if it is wrong in production, how many users, how much money, how many hours of incident response?

That gives four buckets, and only three of them should ever touch a free lane:

Low blast, reversible — docs, tests, fixtures, log messages, internal tooling. Free model lane. One reviewer, same day.
Low blast, hard to reverse — schema tweaks, cache key formats, anything with a write path. Paid lane or free lane with an owner sign-off.
High blast, reversible — feature flags, config toggles behind an off switch. Paid lane, plus a kill-switch check.
High blast, hard to reverse — auth, billing, migrations, public API contracts. Human-authored or human-rewritten. No exceptions older than 30 days.

Is that last line too rigid? Maybe. But I have never regretted it, and I have definitely regretted the alternative.

A 60-line router you can run today

Scores are a conversation tool, not objective truth. The point is to make the routing rule explicit and identical for everyone, instead of letting whoever is on triage that morning decide.

#!/usr/bin/env python3
"""route_ai_work.py - classify one change set into a review lane.

Stdlib only. No network calls. Feed it a JSON file.
"""
import json
import sys

WEIGHTS = {
    "files_changed": 1.0,
    "lines_added": 0.05,
    "lines_deleted": 0.10,      # deletion is riskier than addition
    "touch_migrations": 25.0,
    "touch_auth": 25.0,
    "touch_billing": 25.0,
    "touch_public_api": 15.0,
    "touch_ci_config": 10.0,
}

LANES = [
    (0,  30,       "free-model lane",  "one reviewer, same day"),
    (30, 60,       "paid-model lane",  "one reviewer + owner sign-off"),
    (60, float("inf"), "human-author lane", "two reviewers, no model-authored diff"),
]

def score(change):
    total = 0.0
    for key in ("files_changed", "lines_added", "lines_deleted"):
        total += change.get(key, 0) * WEIGHTS[key]
    for flag in change.get("flags", []):
        if flag not in WEIGHTS:
            raise SystemExit(f"unknown flag {flag!r}; add it to WEIGHTS first")
        total += WEIGHTS[flag]
    return round(total, 1)

def route(total):
    for low, high, lane, review in LANES:
        if low <= total < high:
            return lane, review
    return "unrouted", "escalate"

if __name__ == "__main__":
    change = json.load(open(sys.argv[1]))
    total = score(change)
    lane, review = route(total)
    print(f"{change.get('id', 'unnamed')}\tscore={total}\t{lane}\t{review}")

A fixture, so results are comparable across teams

{"id": "ENG-4412", "files_changed": 6, "lines_added": 210, "lines_deleted": 40, "flags": ["touch_migrations"]}

$ python3 route_ai_work.py fixture_paid.json
ENG-4412    score=45.5  paid-model lane one reviewer + owner sign-off

Three fixtures I keep in the repo, with expected output, so anyone can sanity-check a weights change before it ships:

docs-only: 2 files, +30 / -5, no flags → score=4.0 → free-model lane.
migration: above → score=45.5 → paid-model lane.
auth-plus-api: 12 files, +600 / -150, flags touch_auth, touch_public_api → score=97.0 → human-author lane.

Calibrate the weights before you trust them. Take 20 PRs you already merged, 10 that went clean and 10 that caused a follow-up fix, and check whether the router separates them. If it does not, your weights are wrong, not your reviewers.

Where the two offers actually fit

Here is where this stops being abstract for me. The offer I have been evaluating is MonkeyCode, an open-source project whose operator describes two things: free model access with a token allowance, and a free server option.

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

I am deliberately not putting numbers on the allowance or the hardware in this post. Those are operator-supplied claims that I have not independently verified, and a quota you read from me is a quota you will argue about later with no source. Verify them yourself, on the date you verify them, and write the date in your own ledger.

What I will say is how the two options map onto the routing above:

Free model access is the natural fuel for the low-blast, reversible bucket — the docs, tests, and internal-tooling work that would otherwise queue behind a human because it feels too small to schedule. It is a bad fit for the human-author bucket, and no amount of free tokens changes that.
The free server option is a different decision entirely. It helps when you have a workload that needs to sit somewhere you control — an internal proxy, a scheduled job, an eval harness. It only helps if you can answer "who patches it?" with a name, not a shrug.

Note what is missing from that list: nothing about replacing your paid lane. Routing is about placement, not substitution.

Hard gates, an owner, and an expiry

Write these down before the first free-lane PR merges:

Gate: no free-lane merge without a named reviewer in the same timezone, same day.
Gate: if review latency for the free lane exceeds one business day for five consecutive working days, the lane is paused until the queue clears.
Owner: one person owns the server option, including patch lag. If the owner changes teams, the option stops — automatically, not by discussion.
Expiry: every routing exception expires in 30 days and must be re-justified by a re-run of the router, not by memory.
Exit: if two incidents in a quarter trace back to model-authored diffs in a bucket you classified as low blast, that bucket gets reclassified upward permanently.

Sensitivity: what would reverse this routing

Run these three what-ifs. Any one of them can flip the plan.

If your median PR review latency is already above one business day, the free-model lane's advantage mostly evaporates. You are review-bound, and adding generation capacity just deepens the queue.
If migrations, auth, and public API changes are more than 40% of your change count, most work routes to the human bucket anyway and the free lane becomes a rounding error. Check the count, not the vibe.
If your server option has no owner after two weeks, its true cost is unbounded — and no token allowance offsets an unpatched box.

Which of those three numbers is closest to flipping for you? That is the one to measure first.

Who should not use this

Solo developers with no review queue. Routing exists to protect reviewers. If you are the only reviewer, you already are the gate — just write the flags file and skip the ceremony.
Teams under compliance regimes that require provenance on every diff. Do the classification, but expect the free lane to be empty.
Anyone who wants the router to decide. It ranks work. It does not own outcomes. If a human cannot defend the routing at postmortem time, the routing was wrong.

If you want to try the offers, try them against one bucket — the low-blast reversible one — for two weeks, with the gates above written down first. That is the whole experiment. Everything else is a lane decision you do not have to make yet.

Free Allowance or Self-Hosted Box? Compute the Crossover Before You Commit

bestbee — Mon, 19 Oct 2026 07:44:46 +0000

A platform lead I'll call Dana pinged me mid-sprint with a one-line message: "our AI lane is free, so why does it feel expensive?"

The lane wasn't the problem. The problem was that nobody had converted "free" into the only unit her org actually budgets in — merged pull requests. This scenario is a composite of conversations I've had with platform leads; the numbers below are illustrative, not audited results from any specific company.

That conversion is the whole article. If you can't say how many merged PRs your allowance covers, you don't have a capacity plan. You have a vibe.

The claim, and what it is worth

MonkeyCode's operators state two things that matter for this decision: free model access with 10 million free tokens, and a free server option. The project is also described as open source. I have not audited the quota mechanics, expiry, or fair-use rules, so treat all of that as a claim to verify inside your own account before you plan around it.

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

A free allowance changes the shape of your cost curve, not the existence of one. Below the line, marginal cost is zero. Above it, you either pay overage or you own hardware. Those are different businesses, and they fail differently.

Step 1: measure tokens per merged PR

Not per seat. Not per developer-day. Per merged PR. Seats hide idle time; days hide rework.

I keep a tiny script for this because the mean lies. Agentic sessions have a long tail — one runaway loop can double your average while the median barely moves.

# tokens_per_pr.py — run against your own usage export
import csv, statistics

rows = list(csv.DictReader(open("usage.csv")))   # columns: pr, tokens
per_pr = {}
for r in rows:
    per_pr[r["pr"]] = per_pr.get(r["pr"], 0) + int(r["tokens"])

vals = sorted(per_pr.values())
median = statistics.median(vals)
p90 = vals[int(len(vals) * 0.9)]
print(f"PRs={len(vals)} median={median} p90={p90} mean={sum(vals)//len(vals)}")

Use the median for planning and the p90 for your worst-case gate. If median and p90 differ by more than 3x, your workflow has an unbounded loop somewhere, and no pricing model will save you from it.

Step 2: convert the allowance into PRs

This is one division, and it is the most useful number in the whole exercise.

covered_prs = allowance_tokens / tokens_per_pr_median

At an illustrative 45,000 tokens per merged PR, 10 million tokens covers roughly 222 merged PRs. Whether that is generous or thin depends entirely on your team, and that is the point — the number is meaningless until it meets your sprint board.

Ask the question that actually decides things: does my pilot need more than ~200 merged PRs to produce a defensible answer? If yes, you are not testing the free lane. You are testing your overage path while calling it a pilot.

Step 3: find the self-host crossover

Here is the counterintuitive part. Self-hosting almost never wins on tokens alone. It wins on control. Let's show the arithmetic instead of asserting it.

# crossover.py — a model, not a benchmark. Plug in measured inputs.
def cost_per_pr(tokens_per_pr, overage_per_million):
    return tokens_per_pr / 1_000_000 * overage_per_million

def break_even_prs(tokens_per_pr, hosted_overage, box_month, ops_hours, loaded_hourly):
    fixed = box_month + ops_hours * loaded_hourly
    saving = cost_per_pr(tokens_per_pr, hosted_overage) - 0.0  # box marginal ~ 0
    return fixed / saving if saving > 0 else float("inf")

n = break_even_prs(
    tokens_per_pr=45_000,
    hosted_overage=0.40,     # $ per 1M tokens after allowance (illustrative)
    box_month=192.0,         # 160 h x $1.20/h (illustrative)
    ops_hours=6.0,
    loaded_hourly=85.0,
)
print(round(n))  # ~39,000 merged PRs/month to justify the box

Thirty-nine thousand merged PRs a month is not a team. It's a CI pipeline with aspirations. At low overage prices, the math says: stay hosted, keep the ops hours for something that compounds.

Now push the overage price up and watch the answer move.

Tokens/PR (median)	Overage $/1M	Self-host fixed $/mo	Break-even PRs/mo
45,000	0.40	702	~39,000
45,000	3.00	702	~5,200
15,000	3.00	702	~15,600
45,000	3.00	2,400	~17,800

Read the last two rows together. Shrinking tokens-per-PR by 3x raises the bar by 3x. Adding an SRE-grade box triples it again. Self-host crossover is a lagging indicator of operational discipline, not a pricing event.

The three gates

A spreadsheet is a conversation tool, not objective truth. Use it to force three yes/no answers.

Coverage gate. allowance / median_tokens_per_pr ≥ your pilot's required merged PRs, with 30% headroom for the p90 tail. Fail this and you are measuring overage, not the free lane.
Ops gate. Name one human who owns patching, upgrades, and on-call for the self-hosted path, with hours on a calendar. No named owner means your ops_hours input is fiction, and the crossover number is fiction with it.
Reversibility gate. What does leaving cost in each lane? Migrating prompts, evals, and CI hooks is the real bill. Open-source matters here far more than price does — you can read the code, fork it, and leave with it. Check the actual license yourself before counting on that.

Fit criteria

Choose the free hosted lane when: your pilot fits inside the coverage gate, you have no data-residency constraint, and your bottleneck is review time rather than token spend. Most teams land here, and pretending otherwise wastes a quarter.

Choose self-hosted when: you need airgapped or residency-bound execution, custom weights, or offline CI. Do it for those reasons and say so out loud — the crossover sheet will not back you up on cost.

Choose a paid seat when: you have crossed the allowance in two consecutive sprints and your p90 is stable. Stable overage is a signal to buy predictability, not to build a data center.

Limitations and who should skip this

This model ignores latency, queueing, egress, storage, and quality differences between models. Tokens are not equal across providers, so never compare raw counts between lanes. Quota terms and prices move; re-run the sheet before each renewal.

Skip this if you have no one who can own infrastructure, if you have a hard residency requirement (that decision is already made for you), or if your actual constraint is reviewer attention — in which case the crossover is the wrong sheet entirely.

The question that should end the meeting

Don't ask whether the free option is good. Ask: which single input would flip my decision? For most teams it is tokens_per_pr, not price. Measure it for two weeks and the argument dissolves.

If you want a zero-cash place to collect your first real tokens_per_pr number, MonkeyCode's free model access is a reasonable lane to start on — bring the spreadsheet, not the enthusiasm.

Should Your Platform Team Take the Free AI Tier? Use This 4-Part Ops-Absorption Test

bestbee — Sun, 18 Oct 2026 06:42:31 +0000

Two posts sat near the top of DEV in the same week, and they were arguing with each other.

"One Weekend: 3,000 Open-Source AI Projects" (2026-10-11) said the supply of free AI tooling is now effectively infinite. "AI Fatigue? Yea I know." (2026-10-13) said the appetite for running any of it is not.

Both can be true. That is exactly the trap for a platform team. Free options multiply, and every one of them asks for the same thing you are shortest on: someone's attention.

So here is the question I want you to answer before you accept any free tier. Not "is the model good?" Not "is the price zero?" But: how many ops hours per week does this lane quietly charge you?

Below is the test I use, a script to measure the one number that drives it, and a worked example with real arithmetic. All numbers are labeled where they are modeled rather than measured. A scorecard like this is a conversation tool, not objective truth.

The decision is not "free vs paid". It is three lanes

Most teams compare two things and miss the third.

Lane	Cash cost	Ops hours	Hard ceiling
A. Free hosted tier	~0	~0	Token or rate allowance, set by the vendor
B. Paid hosted API	Per 1M tokens	~0	Budget only
C. Self-hosted model server	Hardware + power, amortized	Yours, weekly, forever	Your patience and your on-call

Lane A and Lane B share a property that Lane C does not: nobody has to get paged. That property is the thing you are actually pricing.

And Lane A has a second property people forget — a ceiling that is not measured in dollars. You cannot buy your way past it with a budget approval. You buy past it with a migration.

Define five variables before you compare anything

Write these on one line and put them in the doc. Undefined variables are how free-tier decisions get made by vibes.

N — engineers using the assistant.
T — tokens per engineer-week, including retries and rejected attempts. Measured, not estimated.
R — your blended hosted price per 1M tokens, from your actual contract.
S — monthly amortized cost of the self-hosted box (hardware over its useful life, plus power and rack).
C — loaded engineer-hour cost. Use your real number; it is usually higher than the one people quote in meetings.

Then two derived numbers:

Hosted monthly = N × T × 4.33 ÷ 1,000,000 × R
Break-even ops hours per week = (hosted monthly − S) ÷ (4.33 × C)

That second formula is the whole article. It tells you how many hours of your team's week the self-hosted lane may consume before it stops being the cheaper option. If the answer is smaller than the hours you already know you'll spend, the decision is made.

The one number to measure first: tokens per accepted change

Here is what I keep seeing. Teams measure token spend per request. That number is useless for this decision, because requests are not the unit anyone cares about.

The unit is the accepted change: a diff that merged and was not reverted within seven days.

Why the seven-day revert window? Because a change that gets rolled back next Tuesday consumed tokens and produced nothing. Counting it as output flatters every lane, and flatters the free one most, since free tokens make failed attempts feel costless.

So log this CSV for one week. Columns: engineer,task,prompt_tokens,completion_tokens,accepted,rework_minutes.

#!/usr/bin/env python3
"""token_shape.py -- measure token shape, then price two lanes.

Input CSV: engineer,task,prompt_tokens,completion_tokens,accepted,rework_minutes
  accepted = 1 when the change merged and was not reverted within 7 days.

Usage:
  python3 token_shape.py tasks.csv
  python3 token_shape.py tasks.csv --team 8 --price 3.00 --server 600 --hour 95 --ops 4
"""
import argparse
import csv

MONTHS = 4.33  # average weeks per month


def load(path):
    rows = []
    with open(path, newline="", encoding="utf-8") as f:
        for row in csv.DictReader(f):
            rows.append({
                "tokens": int(row["prompt_tokens"]) + int(row["completion_tokens"]),
                "accepted": row["accepted"].strip() == "1",
                "rework": float(row["rework_minutes"]),
            })
    return rows


def shape(rows):
    accepted = [r for r in rows if r["accepted"]]
    n_acc = max(len(accepted), 1)
    total = sum(r["tokens"] for r in rows)
    return {
        "tasks": len(rows),
        "accepted": len(accepted),
        "tokens_per_accepted_change": total / n_acc,
        "rework_min_per_accepted_change": sum(r["rework"] for r in accepted) / n_acc,
    }


def lanes(team, tokens_week_per_eng, price_per_mtok, server_month, loaded_hour, ops_hours_week):
    hosted = team * tokens_week_per_eng * MONTHS / 1_000_000 * price_per_mtok
    owned = ops_hours_week * MONTHS * loaded_hour + server_month
    breakeven_ops = (hosted - server_month) / (MONTHS * loaded_hour)
    return hosted, owned, breakeven_ops


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("csv")
    ap.add_argument("--team", type=int, default=8)
    ap.add_argument("--price", type=float, default=3.00)
    ap.add_argument("--server", type=float, default=600.0)
    ap.add_argument("--hour", type=float, default=95.0)
    ap.add_argument("--ops", type=float, default=4.0)
    ap.add_argument("--changes-per-eng-week", type=float, default=6.0)
    ap.add_argument("--allowance", type=float, default=10_000_000)
    args = ap.parse_args()

    s = shape(load(args.csv))
    per_acc = s["tokens_per_accepted_change"]
    print(f"tasks={s['tasks']} accepted={s['accepted']}")
    print(f"tokens_per_accepted_change={per_acc:,.0f}")
    print(f"rework_min_per_accepted_change={s['rework_min_per_accepted_change']:.1f}")
    print(f"allowance_covers_accepted_changes={args.allowance / per_acc:,.0f}")

    tokens_week = per_acc * args.changes_per_eng_week
    hosted, owned, breakeven = lanes(
        args.team, tokens_week, args.price, args.server, args.hour, args.ops
    )
    print(f"hosted_month=${hosted:,.0f}")
    print(f"self_hosted_month=${owned:,.0f}")
    print(f"breakeven_ops_hours_per_week={breakeven:.2f}")


if __name__ == "__main__":
    main()

Run it. Then look at tokens_per_accepted_change. That single number decides whether you are in a light shape or a heavy one, and those two shapes lead to completely different conclusions about the same nominal free allowance.

Worked example: same allowance, two very different worlds

Here is the arithmetic I get asked to do most often, done out loud. Assume an operator-supplied free allowance of up to 10,000,000 tokens (the figure given to me for this piece, verify it in-product before you rely on it).

Shape	Tokens per accepted change	Accepted changes the allowance covers
Context-light edit loop	~165,000	~60
Context-heavy agent loop (large repo, retries)	~1,900,000	~5

Same allowance. One is a usable month for a small team. The other is a measurement budget.

That is not a knock on the free tier. It is a statement about your workload. If you don't know which row you are in, you don't know what you were offered, and neither does the person who approved it.

The lane comparison, filled in

Modeled example, not measured. N = 8, heavy shape at 6 accepted changes per engineer-week → T ≈ 11.4M tokens/engineer-week. R = $3.00/1M. S = $600/month. C = $95/hour.

Hosted monthly = 8 × 11.4M × 4.33 ÷ 1M × $3 ≈ $1,185
Self-hosted at 4 ops h/week = 4 × 4.33 × $95 + $600 ≈ $2,245
Break-even ops hours = (1,185 − 600) ÷ (4.33 × 95) ≈ 1.4 h/week

Read that last line again. Self-hosting this workload wins on cash only if your team spends under roughly ninety minutes a week keeping the box alive. Not during migration. Every week, including the week after a driver upgrade.

Sensitivity: where the line moves

Ops hour sensitivity, holding everything else fixed:

Ops h/week	Self-hosted $/mo	Hosted $/mo
1	$1,011	$1,185
2	$1,423	$1,185
3	$1,834	$1,185
4	$2,245	$1,185
6	$3,068	$1,185

Price sensitivity at H = 4:

R ($/1M)	Hosted $/mo	Break-even ops h/week
$1	$395	never (negative)
$3	$1,185	1.4
$8	$3,159	6.2
$15	$5,924	12.9

Notice the direction. Cheaper hosted tokens make self-hosting harder to justify, not easier. That is the opposite of the intuition that sends teams shopping for GPUs.

One incident, priced

An afternoon outage with 8 engineers, 6 hours, 30% blocked: 8 × 6 × 0.3 × 95 ≈ $1,368. That single afternoon is larger than the monthly hosted premium. Two such afternoons a year and the "free" server has cost more than the API line item — before you count the roadmap you didn't ship.

The 4-part gate, with hard stops

Run these in order. A fail is a stop, not a discussion.

Gate 1 — Shape. Do you know tokens_per_accepted_change from at least one week of logged tasks? No measurement, no decision. Stop.

Gate 2 — Ops budget. Is there a named owner with H hours blocked on a calendar, every week, not borrowed from feature work? "We'll find the time" is a fail. Stop.

Gate 3 — Data boundary. Can your code leave the environment at all? If any repo in scope is under a contractual or regulatory restriction, the free hosted lane and the paid hosted lane are both out. Stop.

Gate 4 — Exit cost. What does leaving cost, in engineer-days, including the prompt and config work you'll rebuild? Write the number down before you start. If it is unknown, it is unbounded.

Owner: the platform lead, named. Expiry: 90 days from the first logged task — re-run the script and re-derive. Exit criteria, written up front: ops hours exceed break-even for three consecutive weeks; or acceptance rate drops below your recorded baseline; or exit cost exceeds the savings you projected.

Where a free hosted lane genuinely earns a place

Not in production. In measurement.

Gate 1 is the cheap gate and the one teams skip. Standing up a self-hosted box to measure your token shape is backwards — you buy the expensive lane to answer a question the cheap lane answers in a week.

This is the honest case for something like MonkeyCode, an open-source AI coding project whose operator offers free model access (up to 10,000,000 tokens as described to me on 2026-10-18) and a free server option. As of that date, both are availability claims to verify in-product, not a contract. Use them for Gate 1: a week of real tasks, real rework minutes, real revert counts, no procurement.

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

What you get out of that week is not a demo. It's the per_acc number that tells you whether your light shape covers 60 accepted changes or your heavy shape covers 5 — and whether Lane C is even worth pricing.

Who should not use this approach

Teams with a hard latency or residency requirement. Hosted lanes of any kind, free or paid, are out. Run Gate 3 and move on.
Teams without a named owner. You will not log a week of data. Buy the paid hosted lane and revisit in two quarters.
Anyone who needs pinned model versions for reproducibility. Free tiers change under you. Your evals will drift and you'll blame the model.
Teams treating the free server as a place to keep the only copy of anything. It is a measurement sandbox. Mean it.
Anyone who thinks this scorecard produces a verdict. It produces the numbers that make the meeting short.

The question that actually reverses this

Don't ask whether the free tier is worth trying. Almost always, yes — for one week, for Gate 1.

Ask instead: what is the highest H your team would still accept for owning the box? Get that number from your manager before you run the script. If the honest answer is "zero" and your break-even comes back at 1.4, you were never making a cost decision. You were making a staffing decision wearing a spreadsheet.

Write down per_acc, the break-even hours, the owner, and the expiry date. Then, in ninety days, ask which of those four moved first.

The Free Tier Is Not the Cheap Lane: Pricing Your AI Coding Options per Merged PR

bestbee — Sat, 17 Oct 2026 05:43:09 +0000

Thursday, 4:40pm. A platform lead drops a screenshot in our channel: free tokens, a free server option, and one line of text — "why are we paying for anything?"

Fair question. Also the wrong unit. We were never paying for tokens. We were paying for the parts tokens do not include: the retry that ate forty minutes, the review that caught a plausible-but-wrong migration, the maintenance window on a box nobody wanted to own.

So let's answer it properly. Not with a feature grid, but with a number you can defend in a budget review.

Define the unit before you define the winner

Price every lane in cost per merged PR. Not cost per seat, not cost per token, not "free".

$$
C_{lane} = \frac{\text{model spend} + \text{retry minutes} \times H + \text{review minutes} \times H + \text{blocked wait} \times H + \text{amortized ops}}{\text{merged PRs}}
$$

Where H is your loaded hourly engineer cost divided by 60. Yes, review minutes belong in the numerator. A free lane that doubles review time is not free; it moved the invoice to a person who does not see it.

Two things to exclude on purpose:

Sunk setup cost. Amortize it, do not argue about it. Past hours are not evidence.
"Developer happiness" unless you have a proxy. A proxy is something like voluntary lane usage after week two.

A scorecard like this is a conversation tool, not objective truth. It exists so two people can disagree about the same numbers instead of different vibes.

The ledger: twelve fields, one line per task

You cannot compare lanes you did not measure. Append-only JSONL, committed to the repo, reviewed in a PR like any other artifact.

{"date":"2026-10-15","lane":"free","task":"TICKET-412","tokens_in":8200,"tokens_out":1900,"wait_s":37,"retries":1,"review_min":22,"merged":true}

Logging one task without a spreadsheet:

start=$(date +%s)
# ... run your agent or assistant on the ticket ...
end=$(date +%s)
printf '{"date":"%s","lane":"%s","task":"%s","tokens_in":%s,"tokens_out":%s,"wait_s":%s,"retries":%s,"review_min":%s,"merged":%s}\n' \
  "$(date -I)" "free" "TICKET-412" 8200 1900 $((end-start)) 1 22 true >> ledger.jsonl

If your tool does not report token counts, write null and record the proxy you used. A labelled proxy beats a fabricated integer every time.

Why JSONL and not a dashboard

Because a dashboard someone else owns becomes a number nobody trusts. A file in the repo survives re-quotes, vendor changes, and the person who set it up leaving.

The script that ends the argument

import json, collections

H = 85 / 60          # loaded engineer cost per minute; replace with yours
RETRY_MIN = 12       # your measured rework per failed attempt; replace

def summarize(path):
    agg = collections.defaultdict(lambda: dict(prs=0, tokens=0, wait=0.0, retries=0, review=0.0))
    with open(path) as f:
        for line in f:
            if not line.strip():
                continue
            r = json.loads(line)
            a = agg[r["lane"]]
            a["prs"]    += 1 if r["merged"] else 0
            a["tokens"] += (r["tokens_in"] or 0) + (r["tokens_out"] or 0)
            a["wait"]   += r["wait_s"] / 60
            a["retries"] += r["retries"]
            a["review"] += r["review_min"]
    out = {}
    for lane, a in agg.items():
        if a["prs"] == 0:
            continue
        minutes = a["review"] + a["wait"] + a["retries"] * RETRY_MIN
        out[lane] = {"prs": a["prs"], "cost_per_pr": round(minutes * H / a["prs"], 2)}
    return out

def break_even(free_per_pr, hosted_var_per_pr, fixed_month, maint_hours, loaded_hourly):
    monthly = fixed_month + maint_hours * loaded_hourly
    saving = free_per_pr - hosted_var_per_pr
    return None if saving <= 0 else round(monthly / saving)

Run it weekly. If a lane has fewer than twenty merged PRs, stop and collect more data — small-n comparisons in this space are mostly noise wearing a decimal point.

Break-even: the only number that survives a re-quote

A self-hosted or paid lane is worth it only above a volume threshold:

N* = (fixed monthly + maintenance hours × loaded hourly) / (free cost per PR − hosted variable cost per PR)

Worked example. All figures below are illustrative inputs, not vendor quotes — plug in your own.

Fixed monthly hosting/seat cost: $180
Setup: 30 hours, amortized over 12 months → 2.5 h/month
Ongoing maintenance: 6 h/month at $85/h
Free lane: $4.10 per merged PR (review-heavy, retry-heavy)
Hosted lane variable: $0.90 per merged PR

Monthly fixed-equivalent = 180 + (6 + 2.5) × 85 = $902.50. Saving per PR = $3.20. So N* = 282 merged PRs per month.

Sensitivity, same base except where noted:

Change	N*
Base	282
Maintenance drops to 2 h/month	176
Maintenance rises to 12 h/month	441
Free lane gets cheaper ($1.80/PR)	1,003
Hosted variable rises to $1.60/PR	361

Read the second row, then the fourth. The decision is far more sensitive to your free-lane cost and your maintenance hours than to list price. That is the whole point of measuring before switching.

Runway: how long a free allowance actually lasts

An allowance is a pilot budget, not a P&L line. The project operator states a free allowance of 10 million tokens and a free server option; verify the current terms yourself before you commit, because allowances move and screenshots go stale.

months_of_runway = allowance / (median_tokens_per_task × tasks_per_month × people)

Illustrative arithmetic with your own median, not a promise: 9,000 tokens per task, 25 tasks per developer per week, 4 developers → 430 tasks/month → 3.87M tokens/month → about 2.6 months. That is enough to fill a ledger. It is not enough to skip the ledger.

MonkeyCode is the open-source project in that screenshot. Disclosure: This article was prepared as part of MonkeyCode's product outreach. The free model access and free server option are what make it a usable zero-cost control arm in the experiment below — that is the honest role, and it is a real one.

Decision table: fit, not features

Your constraint	Free lane fits when…	Self-hosted fits when…	Paid seat fits when…
Volume	below `N*`, i.e. you are still learning	above `N*` for two consecutive months	unpredictable, spiky
Review capacity	you have slack reviewers	you have a platform owner	vendor review tooling is the point
Data sensitivity	work is public or synthetic	data cannot leave your network	contract terms beat your own ops
Ops appetite	nobody wants a pager	you already run services	you want no pager at all
Reproducibility	you can tolerate drift	you need pinned versions	you need a paper trail, not control

Three gates, one owner, one expiry

Every pilot needs an end date or it becomes architecture by accident.

Gate 1 — Instrument (days 0–3). Owner: the lead running the pilot. Exit: twenty merged PRs per lane in the ledger, or the comparison is void.
Gate 2 — Compare (day 14). Exit: N* computed and compared to your actual monthly volume. Decision rule: below 0.5 × N*, stay free; above 2 × N*, re-quote hosted; between, extend once, with a written reason.
Gate 3 — Re-verify and exit (day 30). Re-check the allowance and server terms on the date you re-check them, then publish the ledger and pick a lane. Expiry: 30 days from Gate 1. No silent renewals.

If you want a zero-cost control arm while you run this, the free tier and free server option are a reasonable place to start logging — check the repo README for current terms first, then let the ledger argue.

Where this model breaks

Thin data. Under twenty PRs per lane, N* is theatre.
Unlogged review debt. If reviewers do not record minutes, the free lane always looks cheaper than it is.
Allowance drift. A quota change mid-pilot invalidates your runway line, not your cost-per-PR line.
Free server expectations you never wrote down. Where the compute lives is not the same as who owns the outage. Ask before you depend on it.
One team's numbers. N* does not transfer between teams with different review cultures.

Who should not use this approach

Teams that cannot commit to logging for two weeks. Teams whose work is confidential and whose free-lane data path is unverified. Teams under roughly 50 merged PRs a month where a single bad week swings the average. And anyone hoping the ledger will confirm a decision they already made.

The reversal question

Before you sign anything, write down which single variable would flip your choice: maintenance hours, review minutes, volume, or the allowance itself. Then go measure that one first.

Which number in your current setup have you never actually measured — and what would it cost you to find out this week?

Free Tokens Are a Claim. Publish a Claim-to-Test Ledger Before You Standardize

bestbee — Fri, 16 Oct 2026 04:40:49 +0000

A message like this lands in an engineering lead's inbox about once a quarter:

"MonkeyCode is open source. Free model access, and a free server option. Give it a try."

Two sentences. No workload, no data class, no expiry date. And still enough to start a standardization debate, because the alternative — self-hosting, or a paid seat — has an actual line item attached. Free is the only option in the room with a zero on the invoice.

So I ask a different question: what would have to be false for your team to walk away? If nobody can answer that, you don't have an evaluation. You have a mood.

The scenario below is a composite, and every number in it is illustrative. Vendor terms are dated and change. Re-verify them before you spend money or reputation on a decision.

Why "free tokens" is the wrong unit of analysis

Free capacity is real value. It's also a terrible unit for a standardization decision, for three structural reasons.

Tokens are an input; work is an outcome. A lane that burns 2M tokens and closes 18 of 20 smoke tasks beats a lane that burns 800K tokens and closes 11. Token counts don't tell you which one you have.
A grant is a stock; your workload is a flow. 10 million tokens sounds enormous until you know your team's monthly burn. A stock figure without a burn rate is a number with no denominator.
The claim expires; the standard doesn't. Free tiers change. If four engineers have already written their rules files and prompt libraries around a lane, the price of reversal isn't the invoice — it's the rewrite.

That third point is where most teams quietly lose two weeks.

Why this specific lane makes a useful test case

MonkeyCode's operator describes it as an open-source project with free model access and a free server option, and states a free grant of 10 million tokens as of 2026-10-16. Those are operator-supplied claims, not verified benchmarks: no public burn rate, no hardware spec, no permanence guarantee. That isn't a defect of the product — it's the normal state of a zero-price offer. And it's exactly why the offer is a good exercise. When the price is zero, the only variables left to test are the ones that actually decide your outcome.

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

The artifact: a claim-to-test ledger

Stop writing evaluation docs. Write falsification docs. Every vendor sentence becomes one row with a test, an owner, and an expiry date.

Column	What goes in it
Claim (verbatim)	Quote it. Never paraphrase a promise.
Falsifying test	The cheapest thing that could prove it false this sprint.
Instrument	Dashboard, CI job, task log, or a stopwatch.
Minutes	Real estimated cost of the test.
Pass if	A threshold you commit to before you see the result.
Reverse signal	What failure would change your decision, not just your mood.
Owner	One human, by name.
Expiry	The date the claim must be re-checked.

Define the variables first

T — number of claims under test
h — average minutes per falsification test
F = T × h / 60 — falsification hours
p — your honest probability of reversing the decision within one quarter
R — rework hours to undo the decision (rules files, prompt library, eval sets, CI wiring, docs)
W — loaded hourly cost

Run the ledger when p × R > F. The break-even threshold is p* = F / R.

W cancels out of both sides. That's the useful part: you never have to defend your loaded hourly rate to anyone.

Worked example (illustrative)

A platform team of six evaluates the lane with nine claims. F = 9 × 40 / 60 = 6 hours. They measure R = 60 hours of context rewrites with the shell snippet below rather than guessing. Then p* = 6 / 60 = 0.10.

Translation: if you believe there's more than a 1-in-10 chance you'd reverse this decision inside a quarter, the ledger pays for itself. That is a much easier argument to win than "let's do a proper evaluation."

The ledger, filled in

#	Claim (abbreviated)	Falsifying test	Min	Reverse signal
C1	free grant, operator-stated	run the 20-task smoke set twice; log tokens and tasks closed	45	grant covers < 5 working days at observed burn
C2	free server option	run the smoke set during a real PR window; record wall-clock queueing	45	queueing longer than your review window
C3	open source	clone it, build it, run the smoke set against your own copy	60	build path requires access you don't have
C4	context export	export rules files and prompt library; diff against your repo	30	export is lossy or manual
C5	CI latency	wire one nightly job; compare p95 wall clock to baseline	45	p95 blows the nightly budget
C6	review latency	count human review minutes on 20 lane-authored PRs	30	review minutes exceed authoring savings
C7	data class	ask policy whether your code class may be processed externally	15	policy answer is an absolute no
C8	offboarding	remove one engineer mid-week; confirm access and cost state	30	access or billing state becomes murky
C9	version pinning	pin a known-good configuration; re-run C1 after a restart	30	behavior drifts with no changelog

Note that C7 costs fifteen minutes and can end the entire evaluation. Cheap tests first. Always.

Sensitivity: when the ledger is not worth running

Scenario	T	h	F	p	R	p×R	Verdict
Beachhead: 2 engineers, 1 repo	4	30	2.0	0.15	12	1.8	Skip the ledger — just pilot
Scale-up: 6 engineers, 3 repos	9	40	6.0	0.30	60	18.0	Run it this sprint
Regulated: 40 engineers, 2 BUs	14	60	14.0	0.40	240	96.0	Run it, then gate on C7 alone

Look at row one. p × R = 1.8 beats F = 2.0 — barely. If your blast radius is one repo and two people, the correct decision is to skip the ceremony and use the lane for a week. Ledgers are for decisions that are expensive to reverse, not for curiosity.

Break-even moves fast: at R = 12 hours, p* = 17%. At R = 60, p* = 10%. At R = 240, p* = 6%. The more context you have to rewrite, the lower the bar for testing.

Measure `R` instead of estimating it

Rework hours are the one number teams routinely invent. Count your context assets first:

# context assets a reversal would force you to rewrite — count, don't guess
rg --files -g 'AGENTS.md' -g '*.mdc' -g 'prompts/**' -g 'evals/**' \
  | xargs -r wc -l | tail -1

Then keep the ledger in a file so it survives the meeting where everyone agrees verbally:

# ledger.yaml — one row per claim you are willing to falsify
# Scaffold only; the operator's stated terms are dated 2026-10-16 and must be re-checked.
decision: standardize-free-lane
owner: platform-lead              # a person, not a team
review_date: 2026-11-13           # claims expire; so does the decision
loaded_hourly_cost: 85
reverse_rework_hours: 60          # measured above, not estimated
claims:
  - id: C1
    claim: "free grant stated by operator (2026-10-16)"
    test: "run the 20-task smoke set twice; log tokens and completed tasks"
    pass_if: ">=18/20 tasks complete, twice"
    reverse_signal: "grant covers < 5 working days at observed burn"
    owner: platform-lead
    expiry: 2026-11-13
  - id: C7
    claim: "we may process this code class externally"
    test: "ask policy; get the answer in writing"
    pass_if: "written yes, with a scope"
    reverse_signal: "any conditional or verbal answer"
    owner: em
    expiry: 2026-11-13

# ledger.py — scaffold I wrote for this article; no tests, only PyYAML required
import sys, yaml, datetime as dt

doc = yaml.safe_load(open(sys.argv[1]))
claims = doc["claims"]
h = sum(c["minutes"] for c in claims) / len(claims)
F = len(claims) * h / 60
p_star = F / doc["reverse_rework_hours"]

print(f"T={len(claims)} h={h:.0f}min F={F:.1f}h break-even p*={p_star:.0%}")
print("run the ledger only if your reversal probability beats that number")

today = dt.date.today()
for c in claims:
    if dt.date.fromisoformat(str(c["expiry"])) < today:
        print(f"EXPIRED {c['id']} — owner {c['owner']}: re-check or drop the standard")

Run that on your own file before your next architecture sync, not after.

Free lane, self-host, or paid seat: fit criteria, not vibes

Criterion	Free hosted lane	Self-host	Paid alternative
Cash price	zero (operator-stated)	infra + ops hours	per seat
Whose machine processes the work	vendor — test C7	yours	vendor
Reversal cost `R`	context rewrites	near zero if the repo is yours	seat migration + retraining
Ops hours you own	lowest	highest	middle
Failure mode	terms change under you	nobody maintains it	renewal becomes the default

Fit rules I'd actually apply:

Take the free hosted lane when F < 8 hours, one team, two repos or fewer, and someone owns a recurring re-check. Free buys you falsification time; it doesn't buy you a standard.
Self-host when the code class can't leave, you already run the ops capacity, and the workload is steady enough to justify it. If self-hosting is a weekend project for one person, you've just created a bus factor.
Pay per seat when administration, procurement, and offboarding consistency matter more than unit price. That's a governance purchase, not an engineering one.

Hard gates, owner, expiry, exit

Gate 1 — owner. No named owner for the C1–C3 re-check, no standardization. The ledger decays the moment nobody owns it.
Gate 2 — spend. No paid commitment before C1, C2, and C7 have a recorded pass or fail.
Gate 3 — data class. If C7 comes back as an absolute no, this was never a ledger question. It's a stop.
Exit criteria. At expiry: standardize if 7 or more of 9 claims pass. Extend one cycle if 5–6 pass with a named owner. Stop if fewer than 5 pass, or if C7 fails.

Limitations, and who should skip this

Every number above is illustrative. A ledger is a conversation tool, not objective truth, and it will not settle a disagreement between people who want different answers.
Operator-stated terms — free model access, the free server option, the stated free grant, the open-source description — are dated 2026-10-16 and may change. The ledger's value is that it forces you to re-test rather than re-cite.
It does not price the human cost of a bad lane: review fatigue, morale, the senior engineer who quietly stops reviewing.
It assumes you can name R with some honesty. If your context assets live in one person's head, measure that problem first.

Skip this approach entirely if you're a solo developer with no shared context to rewrite (just use the thing for a week), if your data policy is already an absolute no, or if you want a benchmark verdict rather than a decision framework. Benchmarks tell you what a lane can do. Ledgers tell you what it would cost to leave.

If you want a lane that's cheap enough to falsify, MonkeyCode's repository is a reasonable place to run C1 and C2 against your own smoke set — the whole exercise costs about forty minutes, and that is the point of a zero-price offer.

One last question, and it's the only one that matters: which single claim in your ledger would flip your decision if it failed — and who is re-checking it on 2026-11-13?

Should Your Team Commit to a Free AI Lane? Use This Exit Amortization Sheet

bestbee — Thu, 15 Oct 2026 11:05:03 +0000

Last Thursday a platform lead asked me a question I get about once a month: "We're running on free AI capacity. When do we have to decide whether to stay?"

I asked him one thing back. What does leaving cost you, in engineer-hours? Silence for a few seconds. Then: "We'd have to rewrite the CI wrapper and port the prompt library. Maybe two weeks?"

That's the number that decides. Not the token count. Not the seats. The exit.

Free capacity gets priced at zero, so most teams quietly treat it as infinite. It isn't. It's a loan, and the balloon payment is called migration — the work you do the day the terms change, the allowance runs out, or your security review catches up with you.

Quick context on why this is showing up now: DEV's front page over the past week carried a lot of AI fatigue discussion (a "AI Fatigue? Yea I know." post picked up 106 reactions on Oct 13) and a piece arguing AI tools improved while the software around them didn't (96 reactions, Oct 9). Community signal is not evidence, but it's a decent hint that teams are consolidating lanes instead of adding them. Consolidation decisions need a number.

Here's the number, and here's how to compute it yourself.

Step 0: Name the three columns

This sheet only makes sense if you're comparing real alternatives. I use three:

Free hosted lane. Concretely, for this walkthrough: MonkeyCode's free model access plus its free server option. The operator describes both as available at no cost, with a stated free allowance of 10 million tokens. Verify current terms on the project page before you build a budget on them — that is true of every free tier, including this one.

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

Paid hosted lane. Any per-seat or per-token plan with a contract, an SLA, and a billing line you can point at during a renewal conversation.
Self-host. You run it. This only exists as a column if the project is open source and the repository's current docs actually support the deployment you need — MonkeyCode is an open-source project, so check its repo before assuming this path is available to you.

The mistake I see most often is comparing column 1 against column 2 by sticker price and comparing column 1 against column 3 by nothing at all.

Step 1: Measure your own burn, not someone else's

A stated allowance is meaningless until it's divided by your consumption. So measure it. Ten merged PRs is enough to get a usable median.

Pick 10 merged PRs from the last month that used the lane.
Log the usage number your client reports for each one, plus whether the PR needed a rewrite after review.
Take the median of the clean ones. Keep the messy ones as a separate "rework" bucket.

Do not use a vendor's tokens-per-task figure. It's measured on someone else's code, at someone else's review standard. If you can't measure 10 PRs, you can't run this sheet yet — that's a real answer.

Step 2: Convert the allowance into runway months

# exit_ledger.py — free-lane runway and exit break-even
# Inputs below are ILLUSTRATIVE. Replace with your measured values.
from dataclasses import dataclass, replace

@dataclass
class Inputs:
    free_tokens: float         # operator-stated allowance; re-verify before budgeting
    tokens_per_pr: float       # YOUR measured median, tokens per merged PR
    prs_per_month: float       # YOUR merged PRs per month on this lane
    saved_hours_month: float   # engineer-hours saved per month vs next-best option
    hourly_cost: float         # fully loaded $ per engineer-hour
    exit_hours: float          # one-time hours to leave or migrate the lane
    residual_hours: float      # monthly overhead the free lane adds (rework, governance)

def runway_months(i: Inputs) -> float:
    burn = i.tokens_per_pr * i.prs_per_month
    return i.free_tokens / burn if burn else float("inf")

def net_savings_month(i: Inputs) -> float:
    return (i.saved_hours_month - i.residual_hours) * i.hourly_cost

def break_even_month(i: Inputs) -> float:
    net = net_savings_month(i)
    if net <= 0:
        return float("inf")   # the free lane costs more than it saves
    return (i.exit_hours * i.hourly_cost) / net

def reversal_exit_hours(i: Inputs) -> float:
    """Exit hours at which savings never amortize inside the runway."""
    return (net_savings_month(i) * runway_months(i)) / i.hourly_cost

def sensitivity(i: Inputs, exits=(20, 40, 80, 160), savings=(8, 16, 24)):
    for h in savings:
        row = []
        for e in exits:
            j = replace(i, exit_hours=e, saved_hours_month=h)
            row.append(f"{break_even_month(j):.1f}")
        print(h, row)

Filled with illustrative numbers — my example, not a benchmark:

Variable	Value
`free_tokens`	10,000,000 (stated allowance, 2026-10-15)
`tokens_per_pr`	45,000 (illustrative median)
`prs_per_month`	40
`saved_hours_month`	24
`hourly_cost`	$85
`exit_hours`	60
`residual_hours`	10

Run it and you get: burn 1.8M tokens/month, runway ≈ 5.6 months, net savings ≈ $1,190/month, break-even ≈ 4.3 months, and a reversal threshold of ≈ 78 exit hours.

Read that last one out loud, because it's the whole point. If porting the CI wrapper and the prompt library takes more than roughly 78 engineer-hours, the free lane's savings never pay back inside its own runway. You would have saved money by starting on the paid column.

Step 3: Sensitize, then set a hard gate

Single-point answers are how teams get burned. Run the grid.

break-even month ↓ / exit hours →	20	40	80	160
net $850/mo	2.0	4.0	8.0	16.0
net $1,190/mo	1.4	2.9	5.7	11.4
net $2,040/mo	0.8	1.7	3.3	6.7

And sensitize the runway, because burn is the variable you control least:

PRs/month	Burn	Runway on 10M
20	0.9M	11.1 months
40	1.8M	5.6 months
80	3.6M	2.8 months

Now the gate. I use break-even ≤ 60% of runway, because free terms move and my measurements are median-based, not precise. At 5.6 months of runway that's a 3.4-month ceiling, which at $1,190/month of net savings caps your exit at about 48 engineer-hours.

Write that cap on the ticket before the pilot ends. Gates that aren't written down before you're attached to the outcome are not gates.

Who owns it, when it expires, when you leave

A ledger without an owner is a spreadsheet. So attach three fields:

Owner: one named person, not a team. This is usually the EM or platform lead who can actually stop the PRs.
Expiry: a date, not "when the allowance runs out." I default to the runway month minus one, so you decide with a month of margin.
Exit criteria: the measured condition that sends you to column 2, written as a number. Example: "if measured burn exceeds 2.5M tokens/month for two consecutive months, move to the paid lane and re-run the sheet."

On the expiry date, do one of three things: renew the free lane with fresh terms, move to paid, or migrate to self-host. Doing nothing is also a choice, and it's the expensive one.

Who should not use this sheet

Be honest about the fit criteria, including the ones that disqualify you:

You have no single owner. Without one person able to kill the lane, the exit cost grows silently.
Your data path isn't cleared. Cost math does not override a security review. Resolve the review first.
You expect less than about two months of use. Then the free lane is the right answer and the ledger is overkill — just use it and don't build tooling around it.
You can't measure tokens per PR yet. Measurement is step 1 for a reason.

And a fairness caveat in the other direction: for a solo developer or a two-person side project, exit cost is near zero and none of this matters. Free is free. This sheet is for teams where migration is a project, not an afternoon.

The question that reverses you

My example lands on "commit, with a 48-hour exit cap." Yours will land somewhere else, and that's fine. A sheet like this is a conversation tool, not objective truth — it makes the disagreement legible, it doesn't settle it.

So here's what I'd actually want to know from you: which single input flips your answer? The exit hours, the burn per merged PR, or the residual overhead? If it's the burn, you can only find out by measuring, and a free lane is the cheapest place to get that measurement.

That's the honest role MonkeyCode plays in this method: it's the column you use to collect a real month of tokens_per_pr before you sign anything. Its free model access and free server option are what make the measurement phase cheap; the ledger does the deciding.

Price the Assistant Path in Disagree-Minutes, Not a Free Sticker

bestbee — Mon, 12 Oct 2026 22:41:53 +0000

Picture a Thursday release desk that I am using as a composite, not as a customer story. Three engineers share one assistant path because the sticker says free. The suggestion looks tidy. Nobody pushes back.

Twenty minutes later the same function is in review again. The assistant nodded at a null check the service has never had. Sound familiar?

Here is the rude question I ask before anyone opens a pricing page. How many minutes did you spend throwing that suggestion away and trying again?

If that number is fat, a free sticker can be the expensive path. If it is thin, buying a second path is theater. Which one is on your board this week?

What I am pricing, and what I refuse to fake

I am not pricing tokens. I am not pricing rollback hours. I am not scoring how "incident-adjacent" the work felt. Those are other decisions, and mixing them is how a review becomes a slogan contest.

This ledger prices disagree-minutes. A disagree event is a suggestion an engineer discards, re-prompts, or rewrites before merge. Clock time. Not vibes.

It is a conversation tool. It is not objective truth, and it is not a benchmark of any vendor. If your inputs are guesses, the output is a guess with cleaner handwriting.

Public developer threads this week kept circling the same bruise: retry decisions, and assistants that agree too fast. I am not treating those posts as evidence about any product. I am treating the bruise as a buying question. When the assistant stops arguing, do you stay, pay, or take the ops bill yourselves?

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

The operator supplied two availability claims for that project, and described it as open source: free model access, and a free server option. I am not asserting a quota, a hardware shape, a duration, a model name, a license text, or permanence. Those are facts you confirm on the current project page the day you decide. If the page and this paragraph disagree, believe the page.

Four paths, one unit

You are not choosing "free versus real." You are choosing among four paths.

Stay on hosted free model access, if that offer still exists when you look.
Use the free server option, if the current offer actually changes who holds the queue and the prompts.
Buy a paid path from a vendor who will invoice you.
Self-host a stack your platform team will still operate in week six.

Define the variables before anyone types a number. Otherwise the meeting will invent a winner.

N — engineers on this path this week
R — discarded suggestions per engineer per week
M — minutes to discard, re-prompt, and re-check one discard
H — loaded hourly cost for those engineers
Q — minutes lost when access stops mid-task, times how often it happened, times H
P — paid invoice for the same week, in money you already spend
S — platform hours for self-host or for running the free server option, times platform hourly cost, plus any hosting you actually pay
D — custody hard-gate, yes or no. Not a made-up dollar figure

Weekly disagree cost is N * R * M / 60 * H. Add Q. Compare that sum with P, and with S.

A score without an owner and an expiry is a poster. Name the engineering manager. Expire the choice in 14 days. Exit if measured R does not move, or if D flips to yes.

A filled example, labeled as fiction

Do not copy these inputs into a slide and call them a pilot. They are a worksheet illustration. They are not a MonkeyCode measurement, not a market study, and not your ROI.

Suppose N = 8, R = 6, M = 12, H = 80. Disagree cost is 8 * 6 * 12 / 60 * 80 = 768 per week. That 768 is the number that can reverse "free is free."

Now a hypothetical paid pilot cuts R from 6 to 2, and P is 400. New disagree cost is 8 * 2 * 12 / 60 * 80 = 256. Savings against the old path: 768 - 256 = 512. Net of the invoice: 512 - 400 = 112. Thin. One stubborn week and the paid path loses.

Sensitivity, same fake inputs. If M is 5, not 12, the original disagree cost falls to 8 * 6 * 5 / 60 * 80 = 320. Paying 400 to chase 320 is a no, unless custody already forced you off hosted free. If the paid path keeps R at 6, you bought a more expensive nod. Why would you renew that?

Self-host uses the same math and a different bill. Six platform hours at 90 is 540, before any model hosting you actually pay. The free server option might shrink S. It might not. I will not pretend I timed it. Put real ops hours into S after a week of running the option, or do not claim a saving.

What reverses the illustration even when 768 looks scary? D = yes. If prompts, diffs, or customer code cannot sit on a hosted free path, the sticker is irrelevant. You leave. Then disagree-minutes only break the tie between a paid contract and self-host, including whether the free server option changes custody or merely changes the login screen.

Incentives, not applause

A free path trains a quiet habit. People stop arguing with the suggestion because arguing feels like wasting a gift. Paid paths train a different quiet habit. People defend the invoice. Self-host trains a third one. Platform defends the cluster they stayed up to build.

Ask who gets praised. The engineer who merges fast, or the engineer who discards a fluent wrong diff? If the first one gets the praise, your R is under-counted, and every path will look smarter than it is.

Log discards like bugs

I want a row each time someone throws a suggestion away. This format is a proposal. I have not run it in your repo, and it does not call a vendor.

# retry-log.tsv
# ts    engineer    lane    minutes reason  page_risk
2026-10-13T15:04:00Z    eng-a   hosted-free 11  agreed-with-missing-null    no
2026-10-13T15:22:00Z    eng-b   hosted-free 18  retried-same-bug    no
2026-10-13T16:01:00Z    eng-c   paid-pilot  4   style-only  no
2026-10-13T16:40:00Z    eng-a   free-server 9   queue-stall-then-rewrite    no

Read it before anyone builds a dashboard:

awk -F'\t' 'NR>2 {n[$3]++; mins[$3]+=$4} END {for (l in n) printf "%s rows=%d minutes=%d\n", l, n[l], mins[l]}' retry-log.tsv

Rows and minutes by path. That will not prove quality. It will stop the argument from living in Slack memory. If page_risk is ever yes, stop the ledger and use your incident review. This sheet is the wrong tool while a pager is hot.

Then a tiny gate. Unexecuted proposal. Swap the constants. The + 50 is a friction buffer I picked so a 10-currency "win" cannot flip a squad. Change it in the review, out loud.

# proposal_retry_gate.py — illustration, not a measured benchmark

def weekly_cost(n, r, m, h):
    return n * r * (m / 60.0) * h

def gate(hosted_cost, hosted_r, paid_invoice, paid_r, self_host, custody_blocked, buffer=50):
    if custody_blocked:
        return "exit-hosted-free"
    paid_total = weekly_cost(8, paid_r, 12, 80) + paid_invoice
    # Recompute paid_total with YOUR n, m, h. The 8/12/80 above match the fiction only.
    if paid_total + buffer < hosted_cost and paid_r < hosted_r:
        return "pilot-paid"
    if self_host < hosted_cost and self_host < paid_total:
        return "price-self-host-or-free-server"
    return "stay-and-remeasure"

hosted = weekly_cost(8, 6, 12, 80)
print(hosted, gate(hosted, 6, 400, 2, 540, False))

On these fake inputs the print is 768 and pilot-paid, because 256 + 400 + 50 is still under 768 and R fell. Drop paid_r back to 6 and the same function should refuse the upgrade. A green demo that never disagrees is not a win. It is an unmeasured nod.

Fix the script before you trust it: pass n, m, and h into gate instead of leaving the illustration constants inside paid_total. I left that smell on purpose. If nobody notices, you are not ready to let a worksheet pick a vendor.

The 4-part gate

Run these in order. Skipping to price is how free stickers win arguments they should lose.

Hard stop. If the change can page a human, the path does not merge it. Hosted free, paid, free server, self-host — same rule. A fluent yes is not a review.
Custody. Can this repo's prompts and diffs live on the hosted free path under current policy? If no, exit today. Then ask whether the free server option changes who holds the data, or only where the process runs. If the docs do not say, the answer is no.
Disagree-minutes versus invoice. Only after the first two. Run a 14-day paid pilot with the same log. If R does not fall enough to beat P plus your buffer, stop. Do not "give it a quarter" because the demo felt sharp.
Ops reality. If self-host, or the free server option, needs a platform owner you do not have, it is not the cheap path. Blank name means S is infinite for this decision.

Owner: the engineering manager for that squad. Expiry: 14 days from the first logged row, dated on the doc, not in someone's head. Exit criteria: R unchanged, custody unclear, or free access interrupted often enough that Q alone exceeds P. Archive the choice in the same doc. No silent renewals.

Re-open the doc if headcount, repo sensitivity, or the vendor's terms change before day 14. A gate that cannot expire is a loyalty program.

Who should walk away

Skip this ledger if any of these are true.

You have no human reviewer. The hole is the merge policy, not the sticker.
You need a quota, an SLA, or a box size. This article is not a spec sheet. Read the current offer.
Your week is incident response. Disagree-minutes are a planning unit, not a pager unit.
You wanted a cluster tutorial. A decision gate will not install one, and I am not going to pretend it will.
You cannot name the variable that would reverse you. Then you are shopping.

Also skip it if the squad will not log discards. An empty TSV makes every path look free, which is the bias we came here to kill.

The only question I want back

Would a drop in M from 12 to 4, with R unchanged, keep you on hosted free model access? Or does custody already force the exit, so the minutes are a footnote?

If you are actually choosing, check the current MonkeyCode terms for free model access and the free server option, confirm the license yourself, log one week of discards, and put your own N, R, M, P, and S into the gate. Then say which input flipped the call. I will trust that over a sticker.

Should Your EM Stay on a Free Coding Lane After the Pilot? Use This Term-Drift Sheet

bestbee — Sun, 11 Oct 2026 19:57:42 +0000

Picture a Thursday standup. Six engineers. One engineering manager. Three sticky notes on the board: free lane, paid seats, self-host.

Nobody is fighting about which demo felt smart. They are fighting about a clock. The pilot felt cheap. The next planning window is ninety days. If the free terms move, who pays the exit?

I use that scene as a composite, not a named customer. I keep the same argument when I write the stay-or-leave call down. So which sticky note still matters if the sticker you liked last month is gone?

The call that can reverse

I am not asking whether AI coding "works." That question is too wide, and it lets everyone win the meeting.

I am asking something an engineering manager can actually own. Should this cohort stay on a free coding lane, buy a paid hosted lane, or self-host, once you price term drift?

Term drift is just this: quota, model set, server option, or data terms can change inside your planning window. You do not need a rumor to model it. You need a weight you will defend, a person who owns the row, and a date when the exception dies.

A scorecard is a conversation tool. It is not objective truth. If finance hates one input, change it and rerun. Why else keep a sheet?

What I will treat as fact

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

The operator describes MonkeyCode as an open-source project with free model access and a free server option. Those two availability claims are the only product facts I will put in column one.

I am not naming models. I am not stating a token quota, a box size, an uptime number, or a duration. A round figure on a slide, including any "millions of tokens" sticker, stays out until someone opens the live terms and writes today's date beside it.

I drafted this on 2026-10-12. If you read it later, re-check the repo and the terms before you reuse my blanks. Would you want a planning sheet that froze a quota I cannot cite from this desk?

Name the inputs before the debate

The numbers that enter the fight

Fill these from your logs and your own quotes. Do not borrow mine past the example, and delete the example when you are done.

N — engineers in the cohort. Useful context. Not the price.
Rw — hours per month on a second human pass you can tie to lane output. Not all review. Only rework you would skip if the lane were absent.
C — fully loaded hourly cost your finance partner already uses. A local number. Not a market average.
I — monthly invoice for the paid hosted alternative, same cohort, quote dated this week.
M — monthly self-host cost: people slice plus infra you would actually pay. Include on-call. Leave sunk laptops out.
E — engineer-hours to leave the free lane. IDE config, CI remote, prompt files, and the habit of pasting into one box.
W — planning window in months. Start at 3 unless your cycle is shorter.
p — a planning weight from 0 to 1 for terms, or the free server option, moving inside W. Your risk appetite. Not a vendor forecast.

N does not enter the formula. I keep it so nobody proves the cost with headcount and walks out early. Seen that move before? I bet you have.

The three monthly costs

Free: F = Rw * C + (p * E * C) / W
Paid: P = I + (p_paid * E_paid * C) / W
Host: H = M

Stay on the free lane only if F is lowest and every hard gate is still true. Otherwise buy or host. A low F never overrides a failed gate. Got that?

Paid can win on a higher sticker if exit load and rework make free worse. Self-host can win while looking expensive, if custody fails for both hosted paths. The unit is planning dollars per month, not a token sticker and not a seat count.

A filled example you should throw away

These numbers are a worksheet. I did not run them on a production org. They are not a product benchmark. Replace each one.

Suppose N = 6. Over 14 days the team labeled 9 pull requests lane-rework. Each second pass took about 25 minutes. That is 9 * 25 / 60 = 3.75 hours in two weeks, about 8 hours in a month. Set Rw = 8.

Finance says C = 110. Friction is 8 * 110 = 880 dollars a month. Small. Maybe too small. We will poke it in a minute.

A paid quote pasted into the doc this week says I = 1800. You think a contracted lane needs less exit work, so you set E_paid = 6 and p_paid = 0.2. Self-host is a quarter of a platform engineer plus a small box. You wrote M = 4600. Leaving the free lane looks like E = 16 hours. You set W = 3 and p = 0.5, because you will not bet a release train on an uncontracted server option.

Then the arithmetic:

Free exit load: (0.5 * 16 * 110) / 3 ≈ 293
F ≈ 880 + 293 = 1173
Paid exit load: (0.2 * 6 * 110) / 3 ≈ 44
P ≈ 1844
H = 4600

On this sheet, free wins the cost line. Does the team stay? Only if the gates pass. A cheap lane that cannot hold secrets, or that nobody can leave, is not cheap. It is an unowned outage with a friendly price.

Three flips I want said out loud

Which single input, moved by a believable amount, reverses the call? If you cannot answer, you do not understand your own sheet.

Rework. If Rw rises from 8 to 22, friction becomes 2420. Free planning cost becomes about 2713, above paid. Buy wins on cost. I would not wait for a prettier demo to notice that. The label log would have screamed first.
Term weight. If p goes from 0.5 to 1.0, free exit load doubles to about 587. F becomes about 1467. Still under paid in this example. So term fear alone does not flip this particular sheet. Rework does. That tells the EM to instrument labels, not to collect hallway rumors.
Custody. If any repo in the cohort is secret-adjacent, and you have not read this week's data terms for the free lane and the free server option, both hosted paths fail the gate. Self-host wins even at 4600. Cost is no longer the argument. Stop quoting it.

The sheet is allowed to say stay. It is also allowed to embarrass the stay. Which outcome are you hoping gets buried in the appendix?

Hard gates, one owner, one expiry

I will not let a low F override these.

Data terms for the free model lane and the free server option were read by a named person in the last 7 days. Link the page. Write the date. A memory from onboarding does not count.
No production secret, customer payload, or unreleased vulnerability note goes through a lane whose retention you cannot describe in one sentence.
The free server option is not the only remote for a release-train job. A second path exists, even if it is slower and annoying.
One owner. Not a chat channel. A person who can pause the lane on a weekday without a committee.
Expiry. The exception dies on a calendar date inside W. Use 30 days, then a rerun. No silent renew.
Exit drill. The owner has run the leave-steps once on a scratch repo. If they have not, E is a fantasy. You may not use it.

Who owns the row? The engineering manager owns the decision. A platform lead owns the exit drill. Finance owns C and I. If those three names are blank, you do not have a decision. You have a vibe with arithmetic on top.

Log the rework, then run the math

The label, before the feelings

Agree on lane-rework before the two-week log. A pull request gets the label only when someone redid work because the lane's output was wrong for this repo. Spec changes do not count. Taste arguments without a redo do not count. Be strict, or Rw becomes a junk drawer.

# Proposal commands. They do nothing until the label exists in your repo.
# Window start is 14 days before the draft date, 2026-10-12.
gh pr list \
  --search "label:lane-rework updated:>=2026-09-28" \
  --state all \
  --limit 200 \
  --json number,title,updatedAt \
  > /tmp/lane-rework.json

jq 'length' /tmp/lane-rework.json

Put minutes in the PR body as a trailer line: rework-min: 25. Crude. Still better than a memory from standup.

gh pr list \
  --search "label:lane-rework updated:>=2026-09-28" \
  --state all \
  --limit 200 \
  --json number,body \
  > /tmp/lane-rework.json

python3 - <<'PY'
import json, re
rows = json.load(open('/tmp/lane-rework.json'))
mins = []
for row in rows:
    found = re.search(r'rework-min:\s*(\d+)', row.get('body') or '')
    if found:
        mins.append(int(found.group(1)))
print('prs', len(rows))
print('with_minutes', len(mins))
print('hours', round(sum(mins) / 60, 2))
PY

Double the two-week hours if you want a rough month. Do not pretend that extrapolation is a forecast. It is a stand-in until you have four weeks. If the two weeks included a holiday, say so in the notes. Why hide the weird week?

The calculator

This script is a proposal. I have not executed it against a real organization, and it does not call a vendor API. It will not tell you that a product is safe.

#!/usr/bin/env python3
'''Term-drift sheet. Replace every number. Not a benchmark.'''

def monthly(rw, c, p, e, w, invoice=0.0, host=0.0, mode='free'):
    if w <= 0:
        raise SystemExit('W must be > 0')
    exit_load = (p * e * c) / w
    if mode == 'free':
        return rw * c + exit_load
    if mode == 'paid':
        return invoice + exit_load
    if mode == 'host':
        return host
    raise SystemExit('unknown mode')

def main():
    c = 110.0
    free = monthly(8.0, c, p=0.5, e=16.0, w=3.0, mode='free')
    paid = monthly(0.0, c, p=0.2, e=6.0, w=3.0, invoice=1800.0, mode='paid')
    host = monthly(0.0, c, p=0.0, e=0.0, w=3.0, host=4600.0, mode='host')
    costs = {
        'free': round(free, 2),
        'paid': round(paid, 2),
        'host': round(host, 2),
    }
    winner = min(costs, key=costs.get)
    print(costs)
    print('cost_winner', winner)
    print('gates_still_required', True)

if __name__ == '__main__':
    main()

python3 term_drift.py
# Edit rw from 8 to 22 and run again. Did the winner move?

The flip point is the only number I want on the whiteboard. Everything else is scaffolding.

Who should not use this

Skip the sheet if you cannot label rework for two weeks. A blank Rw makes free look free. That is how a zero becomes a strategy.

Skip it if the cohort handles regulated data and nobody has read the current terms. Do not pilot first and ask legal later. Later is how an unreviewed server option becomes a finding.

Skip it if you wanted a model bake-off. This does not score answer quality. It scores whether a cheap lane still fits after drift, rework, and exit. A green toy prompt will not save the meeting.

Skip it if you need a procurement signature tonight. The sheet is not a contract review, a security assessment, or a capacity test of anyone's free server.

Skip it if the owner will not put an expiry on the calendar. An exception without a death date becomes the architecture. You do not need a brand name on that pattern to recognize it.

Limits I want in the notes

p is not a probability I measured. It is a weight. Write that next to the cell, or a later reader will quote it as science.

E is usually too low the first time. People forget prompt files, CI secrets, and the junior who only knows one remote. Add a second pass after the scratch-repo drill, then trust the number.

The paid quote goes stale. Date it. A quote older than W does not count, even if the PDF still looks official.

Self-host M hides on-call until the first weekend page. If your platform team is already saturated, add a delay cost or stop pretending M is complete.

I also did not compare features, latency, or model quality. I cannot, not from this desk, and I will not invent a leaderboard to decorate the post. If quality is the real fight, review your own repos. Then come back and put the rework hours here.

Open-source does not, by itself, answer custody or exit. A repo you can read is not the same as a server option you can leave on a Tuesday. Treat those as separate rows.

Where column one can come from

If a free model lane and a free server option are the hosted pair you want in the free column, read MonkeyCode's current repository and terms, write the date on the sheet, and only then drop in numbers you can defend. I would rather you delete my example than inherit it.

So which input flips your call: rework hours, the term weight, or a custody gate you have been skipping?

Your Green Toy Eval Cannot Pick the Lane. Use This Review-Debt Gate

bestbee — Sat, 10 Oct 2026 16:03:03 +0000

Here is the meeting I reconstruct when a platform lead says the demo already decided the vendor.

An engineering manager has a free coding lane. It drafts a small internal page. A toy eval written before lunch comes back green. Someone asks the question that sounds frugal and is actually reckless. If this lane is clean, why are we still pricing a paid seat or a box in our own network?

I would ask a different question. What did that eval refuse to look at?

The quiet usually answers it. Happy-path JSON passed. Auth did not run. Migration order did not run. The files that page on-call never opened. A green toy eval is a mood. It is not a lane decision.

That is the tradeoff that can reverse the call. Not market excitement. Not a token sticker. Review debt, custody, and the week the free option changes.

Name the choice before you name a product

Three options sit on the table. Keep generating on free model access plus a free server. Move the same workflow to a paid hosted lane. Or self-host.

Which one survives the next month of real diffs? If you cannot say what would flip you, you are not deciding. You are shopping.

I am using MonkeyCode as the free-lane column in this comparison. Disclosure: This article was prepared as part of MonkeyCode's product outreach. The outreach describes free model access and a free server option, and it positions the project as open source.

I have not verified the license, the repo contents, quotas, model names, hardware, uptime, or how long either offer lasts. If a chat brief waved a round token figure at you, do not paste it into a budget. Copy the live number, and the date you read it, from the project page. A sticker is not capacity you own.

If the page and this article disagree, the page wins. Open source is not a support plan. Read the license before you fork, and confirm what "open" does not include.

The unit I will actually price

I will not price this on seats. I will not price it on a token pool. I will not price it on one green run.

I price reviewer-minutes on defects a human still has to catch. Call that review debt. If the lane saves drafting time and then spends it back in review, you do not have free capacity. You have a queue with a costume.

Does your toy eval even see the files your reviewer rewrites? If it does not, your escape rate is a guess wearing a checkmark.

Variables, defined before the argument

D — drafts per week a human must review. Diffs, not chat turns.
M — reviewer minutes per draft, including rewrites. Time it. Do not recall it.
E — escape rate. Share of drafts where review finds a defect the toy eval missed. From 0 to 1.
C — loaded cost of one reviewer minute, in your currency.
S — drafting minutes the lane actually saves per draft, on your work.
K — extra minutes per draft if you self-host. Patching, babysitting, key rotation. Measured, or marked unknown.
P — paid hosted cost per draft, fully loaded. Seats spread across D, plus overage you have already seen.
B — custody block. 1 if the diff may not leave your boundary. 0 if it may.

Weekly review debt is RD = D * M * E * C. Weekly drafting value is DV = D * S * C.

Free-lane net, ignoring the chance the offer vanishes, is NF = DV - RD.

Paid net uses its own escape rate, not a hoped-for one: NP = D * S * C - D * M * E_paid * C - D * P.

Self-host net is NS = D * S * C - D * M * E_self * C - D * K * C.

You do not get to assume E falls because you paid, or because you rented a box. If you have not sampled those lanes, set E_paid and E_self equal to E. Then paid and self-host must win on custody, support, or continuity. Not on a fantasy quality jump.

A filled sheet that is not a customer

These numbers are hypothetical. I made them up so the arithmetic is visible. They are not a benchmark. They are not MonkeyCode results. They are not your team.

D = 30. M = 18. E = 0.25. C = 1.4. S = 12. P = 6. K = 8. B = 0 only while the sample stays off customer data.

Free lane: RD = 30 * 18 * 0.25 * 1.4 = 189. DV = 30 * 12 * 1.4 = 504. NF = 315.

Paid, same escape rate: NP = 504 - 189 - 180 = 135.

Self-host, same escape rate: NS = 504 - 189 - 336 = -21.

On this invented board, the free lane wins the week, and self-host loses. Thin win. Do not laminate it.

Sensitivity, the part that should make you nervous

Move only E on the free lane to 0.55. That is what I expect when the eval never opened auth or migrations.

RD = 30 * 18 * 0.55 * 1.4 = 415.8. NF = 88.2. Still positive. Barely.

Now the reviewer is rewriting, so S drops to 6. DV = 252. NF = 252 - 415.8 = -163.8.

The free lane just went negative. No sticker caused that. Reviewer minutes did. Would your lead still call it free?

Flip B to 1 and stop. A pretty NF does not outrank a custody rule. Free model access that sends code off-boundary is a no, even when the weekly math looks kind.

What about the week the free server changes? I will not invent an uptime number to decorate this. Price a stuck week as D * M * C of drafts with nowhere to land, and ask if you can absorb it. If you cannot, the free column was never a default. It was a pilot with a calendar.

Hard gates I will not let you average away

Custody. B = 1 means the free hosted lane is out. Compare a contracted paid lane with self-host. Read the contract. Do not guess the data terms.
Owner. One named person. Not a channel reaction.
Expiry. This sheet dies in 14 days, or on the day the project page changes the free terms. Whichever comes first.
Toy-eval scope. If the eval skips one failure path from last month's incident review, it cannot justify "stay."
Exit. Leave the free lane when NF is negative on two weekly samples, or when one escaped defect touches a paging path.
No silent default. The free lane is not the only editor for new hires until the owner re-signs.

A scorecard is a conversation tool. It is not objective truth. If two leads disagree on E, argue about the sample. Do not argue about the logo.

Questions I ask out loud

Who gets paged if this diff is wrong?
Which file did the toy eval never open?
If the free server is gone on Thursday, where do these drafts land?
Are you about to treat a smooth surface as a reviewed change?

If the room cannot answer, you do not have a pilot. You have a demo that escaped.

Fit, in one glance

Question	Free model access + free server	Paid hosted	Self-host
When it fits	`B = 0`, `NF > 0`, owner named, expiry written	You need support or terms you can cite	`B = 1`, or you already run the stack and `K` is measured
When it fails	Terms can move and you have no exit week	`D * P` eats the review-debt gap	`K` is a guess you are treating as a fact
What you owe	A 10-draft sample and a boundary check	A premium you have seen, not a list price you liked	Patch owner, key owner, and a rollback path

This gate also ignores prompt retention, output license, and whatever counsel already forbade. If legal has a written no, the spreadsheet does not get a vote.

Run the arithmetic before the meeting

This script is a proposal. I have not executed it against a live product. Change every input. If you paste my hypotheticals into a slide, you are the problem.

# review_debt_gate.py
# Proposal only. Hypothetical inputs. Not a benchmark.

def weekly(d, m, e, c, s, extra):
    review_debt = d * m * e * c
    draft_value = d * s * c
    return review_debt, draft_value, draft_value - review_debt - extra

def main():
    d, m, c, s = 30, 18, 1.4, 12
    e_free = e_paid = e_self = 0.25
    paid_premium, self_host_minutes = 6.0, 8.0
    custody_block = False

    rows = {
        'free': weekly(d, m, e_free, c, s, 0),
        'paid': weekly(d, m, e_paid, c, s, d * paid_premium),
        'self_host': weekly(d, m, e_self, c, s, d * self_host_minutes * c),
    }
    for name, (rd, dv, net) in rows.items():
        print(f'{name}: debt={rd:.1f} value={dv:.1f} net={net:.1f}')

    if custody_block:
        print('GATE: free hosted is blocked. Compare paid vs self-host only.')
        return
    winner = max(rows, key=lambda n: rows[n][2])
    print(f'Arithmetic pick: {winner}. Re-check gates before you tell the squad.')

if __name__ == '__main__':
    main()

python3 review_debt_gate.py

Then break the free lane on purpose. This is the sensitivity I want on a whiteboard, not in a keynote.

python3 - <<'PY'
d, m, c, s = 30, 18, 1.4, 12
for step in range(1, 8):
    e = step / 10
    net = d * s * c - d * m * e * c
    print(f'E={e:.1f} free_net={net:.1f}')
PY

Where free_net crosses zero, stop debating vendors. Pull ten real diffs. A half hour of notes beats another slide.

Record the decision so it can expire:

date -u +%F > lane-decision-date.txt
printf 'owner=%s\nexpiry_days=14\ncustody_block=%s\n' "$OWNER" "$B" >> lane-decision-date.txt

Sample ten drafts, skip the pretty one

For each draft, four lines. Did a human touch auth, data, or migrations? Minutes spent, rewrite included. Would the toy eval have failed it? Could the diff have left the boundary?

# drafts.tsv columns: minutes, escaped(0/1), boundary(0/1)
awk -F'\t' 'NR>1 {n++; mins+=$1; esc+=$2; b+=$3} END {
  printf "n=%d avg_min=%.1f escape=%.2f boundary_share=%.2f\n", n, mins/n, esc/n, b/n
}' drafts.tsv

That is an average, not a median. I know. It is still enough to stop a meeting that wants to standardize a demo. If boundary_share is not zero, the free hosted option is already on probation.

Who should not use this gate? A solo maintainer with no reviewer. The formula assumes a human queue. A team that already has one contracted lane and no appetite for a second path. Anyone who wants a blessing for a number they have not timed. And anyone about to point a free server at production CI.

A free server option is a pilot host, not your build farm, until you have an exit you have rehearsed. Would you bet a Thursday incident on a host you do not control? Then it is not the default.

What I am not claiming

I am not claiming MonkeyCode is faster, cheaper in outcome, or more accurate than a paid lane or a self-hosted stack. I did not run that test. I am not naming models, because I will not invent them. I am not locking a token allowance into this article, because an allowance I have not re-read today is already stale.

Use the free column when the work is non-production, the boundary check is clean, you have an owner, and you have an expiry. That is a sane way to learn whether drafting time is real before you buy seats or stand up hardware.

Do not use it for customer data, paging paths, or a hiring exercise you will later pretend was production code. A surface that looks finished is how review debt hides. Your on-call does not grade the demo. It grades the diff.

Which input flips your call: escape rate, reviewer minutes, or the custody bit? If none of them move, you are shopping. Date the sheet, name the owner, and throw it out when it expires. If you try a free model lane or a free server before that date, copy the live terms that morning instead of trusting this page, and keep the lane off paging paths until the second weekly sample.

Should Your Platform Lead Trust a $0 Coding Lane? Use This Page-Owner Gate

bestbee — Fri, 09 Oct 2026 11:29:07 +0000

I use a composite scene for this call, because the real company names are not mine to publish. The invoice says $0. The pilot is fourteen days old. A generated pull request touches a billing path at 23:10, and the on-call column for agent mistakes is blank.

Would you keep that lane because the vendor bill was quiet?

I would not. Not while the page owner is an empty cell. A free hosted lane can still be the right four-week probe. It is a bad default the morning you need a human.

Every figure below is a placeholder you replace. This scorecard is a conversation tool, not objective truth.

The unit that can flip the decision

Token stickers and seat counts will not save you in that 23:10 review. I have priced other units in other write-ups. This one is the pager.

Who gets the page when the agent is wrong, and what does that hour cost? If you cannot name the person, you do not have a pilot. You have a login and a hope.

Three columns usually show up on the same slide:

A free hosted lane, sometimes with free model access and a free server option.
Self-hosting an agent you are actually allowed to run, patch, and shut down.
A paid lane with a contract, a support path, and a renewal date.

Cash is one row. Page ownership is the row that changes a founder's mind.

Put the free column in its place

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

MonkeyCode belongs in this worksheet as a free-column candidate: free model access, plus a free server option, as supplied for this draft. I am not stating a model name, a token quota, a hardware shape, a duration, or an uptime number. Those were not attached as dated primary facts, and a decision guide should not invent them. Read the live terms on the day you decide. A post is not your contract.

Does that make the free column useless? No. It makes it a probe with an owner, not a permanent architecture.

I would use a free hosted lane only when all four lines are true:

The repos in scope have no customer data, secrets, or production credentials.
A human already owns review, and that human knows they own the page.
You can exit in weeks. "After the next planning cycle" is not an exit.
You are testing workflow fit, not crowning a model.

Miss one line, and self-host or paid can be the honest column even when the invoice looks worse. If the project is described as open source, that still does not fill the self-host column for you. Read the license. Name the person who will patch it. A free server does not answer either question.

The Page-Owner Gate

Define the variables before anyone says "AI ROI."

E — bad changes per week that need a page, a rollback, or a revert. You measure this. Do not borrow mine.
H — reviewer or on-call hours per bad change.
R — loaded hourly cost of the person who owns the page.
W — decision window in weeks.
Cash — invoice plus unavoidable ops cash for that window.
Boundary — security or legal hours, priced once, if code or prompts cross a boundary you care about.

Page cost is E * H * R * W. Option total is Cash + page cost + Boundary.

This script is a local worksheet. It does not call a vendor, and it cannot apply a data gate. Label it as a proposal, then replace every input.

# page_owner_gate.py
# Illustrative inputs only. Not a measured result for any product.

def option_total(cash, events, hours, rate, weeks, boundary):
    page = events * hours * rate * weeks
    return cash + page + boundary, page

def break_even_events(hours, rate, weeks, free_boundary, other_total):
    page_per_event = hours * rate * weeks
    return (other_total - free_boundary) / page_per_event

weeks = 4
hours = 2.0
rate = 120.0

# Placeholders for a conversation, not quotes.
options = {
    "free_hosted": {"cash": 0, "events": 1.5, "boundary": 900},
    "self_host": {"cash": 2400, "events": 1.2, "boundary": 300},
    "paid_lane": {"cash": 1600, "events": 0.8, "boundary": 200},
}

scored = {}
for name, row in options.items():
    total, page = option_total(
        row["cash"], row["events"], hours, rate, weeks, row["boundary"]
    )
    scored[name] = total
    print(f"{name}: total={total:.0f} page={page:.0f}")

be = break_even_events(hours, rate, weeks, 900, scored["paid_lane"])
print(f"free_vs_paid break-even E={be:.2f} bad changes/week")

Run it locally:

python3 page_owner_gate.py

On these placeholders the sheet looks like this:

Option	Cash	E / week	Boundary	Page cost	Total
Free hosted	0	1.5	900	1,440	2,340
Self-host	2,400	1.2	300	1,152	3,852
Paid lane	1,600	0.8	200	768	2,568

Arithmetic likes the free column. So what? Arithmetic does not own the pager.

Sensitivity, because E is the number people sand down

Hold H, R, and W fixed. Free total is 960 * E + 900. Paid total on this sheet is 2,568. Set them equal and E is about 1.74 bad changes per week. The script prints that break-even. Do not trust my sentence if your run disagrees.

Cross 1.74 and the free column loses on cost alone, before any data rule. Drop free-lane E to 0.4 and page cost falls to $384. Then the free column wins by a wide gap. It wins only if the hard gates also pass.

Self-host loses this particular sheet because I priced operator time instead of hiding it in "someone will maintain it." Will they? If your real self-host cash is $400, rerun the script. Do not argue with a cell you refused to fill.

Gates that override the cheap winner

Print the low total. Then apply the gates. A failed gate means stop, even when the spreadsheet smiles.

Data boundary. Customer data, secrets, or production credentials on a free hosted lane need a written exception. No exception, no invite.
Named page owner. One person, not a channel. If the name is "the team," you failed.
Exit date. A date on a calendar. "When we see value" is not a date.
Measured E. If week one has no count of bad changes, you are collecting anecdotes.
Operate rights, for self-host. If you cannot confirm you may run, patch, and shut the agent down, it does not belong in that column. A free server option is not a cluster you control.

Log the call without secrets or customer identifiers:

printf '%s\t%s\t%s\t%s\n' \
  "$(date -u +%Y-%m-%d)" \
  "free_hosted" \
  "HOLD" \
  "page-owner=alex; exit=2026-11-06; gate=data-ok" \
  >> page-owner-log.tsv

The platform lead owns the card. A named engineer or EM owns the page. Security owns the data exception, and that exception expires. In this example the window ends on 2026-11-06. Then you re-score, or you archive the lane.

Any one of these is an exit:

Measured E crosses your break-even against the next-best column.
The page owner misses a revert window you wrote down in advance.
The data exception expires.
The terms you actually read no longer match the boundary you approved.

Four weeks, then a real choice

Week 0 is the gate, not the install party. I would block the invite until the log line exists. No owner, no date, no pilot.

Week 1, count bad changes. A revert is only a floor. Review rejects never hit main, so git will undercount. Still, write the floor down where finance can see it later.

# Floor for E, not the definition. Caught-in-review misses are invisible here.
git log --since='7 days ago' --grep='Revert' --oneline | wc -l

Week 2, ask the page owner one question. If this lane vanished on Friday, what breaks? "Nothing we cannot do by hand" means you still have an exit. "The team's whole flow" means you standardized by accident. That is how a free lane becomes unowned infrastructure.

Week 4, rerun the script with measured E. Keep, move to a lane you operate, or buy. Do not extend a HOLD because the invoice is still zero.

Who should skip this gate

Skip it if you have no pager and no reviewer. A solo sketch does not need a page-owner card.

Skip it if the real question is which model wins a benchmark. I am not supplying scores, and a cost gate will not invent them.

Skip it if the repo is incident-adjacent production and you wanted a lighter change process. A $0 lane is not lighter change management. It is a missing owner with a friendlier invoice.

Skip it if you need a quota, a GPU shape, or a permanence promise before you will even pilot. I do not have those facts. Waiting for a primary source is cheaper than publishing a fake one.

What the sheet will not prove

H ignores the rest of the context switch. The sheet ignores morale. It also ignores a paid support desk that replies slower than your own on-call. Cheap support is not the same thing as fast support.

Founders sand down self-host cash. Champions sand down free-lane E. If both arrive with heroic inputs, the meeting is theater. Send them back to measure.

The feed this week is loud about vibe-coded demos, and about agents that notice something sensitive and stay quiet. I am not treating those posts as audited studies. I am treating them as a reminder. The agent does not own the outcome. You do.

If a free model lane and a free server are already on your shortlist, fill this card with your own E, H, and R before you send the invite. Confirm the live terms that day. Then keep, move, or stop.

Which single input, measured next week, would flip your column — E, the boundary hours, or the empty page-owner field?

Free Hosted, Paid, or Self-Host: A Custody Worksheet for PR Spikes

bestbee — Thu, 08 Oct 2026 08:58:21 +0000

I start October routing reviews with one rude question. If the private monorepo vanished from the queue, would you still be arguing about tokens?

Most weeks the answer is no. The fight was never about the pool. It was about who is allowed to see the diff.

Picture a Thursday in early October. Two senior maintainers. A public repo that suddenly has a crowd. A private monorepo that cannot leak. Someone posts, 'We already have a free lane. Why are the seniors still reading every patch by hand?'

Good instinct. Bad unit.

Three lanes, one job

The job is narrow. Draft a review note. Suggest a small patch. A human still merges.

The lanes are not narrow. They fail for different reasons.

A free hosted lane, sometimes paired with a free server you do not pay for yet.
A paid vendor lane, where the invoice is really a contract.
A self-hosted lane, where you own the process and the pager.

Which one should hold a contribution spike? I do not start from the sticker. I start from custody.

What the brief actually states

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

The brief for this piece describes MonkeyCode as an open-source project, with free model access and a free server option. It also states a free-token pool of 10 million tokens. That is the claim I was given, dated against 8 October 2026. It is not a screenshot from last quarter, and it is not an SLA I measured.

Read the license file and the allowance page on the day you decide. A wiki paste of a token number is how teams budget a sprint on a stale page.

What I refuse to infer

I am not adding model names, hardware sizes, uptime, latency, or a quality score. I am not saying the pool is permanent. I am not saying the free server has a duration.

A large pool can still be the wrong lane. Have you watched a team miss that?

Open source does not mean 'fine for customer code.' It means you can read the license. If you have not opened that file, you do not have a lane yet. You have a rumor.

Name the variables, or the meeting is theater

I will not score a lane until these symbols are written down. If a symbol has no owner, it does not enter the decision.

V — share of assisted tasks that touch private code, secrets, or customer data. From 0 to 1.
C — custody bar. 0 means public code only. 1 means prompts and diffs stay in a tenant you control.
A — assisted diffs you expect per week.
H — minutes a named reviewer will actually spend on each assisted diff. Not the minutes you wish they had.
R — reviewer hours available per week for this lane.
S — spike length in weeks.
T — tokens per assisted diff, measured on your repos. Not borrowed from a launch post.
F — stated free-token pool. The brief says 10,000,000. Re-read it. Do not hard-code a blog.
U — paid price per million tokens, from a quote you hold. I will not invent one.
O — self-host ops hours per week, times loaded hourly cost.

Review load is A * H / 60. If that exceeds R, stop. You do not have a model problem. You have a calendar problem.

Spike burn is A * S * T. Headroom is F / burn - 1. I want at least 0.20 before a free pool carries a public spike. That 0.20 is a policy choice. Say so in the ticket.

A scorecard is a conversation tool. It is not objective truth. Change the threshold and you can change the winner. Pretending otherwise is how a worksheet becomes a slogan.

Fill last year's spike before you guess `A`

Do not borrow my sketch as your forecast. Count your own default branch. Last October is a baseline, not a destiny.

# Merges in last October. Swap the branch and the dates.
git log origin/main --since="2025-10-01" --until="2025-10-28" --merges --oneline | wc -l

# Who actually merged? If two names dominate, R is smaller than the org chart.
git log origin/main --since="2025-10-01" --until="2025-10-28" --merges --pretty=format:'%an' | sort | uniq -c | sort -nr

Public-event calendars make October loud. Hacktoberfest is the obvious one. I am not quoting this year's rules, prizes, or dates. If badges matter to your contributors, read the current event page. Your merge log matters more than the badge.

Why pull last year at all? Because a spike you did not count will be replaced by a round number someone likes. Round numbers are where free pools go to die.

A sketch, so the arithmetic is visible

Not a customer. Not a benchmark. Replace every number before you forward this to finance.

Public assisted diffs: 40 per week. Private: 8 per week.
H = 12 minutes. Two reviewers, 5 hours each, so R = 10.
S = 4. T = 8,000. Illustrative until you measure 20 real diffs.
U = 3 currency units per million tokens. Placeholder. Throw it out when the quote arrives.
Self-host: 4 ops hours per week at 80 per hour, so weekly O = 320.

Public review load is 40 * 12 / 60 = 8 hours. Private adds 1.6. Total 9.6 against 10. One sick day and the lane is fiction.

Public burn is 40 * 4 * 8000 = 1,280,000 tokens. Private adds 256,000. Combined 1,536,000. Against a stated pool of 10,000,000, headroom looks luxurious. Only if that pool is still the number on the page. And only if private diffs are allowed to leave your tenant.

They are not, in this sketch. So the free hosted column dies on the private slice even while the pool looks fat. See how fast the sticker stopped mattering?

Paid token bill at the placeholder rate is about 1.536 * 3 = 4.6 currency units for the month. Tiny next to reviewer time. If your real quote looks like this, do not pretend price is the decision. If your quote is a hundred times higher, rerun the line. Still compare it to ops cost and to R, not to a vibe.

Self-host for four weeks is 320 * 4 = 1,280 before any machine you already rack. You are buying control. You are also buying a ceiling you have to measure yourself. I am not going to invent that ceiling here.

What flips the call

Would you still send those 8 private diffs if the free pool doubled? I would not. Custody does not scale with tokens.

Would you still self-host if every assisted diff stayed on public repos whose license you already understand? Maybe not. Ops cost is a tax on control you may not need for a four-week crowd.

Would you still buy the paid lane if counsel says the free hosted terms already clear your bar for public code? Then buy only the private slice. A blend rate for work that never needed it is how budgets get muddy.

Three sensitivities. Then stop debating adjectives.

If T is 5x the sketch, public burn alone is 6.4 million. Add the private slice and you are leaning on a pool you have not re-read. Measure T before you argue.
If H moves from 12 to 20 minutes, public review load is 13.3 hours. Over R. The lane is a no at every price, including free.
If private work becomes half the queue, free hosted is out. Do not negotiate with that gate.

Lane	Fits when	Fails when	What you actually pay
Free hosted, plus the stated free server option	Public repos, license read, allowance re-checked today, no unnamed tool grant	Any private or secret path, unread terms, pool you cannot point to	Reviewer hours, and the chance the allowance moves
Paid	Counsel accepts the terms and the private slice is real	The quote is standing in for a custody rule you never wrote	Quote, switching cost, reviewer hours
Self-host	`C = 1` and someone owns the pager through expiry	No pager owner, or you only needed public notes	Ops hours, plus a ceiling you measure

Gates, owner, expiry, exit

Five gates. Fail one, and that workload leaves the free hosted column. I do not average them into a green score.

Custody. A secret, a production credential, a customer payload, or a private repo sits in the prompt path. Free hosted is a no.
Review capacity. A * H / 60 > R. Cut scope or add a human. Do not add a model and call it a plan.
Pool headroom. Spike burn exceeds 80% of the stated pool, or you cannot open the allowance page today. Do not plan on it.
License. You have not read the project license and the output terms against the repo you merge into. Stop.
Tool reach. The assistant can call tools outside the repo. That is a grant. No named owner, no grant.

Owner: one engineering manager, named on the ticket. A Slack channel is not an owner.

Expiry: the last day of the spike, or 30 days from the decision, whichever comes first. An allowance you have not re-checked is an expired assumption.

Exit: archive the routing note when private share crosses your line, when the allowance page changes, or when reviewers miss H for two weeks. A stale 'free is fine' wiki page is how the next incident gets a head start.

Who writes the archive line? The same named owner. If they have left the team, the note expires that day. Do not inherit a dead assumption with the repo.

Run both cases before the meeting

This script is a worksheet. It does not call a model. It does not time a server. I am not publishing it as a benchmark. Paste your numbers. Read the fails.

#!/usr/bin/env python3
"""Custody gate worksheet. Sketch math only. Not a product test."""
import json, sys

def gate(d):
    review_h = d["assisted_per_week"] * d["minutes_per_diff"] / 60
    burn = d["assisted_per_week"] * d["weeks"] * d["tokens_per_diff"]
    headroom = (d["stated_free_tokens"] / burn) - 1 if burn else float("inf")
    reasons = []
    if d["private_or_secret"]:
        reasons.append("FAIL custody: private or secret path")
    if review_h > d["reviewer_hours"]:
        reasons.append(
            "FAIL review capacity: %.1fh > %.1fh" % (review_h, d["reviewer_hours"])
        )
    if headroom < 0.20:
        reasons.append("FAIL pool headroom: %.0f%%" % (headroom * 100))
    if not d["license_read"]:
        reasons.append("FAIL license: unread")
    if d["tools_enabled"] and not d["grant_owner"]:
        reasons.append("FAIL tool grant: no owner")
    return {
        "review_hours": round(review_h, 2),
        "token_burn": burn,
        "headroom": round(headroom, 2),
        "free_hosted_ok": not reasons,
        "reasons": reasons or ["PASS for this public slice only"],
    }

if __name__ == "__main__":
    print(json.dumps(gate(json.load(sys.stdin)), indent=2))

cat <<'EOF' | python3 custody_gate.py
{
  "assisted_per_week": 40,
  "minutes_per_diff": 12,
  "weeks": 4,
  "tokens_per_diff": 8000,
  "stated_free_tokens": 10000000,
  "reviewer_hours": 10,
  "private_or_secret": false,
  "license_read": true,
  "tools_enabled": false,
  "grant_owner": ""
}
EOF

On that public sketch the worksheet returns review_hours 8.0, token_burn 1280000, headroom about 6.81, and a pass that applies to the public slice only. Flip private_or_secret to true and the same pool fails. If you only run the flattering case, you do not have a decision. You have a wish.

After the free column fails, compare the other two with your quote, not with mine.

paid_month = (burn / 1000000) * U
self_month = ops_hours_per_week * loaded_hourly * weeks
pick paid  if counsel accepts vendor terms AND paid_month + switching_cost < self_month
pick self  if C == 1 AND a named person owns the pager until expiry
pick neither if review_hours > R

Who should walk away

Skip this if you need a model bake-off. I did not run one. I will not invent quality scores to fill the gap.

Skip it if counsel has not opened the data-processing terms. A table is not a DPA.

Skip it if you want the free server as a permanent production dependency. The brief states an option. It does not state a duration, a machine size, or an SLA. I will not decorate that silence.

Skip it if you are about to point an agent at a third-party system 'just to see.' Early October chatter included writeups about agents and real-company targets. I am not repeating those experiments, and I am not treating a DEV headline as a measured rate. The useful bit is boring. Tool reach is a grant. Unowned grants do not belong in a contribution pilot.

And skip it if you already know review hours are the bottleneck. Tokens will not hide that. Not at 10 million. Not at 10 times that.

Then decide

If you are weighing hosted free capacity against a server you would run yourself, read the current license and the allowance page, then run the worksheet twice. I would rather you close the tab than route a private diff because a pool looked large.

Which variable, if it moved, would reverse your call — custody, review hours, or the allowance you re-read today?

DEV Community: bestbee

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

The lane you pick is a statement about what you can refuse

Why price goes last

The worksheet: exclude first, tie-break second

What it prints (illustrative, from the placeholders above)

Read the output like a lead, not like a spreadsheet

Where the free lane genuinely earns its place

The flip test is the part people skip

Who should not use this

Limitations I want on the record

Owner, expiry, exit

Two Free Offers, Two Failure Modes: Route AI Work by Blast Radius, Not by Lane

Why this keeps going wrong

The two offers fail differently

Workload fission: route the change, not the team

A 60-line router you can run today

A fixture, so results are comparable across teams

Where the two offers actually fit

Hard gates, an owner, and an expiry

Sensitivity: what would reverse this routing

Who should not use this

Free Allowance or Self-Hosted Box? Compute the Crossover Before You Commit

The claim, and what it is worth

Step 1: measure tokens per merged PR

Step 2: convert the allowance into PRs

Step 3: find the self-host crossover

The three gates

Fit criteria

Limitations and who should skip this

The question that should end the meeting

Should Your Platform Team Take the Free AI Tier? Use This 4-Part Ops-Absorption Test

The decision is not "free vs paid". It is three lanes

Define five variables before you compare anything

The one number to measure first: tokens per accepted change

Worked example: same allowance, two very different worlds

The lane comparison, filled in

Sensitivity: where the line moves

One incident, priced

The 4-part gate, with hard stops

Where a free hosted lane genuinely earns a place

Who should not use this approach

The question that actually reverses this

The Free Tier Is Not the Cheap Lane: Pricing Your AI Coding Options per Merged PR

Define the unit before you define the winner

The ledger: twelve fields, one line per task

Why JSONL and not a dashboard

The script that ends the argument

Break-even: the only number that survives a re-quote

Runway: how long a free allowance actually lasts

Decision table: fit, not features

Three gates, one owner, one expiry

Where this model breaks

Who should not use this approach

The reversal question

Free Tokens Are a Claim. Publish a Claim-to-Test Ledger Before You Standardize

Why "free tokens" is the wrong unit of analysis

Why this specific lane makes a useful test case

The artifact: a claim-to-test ledger

Define the variables first

Worked example (illustrative)

The ledger, filled in

Sensitivity: when the ledger is not worth running

Measure R instead of estimating it

Free lane, self-host, or paid seat: fit criteria, not vibes

Hard gates, owner, expiry, exit

Limitations, and who should skip this

Should Your Team Commit to a Free AI Lane? Use This Exit Amortization Sheet

Step 0: Name the three columns

Step 1: Measure your own burn, not someone else's

Step 2: Convert the allowance into runway months

Step 3: Sensitize, then set a hard gate

Who owns it, when it expires, when you leave

Who should not use this sheet

The question that reverses you

Price the Assistant Path in Disagree-Minutes, Not a Free Sticker

What I am pricing, and what I refuse to fake

Four paths, one unit

A filled example, labeled as fiction

Incentives, not applause

Measure `R` instead of estimating it

Fill last year's spike before you guess `A`