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

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

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

Can your squad still defend that exception next Friday?

The scene that should reverse the call

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

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

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

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

Seat count is the wrong proxy

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

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

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

Variable definitions

Five fields. Fill them weekly. Expire the card.

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

Starting gates I use as conversation numbers, not laws:

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

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

The 4-clock ledger

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

Clock 1 — Data

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

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

Clock 2 — Path

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

Proposed measurement, unexecuted. Tag PRs. Then count.

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

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

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

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

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

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

Clock 3 — Review net

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

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

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

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

Clock 4 — Uptime / blast

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

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

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

Policy file the squad can argue with

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

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

Scorer you can run locally

Proposed script. Not a benchmark. Not production telemetry.

from datetime import date

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

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

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

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

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

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

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

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

Filled example, then sensitivity

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

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

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

Now flip three knobs.

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

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

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

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

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

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

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

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

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

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

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

Owner, expiry, exit, archive

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

Who should not use this

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

Limitations

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

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

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

Comments

[Dean Lee]

The reason free AI tiers persist on critical paths is that accounting systems track direct cash outflows rather than the negative carry of unhedged operational risk.

When a team adopts an uncontracted model lane to bypass procurement, they are essentially selling an out-of-the-money put option on production stability to harvest a few hundred dollars in visible monthly savings. The premium looks like pure margin expansion during quiet quarters. The payout occurs on Friday afternoon when an un-narrated diff alters retry logic, the external endpoint hits an unannounced rate limit, and the author has no contractual recourse or vendor SLA to escalate to.

The net review hours metric cuts straight to the real economic subsidy. Fast generation by authors is frequently paid for by transferring cognitive drag onto senior reviewers. If a staff engineer spends three hours reverse-engineering an agent-generated state machine to verify boundary conditions, the team did not lower development expense. They simply converted a small SaaS subscription into heavy depreciation on their most expensive engineering capital.