DEV Community: Avery Lin

Parse, Validate, Then Persist

Avery Lin — Tue, 20 Oct 2026 09:29:58 +0000

Last Saturday I shipped a receipt scanner for a side project. It takes a photo, asks a model for JSON, and writes one row into SQLite. Two hours later my ledger showed a coffee costing $1,240.00.

The model returned "amount": "12,40". My parser stripped the comma and moved on. Nothing crashed, so nobody complained.

That is the standard failure mode of cheap model calls. The call succeeds and the data is wrong. A free tier makes it worse, because you run more calls and read fewer outputs.

I fixed it with a gate. The gate is about forty lines of Python. It has saved me more time than any prompt rewrite.

The model reads. The code decides.

Two conditions must hold before a draft touches a database. It must parse as JSON. It must match a schema you wrote by hand.

Nothing else belongs in the gate. Do not ask the model to grade itself. Do not ask a second model to approve the first. Keep the decision deterministic, fast, and boring.

Here is the schema for one receipt. The bounds are the point.

# gate.py
import json, sqlite3, jsonschema

SCHEMA = {
    "type": "object",
    "additionalProperties": False,
    "required": ["merchant", "amount_cents", "currency", "date"],
    "properties": {
        "merchant":     {"type": "string", "minLength": 1, "maxLength": 120},
        "amount_cents": {"type": "integer", "minimum": 1, "maximum": 5_000_000},
        "currency":     {"type": "string", "enum": ["USD", "EUR", "GBP"]},
        "date":         {"type": "string", "pattern": r"^\d{4}-\d{2}-\d{2}$"},
    },
}

amount_cents is an integer with a ceiling. That one line kills the $1,240.00 coffee. A comma decimal cannot pass as an integer, so the gate returns a reject instead of a bad row.

Why not just write a better prompt.

Prompts decay. They are tied to a model version, and free tiers rotate versions quietly. The schema does not move. It is the only part of this pipeline you actually control.

Retry once. Then reject loudly.

Free access changes shape without notice. One retry with stricter instructions is cheap insurance. A third retry means the prompt is wrong, not the model.

def parse_receipt(text, call_model):
    last_error = None
    for attempt in (1, 2):
        raw = call_model(text, strict=(attempt == 2))
        try:
            doc = json.loads(raw)
            jsonschema.validate(doc, SCHEMA)
            return doc
        except (json.JSONDecodeError, jsonschema.ValidationError) as exc:
            last_error = str(exc)[:300]
    record_reject(text, last_error)
    raise ValueError("reject: see rejects table")

record_reject writes the raw text and the error string into a table. You never lose the evidence. You also never write it into the ledger.

CREATE TABLE IF NOT EXISTS rejects (
  id INTEGER PRIMARY KEY,
  created_at TEXT DEFAULT (datetime('now')),
  raw TEXT NOT NULL,
  error TEXT
);

Five fixtures that must never pass.

An untested gate is decoration. I keep five bad payloads in a parametrized test. Each one is a real output I have seen from a cheap call.

import json, jsonschema, pytest
from gate import SCHEMA

BAD = [
    '{"merchant":"Cafe","amount_cents":1240.0,"currency":"USD","date":"2026-10-18"}',
    '{"merchant":"Cafe","amount_cents":1240,"currency":"usd","date":"2026-10-18"}',
    '{"merchant":"Cafe","amount_cents":1240,"currency":"USD"}',
    '{"merchant":"Cafe","amount_cents":1240,"currency":"USD","date":"2026-10-18","tip":2}',
    '{"merchant":"Cafe","amount_cents":0,"currency":"USD","date":"2026-10-18"}',
]

@pytest.mark.parametrize("raw", BAD)
def test_gate_rejects(raw):
    with pytest.raises(jsonschema.ValidationError):
        jsonschema.validate(json.loads(raw), SCHEMA)

Run it before every deploy. The command is one line.

pytest -q tests/test_gate.py

One request proves the wiring.

You want a single endpoint that returns a row or an error id. Never both, and never a half row.

curl -s -X POST localhost:8000/parse \
  -H 'content-type: application/json' \
  -d '{"text":"CAFE LUNA 12,40 EUR 2026-10-18"}'

A bad decimal now returns {"error":"reject","id":41}. That id points straight at the raw text in the rejects table.

The reject table is your roadmap.

One query tells you what to fix next. Compare rejects against successes for the same day. The ratio is the only metric that matters here.

SELECT date(created_at) AS day, COUNT(*) AS rejects
FROM rejects GROUP BY day ORDER BY day DESC LIMIT 7;

My rule is simple. Above two percent, stop adding features and rewrite the failing part of the prompt. Below one percent, the parser is good enough to keep shipping.

Where the free tier earns its place.

I run this loop against MonkeyCode's free model access. The gate calls the model twice on bad output, so usage grows while you tune. A free tier absorbs that iteration without a billing surprise at the end of the month.

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

The free server option hosts the same FastAPI app and the same SQLite file. The validator sits next to the reject log, which is where it belongs. Read the project page for the current limits and re-read them each release. Treat them as limits, not commitments.

What the gate cannot do.

A valid row can still be a wrong row. The gate checks shape, bounds, and enums. It cannot check whether the merchant name is spelled correctly, or whether the receipt was already scanned last week.

Keep a one-tap confirm screen for the user. Store the raw text beside the parsed row. When someone disputes a number, you need both.

The gate also costs latency on failure. A retry is a full model round trip, and on a small free box that trip is slower than the happy path.

Who should skip this.

Skip it if a human reads every output anyway. Skip it if the payload is free text with no numbers or dates downstream. Skip it if you need signed audit records, because SQLite on an ephemeral box will not carry that weight.

Ship the gate this afternoon.

Pick one narrow parser. Write the schema before you write the prompt. Add five fixtures and a rejects table. Then let the free tier absorb the retries while you watch the ratio. That is the whole workflow, and it fits in a single sitting.

Ship the Feature That Survives a 429

Avery Lin — Mon, 19 Oct 2026 08:13:42 +0000

A solo founder demoed her triage feature on a Saturday. Twenty seconds in, the model endpoint returned 429. The screen showed a spinner, then a red box. The buyer closed the tab.

The fix took an hour. The lesson took longer. Free capacity fails in public, not in staging.

Free model access and a free server are real options on a solo budget. They are also borrowed capacity. The bill stays at zero because someone else sets the ceiling. MonkeyCode offers free model access and a free server option, which is the setup this workflow targets. Disclosure: This article was prepared as part of MonkeyCode's product outreach.

The point is not to avoid those limits. The point is to ship a product that degrades in a readable way when they bite. That is a design choice you can make in one evening.

Three tiers, one return shape

Every AI call in an indie app should return the same object. Mine carries two fields: text and tier. The tier records what actually happened.

That single field turns a demo into something you can operate. You can count it, chart it, and alert on it. Without it, every failure looks like a blank screen.

Tier one is the cache. Same ticket, same body, no network. Tier two is the model. Tier three is plain code, and it always answers.

The ordering matters more than the technology. Cheap and certain runs first. Slow and borrowed runs last.

Tier	Path	Cost	Failure mode
cache	local store	none	stale text
model	free endpoint	free quota	429, timeout, empty reply
rules	pure function	none	shallow but honest

The router

The router below is a single function. It never throws at the caller. Point model.summarize at whichever free endpoint you use; the pipeline only needs a promise and a timeout. The example is untested in your environment, so run it before you trust it.

// tiers.js — Node 18+
import { createHash } from "node:crypto";

const keyOf = (t) =>
  createHash("sha1").update(t.ticketId + t.body).digest("hex");

const MIN_CHARS = 40;

function isUsable(text, ticket) {
  if (typeof text !== "string") return false;
  const t = text.trim();
  if (t.length < MIN_CHARS) return false;
  if (t.includes(ticket.body.slice(0, 30))) return false; // echo guard
  return true;
}

export function createPipeline({ store, model, rules, log = () => {} }) {
  return async function answer(ticket) {
    const key = keyOf(ticket);
    const hit = await store.get(key);
    if (hit) return { text: hit, tier: "cache" };

    try {
      const text = await model.summarize(ticket.body, { timeoutMs: 4000 });
      if (isUsable(text, ticket)) {
        await store.set(key, text);
        return { text, tier: "model" };
      }
      log("unusable_output");
    } catch (err) {
      log(`model_failed:${err.status ?? err.code ?? "unknown"}`);
    }

    return { text: rules(ticket.body), tier: "rules" };
  };
}

The echo guard earns its line. A 200 with the prompt repeated back is worse than a clean 429. The timeout earns its line too; a hung socket will hold your request open far longer than a rate limit ever will.

The fallback is a product decision

Most teams write the fallback as a stub that returns an apology. That is why the feature looks broken when quota runs out. Write the fallback as the version of the feature you can defend on your worst day.

// rules.js
const SIGNALS = [
  [/refund|chargeback|invoice/i, "billing"],
  [/log ?in|password|2fa/i, "auth"],
  [/crash|traceback|500/i, "bug"],
];

export function rules(body) {
  const tag = SIGNALS.find(([re]) => re.test(body))?.[1] ?? "general";
  const line = body.split("\n").map((s) => s.trim()).find(Boolean) ?? "No body";
  return `[${tag}] ${line.slice(0, 140)}`;
}

This returns a labeled line, not a summary. A support agent reads [billing] and routes it in two seconds. The label is also an honest signal that the model did not answer.

Write this file before you write the prompt. If you cannot describe the feature without the model, it is not ready for a free tier. You have built a dependency, not a product.

Test the bad day, not the good one

Happy-path tests pass all week and teach you nothing. The four cases that kill a demo are rate limit, timeout, empty reply, and the same ticket arriving twice.

// tiers.test.js
import { describe, it, expect, vi } from "vitest";
import { createPipeline } from "./tiers.js";
import { rules } from "./rules.js";

function memoryStore() {
  const m = new Map();
  return { get: async (k) => m.get(k), set: async (k, v) => void m.set(k, v) };
}

const ticket = {
  ticketId: "t-1",
  body: "Please refund invoice 88, the card was charged twice.",
};

const good = "Billing issue: duplicate charge on invoice 88. Refund queued for review.";

describe("answer()", () => {
  it("falls back to rules on 429", async () => {
    const model = {
      summarize: vi.fn().mockRejectedValue(
        Object.assign(new Error("slow down"), { status: 429 }),
      ),
    };
    const answer = createPipeline({ store: memoryStore(), model, rules });
    const out = await answer(ticket);
    expect(out.tier).toBe("rules");
    expect(out.text).toContain("billing");
  });

  it("falls back on a hang", async () => {
    const model = { summarize: vi.fn().mockRejectedValue({ code: "ETIMEDOUT" }) };
    const answer = createPipeline({ store: memoryStore(), model, rules });
    await expect(answer(ticket)).resolves.toMatchObject({ tier: "rules" });
  });

  it("rejects an empty reply", async () => {
    const model = { summarize: vi.fn().mockResolvedValue("   ") };
    const answer = createPipeline({ store: memoryStore(), model, rules });
    await expect(answer(ticket)).resolves.toMatchObject({ tier: "rules" });
  });

  it("calls the model once per identical ticket", async () => {
    const model = { summarize: vi.fn().mockResolvedValue(good) };
    const answer = createPipeline({ store: memoryStore(), model, rules });
    await answer(ticket);
    const second = await answer(ticket);
    expect(second.tier).toBe("cache");
    expect(model.summarize).toHaveBeenCalledTimes(1);
  });
});

Run it with two commands. No API key, no network, no waiting on a quota window.

npm i -D vitest
npx vitest run tiers.test.js

That last test is the money test. It tells you how much model traffic your cache removes. On repetitive support queues, the number is often larger than the founders expect.

What the free box still needs

Free servers restart. Processes vanish without a warning. Keep the cache and any job state somewhere that survives a restart, such as a file or a small managed database. A module-level Map is not storage; it is a memory leak with good manners.

Point uptime checks at your own edge, not at the free box. A monitor that pings the box becomes traffic, and traffic becomes a quota problem you created for yourself.

Log the tier on every request from day one. After a week, count the mix. That ratio is your real capacity plan, and it beats any estimate you would have written on a napkin.

Limits and who should skip this

The ladder hides failures. That is the point, and it is also the danger. Never use it where a wrong but confident answer costs money or health. Billing disputes, medical intake, legal advice, and security decisions need an error, not a guess.

Skip this if you need a latency guarantee, a signed data agreement, or volume well past a free tier. Skip it if your fallback output would mislead a user who cannot see which tier answered. Free capacity is a starting line, not a contract, and the ceiling can move.

If you are shipping alone this weekend, build tier three first. Then let a free model handle the happy path and watch what the ladder catches.

Measure the Cold Start Before the Demo

Avery Lin — Sat, 17 Oct 2026 06:00:08 +0000

An indie founder shipped a demo at 23:40 on a Sunday. The link went into a direct message five minutes later. The first request took thirty-eight seconds. The visitor closed the tab before the spinner stopped.

Nothing was broken. The free host had gone to sleep. That is the whole failure mode: the first request is the one a stranger judges.

Free hosts sleep when idle. Free model endpoints throttle under bursts. Both give way at the same moment, which is the first honest request from someone who is not the author. A warm browser tab hides it. A local run hides it too.

So the useful check is not whether the app works. It is how long the app takes after ten quiet minutes. That number is small, measurable, and it fits in one shell script.

Probe the first request

The script below measures three things against a deployed URL. It records a warm hit, waits for the host to fall asleep, then records the first hit after the sleep. A third probe touches the route that calls a model on the server.

#!/usr/bin/env bash
# probe.sh — warm, cold and model-path latency for one deployed URL.
set -uo pipefail

BASE="${1:?usage: ./probe.sh https://your-app.example.com}"
IDLE="${IDLE:-420}"        # seconds to let the free host fall asleep
OUT="${OUT:-probe.tsv}"

run() {
  local label="$1" url="$2" res code ttfb total
  res=$(curl -sS -o /dev/null --max-time 90 \
        -w '%{http_code} %{time_starttransfer} %{time_total}' "$url" 2>/dev/null) \
        || res='000 0 0'
  read -r code ttfb total <<<"$res"
  printf '%s\t%s\t%s\t%s\t%s\n' \
    "$label" "$(date -u +%FT%TZ)" "$code" "$ttfb" "$total" | tee -a "$OUT"
}

: > "$OUT"
printf 'label\ttime\tcode\tttfb_s\ttotal_s\n' | tee -a "$OUT"

run warmup    "$BASE/healthz"
run warmup_ui "$BASE/"
sleep "$IDLE"
run cold      "$BASE/healthz"
run cold_ui   "$BASE/"
run model     "$BASE/api/ping"   # one short server-side model call

Run it three times, not once. A single sample is noise, and a sleeping host is slow in bursts.

The /healthz route should render a fixed string and touch nothing else. A health check that queries a database measures the database, not the sleep penalty. The /api/ping route sends one short prompt through the server-side model call and returns a fixed marker.

Read the numbers, not the dashboard

The columns carry different meanings. time_starttransfer is the first byte, which is what the visitor perceives as the spinner stopping. time_total includes the rest of the body, so a large gap between the two points at a heavy payload instead of a cold process.

A one-line comparison turns the file into a verdict.

awk -F'\t' '
  $1=="warmup" {w=$5}
  $1=="cold"   {c=$5}
  $1=="model"  {m=$5}
  END {printf "warm %.2fs | cold %.2fs | model %.2fs | cold/warm %.1fx\n", w, c, m, c/w}
' probe.tsv

The ratio matters more than the absolute number. A warm request at 0.3s and a cold one at 12s is a 40x cliff. The app is fine at 12s for a crawling bot and fatal for a person with a phone in one hand.

cold total	what the visitor sees	what to do
under 2s	a normal page	ship the link
2 to 10s	a short wait	pre-warm 60s before sending it
10 to 45s	a dead tab	serve a static landing page first
timeout or 5xx	an error	fix the app, not the host

That table is a decision aid, not a benchmark. Thresholds move with the audience. A demo sent to one investor tolerates more waiting than a link posted in a public thread.

Warm it before the link, not after

Scheduled pings are the obvious fix and the fragile one. Cron services and CI schedules fire late under load, often by several minutes. Some free tiers also treat artificial keep-alive traffic as abuse, so read the terms before adding a pinger.

The cheaper move is a manual pre-warm. Hit the URL once, sixty seconds before the link goes out, from the same laptop that sends it. That single request moves the visitor from a cold tab to a warm one, and it costs nothing.

The second move is honesty in the UI. A page that says it is starting beats a blank screen that looks dead. A static shell that renders in 200ms and fills in later keeps the visitor reading while the process wakes.

The model call shares the same budget

A sleeping host and a slow model compose badly. The request that wakes the process is also the request that waits on a remote completion. Two queues stack in one tab.

Keep the model path to a single round trip during a demo. Ask for a short answer, set a hard client timeout, and never chain two completions in the same click. The probe above measures that path so the number is known before a stranger finds it.

Repeated demo clicks should not cost anything either. A small file cache keyed by prompt hash removes the second call entirely.

import { createHash } from 'node:crypto';
import { mkdir, readFile, writeFile } from 'node:fs/promises';

const dir = '.cache/answers';
const key = (p) => createHash('sha256').update(p).digest('hex').slice(0, 16);

export async function answer(prompt, call) {
  await mkdir(dir, { recursive: true });
  const path = `${dir}/${key(prompt)}.json`;
  try {
    return JSON.parse(await readFile(path, 'utf8'));
  } catch {
    // cache miss, fall through to the model
  }
  const out = await call(prompt);
  await writeFile(path, JSON.stringify(out));
  return out;
}

That cache lives on the same disposable disk as the app. It dies with a restart, which is acceptable for a demo and wrong for a record of anything a customer paid for.

Limits that survive the fix

A free host still sleeps on its own schedule. It runs in one region, behind one IP, with no commitment to uptime. A probe run at 02:00 says nothing about 14:00 on a launch day.

Free model access has its own ceiling. Throughput is shared, quality varies by task, and the allowance can change without a migration path. The operator of the MonkeyCode project describes a free token allowance, quoted at ten million tokens at the time of writing, plus a free server option. Treat both as time-sensitive facts and confirm them on the project page rather than in a blog post. Disclosure: This article was prepared as part of MonkeyCode's product outreach.

Anyone with an uptime clause, an inbound webhook with tight timing, or regulated data should not build here. Paying customers behind a host that naps is a support queue, not a business. Teams that need a GPU or a fixed IP should look elsewhere too.

The indie case is narrower and honest. One builder, one demo, one week of attention, a bill of zero. Ship today, keep the number small, and accept the ceiling out loud.

The probe costs ten minutes. The demo link costs one click that cannot be taken back.

If a zero-bill stack is the goal, the free model access and free server option in MonkeyCode are worth a look. Run the probe first, then decide.

Build a Spend Breaker Before You Ship AI

Avery Lin — Fri, 16 Oct 2026 04:58:10 +0000

Build a Spend Breaker Before You Ship AI

A solo founder ships one AI button on a Friday afternoon. The button turns a messy customer note into three tidy bullets. The demo lands, the weekend starts, and nobody watches the endpoint.

By Monday morning that endpoint has answered tens of thousands of calls. A worker retry loop kept hammering a timeout. The free allowance is gone, and every request now costs real money.

The numbers in that story are illustrative. The shape of the failure is not. A free tier never removes the budget; it changes the unit from dollars to tokens and CPU.

Arguments about AI fatigue keep circling the feed this week. The quieter question is who pays when a shipped AI feature misbehaves at three in the morning. For a solo build, the answer has to live in code, not in attention.

The loop that eats a free tier

Most first versions look like this.

// worker.mjs — the version that eats a weekend
async function summarize(note) {
  while (true) {
    try {
      return await callModel(note);
    } catch {
      // retry forever, because "free"
    }
  }
}

That loop has no governor. A timeout, a 429, or a slow backend turns one user action into thousands of billed calls. Providers are happy to keep answering until the quota runs out, then charge or refuse.

MonkeyCode is an open-source project that lists free model access and a free server option, both supplied by the operator. The free token allowance is currently advertised at 10 million tokens. Verify the project's current terms before you depend on any number, because allowances and limits change.

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

A free allowance is still a budget. It just spends tokens instead of dollars, and it refills on someone else's schedule. So the breaker counts tokens first and money second. That order matters on day one of any indie build.

Three pieces: ledger, gate, settle

The breaker is small and deliberately boring. One append-only ledger, one gate before the call, one settle after it.

// spend.mjs
import { appendFileSync, readFileSync, existsSync } from "node:fs";

const LEDGER = process.env.LEDGER ?? "./spend.jsonl";
const TOKEN_BUDGET = Number(process.env.TOKEN_BUDGET ?? "200000");
const USD_BUDGET = Number(process.env.USD_BUDGET ?? "0");
const EST_OUT = Number(process.env.EST_OUT ?? "256");

export function estimateTokens(text) {
  // Rough heuristic: about four characters per token for English prose.
  // Treat this as a guess and settle with provider-reported usage.
  return Math.ceil(String(text).length / 4);
}

export function spendToday(now = new Date()) {
  const day = now.toISOString().slice(0, 10);
  const totals = { day, in: 0, out: 0, usd: 0, calls: 0 };
  if (!existsSync(LEDGER)) return totals;
  for (const line of readFileSync(LEDGER, "utf8").split("\n")) {
    if (!line.trim()) continue;
    let row;
    try { row = JSON.parse(line); } catch { continue; }
    if (!String(row.ts).startsWith(day)) continue;
    totals.in += row.in ?? 0;
    totals.out += row.out ?? 0;
    totals.usd += row.usd ?? 0;
    totals.calls += 1;
  }
  return totals;
}

export function gate(text, now = new Date()) {
  const estIn = estimateTokens(text);
  const s = spendToday(now);
  const projected = s.in + s.out + estIn + EST_OUT;
  if (projected >= TOKEN_BUDGET * 0.9) {
    return { ok: false, reason: "token-budget", estIn, ...s };
  }
  if (USD_BUDGET > 0 && s.usd >= USD_BUDGET) {
    return { ok: false, reason: "usd-budget", estIn, ...s };
  }
  return { ok: true, estIn, ...s };
}

export function settle(row, now = new Date()) {
  const record = { ts: now.toISOString(), ...row };
  appendFileSync(LEDGER, JSON.stringify(record) + "\n");
  return record;
}

The gate closes at ninety percent, not at one hundred. A closed gate still has to answer the user, so the wrapper ships a deterministic fallback instead of an error page.

// guard.mjs
import { gate, settle } from "./spend.mjs";

export function cheapFallback(note) {
  // No model call. Boring, instant, always available.
  const first = String(note).split(/[.!?]\s/)[0] ?? "";
  return first.slice(0, 120) || "Summary unavailable.";
}

export async function guardedSummarize(note, { callModel, now = new Date() }) {
  const verdict = gate(note, now);
  if (!verdict.ok) {
    settle({ route: "fallback", in: 0, out: 0, usd: 0, reason: verdict.reason }, now);
    return { text: cheapFallback(note), route: "fallback", reason: verdict.reason };
  }
  try {
    const res = await callModel(note);
    settle({
      route: "model",
      in: res.usage?.input_tokens ?? verdict.estIn,
      out: res.usage?.output_tokens ?? 0,
      usd: res.usage?.cost_usd ?? 0,
    }, now);
    return { text: res.text, route: "model" };
  } catch (err) {
    // Failed attempts usually still consume input tokens.
    settle({ route: "error", in: verdict.estIn, out: 0, usd: 0, error: String(err) }, now);
    throw err;
  }
}

The model call itself stays behind a thin adapter. Any OpenAI-compatible endpoint works, so the breaker never locks a solo build to one vendor.

// model.mjs — OpenAI-compatible adapter
export function makeCaller({ baseUrl, apiKey, model }) {
  return async function callModel(note) {
    const res = await fetch(`${baseUrl}/chat/completions`, {
      method: "POST",
      headers: {
        "content-type": "application/json",
        authorization: `Bearer ${apiKey}`,
      },
      body: JSON.stringify({
        model,
        messages: [{ role: "user", content: `Summarize in 3 bullets:\n${note}` }],
        max_tokens: 256,
      }),
    });
    if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);
    const json = await res.json();
    return {
      text: json.choices?.[0]?.message?.content ?? "",
      usage: {
        input_tokens: json.usage?.prompt_tokens ?? 0,
        output_tokens: json.usage?.completion_tokens ?? 0,
      },
    };
  };
}

Read baseUrl, apiKey, and model from environment variables filled in from the project's own setup page. Never hardcode a key into a repo that a free host will clone.

A test that proves the gate closes

The breaker is worth nothing if it is only read and never run. Here is a fully offline test with a stubbed model and an explicit clock.

// spend.test.mjs
import test from "node:test";
import assert from "node:assert/strict";
import { mkdtempSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

const dir = mkdtempSync(join(tmpdir(), "spend-"));
process.env.LEDGER = join(dir, "spend.jsonl");
process.env.TOKEN_BUDGET = "1000";
process.env.USD_BUDGET = "0";

const { guardedSummarize } = await import("./guard.mjs");
const { spendToday } = await import("./spend.mjs");

const callModel = async () => ({
  text: "ok",
  usage: { input_tokens: 40, output_tokens: 60 },
});

const note = "short note about a late invoice. ".repeat(4);

test("the gate closes before the budget is spent", async () => {
  const now = new Date("2026-10-16T09:00:00Z");
  const routes = [];
  for (let i = 0; i < 40; i++) {
    const out = await guardedSummarize(note, { callModel, now });
    routes.push(out.route);
  }
  const modelCalls = routes.filter((r) => r === "model").length;
  const total = spendToday(now);
  assert.ok(modelCalls > 0, "at least one model call reached the endpoint");
  assert.ok(total.in + total.out < 1000, "stayed under the hard token budget");
  assert.equal(routes.at(-1), "fallback", "the gate closes and stays closed");
});

test("a new day reopens the gate", async () => {
  const day2 = new Date("2026-10-17T09:00:00Z");
  const out = await guardedSummarize(note, { callModel, now: day2 });
  assert.equal(out.route, "model");
});

Run it with the budget in the environment, so the numbers stay visible and easy to change.

LEDGER=/tmp/spend.jsonl TOKEN_BUDGET=1000 node --test spend.test.mjs

The first test loops forty times and still finishes in a few milliseconds. That is the point of an offline stub. The failure you fear took someone a weekend; here it takes a test run.

Where the free server fits

Run the worker and the ledger in the same process, on the same small host. The free server option is a reasonable place for exactly that shape: one Node process, one SQLite or JSONL file, one external model endpoint.

Keep the ledger path inside the app directory, not /tmp. A restart should not silently refund the day's spend. Limit the process to a single instance as well, because two workers writing the same file can double-count or lose rows.

Free hosts impose limits of their own. Read the current ones before you promise a customer anything, and decide what a cold or throttled start does to your fallback path.

A routing matrix for the first month

Situation	Route	Why
One user click, user is waiting	Model call, gated	Latency is acceptable, one call per action
Background job over many rows	Batch with a per-run cap	Runaway loops start in workers, not in UI
Gate already closed	Deterministic fallback	Ship a worse answer, not an outage
Provider returns 429 or 5xx	Two retries, then fallback	Unbounded retries multiply token spend
Accounting must be exact	Neither route	Use a billing system, not a JSONL file

Limitations and who should skip this

The ledger is per-process and file-based. Fine for one solo app, wrong for anything running multiple regions. The ninety percent threshold is a guess that you should tune against real traffic. The token estimate drifts from provider counts, so settle with reported usage whenever the endpoint returns it.

Above all, a breaker protects the allowance, not correctness. A bad prompt still returns bad summaries under budget. And free model access, like any free tier, is a moving target; check the current terms before you build a business rule on top of it.

Skip this approach if you already have provider-side quotas and a billing dashboard. Skip it for high-throughput services where a gateway belongs in front of every call. Skip it if you cannot read and re-read the provider's limits. A solo build with one AI button is the sweet spot, because a JSONL file and forty lines of Node buy you the one guarantee that matters: the weekend stays boring.

If you want to run this loop yourself, MonkeyCode's free model access and free server option are a cheap place to start. Bring the test file, not the feature.

One Sale Survives the Restart

Avery Lin — Tue, 13 Oct 2026 00:24:04 +0000

A solo founder closes the laptop after midnight. A stranger has paid nineteen dollars for a pack. The receipt write dies when the free process restarts.

The provider sends that same event a second time. The new process has no memory of the first write. Two receipt emails leave for one card charge.

That failure is not a clever model mistake. The handler treated a replay as a fresh sale. A restart is normal on a small free box.

A zero bill still needs a memory

An indie launch still wants a public URL today. The bill for that first night should stay at zero. The limit is real, and the design must accept it.

The practical gap shows up in ordinary launch code. A drafted handler can look finished on first read. Retry and restart behavior still belongs to the software.

A free coding model can sketch the route quickly. It cannot promise that a killed process stays honest. The founder needs a ledger before any customer link.

The useful split is small, boring, and local. Local tests own the money rule before any deploy. The server only hosts a process that already passed.

The rule is one sale and one receipt. The key joins the provider event and the order. A second delivery returns the stored result only.

SQLite fits a zero-bill night better than a hosted queue. The file lives beside the app and restarts with it. A bigger broker can wait until revenue pays for it.

The contract, not the framework

The snippet below is an unexecuted local example. The example uses the standard library plus pytest. The point is the contract, not the framework fashion.

# Unexecuted example: one sale, one receipt.
# Not a claim that this file was executed on a host.
import hashlib
import hmac
import json
import os
import sqlite3
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path

DB_PATH = Path(os.environ.get("LEDGER_PATH", "ledger.sqlite3"))

def connect():
    conn = sqlite3.connect(DB_PATH)
    conn.execute("PRAGMA journal_mode=WAL")
    conn.execute(
        """
        CREATE TABLE IF NOT EXISTS receipts (
            event_key TEXT PRIMARY KEY,
            order_id TEXT NOT NULL,
            amount_cents INTEGER NOT NULL,
            status TEXT NOT NULL
        )
        """
    )
    return conn

def event_key(provider_event_id, order_id):
    raw = f"{provider_event_id}:{order_id}".encode()
    return hashlib.sha256(raw).hexdigest()

def signature_ok(secret, body, header):
    digest = hmac.new(secret.encode(), body, hashlib.sha256).hexdigest()
    return hmac.compare_digest(digest, header or "")

def record_payment(provider_event_id, order_id, amount_cents):
    key = event_key(provider_event_id, order_id)
    conn = connect()
    try:
        conn.execute("BEGIN IMMEDIATE")
        conn.execute(
            """
            INSERT OR IGNORE INTO receipts
                (event_key, order_id, amount_cents, status)
            VALUES (?, ?, ?, 'accepted')
            """,
            (key, order_id, amount_cents),
        )
        row = conn.execute(
            "SELECT status, amount_cents FROM receipts WHERE event_key = ?",
            (key,),
        ).fetchone()
        conn.commit()
        status, stored_amount = row
        if stored_amount != amount_cents:
            return "amount_mismatch"
        return status
    except Exception:
        conn.rollback()
        raise
    finally:
        conn.close()

def mark_mailed(provider_event_id, order_id):
    key = event_key(provider_event_id, order_id)
    conn = connect()
    try:
        conn.execute("BEGIN IMMEDIATE")
        conn.execute(
            """
            UPDATE receipts
               SET status = 'mailed'
             WHERE event_key = ?
               AND status = 'accepted'
            """,
            (key,),
        )
        conn.commit()
    except Exception:
        conn.rollback()
        raise
    finally:
        conn.close()

def apply_event(provider_event_id, order_id, amount_cents, send_mail):
    status = record_payment(provider_event_id, order_id, amount_cents)
    if status in ("amount_mismatch", "mailed"):
        return status
    send_mail(order_id, amount_cents)
    mark_mailed(provider_event_id, order_id)
    return "mailed"

def send_mail(order_id, amount_cents):
    # Stand-in for an idempotent mail call keyed by event id.
    print(f"mail order={order_id} amount_cents={amount_cents}")

class Handler(BaseHTTPRequestHandler):
    def do_GET(self):
        if self.path != "/health":
            self.send_response(404)
            self.end_headers()
            return
        body = b'{"ok":true}'
        self.send_response(200)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        self.wfile.write(body)

    def do_POST(self):
        if self.path != "/hooks/payment":
            self.send_response(404)
            self.end_headers()
            return
        length = int(self.headers.get("Content-Length", "0"))
        raw = self.rfile.read(length)
        secret = os.environ.get("HOOK_SECRET", "")
        if not secret:
            self.send_response(500)
            self.end_headers()
            return
        header = self.headers.get("X-Signature", "")
        if not signature_ok(secret, raw, header):
            self.send_response(401)
            self.end_headers()
            return
        payload = json.loads(raw or b"{}")
        status = apply_event(
            payload["event_id"],
            payload["order_id"],
            int(payload["amount_cents"]),
            send_mail,
        )
        body = json.dumps({"status": status}).encode()
        code = 409 if status == "amount_mismatch" else 200
        self.send_response(code)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        self.wfile.write(body)

def main():
    if not os.environ.get("HOOK_SECRET"):
        raise SystemExit("HOOK_SECRET is required")
    host = os.environ.get("HOST", "127.0.0.1")
    port = int(os.environ.get("PORT", "8080"))
    ThreadingHTTPServer((host, port), Handler).serve_forever()

if __name__ == "__main__":
    main()

The function opens one short transaction per event. Insert or ignore treats the key as a lock. A second writer finds the row instead of a new sale.

The stored amount must match the replayed amount. A mismatch returns a stop status and sends no mail. Silence is safer than a creative explanation to the buyer.

Mail should leave only after the row exists. The send sits outside the database lock on purpose. A slow mailbox must not freeze the second webhook.

A crash can still sit between send and update. The next replay may send the receipt one more time. That is at least once delivery, not a magic once.

The mailer should key on the same event id. A second send with that key becomes a no-op. Without that key, the ledger cannot save the inbox.

The status names stay dull for a reason. Accepted means the sale is stored and mail is pending. Mailed means the buyer path already ran to completion.

A founder should not invent extra states tonight. Paid, pending, and success overlap in ugly ways. Two words are enough until a real refund appears.

Refunds do not belong in this first handler. A refund is a new event with its own key. Mixing it into the sale row hides a second money movement.

The signature check belongs in front of the ledger. A bad signature never touches the database file. The comparison uses a constant-time helper, not a raw equal sign.

The secret comes from the process environment only. It never sits in the repository or the prompt. A free model does not need the live signing key.

The handler in that file is also an unexecuted example. It accepts one JSON post and returns a status. It does not speak to a real card network.

Tests before any public URL

The test uses a temporary database path on purpose. The first call must insert exactly one row. The second call must not insert another row.

# Unexecuted example test. It documents the contract.
import sqlite3
import ledger

def test_replay_keeps_one_row(tmp_path, monkeypatch):
    monkeypatch.setattr(ledger, "DB_PATH", tmp_path / "ledger.sqlite3")
    sends = []

    def fake_mail(order_id, amount_cents):
        sends.append((order_id, amount_cents))

    first = ledger.apply_event("evt_1", "ord_9", 1900, fake_mail)
    second = ledger.apply_event("evt_1", "ord_9", 1900, fake_mail)
    assert first == "mailed"
    assert second == "mailed"
    assert sends == [("ord_9", 1900)]
    conn = sqlite3.connect(tmp_path / "ledger.sqlite3")
    count = conn.execute("SELECT COUNT(*) FROM receipts").fetchone()[0]
    assert count == 1

def test_amount_mismatch_stops(tmp_path, monkeypatch):
    monkeypatch.setattr(ledger, "DB_PATH", tmp_path / "ledger.sqlite3")
    ledger.apply_event("evt_1", "ord_9", 1900, lambda o, a: None)
    status = ledger.record_payment("evt_1", "ord_9", 2000)
    assert status == "amount_mismatch"

def test_crash_before_mark_sends_again(tmp_path, monkeypatch):
    monkeypatch.setattr(ledger, "DB_PATH", tmp_path / "ledger.sqlite3")
    sends = []

    def fake_mail(order_id, amount_cents):
        sends.append(order_id)

    status = ledger.record_payment("evt_2", "ord_2", 1900)
    assert status == "accepted"
    fake_mail("ord_2", 1900)  # process dies before mark_mailed
    again = ledger.apply_event("evt_2", "ord_2", 1900, fake_mail)
    assert again == "mailed"
    assert sends == ["ord_2", "ord_2"]

The mail callback counts sends inside the test. One replay after a clean mail should not send again. A forced crash before the status update should send once more.

That second case is the honest failure window. The test should fail if someone deletes it later. A green suite that hides the window is theater.

Commands stay plain so a tired founder can rerun them. Pytest is the gate before any public URL. Curl is only a smoke check after the gate is green.

python -m pytest -q test_ledger.py
export HOOK_SECRET=dev-only-secret
export LEDGER_PATH=./ledger.sqlite3
python ledger.py

export HOOK_SECRET=dev-only-secret
export BODY='{"event_id":"evt_1","order_id":"ord_9","amount_cents":1900}'
export SIG=$(python -c 'import hmac,hashlib,os; print(hmac.new(os.environ["HOOK_SECRET"].encode(), os.environ["BODY"].encode(), hashlib.sha256).hexdigest())')
curl -s -X POST http://127.0.0.1:8080/hooks/payment \
  -H "Content-Type: application/json" \
  -H "X-Signature: $SIG" \
  -d "$BODY"
curl -s -X POST http://127.0.0.1:8080/hooks/payment \
  -H "Content-Type: application/json" \
  -H "X-Signature: $SIG" \
  -d "$BODY"
sqlite3 ledger.sqlite3 "SELECT COUNT(*) FROM receipts;"
cp ledger.sqlite3 ledger.sqlite3.bak

The first curl should return the mailed status. The second curl should return the same status. The count query should print the number one.

If the count prints two, the key is wrong. If the second curl sends mail, the status update was skipped. Those two symptoms are the whole debugging map.

Logs should print the event id and the status. Logs should not print the body or the secret. A free box log is still a copy of private data.

Draft on a free model, host after green

Disclosure: This article was prepared as part of MonkeyCode's product outreach. MonkeyCode's free model access can draft the handler from the tests. Its free server option can host the process after those tests pass.

The model is a drafter, not the source of truth. The founder pastes the failing test first and asks for a narrow fix. The founder rejects any draft that changes the assertions to get green.

That order matters more than the wording of the prompt. A model that sees only the route will agree too fast. The test is the disagreement the founder actually needs.

A founder should not paste live customer rows into the chat. Fake event ids and a nineteen dollar fixture are enough. Real buyer data does not improve this particular lesson.

Quotas, model names, and hardware can change without notice. This article does not claim a token count or a machine size. The founder reads the current product terms before a launch depends on them.

Where this pattern stops

Disk choice matters more than the model choice. This ledger works only if the file survives a restart. An ephemeral disk forgets the sale and breaks the rule.

The founder confirms that fact on the chosen host before launch. A founder should not assume a free plan keeps files forever. If the disk resets, the file moves to durable storage.

A sleeping process is a different kind of limit. The first buyer after sleep may wait on a cold start. The handler should return the stored row, not a new sale.

Timeouts from the provider need a calm response code. A slow handler gets another delivery, which this design expects. A crash loop is different, and bad config should exit.

Bad config means a missing secret or a missing path. The process should refuse to boot in that case. A silent empty secret would accept unsigned posts.

Traffic shape is the next honest limit here. One SQLite file on one box serves a small launch. Two app instances writing one file will fight each other.

When a second instance becomes necessary, stop this pattern. The unique key moves to a shared database then. The same test names stay so the rule does not drift.

The free server is a launch pad, not a bank. It can host the smoke process for a zero-bill night. It should not store card numbers or raw provider bodies.

A founder who needs a signed uptime promise should not stop here. A team that already runs multi-region payments should not stop here. A product that stores card data itself should not use this box.

The approach also fails for marketplaces with split payouts. Those flows need ledger entries the toy schema cannot name. Shipping the toy anyway would hide missing money.

Support mail is another trap on night one. The handler should not draft refund promises to a buyer. A template that says the event was recorded is enough.

The public surface stays at one route only. A health route can return ok without touching the ledger. A second money route doubles the replay risk for no gain.

Backups are a manual habit on a zero bill. The founder copies the SQLite file before any schema change. A model-written migration without a copy can erase memory.

The copy command is dull and that is the point. The copy runs, then the tests run, then the process restarts. None of those steps should be skipped because the draft looked confident.

A schema change should add a column, not rewrite history. The old event key must remain valid after the alter. New code that rehashes old rows will mint duplicate receipts.

There is a small decision buried in the file choice. SQLite stays while one process owns the file. The pattern ends when a second process or a refund ledger appears.

That decision is the whole cost control for tonight. Extra services feel safe and quietly start a bill. The bill can wait until the replay test feels boring.

The pack page ships only after the count stays at one. The webhook URL goes into the provider after the curls agree. Early buyers hear that the receipt may arrive once or twice.

A second charge is the failure this night refuses. A duplicate email is an apology a founder can send by hand. Those two outcomes are not equal, and the code should know it.

A founder who wants that split can draft against the tests in MonkeyCode. The free server should open only after the replay count stays at one.

Serve the File, Not the Model

Avery Lin — Sun, 11 Oct 2026 20:49:47 +0000

A solo founder has one quiet morning and a half-built changelog tool. The landing page still lives as a prompt in a scratch file. A paid host would clear the card before the first user arrives.

The useful move is smaller than a full product launch. Freeze the prompt, write one static page, and commit that file. After the commit, the public box only serves the file.

No visitor request should wake a model again. That split keeps the morning bill at zero. It also accepts a blunt limit: the page cannot think.

Think of a bakery that prints the menu before dawn. The counter hands out paper and never cooks a new sentence. A free server works the same way when the file is already done.

The sketch uses one free coding-model pass, then stops. The operator describes MonkeyCode as an open-source project with free model access. A free server option is the other operator-supplied claim.

Disclosure: This article was prepared as part of MonkeyCode's product outreach. Those two availability claims are not a measured quota or a hardware spec. Readers should confirm the live project page before relying on either offer.

A specific token grant is easy to quote and easy to stale. This article refuses a number for that reason. The workflow treats whatever allowance exists as finite and changeable.

A zero-bill day fails when generation hides inside the request path. Each refresh spends allowance, and a spike can exhaust it. The page also slows down, because a model sits on the critical path.

The fix is a gate that refuses repeat work. A hash of the prompt file becomes the lock. If the hash matches the last stamp, the script exits before any call.

The local budget is a character ceiling, not a vendor meter. Twelve thousand characters is a proposal for this sketch, not a benchmark. A longer prompt means the founder should cut scope first.

Raising the ceiling in silence hides the real cost. Cut a section, or split the page into a second frozen file. Do not let the model invent a backend to make it dynamic.

The lock in code

The script below is an unexecuted example for a local repo. It writes a static page and a small ledger. Swap the placeholder writer for the current free-model client.

#!/usr/bin/env python3
"""Freeze a prompt and refuse a repeat model call.

Unexecuted example. write_page() does not call a network.
Replace it with the current free-model client when needed.
"""
import hashlib
import sys
from datetime import datetime, timezone
from pathlib import Path

ROOT = Path(__file__).resolve().parent
PROMPT = ROOT / "prompts" / "changelog.md"
OUT = ROOT / "public" / "index.html"
LEDGER = ROOT / ".token-ledger.tsv"
STAMP = ROOT / ".gen-stamp"
CHAR_BUDGET = 12_000

def fail(msg: str, code: int = 2) -> None:
    print(msg, file=sys.stderr)
    raise SystemExit(code)

def write_page(tmp: Path) -> None:
    html = "\n".join([
        "<!doctype html>",
        "<html lang='en'>",
        "<meta charset='utf-8'>",
        "<title>Ship notes</title>",
        "<main>",
        "<h1>Ship notes</h1>",
        "<p>Frozen artifact. This page does not call a model.</p>",
        "</main>",
        "</html>",
        "",
    ])
    tmp.write_text(html, encoding="utf-8")

def main() -> None:
    if not PROMPT.is_file():
        fail(f"missing prompt file: {PROMPT}")
    raw = PROMPT.read_bytes()
    if len(raw) > CHAR_BUDGET:
        fail(f"prompt exceeds local char budget: {len(raw)}")
    digest = hashlib.sha256(raw).hexdigest()
    old = STAMP.read_text().split()[0] if STAMP.exists() else ""
    if digest == old and OUT.is_file() and OUT.stat().st_size > 0:
        print("prompt unchanged; refusing a new model call")
        return
    OUT.parent.mkdir(parents=True, exist_ok=True)
    tmp = OUT.with_suffix(".html.tmp")
    write_page(tmp)
    if tmp.stat().st_size == 0:
        fail("refusing to publish an empty page")
    tmp.replace(OUT)
    now = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
    with LEDGER.open("a", encoding="utf-8") as handle:
        handle.write(f"{now}\t{digest}\t{len(raw)}\n")
    STAMP.write_text(digest + "\n", encoding="utf-8")
    print(f"wrote {OUT}")

if __name__ == "__main__":
    main()

The hash check is a lock on the door, not a timer. Unchanged prompts should not buy a second opinion from the model. Changed prompts still need a human to read the HTML before publish.

Write to a temp file, then rename it into place. A crash mid-write should not leave a half page live. The rename is a small trick a free box will not add.

The ledger stores time, hash, and character count. It does not store a vendor invoice, because this sketch never saw one. Treat each row as a local receipt, not as proof of a free balance.

A dumb public tree

Serving stays dumb on purpose for this class of tool. A static file server has no secret and no session. Python's module server is only a local stand-in for the free box.

mkdir -p prompts public
printf 'Ship notes for a one-morning changelog.\n' > prompts/changelog.md
python3 freeze_page.py
python3 -m http.server 8080 --directory public

Before upload, a second script walks the public tree. It looks for model endpoints that would run per visit. A match means the freeze failed, so the upload stops.

#!/usr/bin/env python3
"""Fail if public files look like a live model client."""
import re
import sys
from pathlib import Path

ROOT = Path(__file__).resolve().parent / "public"
PATTERN = re.compile(
    r"api\.openai|anthropic\.com|generativelanguage|fetch\s*\(|XMLHttpRequest",
    re.I,
)

def main() -> None:
    if not ROOT.is_dir():
        print("missing public dir", file=sys.stderr)
        raise SystemExit(2)
    bad = []
    for path in ROOT.rglob("*"):
        if not path.is_file():
            continue
        text = path.read_text(encoding="utf-8", errors="ignore")
        if PATTERN.search(text):
            bad.append(str(path))
    if bad:
        print("request path is not frozen", file=sys.stderr)
        print("\n".join(bad), file=sys.stderr)
        raise SystemExit(3)
    print("public tree has no obvious model call")

if __name__ == "__main__":
    main()

This is a test plan, not a claim about a live host. Run the writer twice with the same prompt file. The second run should print a refusal and leave the ledger unchanged.

Then change one line in the prompt and run again. The stamp should move, and the ledger should gain one row. Open the page and confirm the HTML contains no fetch to a model.

A third check belongs in the browser, not only in grep. Disable the network after load and reload the page. A frozen page still renders, because nothing remote was required.

python3 freeze_page.py
python3 freeze_page.py
python3 check_public.py
test -s public/index.html
awk -F '\t' 'END {print NR}' .token-ledger.tsv

A morning sequence keeps the founder honest about spend. Create the prompt file before opening any model chat. Run the freeze script, read the HTML, then run the public check.

Only after both commands pass should the public directory be copied. Copy means an upload, not a second generation pass. The free server then has nothing left to decide.

If the check fails, fix the file by hand. Do not ask the model to remove the script in a loop. Each loop is another spend, and the hash will move.

Hand edits after generation are allowed, and they should be committed. They do not require a new model call. The stamp still refers to the prompt, not to the HTML.

That mismatch is intentional for this small workflow. The lock stops repeat generation from the same prompt. It does not block a human from correcting a sentence.

Failures worth catching

Read the ledger the next morning before any new prompt edit. One row means one intentional generation, which is the point. Three rows from a single morning mean the gate was bypassed.

Bypass usually comes from a temp file left outside the stamp. Point the client at the same prompt path every time. A second prompt file is a second bill, even when the words match.

Partial pages are the other quiet failure mode. If the output file is empty, the stamp must not update. The example updates the stamp only after a successful replace.

Clock skew does not matter to the hash, and that is deliberate. The stamp stores a digest, not a timestamp comparison. Two machines can disagree on time and still agree on the file.

The free server should receive only the public directory. Do not upload the prompt, the stamp, or the ledger. Those files are workshop notes, and they do not belong in public.

A tiny contract keeps the model from drifting into an app. The page must be one HTML file with no script source. The title must be plain text, and the body must not embed a key.

If the generated file adds a script tag, reject it. If it adds a form that posts somewhere, reject it. The founder is shipping notes, not a signup funnel, on this morning.

Who should skip it

Limits sit in the open for anyone copying this loop. A character count is not a token count, and vendors count differently. The ledger can drift from the real bill if the client adds hidden context.

Free hosting can sleep, rate-limit, or reject a custom domain. This draft does not name hardware, regions, or uptime. Those facts change, and a blog post should not freeze them.

The page cannot personalize, charge a card, or store a user. Auth, webhooks, and per-visit generation do not belong here. If the product needs those, this zero-bill shape is the wrong tool.

Who should skip the approach is equally concrete. A team with an uptime contract should not bet on a free box. A founder who will not read generated HTML should not publish it.

Anyone handling private customer text should stay off this path. The prompt file can leak into the artifact and the ledger. Keep secrets out of both, and keep the repo private until review.

There is a quieter cost than the hosting bill. A frozen page goes stale the hour the product changes. The founder must choose staleness, or spend another generation pass.

That choice is the indie constraint in plain clothes. Ship the file today, and accept that it will not adapt. Update it tomorrow only when the prompt hash truly changes.

MonkeyCode fits this loop only as the optional generator and host. Remove the name and the method still stands. The method is the split between a one-time write and a dumb read.

The same split works with any client that can write a file once. If current free model access and a free server still fit, use them here. Read the live terms first, then run the hash gate before the first call.

Fit the App to the Free Box

Avery Lin — Sat, 10 Oct 2026 17:15:58 +0000

A solo founder clears the kitchen table after nine. The landing page is already up on a free host. Monday still needs one working route and a health check.

The credit card stays in the drawer on purpose. The budget for tonight is zero dollars and one evening. That constraint decides the shape of the app.

Free model access can draft the small handler. A free server option can run one modest process. Both of these availability claims are operator-supplied here.

Disclosure: This article was prepared as part of MonkeyCode's product outreach. The outreach note describes a free token allotment of ten million tokens. It also describes a free server option for a small process.

This page does not treat either offer as a permanent contract. Quotas, model names, and machine size can change without notice. A founder should confirm the current project notes before a launch depends on them.

The useful move is to shrink the app until the box can hold it. Picture a suitcase that closes only after one pair of shoes comes out. The free server is that suitcase, and extra features are the spare shoes.

One process listens on one port for the whole service. One route answers a tiny JSON body and nothing else. No worker fleet starts beside that web process.

MonkeyCode can sit in the drafting seat for that small surface. It should not sit in the billing seat or the deploy seat. The founder still owns the diff, the env file, and the stop choice.

Remove every product name and the rehearsal below still holds. Any local editor and any small host can run the same gate. The gate is the lesson, and the brand is optional.

The gate has three jobs before anything leaves the laptop. It proves the process boots on a local port. It proves one route answers with the expected word.

It also proves the boot path does not name a paid secret. Fail any job and the upload waits until the next morning. That wait is cheaper than a surprise hold on a card.

The files below are a labeled proposal, not a captured production log. They were not executed for this article and they are not a benchmark. A founder should run them on a private machine and keep the output.

An empty env example file gives the secret scan a real target. A missing file makes the scan quiet, which is a weak gate. The scan looks for paid key names, not for a hidden value.

#!/usr/bin/env bash
set -euo pipefail

# rehearse.sh — local gate before a free-server upload
# Proposal only. Not a recorded run and not a benchmark.

ROOT="${1:-.}"
PORT="${PORT:-8787}"
APP="${ROOT}/app.py"
ENV_EXAMPLE="${ROOT}/.env.example"

test -f "$APP" || { echo "missing $APP"; exit 2; }
test -f "$ENV_EXAMPLE" || { echo "missing $ENV_EXAMPLE"; exit 2; }

if grep -E 'STRIPE_SECRET|AWS_ACCESS_KEY_ID|OPENAI_API_KEY' "$ENV_EXAMPLE"; then
  echo "boot path names a paid secret; trim it first"
  exit 3
fi

python3 -m py_compile "$APP"
python3 "$APP" &
PID=$!
trap 'kill "$PID" 2>/dev/null || true' EXIT

ready=0
for _ in 1 2 3 4 5 6 7 8; do
  if curl -fsS "http://127.0.0.1:${PORT}/health" >/dev/null; then
    ready=1
    break
  fi
  sleep 0.25
done

test "$ready" -eq 1
curl -fsS "http://127.0.0.1:${PORT}/health" | grep -q '"ok": true'
curl -fsS -X POST "http://127.0.0.1:${PORT}/echo" \
  -H 'content-type: application/json' \
  -d '{"text":"ship"}' | grep -q 'ship'

echo "local gate passed; a free box may receive this build"

The companion app stays small for the same reason as the gate. It imports only the standard library and binds only to localhost. A paid client must not load at import time.

# app.py — single process, standard library only
# Proposal only. Not a recorded run.
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import json

PORT = 8787

class Handler(BaseHTTPRequestHandler):
    def _send(self, code, payload):
        body = json.dumps(payload).encode()
        self.send_response(code)
        self.send_header("content-type", "application/json")
        self.send_header("content-length", str(len(body)))
        self.end_headers()
        self.wfile.write(body)

    def do_GET(self):
        if self.path != "/health":
            self._send(404, {"ok": False})
            return
        self._send(200, {"ok": True, "role": "free-box"})

    def do_POST(self):
        if self.path != "/echo":
            self._send(404, {"ok": False})
            return
        length = int(self.headers.get("content-length", "0"))
        raw = self.rfile.read(length) if length else b"{}"
        data = json.loads(raw or b"{}")
        text = data.get("text", "")
        self._send(200, {"ok": True, "text": text})

    def log_message(self, fmt, *args):
        return

if __name__ == "__main__":
    ThreadingHTTPServer(("127.0.0.1", PORT), Handler).serve_forever()

The health grep expects a space after the colon from the standard dump. A minified body fails that check on purpose, and that failure is fine. A bad JSON body can crash this sample handler.

A try block belongs in the route before real traffic. A free coding model may draft both files in one sitting. The founder then runs the gate and reads the diff line by line.

If the draft adds a cloud SDK, the secret scan should fail. A failed compile is also a valid stop for the evening. Free tokens spent on a rejected draft still cost attention.

They do not cost a card charge if no paid key was used. Attention is the real limit on a zero dollar night. Token use needs a handwritten cap beside the repo.

This article will not invent a live usage meter. A founder should fill the numbers from the tool's own usage line. A guessed figure should never be labeled as a measurement.

# token-log.md
# date | task | reported tokens | keep or drop
# 2026-10-10 | draft health handler | fill from the tool | keep if the gate passes

Ten million tokens, if that allotment is still live, is a runway. It is not a personality and it is not a promise. A solo founder can burn that runway on retries that never boot.

After two failed drafts of the same file, the founder should edit by hand. Hand edits keep the evening finite and the invoice at zero. The free server step starts only after the local gate is green.

Copy the same app file only after that green result. The host bind notes should be read before the upload. This page will not invent CPU, memory, region, or uptime.

Local rehearsal should bind to localhost and nowhere else. The remote host may want a different address in its own docs. Guessing that address is how a green local gate becomes a dead upload.

If the panel wants a card for a custom domain, the domain can wait. A raw host URL is enough for a Monday check with one friend. Customers can wait for a name, and the card can wait with them.

The request path needs the same discipline as the process count. One route reads JSON and writes JSON back. No file upload, no queue, and no webhook that must stay awake.

Those extra paths want a paid always-on box and a real owner. They can arrive after the first paying user, not before that user. Shipping them early turns a free stool into an unpaid operations job.

The analogy is a food stall with one burner and a short menu. The menu is soup, and soup can sell on the first night. A five-course kitchen does not fit the stall and starts a mess.

When the draft suggests a database, a flat file may still be enough. An echo route needs no store beyond the request itself. A waitlist of twenty names can live in one JSON file.

Payments do not belong on an unattended free box. Health data and private customer files do not belong there either. Those workloads need a different host, a different review, and a card.

Founders who need a signed uptime target should skip this approach. Founders who need a named model should skip this path too. This page verifies neither, so a launch plan should not pretend otherwise.

Founders who want an unattended model deploy should skip the path. The free path is a launch stool, not a control plane. A team with an on-call rotation needs a sturdier floor.

Limits should be said aloud before a friend sees the URL. Free access can end, shrink, or sit in a queue. A free server can sleep, restart, or reject a bind.

This draft does not measure latency and does not name a model. The script checks a local process and nothing on the public internet. It does not prove the remote host will behave the same way.

After upload, the same two curls should run against the public URL. That output should sit next to the token log. The second run is the real ship signal, not the local echo.

Current MonkeyCode access notes should be read before any count. That read is the only soft step this page will ask for. If those notes disagree with this page, the notes win.

The one route can ship, and the card can stay in the drawer. A Monday friend can hit the raw URL and stop there.

One Click, One Row

Avery Lin — Fri, 09 Oct 2026 13:23:35 +0000

A solo founder opens the inbox before the first coffee.
Two welcome notes name the same new address.
The public waitlist form accepted a double click.

The second database row is not a mystery.
The button fired again before the first write finished.
A bigger cloud invoice will not remove that race.

The cloud bill must stay at zero today.
The patch must land before the next signup wave.
A rented lab machine is the wrong shape of help.

The generated form was a fast win on the surface.
Fast generation skipped the second-click story in full.
The harness puts that story back into the repo.

The first request starts a write and yields the thread.
The second request arrives before that write commits.
Both reads see an empty slot and both insert.

A coat check, not a second coat

Picture a coat check at a crowded door.
The first click parks the coat and takes a stub.
The second click must show that stub and leave.

A free draft lane can still earn its place.
MonkeyCode is presented as an open-source coding assistant here.
Disclosure: This article was prepared as part of MonkeyCode's product outreach.

MonkeyCode offers free model access for a narrow coding pass.
It also offers a free server option for that pass.
The free lane drafts the patch and nothing more.

The local harness decides whether that patch is real.
Current terms live on the project page, not in memory.
Quotas, model names, and uptime are not assumed here.

The operator points to a free token allowance as well.
The live figure must be read on that same page.
This draft will not freeze a number that can move.

One folder, one bug

The founder copies one module into a scratch folder.
That folder holds the signup claim and its proof.
No customer export rides along with the prompt.

The prompt names the bug in plain words.
Two requests with one normalized email must yield one row.
The model may suggest code, not production credentials.

A secret key in the prompt is a leaked key.
A real email list is not a safe fixture.
Synthetic names keep the free server boring and safe.

These files are an unexecuted sketch for a scratch repo.
They are not a log from a live customer system.
A local run must happen before any trust is assigned.

Bug: two posts of the same email create two rows.
Constraint: one normalized email may claim only one row.
Do not add network calls. Do not read environment secrets.
Files in scope: waitlist.py only.

The prompt above is a boundary, not a spell.
It keeps the free server on one file and one rule.
A wider paste invites a wider and quieter mistake.

The claim that must win twice

The claim function is short enough to read aloud.
It returns the old row when the email already exists.
It writes once, then reports that the write happened.

def normalize_email(email):
    """Fold case and space so one person keeps one stub."""
    cleaned = email.strip().lower()
    if "@" not in cleaned or cleaned.startswith("@") or cleaned.endswith("@"):
        raise ValueError("email required")
    return cleaned


def claim_signup(email, store):
    """Return the existing row when the email was already claimed."""
    key = normalize_email(email)
    prior = store.get(key)
    if prior is not None:
        return prior, False
    row = {"email": key}
    store[key] = row
    return row, True


def maybe_send_welcome(row, created, outbox):
    """Append one welcome note only for a new claim."""
    if not created:
        return False
    outbox.append({"to": row["email"], "kind": "welcome"})
    return True

The store in this sketch is a plain dict.
A real app should use a unique database constraint.
The dict still teaches the branch the bug forgot.

Lowercasing the mail stops a case-only twin.
The strip call drops a pasted trailing space.
Those two cleanups belong inside the claim itself.

A blank email is a broken ticket, not a guest.
The function raises before a nameless row can land.
That failure is safer than a silent duplicate.

Proof that never dials out

The harness must run on a laptop without network.
A green model reply is not evidence of a fix.
The script below is the only evidence that counts.

from waitlist import claim_signup, maybe_send_welcome


def prove():
    store = {}
    first, created = claim_signup("Ada@Example.com ", store)
    second, again = claim_signup("ada@example.com", store)
    assert created is True
    assert again is False
    assert first["email"] == "ada@example.com"
    assert second is first
    assert len(store) == 1
    outbox = []
    assert maybe_send_welcome(first, created, outbox) is True
    assert maybe_send_welcome(second, again, outbox) is False
    assert len(outbox) == 1
    other, other_created = claim_signup("lin@example.com", store)
    assert other_created is True
    assert other is not first
    assert len(store) == 2
    try:
        claim_signup("not-an-email", store)
    except ValueError:
        bad_rejected = True
    else:
        bad_rejected = False
    assert bad_rejected is True
    print("waitlist claim held")


if __name__ == "__main__":
    prove()

A missing import fails before any hosted draft runs.
A red assert fails closed and blocks the merge.
A quiet print line means the double click lost.

The shell steps are dull on purpose today.
The compile step runs, then the proof, then a stop.
Nothing in that chain should open a socket.

python3 -m venv .venv
. .venv/bin/activate
python3 -m py_compile waitlist.py prove_waitlist.py
python3 prove_waitlist.py

Let the free pass draft, then sit down

The founder pastes the function and the failing trace.
The ask stays small and names the second call.
The free server runs that narrow pass, then stops.

MonkeyCode is the drafting bench in this workflow.
It is not the database, the mailer, or the judge.
If the free server is dark, the harness still runs.

A hand-written guard is still a valid ship.
Speed comes from the small scope, not from magic.
The zero bill comes from refusing a new rental.

When the draft returns, the same script runs again.
A changed signature must fail the compile step first.
Only a green local run may touch the real branch.

The index that closes the door

A unique index turns the second insert into an error.
The handler must catch that error and read the winner.
A blind retry will recreate the double welcome note.

CREATE UNIQUE INDEX waitlist_email_key
    ON waitlist_signups (email);

The SQL beside the function is short and blunt.
It refuses a second insert with the same email.
The app then reads the row it already stored.

def on_unique_violation(email, store):
    row = store.get(normalize_email(email))
    if row is None:
        raise LookupError("winner missing after conflict")
    return row, False

That helper is a sketch of the conflict path.
A real driver raises its own integrity error class.
The handler maps that class and leaves other errors alone.

The founder checks the index before blaming the button.
A missing index lets the app branch lie in comfort.
The database, not the button color, owns the rule.

Mail only on the first claim

Mail should send only when the created flag is true.
That rule stops the second welcome note cold.
The inbox story ends when one address gets one note.

The welcome helper lives beside the claim function.
A false created flag must leave the outbox alone.
The proof asserts a single note after both calls.

sent = maybe_send_welcome(second, False, outbox)
assert sent is False
assert len(outbox) == 1

A failed send should not roll back a stored claim.
The row is the source of truth after the unique write.
Mail can retry later without inserting a twin.

Bad patches that look clever

Three bad patches show up often in this lane.
One patch mints a fresh client key on every click.
Another patch sleeps, then hopes the race has ended.

A third patch catches the click in the browser only.
A fresh client key fails when the second click differs.
A sleep call fails when the network slows down.

A browser lock fails when two devices race apart.
The model may invent a lock the database cannot keep.
The model may skip the unique index and smile.

The assert on store length is the smile detector.
A unique email index fails closed, which is the point.
A green chat bubble cannot overrule that length check.

A note the week can trust

A tiny runner writes the result to a local log.
The log stores the date, the file hash, and the verdict.
That note is the memory when the week gets loud.

import hashlib
import subprocess
import sys
from datetime import date
from pathlib import Path


def file_hash(path):
    data = Path(path).read_bytes()
    return hashlib.sha256(data).hexdigest()[:12]


def main():
    target = "waitlist.py"
    digest = file_hash(target)
    run = subprocess.run(
        [sys.executable, "prove_waitlist.py"],
        check=False,
    )
    verdict = "pass" if run.returncode == 0 else "fail"
    line = f"{date.today().isoformat()} {digest} {verdict}\n"
    with open("proof.log", "a", encoding="utf-8") as handle:
        handle.write(line)
    print(line.strip())
    return run.returncode


if __name__ == "__main__":
    raise SystemExit(main())

python3 -m py_compile note_proof.py
python3 note_proof.py

The hash stops a silent edit after a green run.
If the file changes, the old pass no longer counts.
The proof runs again and a fresh line is appended.

Who should walk past this door

Some days the free lane is the wrong door.
A repo full of payment secrets should stay offline.
A regulated customer file should never board that server.

A founder who needs a support contract needs a vendor.
A team that must audit every prompt needs another path.
This sketch has no legal review and no uptime promise.

A huge monorepo will not fit a short free pass.
The cut continues until one file tells the story.
If that cut fails, the guard is written by hand.

This path fits a solo founder who can read a diff.
It fits a scratch app with synthetic fixtures only.
It does not fit a team that shares live customer data.

The limits are accepted before the first prompt leaves.
Free access can throttle, pause, or change shape.
A dark lane is a cue to type the guard by hand.

Leave the invoice asleep

The production step is still a human merge.
The unique index belongs beside the claim function.
The bill stays quiet because no new machine started.

A reader can copy the harness into a scratch repo today.
The same reader confirms the repository, license, and live terms first.
The proof runs before any generated line is trusted.

Free Tokens Are a Deadline

Avery Lin — Thu, 08 Oct 2026 09:24:12 +0000

Free Tokens Are a Deadline

A solo founder wants to ship a changelog triage tool before Monday. The scenario below is illustrative, not a case study. The tool reads release notes, groups them, and posts a digest to a webhook. The hosting budget is zero dollars.

Free model access looks like an infinite runway. It is not. It is a deadline with an unknown date.

That single reframing changes the whole design. An allowance is a countdown, not a wallet.

Free access has no calendar

An agent that retries a failed tool call three times bills the full prompt three times. Loops are the expensive part, not long answers. A ten-million-token allowance is generous for humans and tight for agents.

The operator of MonkeyCode states two things: a free model allowance of that size, and a free server option. Those are operator-supplied claims, and they will change. Read the project's own page before designing a business around either one.

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

The practical takeaway is narrow. Treat the allowance as a finite resource with a meter, and treat the free server as a staging tier that can hold real traffic for a while. Neither one is a promise of permanence.

The recent wave of model-generated side projects makes this worse. More generation means more retries, more context, and more forgotten background jobs at 3 a.m.

Write the ledger before the first request

The cheapest guard is a file that only grows. Every response carries a usage object. Append it, then read it back before the next call.

# ledger.py — append-only usage ledger with a hard stop.
# The cap is self-imposed. Keep headroom under any real allowance.
import json, os, time

LEDGER = os.environ.get("MC_LEDGER", "usage.jsonl")
CAP = int(os.environ.get("MC_TOKEN_CAP", "8000000"))


def spent() -> int:
    if not os.path.exists(LEDGER):
        return 0
    total = 0
    with open(LEDGER) as fh:
        for line in fh:
            total += json.loads(line)["total_tokens"]
    return total


def gate(estimated: int) -> None:
    if spent() + estimated > CAP:
        raise RuntimeError("allowance reached: degrade or stop")


def record(model: str, usage: dict) -> None:
    with open(LEDGER, "a") as fh:
        fh.write(json.dumps({
            "ts": time.time(),
            "model": model,
            "prompt_tokens": usage["prompt_tokens"],
            "completion_tokens": usage["completion_tokens"],
            "total_tokens": usage["total_tokens"],
        }) + "\n")

The call site stays boring. The example below assumes an OpenAI-compatible request shape. Check the current docs for the base URL and the live model list before copying it.

import os, requests
from ledger import gate, record

BASE = os.environ["MC_BASE_URL"]
MODEL = os.environ["MC_MODEL_ID"]
KEY = os.environ["MC_API_KEY"]


def ask(prompt: str, est: int = 800) -> str:
    gate(est)
    r = requests.post(
        f"{BASE}/chat/completions",
        headers={"Authorization": f"Bearer {KEY}"},
        json={"model": MODEL, "messages": [{"role": "user", "content": prompt}]},
        timeout=60,
    )
    r.raise_for_status()
    data = r.json()
    record(MODEL, data["usage"])
    return data["choices"][0]["message"]["content"]

A weekly glance at the ledger is enough reporting. Ten lines of standard library beat a dashboard nobody opens.

python - <<'PY'
import json
tot = {}
for line in open("usage.jsonl"):
    d = json.loads(line)
    tot[d["model"]] = tot.get(d["model"], 0) + d["total_tokens"]
for k, v in sorted(tot.items(), key=lambda x: -x[1]):
    print(f"{v:>9,}  {k}")
PY

Route work by cost, not by preference

The right question is not which model is best. It is which work can tolerate a slow, imperfect answer. Route accordingly.

Workload	Where it runs	Why
Nightly digest, batch, cached	Free model	Latency is irrelevant; a human re-reads the output
Issue label suggestions	Free model, low confidence flagged	A wrong label costs one click
Customer-facing chat	Paid tier or nothing	A free tier carries no uptime promise
Prompts containing secrets	Nowhere	Prompts leave the machine

Caching is the highest-leverage trick. Hash the input, store the output, and never pay twice for the same release note.

Put it on the free server honestly

A free server is fine for a tool with a forgiving audience. It is not fine for a product that promises five nines. Configure the reverse proxy, then let the process restart itself.

ship.example.com {
    reverse_proxy 127.0.0.1:8000
    encode gzip
}

[Unit]
Description=changelog triage
After=network.target

[Service]
WorkingDirectory=/srv/app
EnvironmentFile=/srv/app/.env
ExecStart=/srv/app/.venv/bin/uvicorn app:api --host 127.0.0.1 --port 8000
Restart=always
RestartSec=3

[Install]
WantedBy=multi-user.target

A health check every five minutes tells the truth about uptime. Log the failures instead of hiding them.

Decide what happens on day one of the shortage

The worst outcome is a silent failure. Build the ladder before the allowance runs out.

Step one: serve cached answers. Step two: switch to a smaller model. Step three: queue the job and tell the user it is delayed. Step four: return a clear 503 with an honest message.

Each step is ten lines of code. Together they turn a cliff into a slope.

Limits and who should skip this

"Free" here means no invoice today, not no cost ever. A free server has no SLA, no autoscaling, and usually one region. Model access without a contract means the endpoint can change under you.

Skip this approach if the product carries customer data under a compliance regime, if latency is part of the promise, or if the business plan assumes the allowance never ends. Solo builders shipping a small, forgiving tool are the right audience. Everyone else should price the paid tier first.

The project's own documentation is the only current source for the allowance and the server option, so start there before the first request.

End the Demo on Purpose

Avery Lin — Thu, 08 Oct 2026 06:47:49 +0000

The opening scene is a composite, not a customer report. A solo founder had a demo call at four. The status page ran only on one laptop.

A friend asked for a link before the call. That laptop could not serve the shared link. A zero bill still needed a public host.

Public posts this week praise generated pages and profile toys. Those pages still need a host boundary and an end time. A pretty demo without a receipt is still a laptop story.

A free coding model can draft a small page. A free server can hold a short demo. Neither tool should hold a customer record.

Disclosure: This article was prepared as part of MonkeyCode's product outreach. MonkeyCode is treated here as an open-source coding assistant. The operator supplied two availability claims for this draft.

Those claims are free model access and a free server option. This draft does not name any current model. This draft does not state a token grant.

Live quotas change, so the docs must win. A founder should read the current project terms first. A number copied from an old post can sink a launch.

The useful artifact is a local receipt drill. The drill freezes scope before any model edit. The drill also refuses customer data on the demo host.

Think of the free server as a borrowed folding table. It can show a poster for one afternoon. It cannot become the shop till or the ledger.

The founder writes the receipt before opening a chat. The receipt is a plain file in the repo root. The model may edit code, but not that file.

The proposed commands below were not executed for this draft. They show a throwaway drill, not a production deploy. Replace paths before use on a real machine.

mkdir -p "$HOME/demo-receipt/public"
cd "$HOME/demo-receipt"
git init
cat > RECEIPT.md << 'EOF'
scope: public status page only
host_role: demo
no_payments: true
no_customer_data: true
no_secrets: true
model_may_edit_receipt: false
retire_after: SET_A_REAL_TIME_BEFORE_SHARING
EOF
git add RECEIPT.md

The scope line is the whole product for today. A status page can say the demo is up. A status page must not charge a card.

Save the next block as health.py beside the receipt. It binds to localhost until a human chooses a host. It reports a start time and a demo flag.

# Proposed local drill. Not executed in this draft.
from http.server import BaseHTTPRequestHandler, HTTPServer
import json
import os
import time

STARTED = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())

class Handler(BaseHTTPRequestHandler):
    def do_GET(self):
        if self.path != "/health":
            self.send_error(404)
            return
        payload = {
            "ok": True,
            "started": STARTED,
            "demo_only": os.environ.get("DEMO_ONLY", "true"),
            "holds_customer_data": False,
        }
        body = json.dumps(payload).encode("utf-8")
        self.send_response(200)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        self.wfile.write(body)

if __name__ == "__main__":
    HTTPServer(("127.0.0.1", 8080), Handler).serve_forever()

Save the next block as guard.sh and mark it executable. It fails when risky filenames appear in the tree. Run it after git add, not before the first add.

# Proposed guard. Not executed in this draft.
set -euo pipefail
test -f RECEIPT.md
grep -q 'no_customer_data: true' RECEIPT.md
grep -q 'model_may_edit_receipt: false' RECEIPT.md
grep -q 'retire_after:' RECEIPT.md
if git ls-files | grep -E '(^|/)(\.env|secrets?|payments?|invoices?)'; then
  echo "demo tree is not clean" >&2
  exit 1
fi
python3 -m py_compile health.py
DEMO_ONLY=true python3 health.py &
pid=$!
trap 'kill "$pid"' EXIT
sleep 0.3
curl -fsS http://127.0.0.1:8080/health | grep '"holds_customer_data": false'

The local port check assumes port 8080 is free. If curl fails, the process never bound the port. Check the terminal for a traceback before blaming any host.

A free server cannot fix a script that dies locally. The founder opens a free model session after the guard exists. The pasted task is narrow and boring on purpose.

The model may add one public line, and nothing more. The task text lives beside the code as a contract. It names the files that are fair game.

Task: add public/index.html with one sentence and a health link.
Allowed files: public/index.html
Forbidden files: RECEIPT.md, health.py, guard.sh
Do not add forms, cookies, payments, or external trackers.
If a change needs a secret, stop and say blocked.

It says to stop if the receipt would change. After the diff lands, the founder runs the guard again. A green guard is not a security audit.

A green guard only means the promise still matches the tree. The founder reads every added line before the commit. A model summary is not a substitute for that read.

The health payload carries four fields for a reason. The ok field means the process answered the route. The other fields mark boot time, demo status, and data limits.

A holds_customer_data value of false is a promise, not a scan. The field does not inspect a database the page forgot. Only the file guard and the human review support that claim.

Secrets fail the drill even when the page looks empty. An env file can hide beside a pretty status card. The name check is crude, and that crudeness is useful.

Crude checks catch the obvious leak before the call. They do not catch a key buried in a comment. That is why the human still reads the diff.

The free server option comes last, not first. The founder publishes the public folder and the health route. The founder does not publish a database or a billing key.

Exact upload steps depend on the current server offer. This draft will not invent a hostname or a lifetime. The project docs are the only honest source for those fields.

A second receipt line belongs after a confirmed upload. That line records the host name a human actually used. That line also records when the demo should die.

# Proposed note after a human confirms the live docs.
printf 'demo_host: REPLACE_AFTER_READING_DOCS\n' >> RECEIPT.md
git add RECEIPT.md public/index.html health.py guard.sh
git commit -m "Record the demo receipt before sharing a link"

Sharing the link is the ship moment for this slice. The call can use that link for one hour. The call must not promote the host into next month.

Failure shows up in ordinary product habits first. The model adds a signup form because pages usually have one. The guard should catch the risky name and stop the share.

Another failure is success that lasts too long. The demo host stays up after the call ends. An old demo link becomes an unpaid production door.

The founder sets a calendar end when the receipt is written. When that time hits, the page comes down. A missing end time means the drill is unfinished.

Free model output remains untrusted text after a tidy diff. It can look clean and still break the health route. The curl check is the small proof that matters today.

Free server capacity stays unknown until the live page is read. A free box can sleep, throttle, or vanish. The public page should say that limit in plain words.

<!-- Proposed public/index.html. Not a claim about any live host. -->
<!DOCTYPE html>
<html lang="en">
  <head><meta charset="utf-8"><title>Demo status</title></head>
  <body>
    <p>This page is a short demo, not a customer system.</p>
    <p><a href="/health">Health</a></p>
  </body>
</html>

The page sentence is part of the product boundary. Visitors should see the limit without opening a repo. A hidden limit turns a free host into a surprise outage.

Who should skip this path is not a mystery. A shop that takes cards should not park checkout here. A team under compliance review needs a controlled environment.

A founder who cannot read the current terms should skip it. Availability claims without a live page are not a plan. Hope is a poor capacity number for a public link.

This path fits a solo founder with one public slice. The slice has no accounts and no personal data. The slice can die tonight without harming a payer.

The folding table analogy returns at cleanup time. Fold the table when the poster comes down. Leave the till, the ledger, and the keys at home.

A later production host can reuse the health route idea. It should not reuse the free demo box by default. Promotion needs a fresh threat pass and a fresh bill plan.

The drill stays useful even if the free offer changes. The receipt file does not depend on a brand. The guard does not need a token counter to reject a secret.

If the live docs show no free server this week, stop. Local health output is still a win for the afternoon. A shared link can wait for a host the founder can describe.

If the live docs show a tight free model cap, shrink the task. One HTML file is enough for a call. A generated framework is how a free afternoon disappears.

No benchmark is claimed anywhere in this draft. No model is ranked against any other model. The only comparison is scoped work against unbounded chat.

The founder keeps the chat log next to the commit. The log shows what was asked, not what was wished. That record helps the next morning more than a glowing summary.

A good close stays dull on purpose today. The shared link works for the invited call. The receipt matches the tree, and the host has an end.

Before the next demo, open the current MonkeyCode docs. Confirm the free model path and the free server terms. Then run this drill on a throwaway repo.

Give the Agent a Curfew

Avery Lin — Wed, 23 Sep 2026 16:23:12 +0000

A solo founder stares at a half-finished webhook on Friday night. Three angry customer mails already sit in the inbox. Sleep can wait, but a cloud invoice cannot.

The founder pastes the repo into a coding agent and leaves. Morning returns a hot laptop and a surprise cloud bill. The agent had retried one flaky tool for six hours.

The webhook still failed after all that wasted heat. This night is a systems problem, not a prompt problem. Weekend shipping dies when the host has no curfew.

The model never truly calls an HTTP API. It emits a structured object with a name and arguments. A local host parses that object and chooses whether to run it.

Product demos hide that handoff behind a friendly chat bubble. Indie work cannot afford that particular kind of hiding. The host is the lock on the door.

Think of the model as a junior contractor with a temporary keycard. The keycard must expire at midnight without any debate. The building should keep few doors and one lobby camera.

Weekend agents need a written allowlist the host can refuse. They also need a dry run that never touches the public network. They finally need a wall-clock curfew that kills the process.

The allowlist comes before any prompt

A clever system prompt will not save a tired Friday. The founder should start with a file the host understands. Missing names become denials, and that silence is the feature.

Label the next block as example config, not production truth.

{
  "agent": "weekend-webhook",
  "timezone": "local",
  "curfew": {
    "max_wall_seconds": 1200,
    "max_tool_calls": 40,
    "max_retries_per_tool": 2
  },
  "tools": [
    {
      "name": "read_file",
      "args": ["path"],
      "network": false,
      "max_calls": 20
    },
    {
      "name": "run_tests",
      "args": ["suite"],
      "network": false,
      "max_calls": 8
    },
    {
      "name": "http_get",
      "args": ["url"],
      "network": true,
      "url_prefix": "https://staging.example.test/",
      "max_calls": 6
    }
  ]
}

The production deploy tool is missing on purpose here. The refund tool is missing on purpose here. Staging GET remains the only network door in the file.

A missing tool is a denied tool on this host. The agent can argue in prose all night long. The JSON file does not argue back at all.

What the host actually receives

Most coding models speak a small JSON dialect for tools. The payload carries a name string and an arguments object. A call identifier sometimes rides along for the next turn.

The host must treat that payload as untrusted input every time. String names can hide paths, shells, or surprise verbs. Arguments can nest until a naive runner finally explodes.

A strict host decodes with a size cap and a known schema. It rejects extra fields rather than forwarding them onward. It never interpolates arguments into a shell string.

# parse_call.py — example parser, not executed here
import json

MAX_CALL_BYTES = 4096

class CurfewError(RuntimeError):
    pass

def parse_call(raw: str):
    if len(raw.encode("utf-8")) > MAX_CALL_BYTES:
        raise CurfewError("call too large")
    data = json.loads(raw)
    if set(data.keys()) - {"name", "args"}:
        raise CurfewError("unexpected fields")
    if not isinstance(data.get("name"), str):
        raise CurfewError("bad name")
    if not isinstance(data.get("args", {}), dict):
        raise CurfewError("bad args")
    return data

That parser is not clever and should remain that way. Clever parsers become the incident well after midnight. Boring parsers keep Friday night small and finite.

Customs at a tiny airport beats a speech about trust. Every incoming bag gets opened on the table. Extra pockets fail the check without appeal.

Dry-run the host, never the wallet

The next artifact is a tiny Python host for local rehearsal. It counts every attempted call against the published envelopes. Network tools return a skip record while dry-run stays true.

Label this sample as an unexecuted example harness.

# dry_run_host.py — example harness, not a product
import json, time, sys
from pathlib import Path

ALLOW = json.loads(Path("tools.allow.json").read_text())
counts = {}
started = time.monotonic()
MAX_CALL_BYTES = 4096

class CurfewError(RuntimeError):
    pass

def parse_call(raw: str):
    if len(raw.encode("utf-8")) > MAX_CALL_BYTES:
        raise CurfewError("call too large")
    data = json.loads(raw)
    extra = set(data.keys()) - {"name", "args"}
    if extra:
        raise CurfewError("unexpected fields")
    if not isinstance(data.get("name"), str):
        raise CurfewError("bad name")
    if not isinstance(data.get("args", {}), dict):
        raise CurfewError("bad args")
    return data

def check_curfew():
    elapsed = time.monotonic() - started
    if elapsed > ALLOW["curfew"]["max_wall_seconds"]:
        raise CurfewError("wall clock expired")
    if sum(counts.values()) >= ALLOW["curfew"]["max_tool_calls"]:
        raise CurfewError("call envelope empty")

def find_tool(name):
    for tool in ALLOW["tools"]:
        if tool["name"] == name:
            return tool
    return None

def handle(call, dry_run=True):
    check_curfew()
    tool = find_tool(call["name"])
    if tool is None:
        raise CurfewError(f"denied tool: {call['name']}")
    used = counts.get(tool["name"], 0)
    if used >= tool["max_calls"]:
        raise CurfewError(f"tool envelope empty: {tool['name']}")
    counts[tool["name"]] = used + 1
    url_prefix = tool.get("url_prefix")
    if url_prefix:
        url = call.get("args", {}).get("url", "")
        if not str(url).startswith(url_prefix):
            raise CurfewError("url outside prefix")
    if dry_run and tool.get("network"):
        return {"ok": True, "dry_run": True, "skipped": call}
    return {"ok": True, "dry_run": dry_run, "echo": call}

if __name__ == "__main__":
    try:
        call = parse_call(sys.stdin.read())
        print(json.dumps(handle(call, dry_run=True)))
    except CurfewError as exc:
        print(json.dumps({"ok": False, "error": str(exc)}))
        sys.exit(2)

The host fails closed on unknown names and empty envelopes. Network tools in dry-run still spend the numbered envelope. Rehearsal that does not spend budget will hide retry loops.

Prove the gate with a command before any chat window opens. Type the denial cases in a real shell. Do this before the first long prompt.

echo '{"name":"stripe_refund","args":{"id":"re_123"}}' | python dry_run_host.py
# expected stderr-free JSON, exit 2, error denied tool: stripe_refund

echo '{"name":"http_get","args":{"url":"https://evil.example/"}}' | python dry_run_host.py
# expected exit 2, error url outside prefix

echo '{"name":"http_get","args":{"url":"https://staging.example.test/health"}}' | python dry_run_host.py
# expected exit 0, skipped http_get, dry_run true

The refund name never appears in the allowlist file. The evil URL fails the prefix check even during dry-run. Both exits should be two, not zero.

Tests the chat window cannot charm

Indie founders skip tests when the clock hits midnight. That is exactly when the agent needs a test. Ten lines can pin the boundary without a rented GPU.

# test_curfew.py — example, unexecuted in this article
import json, subprocess

def run(call):
    proc = subprocess.run(
        ["python", "dry_run_host.py"],
        input=json.dumps(call),
        text=True, capture_output=True,
    )
    return proc.returncode, json.loads(proc.stdout)

def test_unknown_tool_is_denied():
    code, body = run({"name": "ship_prod", "args": {}})
    assert code == 2
    assert "denied" in body["error"]

def test_staging_get_is_skipped_in_dry_run():
    code, body = run({
        "name": "http_get",
        "args": {"url": "https://staging.example.test/health"},
    })
    assert code == 0
    assert body["skipped"]["name"] == "http_get"

def test_foreign_host_fails_prefix():
    code, body = run({
        "name": "http_get",
        "args": {"url": "https://evil.example/"},
    })
    assert code == 2
    assert "prefix" in body["error"]

Run it like any other unit file in the repo. Green means the host still refuses stranger names. Red means the Friday host already drifted.

python -m pytest test_curfew.py -q

The prompt can change every hour without ceremony. The allowlist should not change without a failing test. The test is memory the model does not keep.

A wall clock the process must obey

Allowlists stop the wrong door from opening tonight. They do not stop a long and confused night. The agent still needs a process-level timer around the loop.

# curfew.sh — example supervisor, not executed here
set -euo pipefail
export PYTHONUNBUFFERED=1
/usr/bin/timeout --kill-after=10s 1200s python agent_loop.py \
  --allow tools.allow.json \
  --dry-run \
  --max-calls 40
echo "agent stopped with $?"

Twelve hundred seconds equal twenty focused minutes of work. That window can edit a stubborn webhook and run tests. It cannot cook the laptop until Saturday dawn.

The kill-after flag handles a frozen child process cleanly. The numeric exit code becomes the whole morning report. Humans should read four lines, not a novel.

When the laptop must close, the same script belongs elsewhere. A disposable remote box can run the curfew while sleep happens. That box must not hold production secrets or customer exports.

MonkeyCode provides free model access and a free server option. Disclosure: This article was prepared as part of MonkeyCode's product outreach. A throwaway staging repo is enough to try the bounded run.

A sketch of the loop

The loop itself should stay as dull as the parser. It asks the model for a proposal, then asks the host. The host return value becomes the next observation.

# agent_loop.py — sketch, not executed here
def loop(model, host):
    observation = {"task": "fix staging webhook tests"}
    for _ in range(40):
        proposal = model.propose(observation)  # untrusted text
        result = host.handle(parse_call(proposal), dry_run=True)
        if not result.get("ok", True):
            return result
        observation = result
    return {"ok": False, "error": "envelope empty"}

Forty turns is not some personality trait. It is the call envelope from the allowlist. When the envelope empties, the process is done.

Live flags stay outside the agent's reach

Dry-run does not prove TLS, auth, or pagination behavior. A skipped call never exercises the real client path. Flip a live flag only after one recorded staging request.

Keep that recording in git beside the allowlist file. Keep the live flag in a file the agent cannot write. The host should refuse tools that can move customer money.

This remains a weekend fence, not a bank control plane. Fancy multi-agent planners can wait for a calmer Monday. A curfew is enough to ship a webhook tonight.

Who should not copy this fence

This workflow is for a solo founder on staging traffic. It is not a HIPAA boundary or a money-movement control. It is not a substitute for a second human review.

Free models drift from one night to the next without notice. The same prompt may emit a brand new tool name tomorrow. The allowlist must fail closed when that happens.

Free servers also sleep, throttle, or vanish without a contract. Do not park customer data on a box that can disappear. Do not treat complimentary uptime as an operations promise.

If the product can move money, this host is too small. Put a human in that loop before any refund tool exists. Give the agent a service account that cannot see billing.

Saturday morning, four lines

Shipping tonight means a failing webhook test now passes. It does not mean the agent gained root on production. It does not mean support mail became an unsupervised loop.

A useful morning log holds four dull lines and then stops. It shows wall time, tool counts, denials, and the diff stat. Anything beyond that is noise around a simple fence.

wall_seconds=842
tool_counts={"read_file":11,"run_tests":4,"http_get":2}
denials=["ship_prod","stripe_refund"]
diff_stat=webhook.py +18 -6

The denials are the actual win from the long night. The agent asked for production ship and a customer refund. The host said no, and the founder still has a weekend.

Indie work rewards people who accept limits in public. Zero bill is a feature for a one-person company. Finite tools and a hard curfew are features too.

The model may be clever inside that small fence. Outside the fence it is an intern with a credit card. Friday can run late, but the agent still stops.

Overlap Before DNS

Avery Lin — Tue, 22 Sep 2026 14:45:14 +0000

The kettle clicked off at twenty to midnight. A solo founder had a landing page and a dream. The checkout handler had never met a second caller.

Stripe sat in test mode beside a README. The DNS record still pointed at a parked domain. Nothing in the stack had overlapped with itself.

That gap is not a branding problem. It is a physics problem on a quiet night. One happy curl does not stand in for twenty.

Public feeds this week filled with louder AI demos. Voice loops and browser agents ate the scroll. A one-person shop still sells through HTTP.

Chasing the demo calendar does not move cash. Overlap still arrives on the first real morning. The invoice should stay blank until then.

Think of a club soundcheck before doors open. One microphone can hide a frayed cable. Twenty open channels reveal the ground hum.

An indie rehearsal can steal that idea. It does not need a rented load farm. It needs a boring harness and a free box.

The proposed method stays small on purpose. The product tree stays frozen during the run. Only the harness files may change at all.

A founder copies the live shape of checkout. The path, headers, and JSON body stay identical. Think-time jitter sits between the worker calls.

Twenty workers start together and then drift. Each records status, latency, and error class. The run fails on any 5xx or hang.

This article does not report executed numbers. The script below is a labeled proposal. Treat it as a starting artifact, not a benchmark.

#!/usr/bin/env python3
"""Proposed overlap harness. Unexecuted here. Not a benchmark."""
from __future__ import annotations

import argparse
import json
import random
import time
import uuid
from concurrent.futures import ThreadPoolExecutor, as_completed
from urllib.error import HTTPError, URLError
from urllib.request import Request, urlopen

WARMUP_MARK = "warmup"


def one_call(url: str, body: bytes, key: str, timeout: float) -> dict:
    started = time.perf_counter()
    req = Request(
        url,
        data=body,
        method="POST",
        headers={
            "Content-Type": "application/json",
            "Idempotency-Key": key,
            "Accept": "application/json",
        },
    )
    try:
        with urlopen(req, timeout=timeout) as resp:
            status = resp.status
            payload = resp.read(2048)
    except HTTPError as exc:
        status = exc.code
        payload = exc.read(2048) if exc.fp else b""
    except URLError as exc:
        return {
            "ok": False,
            "class": "network",
            "status": 0,
            "ms": round((time.perf_counter() - started) * 1000, 1),
            "key": key,
            "err": str(exc.reason),
        }
    except TimeoutError:
        return {
            "ok": False,
            "class": "timeout",
            "status": 0,
            "ms": round((time.perf_counter() - started) * 1000, 1),
            "key": key,
            "err": "timeout",
        }
    ms = round((time.perf_counter() - started) * 1000, 1)
    klass = "pass"
    ok = 200 <= status < 300 or status == 409
    if status >= 500:
        klass = "5xx"
        ok = False
    elif status == 409:
        klass = "idempotent-replay"
    elif status == 429:
        klass = "limited"
        ok = False
    elif not ok:
        klass = f"http-{status}"
    return {
        "ok": ok,
        "class": klass,
        "status": status,
        "ms": ms,
        "key": key,
        "bytes": len(payload),
    }


def main() -> int:
    parser = argparse.ArgumentParser(description="Proposed checkout overlap rehearsal")
    parser.add_argument("--url", required=True)
    parser.add_argument("--workers", type=int, default=20)
    parser.add_argument("--warmup", type=int, default=5)
    parser.add_argument("--timeout", type=float, default=8.0)
    parser.add_argument("--jitter", type=float, default=0.35)
    parser.add_argument("--sku", default="starter-pack")
    args = parser.parse_args()

    body = json.dumps({"sku": args.sku, "qty": 1, "source": "rehearsal"}).encode()
    run_id = uuid.uuid4().hex[:8]
    jobs = []
    for i in range(args.warmup):
        jobs.append((f"{WARMUP_MARK}-{run_id}-{i}", True))
    for i in range(args.workers):
        jobs.append((f"rehearsal-{run_id}-{i}", False))
    # One deliberate replay of the first live key.
    if args.workers:
        jobs.append((f"rehearsal-{run_id}-0", False))

    rows = []
    with ThreadPoolExecutor(max_workers=args.workers) as pool:
        futs = []
        for key, is_warmup in jobs:
            time.sleep(random.random() * args.jitter)
            futs.append(pool.submit(one_call, args.url, body, key, args.timeout))
            futs[-1].warmup = is_warmup  # type: ignore[attr-defined]
        for fut in as_completed(futs):
            row = fut.result()
            row["warmup"] = bool(getattr(fut, "warmup", False))
            rows.append(row)

    live = [r for r in rows if not r["warmup"]]
    fails = [r for r in live if not r["ok"]]
    lat = sorted(r["ms"] for r in live) or [0.0]
    report = {
        "run_id": run_id,
        "url": args.url,
        "workers": args.workers,
        "live_calls": len(live),
        "fails": len(fails),
        "p50_ms": lat[len(lat) // 2],
        "p95_ms": lat[min(len(lat) - 1, int(len(lat) * 0.95))],
        "classes": {},
        "fail_samples": fails[:8],
    }
    for r in live:
        report["classes"][r["class"]] = report["classes"].get(r["class"], 0) + 1
    print(json.dumps(report, indent=2))
    return 1 if fails else 0


if __name__ == "__main__":
    raise SystemExit(main())

The harness speaks HTTP and nothing else. It never imports application code from the shop. That fence keeps drafts away from money paths.

A tiny stub helps prove the harness before the real route. The stub is a stand-in, not a product. Production rehearsal still needs the real checkout shape.

#!/usr/bin/env python3
"""Proposed local stub. Unexecuted here. Not the product."""
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import json

SEEN = set()

class Handler(BaseHTTPRequestHandler):
    def do_POST(self):
        if self.path != "/checkout":
            self.send_error(404)
            return
        length = int(self.headers.get("Content-Length", "0"))
        _ = self.rfile.read(length)
        key = self.headers.get("Idempotency-Key", "")
        if key in SEEN:
            body = {"ok": False, "reason": "replay"}
            raw = json.dumps(body).encode()
            self.send_response(409)
        else:
            SEEN.add(key)
            body = {"ok": True, "order_id": f"ord-{len(SEEN):04d}"}
            raw = json.dumps(body).encode()
            self.send_response(200)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(raw)))
        self.end_headers()
        self.wfile.write(raw)

    def log_message(self, fmt, *args):
        return

if __name__ == "__main__":
    ThreadingHTTPServer(("127.0.0.1", 8080), Handler).serve_forever()

The commands stay copyable and intentionally dull. A founder runs the stub, then the harness. The same pair later aims at a rehearsal URL.

chmod +x harness.py stub.py
python3 stub.py &
STUB_PID=$!
sleep 0.4
python3 harness.py \
  --url http://127.0.0.1:8080/checkout \
  --workers 20 \
  --warmup 5 \
  --timeout 8 \
  --jitter 0.35 \
  --sku starter-pack
STATUS=$?
kill "$STUB_PID"
exit "$STATUS"

Cold start on a free server will skew the first wave. Discard the warmup batch before reading latency. Keep the error classes even when latency looks fine.

A timeout wrapped in silence is still a fail. An idempotent 409 from a replayed key can pass. A 500 from a unique constraint is a stop-ship.

Twenty overlaps is a soundcheck, not a capacity plan. It will not find a lock that appears at two hundred. It will find the crash that appears at two.

The JSON report is the only trophy that matters. Classes tell a story that averages hide. A pile of limited rows is a lesson, not a green check.

Disclosure: This article was prepared as part of MonkeyCode's product outreach. MonkeyCode offers free model access for harness drafts. The same product line includes a free server option.

A founder can generate the script, then run it there. The model should edit harness files and ignore product code. A short prompt can state that fence in plain words.

Draft only files under ./harness.
Do not open, quote, or patch ./app.
Keep the worker count at 20.
Fail the run on timeout or 5xx.
Treat 409 on a repeated Idempotency-Key as success.
Do not add third-party calls.
Do not print secrets from the environment.

Those are the operator-supplied availability claims used here. This article invents no model names or quotas. It invents no hardware, duration, or permanence.

The free server is a rehearsal hall, not a club night. Upload the two files and point --url at that host. Leave public DNS on the parked record until the report is clean.

# Proposed remote shape. Hostnames and auth stay with the founder.
python3 harness.py \
  --url https://REHEARSAL_HOST/checkout \
  --workers 20 \
  --warmup 5 \
  --timeout 8

A free server is not a quiet production twin. Sleep states and noisy neighbors both exist. Shared CPU will lie about p95 under dusk traffic.

The coding model will happily draft a wrong assertion. It may treat 429 as success if the prompt is vague. The founder still reads every failure class by hand.

This rehearsal is a poor fit for some shops. Regulated teams need a named staging environment with logs. Anyone hitting a third-party quota should not spray twenty workers at it.

Load against Stripe, email, or SMS is out of bounds. Paid multi-region traffic belongs on a paid stage. A marketplace API with strict rate limits is also off limits.

Letting a model own the product loop dulls judgment. Letting it draft a disposable harness keeps the edge. The difference is who holds the stop-ship pen.

The founder still decides what a fail means. The script only reports status, timing, and class. Judgment stays with the person who will refund a user.

Ship after the soundcheck, not after the demo reel. Keep the bill at zero while the path is still fiction. Accept that twenty workers will miss the rare lock.

Founders who need a zero-bill rehearsal have a small path. They can try the free model and free server, then commit the harness. Overlap cannot wait for a paid cluster.