DEV Community: Quinn Li

Letter to Pre-Router-Me: Route the Job Before You Spend a Token

Quinn Li — Tue, 27 Oct 2026 13:05:15 +0000

Last week I lost a day to one missing decision.

Every job I owned ran on the same box. A README summarizer, a repo scanner, and a stateful indexer shared one default.

The box restarted mid-afternoon. The summarizer recovered fine. The indexer came back empty.

I spent hours blaming the model. It was not a model problem. It was a routing problem.

This letter is what I should have written before the first run. Three mistakes, one router, one test plan.

Mistake 1: Treating a disposable box as a worker

A free server is disposable by design. That is the feature, not a bug.

Anything that must survive a restart does not belong there. Counters, caches, queues, and lock files all reset.

Verify this before you trust any box. One marker test is enough.

touch /tmp/marker && echo "marker set"
# restart or redeploy the server here
test -f /tmp/marker && echo "state survived" || echo "state gone"

If the marker is gone, no job on that box may own state. Keep the box for stateless steps only.

Mistake 2: Routing by size instead of shape

Big tasks feel like they need big machines. That instinct is usually wrong.

Shape beats size for routing decisions. Shape means three questions: does it write state, does it need network egress, does it execute code.

A 200-token job that writes a shared database is riskier than a 5,000-token summarizer. Size gave me nothing. Shape gave me a rule.

Here is the rule I use now.

Job shape	Target	Why
Writes shared state	Local or managed store	Ephemeral boxes lose it
Writes local state, single run	Local	A restart kills the run
Executes untrusted code, no state	Disposable server	Cheap to throw away
Read-only reasoning, short output	Free model access	No state, easy to retry
Read-only, long output, flaky upstream	Local	Retries get expensive

Four rows would have saved my afternoon. The table is not clever. It is just written down.

Mistake 3: No stop condition

I retried one failing step for most of an evening. Same input, same prompt, same error.

Retries without a ceiling are a budget leak. The counter has to be per step name, not per run.

Two numbers are enough. Max three attempts per step name, max one retry per distinct error string.

After that, stop and write a diff. Silent loops are worse than loud failures.

The artifact: a router that runs before any model call

This is a 40-line classifier. Standard library only. It reads a job description on stdin and prints a target.

#!/usr/bin/env python3
# route.py - decide the target before spending anything
import json, sys
from dataclasses import dataclass

@dataclass
class Job:
    name: str
    executes_code: bool
    writes_state: bool
    needs_egress: bool
    max_out_tokens: int
    blast_radius: str  # read-only | writes-local | writes-shared

def route(job):
    if job.blast_radius == 'writes-shared':
        return 'local', 'shared writes never leave your machine'
    if job.writes_state:
        return 'local', 'ephemeral boxes drop state on restart'
    if job.executes_code and job.blast_radius == 'read-only':
        return 'free-server', 'disposable execution, nothing to keep'
    if job.blast_radius == 'read-only' and job.max_out_tokens <= 2000:
        return 'free-model', 'short read-only reasoning'
    return 'local', 'long output or egress makes retries costly'

if __name__ == '__main__':
    job = Job(**json.load(sys.stdin))
    target, why = route(job)
    print(json.dumps({'job': job.name, 'target': target, 'reason': why}))

Feed it a job and read the verdict.

echo '{"name":"summarize-readme","executes_code":false,"writes_state":false,"needs_egress":false,"max_out_tokens":600,"blast_radius":"read-only"}' | python3 route.py

Expected output:

{"job": "summarize-readme", "target": "free-model", "reason": "short read-only reasoning"}

Now flip one field. Set "writes_state": true and run it again. The target must move to local.

That flip is the regression test. It costs one second and catches the whole bug class I hit.

Step budget: a wrapper with a hard ceiling

Routing decides where a job runs. It does not stop a loop.

Add a wrapper that caps each step and logs every exit code. Separate streams, one JSONL ledger.

#!/usr/bin/env bash
# guard.sh - one step, one ceiling, one ledger line
set -uo pipefail
STEP="${1:?step name}"; LIMIT="${2:-120}"; shift 2
mkdir -p out
start=$(date +%s)
timeout "$LIMIT" "$@" >"out/$STEP.stdout" 2>"out/$STEP.stderr"
rc=$?
printf '{"step":"%s","rc":%d,"secs":%d}\n' "$STEP" "$rc" "$(( $(date +%s) - start ))" >> ledger.jsonl
exit $rc

Then read the ledger, not the transcript.

python3 - <<'PY'
import json, collections
rows = [json.loads(l) for l in open('ledger.jsonl')]
bad = [r for r in rows if r['rc'] != 0]
print('steps', len(rows), 'failed', len(bad))
print(collections.Counter(r['step'] for r in bad).most_common(3))
PY

The counter answers one question fast. Which step name repeats?

If one name dominates the failures, stop. The bug is in that step, not in the model.

A test plan you can finish in ten minutes

Run the marker test on the box. Record the result.
Classify five real jobs with route.py. Write down each target.
Set writes_state: true on all five. Confirm every target moves to local.
Wrap two steps in guard.sh with a 60-second ceiling. Confirm the ledger has two lines.
Force a failure with false. Confirm the counter reports exactly one hit.

Five steps, zero model calls. That is the point.

Where free access actually fits

MonkeyCode offers free model access and a free server option, per the operator. I use both in narrow slots.

Free model access handles short, read-only tasks in my router. The free server handles throwaway execution with no state.

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

Quota terms and hardware change. Check the current product page before planning a budget around them. I deliberately left numbers out here, because stale numbers are worse than none.

Limitations

The router is a heuristic. It cannot tell you whether a task is correct.

Latency varies by time of day. A passing run tonight does not prove a passing run tomorrow.

The marker test checks one restart. Long-lived processes may behave differently.

Nothing here covers secrets. Keep credentials off shared boxes entirely.

Who should not use this

Skip it if your jobs write shared state. Move those to a managed store first.

Skip it if you handle regulated data. The data-flow review comes before any free tier.

Skip it if you need hard latency guarantees. A discretionary free box is not a scheduler.

What I would tell myself now

Write the routing table before the first job. Two minutes, five rows, done.

Then add one ledger line per step. Read the counter, not the transcript.

If you want to test the router, start with the read-only fixtures. They are the cheapest place to be wrong.

Cold-Start Audit: What I Measure Before Pointing an Agent at a Free Server

Quinn Li — Mon, 26 Oct 2026 11:37:12 +0000

Cold-Start Audit: What I Measure Before Pointing an Agent at a Free Server

Last Friday I had zero budget and one goal. Ship a small agent by lunch. I had free model access and a free server, both from MonkeyCode.

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

Lunch came and went. I spent the day debugging an environment I never measured.

This is a letter to setup-me. Three ordering mistakes cost me a full day. None of them were about the model itself.

The three mistakes, in the order I made them

I wired the agent loop before probing the endpoint.
I treated the free box as idle and predictable.
I had no snapshot, so every retry paid full cold-start cost.

Each mistake has a cheap fix. Each fix takes under ten minutes.

Step 1 — Probe the endpoint before you write the loop

A free tier is a shared resource. Latency and failures will vary by hour. You cannot plan around numbers you never collected.

Run 20 sequential calls. Record success rate, p50, max, and error codes.

#!/usr/bin/env python3
# probe.py - Python 3.9+, stdlib only. Unverified template: I have not run this
# against the current endpoint. Set env vars from the project's current docs.
import json, os, statistics, time, urllib.error, urllib.request

BASE_URL = os.environ["MC_BASE_URL"].rstrip("/")   # do not hardcode; URLs move
MODEL = os.environ["MC_MODEL"]                     # the model id you actually have
KEY = os.environ.get("MC_API_KEY", "")
CALLS = int(os.environ.get("CALLS", "20"))

def one_call(prompt):
    body = json.dumps({
        "model": MODEL,
        "messages": [{"role": "user", "content": prompt}],
        "max_tokens": 16,
    }).encode()
    headers = {"Content-Type": "application/json"}
    if KEY:
        headers["Authorization"] = "Bearer " + KEY
    req = urllib.request.Request(BASE_URL + "/chat/completions", data=body, headers=headers)
    start = time.monotonic()
    try:
        with urllib.request.urlopen(req, timeout=90) as r:
            r.read()
        return time.monotonic() - start, True, ""
    except urllib.error.HTTPError as e:
        return time.monotonic() - start, False, "http_" + str(e.code)
    except Exception as e:
        return time.monotonic() - start, False, type(e).__name__

rows = []
for i in range(CALLS):
    dt, ok, err = one_call("reply with the single word: ready")
    rows.append({"i": i, "s": round(dt, 2), "ok": ok, "err": err})
    time.sleep(1)  # stay gentle; respect documented rate limits

good = [r["s"] for r in rows if r["ok"]]
print(json.dumps({
    "summary": {
        "calls": CALLS,
        "ok": len(good),
        "fail": CALLS - len(good),
        "p50_s": round(statistics.median(good), 2) if good else None,
        "max_s": max(good) if good else None,
        "errors": sorted({r["err"] for r in rows if not r["ok"]}),
    },
    "rows": rows,
}, indent=2))

The first call is usually the slowest. Treat call 0 as warm-up and read p50 from the rest.

Read the summary before you read the model output. Three numbers decide the architecture.

fail > 0: add retries and a dead-letter file before the loop exists.
max_s far above p50_s: never assume steady latency inside a loop.
http_429: back off and stop. Do not retry around a rate limit.

That last one matters. Retrying around a 429 is how a free allowance disappears.

Step 2 — Baseline the free server before the first prompt

A free box may share CPU. Fresh disk may be slower than steady-state disk. Measure now, not after a timeout.

#!/usr/bin/env bash
# baseline.sh - Linux sandbox. /proc and /usr/bin/time do not exist on macOS.
set -euo pipefail
stamp="$(date -u +%Y%m%dT%H%M%SZ)"
out="baseline-${stamp}.json"

cpu_s=$( { /usr/bin/time -f '%e' python3 -c 'i=0
for _ in range(3000000): i += 1' ; } 2>&1 | tail -1 )

write_s=$( { /usr/bin/time -f '%e' dd if=/dev/zero of=./.probe bs=1M count=256 conv=fsync ; } 2>&1 | tail -1 )
rm -f ./.probe

cat > "$out" <<JSON
{
  "stamp": "${stamp}",
  "nproc": $(nproc 2>/dev/null || echo null),
  "mem_total_kb": $(awk '/MemTotal/{print $2}' /proc/meminfo 2>/dev/null || echo null),
  "disk_avail_kb": $(df -Pk . | awk 'NR==2{print $4}'),
  "loop_3m_seconds": ${cpu_s},
  "write_256mb_seconds": ${write_s}
}
JSON

jq . "$out" > /dev/null && echo "valid: $out"

Keep the receipt. Re-run the same script at a different hour. A two-second swing on the loop is noise. A tenfold swing means the box is busy.

Compare the receipt, never your memory of it. Three receipts from three hours beat one lucky sample.

Step 3 — Snapshot first, then log every run as one line

The day-killer was retry cost. Every failed run rebuilt its environment from scratch. Free the loop from dependency roulette: build the working state once, snapshot it, reuse it.

Then append one JSONL line per run. The ledger answers "what changed?" without a debugging session.

run_id="$(date -u +%Y%m%dT%H%M%SZ)"
jq -cn \
  --arg id "$run_id" \
  --arg sha "$(git rev-parse --short HEAD 2>/dev/null || echo no-git)" \
  --argjson wall "$SECONDS" \
  --arg status "${1:-ok}" \
  '{run:$id, commit:$sha, wall_s:$wall, status:$status}' >> runs.jsonl

Three fields are enough to start. Add token counts and exit codes when you have them. Do not add free-text notes.

Where the free tier actually fits

Free model access plus a free server is a strong fit for measured, low-volume work. It is a weak fit for anything you cannot observe.

Situation	Fits the free tier?	Reason
Under ~30 calls, human watching	Yes	Cold-start cost is tolerable
Latency-insensitive batch job	Yes	Queue time rarely matters
Teaching, demos, screenshots	Yes	Reproducible and cheap
Long unattended agent loops	No	Failure cost compounds
Hard p95 latency contract	No	Shared capacity varies
Regulated or secret data	No	Verify your own compliance first

This table is a starting position, not a verdict. Measure, then edit it.

Limitations, said plainly

The scripts above are templates. I have not executed them against the current endpoint. The output shape is real; the numbers are yours to collect.

Availability, quotas, and model lists change without notice. Confirm current limits on the project page before you design around them. Do not plan capacity from a blog post, mine included.

The approach also adds friction. Two probes and a ledger cost about fifteen minutes. If your task is a single prompt you read once, skip all of it.

Skip this workflow entirely if you need guaranteed throughput today. Skip it if your data cannot leave your own network, or if you cannot read the language the endpoint errors come back in.

What I would tell setup-me

Probe before you wire. Baseline before you prompt. Snapshot before you retry.

A day of debugging bought three small scripts. The scripts take ten minutes to run, and they still pay for themselves.

If you want to try the audit without paying for the first step, the free model access and free server option lower the entry cost. Start with probe.py, and read the summary before you read the model.

Letter to Pre-Loop-Me: Build the Token Ledger Before the Agent Runs

Quinn Li — Tue, 20 Oct 2026 09:42:11 +0000

Dear pre-loop me,

You will lose a day. Not to a hard bug. To bookkeeping you skipped.

You will point an agent at a task, watch it loop twelve turns, and have no idea what it spent. Then you will try again on a different machine and learn nothing new. Here is the letter I wish I had received, written in the order the mistakes actually happened.

Mistake 1: You counted output tokens and ignored the input

You assumed the expensive part is what the model writes back. It is not. Every turn resends the whole conversation. So prompt tokens grow with every message you append.

With a constant base prompt and a fixed per-turn growth, total prompt tokens look like this:

prompt_total(n) = n * base + growth * n * (n - 1) / 2

The second term is quadratic. That is why turn 10 costs far more than turn 1, and why a "small" loop is not small.

Here is the estimator, as a plain function you can unit-test:

// estimate.mjs
export function estimatePromptTokens({ turns, base, growth }) {
  if (turns <= 0) return 0;
  return turns * base + (growth * turns * (turns - 1)) / 2;
}

// Example shape only - plug in your own measured base and growth.
const plan = { turns: 12, base: 1200, growth: 700 };
console.log(estimatePromptTokens(plan));

The lesson: measure base and growth on turn one and two. Then you can forecast the whole run before you start it.

Mistake 2: You treated free capacity as unlimited concurrency

Free tiers are shared tiers. Under concurrency you will meet 429, and you will meet it at the worst moment.

You will then do the thing that costs the most: retry immediately in a tight loop. That converts one rate-limit event into a burst, and the burst into a longer cooldown.

What you want is a single-flight queue with jittered exponential backoff, and a hard cap on attempts.

// guard.mjs
export const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

export async function withRetry(fn, { attempts = 4, baseMs = 1000 } = {}) {
  let lastErr;
  for (let i = 0; i < attempts; i++) {
    try {
      return await fn();
    } catch (err) {
      lastErr = err;
      if (err.status !== 429) throw err;
      const wait = baseMs * 2 ** i + Math.random() * 250;
      console.log(`429 -> retry ${i + 1}/${attempts} in ${Math.round(wait)}ms`);
      await sleep(wait);
    }
  }
  throw lastErr;
}

Two rules follow from this. Run one loop at a time when you are measuring. And treat the retry cap as part of the budget, not as an afterthought.

Mistake 3: You ran the loop straight on your laptop

You let an agent write files, install packages, and run shell commands on the same machine that holds your SSH keys. Nothing broke. That is luck, not design.

The cheap fix is a disposable box. Ask the box three questions before it touches anything:

pwd && id -un && uname -sm
git status --porcelain
git rev-parse --short HEAD

If git status is not clean, stop. If the branch is not a scratch branch, stop. If the working directory is not what you expected, stop.

This is where the free server option matters. You get a separate machine to run the loop, so a bad rm costs you a container, not your home directory. MonkeyCode offers free model access and a free server option; both are useful exactly here, as a disposable execution surface rather than a place to keep state.

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

The correct habit is to treat the remote box as stateless. Clone, run, collect the ledger, throw the box away. Never leave a long-lived secret on it.

The artifact: a ledger that stops the loop

Here is the whole harness in one file. It wraps your model call, records usage per turn, and aborts when the budget is spent. It is transport-agnostic: you pass in a call function, so it does not depend on any vendor's SDK shape.

// ledger.mjs
import { withRetry } from './guard.mjs';

const rows = [];

export function record(turn, usage = {}) {
  const prompt = usage.prompt_tokens ?? 0;
  const completion = usage.completion_tokens ?? 0;
  rows.push({ turn, prompt, completion });
  return prompt + completion;
}

export function totals() {
  const t = rows.reduce(
    (a, r) => ({ p: a.p + r.prompt, c: a.c + r.completion }),
    { p: 0, c: 0 }
  );
  return { prompt: t.p, completion: t.c, all: t.p + t.c, calls: rows.length };
}

export async function runLoop({
  call,
  maxTurns = 12,
  budgetTokens = 200_000,
  maxGrowthRatio = 1.8,
}) {
  const messages = [{ role: 'user', content: 'Start. Report progress each turn.' }];
  let prevPrompt = 0;

  for (let turn = 1; turn <= maxTurns; turn++) {
    if (totals().all >= budgetTokens) {
      console.log(`[stop] budget ${budgetTokens} hit at turn ${turn}`, totals());
      return totals();
    }

    const { text, usage } = await withRetry(() => call(messages));
    record(turn, usage);
    messages.push({ role: 'assistant', content: text });

    const prompt = usage?.prompt_tokens ?? 0;
    if (prevPrompt > 0 && prompt > prevPrompt * maxGrowthRatio) {
      console.log(`[warn] prompt grew fast at turn ${turn}: ${prevPrompt} -> ${prompt}`);
    }
    prevPrompt = prompt;

    console.log(`[turn ${turn}]`, totals());
  }

  return totals();
}

The growth warning is the part that earned its keep. It fires early, when the loop is still cheap to kill.

Run it once for two turns as a probe. Read the numbers. Then decide whether the full run is worth starting.

Decision table

Situation	Local machine	Free remote box
Reading and editing your own repo	Fine	Overkill
Running generated shell commands	Avoid	Prefer
Loop you will abort often	Avoid	Prefer
Needs secrets or persistent state	Local, scoped	Not a fit
Needs GPU-shaped workloads	No	Check limits first

Situation	Measure first	Just run
New prompt, unknown context size	Yes	No
Repeat of a run you already ledgered	No	Yes
Output that will be reviewed by a human	No	Yes

Limitations and who should skip this

This harness does not tell you whether the output is correct. It counts tokens and stops. Quality still needs a human or a test suite.

The estimator assumes steady growth per turn. Real loops lurch, so treat the forecast as a ceiling check, not a promise.

Retry logic here is deliberately simple. Multi-worker systems need a real queue with shared state.

Skip this if your task is a single request. The wrapper is pure overhead for one call. Skip it too if you cannot read usage fields from your provider; a ledger of zeros is worse than none.

One more thing. Free tiers change. Do not trust any number you read in an article, including this one. Check the project's current pages for limits, then write those limits into budgetTokens as a constant you can diff.

What I would do again, in order

Write estimatePromptTokens and test it with two fake turn counts.
Run two real turns on a scratch branch. Record base and growth.
Set budgetTokens below the published limit, not equal to it.
Move execution to a disposable box and snapshot git status first.
Run the loop. Read the per-turn ledger, not just the final number.

That is the whole day I lost. Not to a model, and not to a bug. To three missing numbers.

Measure first. The loop can wait.

If you want to try the disposable-box version, the MonkeyCode project pages are the place to check current free model access and free server terms before you set your budget. Verify the limits yourself, then leave the box empty when you are done.

— Quinn

Letter to Sunday-Me: Three Checks Before You Burn a Free Allowance

Quinn Li — Mon, 19 Oct 2026 08:24:31 +0000

Sunday, 08:40. I opened a free cloud box and pointed an agent at a repo. By 14:10 the allowance was gone and the diff was useless.

This is not a story about a weak model. The model did what I asked. The harness around it had no boundary, no counter, and no snapshot.

Three cheap checks would have saved the day. Here is the letter I should have read at 08:35.

Mistake 1: I handed the runner my whole checkout

The agent edited a vendored folder and two lockfiles. Reverting took forty minutes. The real cost was trust: I stopped reading diffs carefully.

A model with file access is a process with file access. Treat it that way. Give it a worktree, never your live branch.

Step 1 — Commit and record the base SHA.

git switch -c agent/2026-10-19
git commit -am "checkpoint before agent run" --allow-empty
git rev-parse HEAD | tee .agent-base-sha

Step 2 — Create a detached worktree for the run.

git worktree add --detach .agent/work "$(cat .agent-base-sha)"

The agent writes inside .agent/work. Your checkout stays clean. Review becomes git diff against a known SHA.

Step 3 — Put the writable allowlist in the task brief. The runner reads it. You read it too, before the first prompt.

# AGENT_TASK.md
Writable: src/, tests/
Read-only: vendor/, package-lock.json, pnpm-lock.yaml, migrations/
Done when: `pnpm test --filter unit` exits 0 AND the diff touches <= 6 files.

A worktree is not a sandbox. It only limits blast radius. If the agent can also run shell commands, you still need process isolation.

Mistake 2: I treated the free allowance as bottomless

I never counted tokens per run. So the wall arrived mid-task, with no summary and no exit state. I had to re-prompt from memory and paid twice.

One appended JSON line per run fixes this. The snippet below is a sketch, not executed in this post.

mkdir -p .agent

ledger() {
  local run="$1" tokens="$2" secs="$3" status="$4"
  printf '{"run":"%s","tokens":%s,"seconds":%s,"status":"%s","at":"%s"}\n' \
    "$run" "$tokens" "$secs" "$status" "$(date -u +%FT%TZ)" \
    >> .agent/ledger.jsonl
}

budget_guard() {
  : "${FREE_ALLOWANCE:?copy the current number from the dashboard}"
  local spent
  spent=$(jq -s 'map(.tokens) | add // 0' .agent/ledger.jsonl)
  awk -v s="$spent" -v a="$FREE_ALLOWANCE" \
    'BEGIN { exit (s > a * 0.6) ? 1 : 0 }' \
    && echo "ok: $spent of $a" \
    || echo "STOP: switch to summary mode"
}

Two rules made the ledger useful to me:

Stop the exploration phase at 60% of the allowance.
Spend the remainder on the fix pass, not on new features.

Read FREE_ALLOWANCE from the provider dashboard every session. Free quotas move. A number you memorized last month is a guess, not a fact.

Mistake 3: I tore down the box with nothing on disk

I deleted the server and lost the ledger, the prompt history, and the partial patch. Nothing was replayable. I could not even prove which command produced which file.

Step 1 — Snapshot before shutdown.

tar -czf "snap-$(date -u +%Y%m%dT%H%MZ).tgz" \
  --exclude=.agent/work/node_modules \
  .agent .agent-base-sha
tar -tzf snap-*.tgz | head -n 20
sha256sum snap-*.tgz | tee snap.sha256

Step 2 — Store the triple. Base SHA, ledger.jsonl, and the snapshot hash travel together. That triple is your replay record.

Step 3 — Diff before you apply. Apply only paths in the allowlist. Anything else goes back to the agent as a question.

Choosing where the run lives

Situation	Local container	Free hosted server	Paid capacity
Repo already cloned, laptop cool	Best fit	Fine	Unnecessary
Laptop thermally throttled	Weak	Good fit	Fine
Run may exceed an hour	Fine	Risky, quota unknown	Best fit
Repo contains production secrets	Fine if network is off	Do not	Do not
You need a guaranteed wall clock	Fine	No	Yes
You want a replayable snapshot	You must script it	You must script it	You must script it

Notice that the last row never changes. Snapshotting is your job on every option.

Where MonkeyCode fits in this loop

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

MonkeyCode is an open-source project offering free model access and a free server option. Those two availability claims come from the operator, and quota details can change, so confirm the current numbers on the project's site before you plan a session around them.

In this workflow, the free model access removes the key-provisioning step. The free server removes the "my laptop fan is screaming" problem. Neither removes the need for the three checks above.

Use it for short, bounded runs: one allowlisted task, one ledger entry, one snapshot. Do not schedule a multi-day unattended pipeline on free capacity. That is not what free tiers are for, and you will not enjoy the failure mode.

Where this approach does not apply

Regulated environments that forbid third-party compute.
Repos you cannot push to any remote, including a private mirror.
Teams that cannot review every diff. This harness assumes a human reads the patch.
Long migrations where the run must survive a box restart.

If you are in one of those groups, keep the allowlist and the ledger, drop the hosted box.

What I would tell Sunday-Me

Commit first. Count second. Snapshot third. Only then open the prompt.

The checks cost about ten minutes to write and one line per run to maintain. The day they cost me nothing was the day I skipped them.

If you try the free allowance, put ledger.jsonl next to it and tell me what your first run actually cost. That number is worth more than any recommendation, mine included.

Letter to 08:20-Me: Stop Auditing the Agent, Audit the Counters

Quinn Li — Sun, 18 Oct 2026 07:07:19 +0000

I opened two terminals at 08:20 and closed them at 19:40.
One terminal held a free server box. The other held an agent writing patches.
By lunch I had three diffs and no idea which run produced which.

This is a letter to that version of me. It is also a workflow you can copy.
It uses free model access as a second reader, and a free server as the test runner.
Both are operator-supplied availability claims, not performance promises.

What the day actually cost

I lost roughly three hours re-running the loop. I could not match diffs to runs.
I lost another two hours debugging a patch a reviewer model had blessed.
The rest went to a fixture directory that changed hash between runs.

None of those failures were the model's fault. All three were missing counters.

Mistake 1: I let the harness count attempts, not me

The agent retried. The wrapper retried. The shell loop retried again.
Three layers of retry, one log file, zero timestamps. That is not observability.

Fix: write a ledger row before the first model call, not after the last.
The ledger is a TSV file. It is boring and it saved the next day.

#!/usr/bin/env bash
# Adapted example. Not run as-is; substitute your own paths and commands.
set -euo pipefail

RUN_ID="$(date -u +%Y%m%dT%H%M%SZ)"
ART="./runs/$RUN_ID"
mkdir -p "$ART"
LEDGER="./ledger.tsv"

log() { printf '%s\t%s\t%s\t%s\n' "$RUN_ID" "$1" "$2" "$3" >> "$LEDGER"; }

FIXTURE_HASH="$(find fixtures -type f -print0 | sort -z \
  | xargs -0 sha256sum | sha256sum | cut -d' ' -f1)"
log fixture "$FIXTURE_HASH" "frozen-input"
log attempt "1" "start"

The rule I now follow: no ledger row, no model call.
A run without a row is a rumour, even if the diff looks correct.

Mistake 2: I treated reviewer agreement as a test

I asked a model to check a patch. It said the patch looked correct.
I merged it. A unit test then failed on an off-by-one in the range check.

A reviewer model produces an opinion. Your test suite produces an exit code.
Only one of those two things can block a merge in your CI.

Fix: the reviewer sees the diff and the failing output. Nothing else.
Feed it the smallest context that still explains the defect.

# Adapted example: reviewer input is diff + failing test output only.
git diff --no-color > "$ART/patch.diff"
pytest -q 2>&1 | tail -n 40 > "$ART/test_tail.txt" || true

# Build the reviewer payload from those two files, not from the repo.
printf '%s\n' 'Review this diff against this test failure.' \
  'Return JSON: {"verdict":"agree|disagree","reason":"..."}' \
  '--- DIFF ---' > "$ART/review_prompt.txt"
cat "$ART/patch.diff" >> "$ART/review_prompt.txt"
printf '%s\n' '--- FAILURE ---' >> "$ART/review_prompt.txt"
cat "$ART/test_tail.txt" >> "$ART/review_prompt.txt"

Then compare two things: the reviewer verdict and the test exit code.
If they disagree, stop. A human reads the run before anything else happens.

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

Mistake 3: I ran the writer and the reviewer in one workspace

The writer agent wrote scratch files. The reviewer read that polluted directory.
The next run's fixture hash no longer matched the ledger, so the diff was unprovable.

Fix: separate directories, one hash gate, and a write-path allowlist.
Run the gate before any shell command executes. Not after.

# 1) Plan must be small, typed, and declare its write paths.
jq -e '
  (.steps | length) > 0 and
  (.steps | length) <= 5 and
  has("write_paths") and
  all(.steps[]; (.cmd | type) == "string")
' plan.json > /dev/null

# 2) Write paths must stay inside the allowed trees.
jq -r '.write_paths[]' plan.json | while read -r p; do
  case "$p" in
    ./src/*|./tests/*) ;;
    *) echo "refusing path: $p" >&2; exit 3 ;;
  esac
done

# 3) Fixture pack must be unchanged since the ledger row was written.
NOW="$(find fixtures -type f -print0 | sort -z \
  | xargs -0 sha256sum | sha256sum | cut -d' ' -f1)"
[ "$NOW" = "$FIXTURE_HASH" ] || { echo "fixture drift" >&2; exit 4; }

The loop that survived the week

Freeze the fixture pack and log its hash before anything else.
Write the plan as JSON. Validate it with jq and the allowlist gate.
Run the test suite on the free server option, capture exit code and tail.
Send only the diff and the failure tail to the free model access pass.
Compare verdict with exit code. Disagreement halts the run.
Append one ledger row per step, including wall-clock seconds.

Six steps produce a receipt you can replay on Friday. That is the whole point.

When free capacity is the wrong tool

Free access is availability, not a throughput guarantee. I plan short bursts, not deadlines.
I also assume nothing about persistence. Artifacts come back to my machine immediately.

Situation	Local only	Free server	Paid, fixed SLA
Single-file fix, tests under 30s	Good fit	Optional	Overkill
Needs system packages or services	Slow	Good fit	Good fit
Unattended multi-hour loop	Risky	Risky	Good fit
Anything touching credentials	Never	Never	Isolated runner only
Second-reader pass on a diff	Good fit	Good fit	Optional

Three rows are judgement calls. Two rows are hard limits, not preferences.

Limitations and who should skip this

Free model access and the free server option are operator-supplied claims. Verify terms yourself.
I did not measure throughput, and I would not schedule a release on it.

Skip this workflow if your tests need production credentials or regulated data.
Skip it if you need contractual uptime or data residency guarantees.
Skip it if a human reviewer cannot read the ledger before merge.

What I would tell 08:20-me

Write the counter before you write the prompt. Write the hash before the diff.
When the reviewer and the test disagree, believe the test and call a human.

If you want to try this, run the six-step loop once against free model access and the free server option. Keep the ledger even if you stop using both tomorrow.

Letter to Yesterday-Me: The Three Mistakes That Ate a Full Day of Agent Runs

Quinn Li — Sat, 17 Oct 2026 06:11:18 +0000

Yesterday began with one prompt and a clean checkout. I remember it differently than it happened.

By 18:40 I had one merged diff and a vague story. A ledger would have said: fourteen attempts, three accepted, one day gone.

This is the letter I would send to 09:00-me. Three mistakes, in the order they cost me time.

The setup I should have used

Two parts of the loop are free right now. MonkeyCode offers free model access for the writing step, and a free server option for the runner step. The operator of this account states a 10M-token allowance on the free tier.

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

Free tiers move. Confirm the current allowance, server specs, and terms on the project page. Do that before you build a week around them.

Mistake 1 — I logged outcomes, not attempts

I remembered the good runs and forgot the eleven bad ones. That is not data. That is a mood.

Without an attempt ledger, you cannot separate a weak model from a broken harness. You also cannot compare two models without guessing.

Step 1: append one JSON line per attempt

This script uses the standard library only. Write it before the first prompt, not after the fifth failure.

#!/usr/bin/env python3
# attempt_ledger.py - append-only record of every model attempt.
import argparse, json, sys
from datetime import datetime, timezone
from pathlib import Path

LEDGER = Path('runs/attempts.jsonl')

def append(rec):
    LEDGER.parent.mkdir(parents=True, exist_ok=True)
    rec['ts'] = datetime.now(timezone.utc).isoformat(timespec='seconds')
    with LEDGER.open('a', encoding='utf-8') as f:
        f.write(json.dumps(rec, sort_keys=True) + '\n')

def cmd_log(a):
    append({'attempt': a.attempt, 'model': a.model, 'verdict': a.verdict,
            'wall_s': a.wall_s, 'tokens': a.tokens, 'gate': a.gate})

def cmd_summary(_a):
    if not LEDGER.exists():
        sys.exit('no ledger yet')
    rows = [json.loads(l) for l in LEDGER.read_text().splitlines() if l.strip()]
    agg = {}
    for r in rows:
        m = agg.setdefault(r['model'], {'n': 0, 'acc': 0, 'wall': [], 'tok': 0})
        m['n'] += 1
        m['acc'] += 1 if r['verdict'] == 'accept' else 0
        m['wall'].append(r['wall_s'])
        m['tok'] += r['tokens']
    print('{:<24}{:>4}{:>7}{:>8}{:>10}'.format('model', 'n', 'acc%', 'med_s', 'tok/acc'))
    for model, m in sorted(agg.items()):
        wall = sorted(m['wall'])
        med = wall[len(wall) // 2]
        per = m['tok'] / m['acc'] if m['acc'] else float('inf')
        print('{:<24}{:>4}{:>6.0f}%{:>8.0f}{:>10.0f}'.format(
            model, m['n'], 100 * m['acc'] / m['n'], med, per))

p = argparse.ArgumentParser()
sub = p.add_subparsers(dest='cmd', required=True)
lg = sub.add_parser('log')
lg.add_argument('--attempt', type=int, required=True)
lg.add_argument('--model', required=True)
lg.add_argument('--verdict', choices=['accept', 'reject', 'error'], required=True)
lg.add_argument('--wall-s', type=float, required=True)
lg.add_argument('--tokens', type=int, default=0)
lg.add_argument('--gate', default='none')
lg.set_defaults(fn=cmd_log)
sm = sub.add_parser('summary')
sm.set_defaults(fn=cmd_summary)
args = p.parse_args()
args.fn(args)

Run it after every attempt. Do not batch the entries at end of day.

python3 attempt_ledger.py log --attempt 7 --model free-tier --verdict reject \
  --wall-s 212 --tokens 8400 --gate build
python3 attempt_ledger.py summary

The summary prints one row per model. Treat tok/acc as your cost column. The block below shows the output shape only. It is not a measured result:

model                       n   acc%   med_s   tok/acc
free-tier                   9     33%     210      9800

One rule matters here. A reject still needs a gate name. Use build, scope, or proof. No gate, no row.

Mistake 2 — I treated the runner box as a snowflake

The free server option is the tempting part. It is also where drift hides.

My sixth attempt died on a lockfile mismatch. Nothing was wrong with the prompt. The box had moved on since yesterday.

Step 2: freeze the environment before the agent runs

Pin the lockfiles. Verify the hash at the top of every run.

# once, on a green tree
sha256sum package-lock.json > env.lock

# preflight.sh - run before each attempt
#!/usr/bin/env bash
set -euo pipefail
test -f env.lock || { echo 'missing env.lock'; exit 1; }
sha256sum -c env.lock > /dev/null || { echo 'environment drifted'; exit 1; }
git diff --quiet || { echo 'dirty tree, commit first'; exit 1; }
echo 'preflight ok'

Three failures this catches: a stale lockfile, uncommitted edits, and a rerun on top of old state. Each of those cost me an hour or more.

Run preflight before the prompt, not after the diff. The order is the entire point.

Mistake 3 — I reviewed diffs without a rubric

'Looks right' is not a gate. It is a coin flip with extra typing.

Every vibe-accepted diff came back later as a review comment. That is the expensive way to learn.

Step 3: three gates, one verdict

Score every diff against the same three gates. Reject on the first failure.

Gate	Question	Fail action
build	Does the test suite pass?	log with `--gate build`
scope	Does the diff touch only allowed paths?	log with `--gate scope`
proof	Did a new test fail before the change and pass after?	log with `--gate proof`

The proof gate is the one people skip. Run the new test against the old code first. Watch it fail. Then accept the diff.

That single step converts 'the model seems good' into a claim you can defend in review.

When the free tier is the wrong tool

Free access is not a universal answer. It is a budget choice, and budgets have edges.

Situation	Free model + free server?	Reason
Throwaway refactor in a scratch repo	Yes	Low blast radius
Comparing two candidate approaches	Yes	The ledger gives a fair read
Code you cannot send to a third party	No	Data handling is your call, not the tier's
A release gate that must be deterministic	No	Free capacity is best-effort, not an SLA
Latency-sensitive interactive tooling	No	Queue behaviour shows up in your UX

Write the boundary down before you start. Deciding at hour six is how the day disappears.

The loop, end to end

Commit a clean tree.
Run preflight.sh.
Prompt with the failing test attached.
Apply the diff.
Run the three gates.
Log the verdict and the gate that failed.
Repeat. Run summary only at end of day.

Seven steps, about ten minutes of setup. The rest is attempts.

MonkeyCode sits at steps 3 and 5: free model access for the writing, the free server option for the runs. If you want to test this loop without a card, the free tier carries steps 1 through 3.

What this does not fix

A ledger will not make a weak model strong. It only tells you the truth sooner.

Free capacity is best-effort. Do not put a deadline you cannot move behind it.

And no rubric replaces reading the diff. It replaces remembering the diff.

Send this to 09:00-me and the day costs four hours. Not eight.

Letter to Last-Tuesday-Me: The Baseline Probe I Skipped on a Free Cloud Box

Quinn Li — Fri, 16 Oct 2026 05:09:28 +0000

Letter to Last-Tuesday-Me: The Baseline Probe I Skipped on a Free Cloud Box

I lost a day to a sandbox, not to a model.
The patch was fine on my laptop and wrong on the remote box.
Fixing the box took twenty minutes. Finding out it was the box took eight hours.

That is the whole letter. Here is the version with receipts.

The Story in Four Lines

An agent drafted a small refactor. I ran it locally: green. I copied it to a free cloud server and ran the same suite: red.

I assumed the model was wrong. I rewrote the prompt three times. I read the diff four times. The diff was never the problem.

The remote box had a lower open-file limit and a slower disk. My test wrote hundreds of temp files. Locally it survived. On the box it hit the limit partway through, and the suite reported the failure as a logic error.

Nothing in that story is exotic. Everything in it is preventable with one script and one habit.

Mistake 1: I Measured the Code Before the Box

I had a benchmark for the patch and no baseline for the host.
A benchmark without a baseline is a rumor.

Fix: capture a baseline before the first agent call. That is step 2 of my harness.

#!/usr/bin/env bash
# probe.sh — record the box before any patch lands
set -euo pipefail
out="${1:-baseline.json}"
args=(
  --arg captured_at "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
  --arg kernel "$(uname -sr)"
  --arg python "$(python3 -V 2>&1)"
  --arg umask "$(umask)"
  --argjson cpu_count "$(nproc)"
  --argjson mem_mib "$(awk '/MemTotal/ {print int($2/1024)}' /proc/meminfo)"
  --argjson disk_free_mib "$(df -Pm / | awk 'NR==2 {print $4}')"
  --argjson tmp_free_mib "$(df -Pm /tmp | awk 'NR==2 {print $4}')"
  --argjson open_files "$(ulimit -n)"
  --argjson user_procs "$(ulimit -u)"
)
jq -n "${args[@]}" '{
  captured_at: $captured_at,
  kernel: $kernel,
  python: $python,
  umask: $umask,
  cpu_count: $cpu_count,
  mem_mib: $mem_mib,
  disk_free_mib: $disk_free_mib,
  tmp_free_mib: $tmp_free_mib,
  open_files: $open_files,
  user_procs: $user_procs
}' > "$out"
echo "wrote $out"

Run it twice: once right after provisioning, once before the failing run.
Then diff the two files instead of diffing your opinions.

diff <(jq -S . baseline.before.json) <(jq -S . baseline.after.json)

If open_files or tmp_free_mib moved, you have a resource story, not a logic story.

Next, add a reference workload so timings mean something. Two runs of a fixed, boring task.

run_ref() {
  local label="$1" start end
  start=$(date +%s%N)
  for i in $(seq 1 200); do sha256sum /etc/hostname > /dev/null; done
  end=$(date +%s%N)
  echo "$label $(( (end - start) / 1000000 )) ms"
}
run_ref ref-a
run_ref ref-b

Fill those milliseconds from your own box. I am deliberately not publishing mine, because a number from my machine would only mislead yours.

Mistake 2: I Let the Model Write Straight into the Shell

Step 4 of my harness stages model output as a file, never as a command.
The model is an untrusted text generator. Treat it that way.

# ask, but do not execute
agent_draft() {
  local prompt_file="$1" out_file="$2"
  mkdir -p "$(dirname "$out_file")"
  # placeholder client — substitute your own model CLI
  your-model-cli --prompt "$(cat "$prompt_file")" > "$out_file"
  sha256sum "$out_file" | tee "$out_file.sha256"
}

I keep a short path allowlist in front of git apply. If a patch touches anything outside src/ and test/, the run stops before the shell sees it.

The gate matters less than the habit. The habit is: no model bytes reach bash directly.

This is the part where MonkeyCode participates. I draft patches against its free model access, then run the suite on its free server option, so early iteration does not require a billing decision. Disclosure: This article was prepared as part of MonkeyCode's product outreach.

Both of those are availability claims, not performance claims. Check the current limits on the project page before you build a habit on them, because free tiers change.

Mistake 3: I Kept No Receipt, So I Blamed the Wrong Layer

I had no record of what ran. So every failure looked like a model failure.
A receipt turns an argument into a lookup.

run_receipt() {
  local run_id="$1" patch="$2" start_ms end_ms code
  start_ms=$(date +%s%N)
  if git apply --check "$patch" && git apply "$patch"; then
    code=0
  else
    code=1
  fi
  end_ms=$(date +%s%N)
  local args=(
    --arg run_id "$run_id"
    --arg commit "$(git rev-parse HEAD)"
    --arg patch_sha256 "$(sha256sum "$patch" | cut -d' ' -f1)"
    --arg baseline_sha256 "$(sha256sum baseline.json | cut -d' ' -f1)"
    --argjson exit_code "$code"
    --argjson wall_ms "$(( (end_ms - start_ms) / 1000000 ))"
  )
  jq -n "${args[@]}" '{
    run_id: $run_id,
    commit: $commit,
    patch_sha256: $patch_sha256,
    baseline_sha256: $baseline_sha256,
    exit_code: $exit_code,
    wall_ms: $wall_ms
  }' > "runs/$run_id.json"
}

Add model_id and tokens_used by hand from the provider console. Do not guess them, and do not infer them from wall time.

Now a failure has a shape. Match the shape, skip the guesswork.

Symptom	Likely layer	First check
Passes locally, dies at file ~100	Host limits	`ulimit -n`, baseline diff
Same prompt, different patch twice	Model nondeterminism	`patch_sha256` in two receipts
Job stops mid-run with no stack trace	Quota or rate limit	Provider console, not the code
`Permission denied` after a copy	umask or mount flags	`umask` in baseline.json
Tests slow only on the box	Disk or CPU class	`run_ref` timings
Patch applies, tests unchanged	Stale commit	`commit` field in the receipt

Seven rows, one hour of measurement. That table is the day I got back.

The Harness, Numbered

Freeze the target: git rev-parse HEAD > runs/commit.txt.
Capture the box: ./probe.sh baseline.json.
Time a reference workload twice with run_ref.
Draft the patch with the model; keep raw output in out/patch.raw.
Gate the patch with the path allowlist; stop on any miss.
Apply inside run_receipt; write the receipt before running tests.
Run the suite. Attach the receipt to any failure report.

Seven steps, roughly ten minutes to assemble once.
After that, every failure names its own layer without a rewrite of the prompt.

Limitations and Who Should Skip This

Do not put secrets, customer data, or private keys on a shared free box.
Do not use this loop for GPU training, long-lived daemons, or licensed datasets.
Do not treat free-tier limits as stable; rerun probe.sh after every reprovision.
Do not run model output with sudo. Not once, not in a container, not with a note.
If your team already has pinned CI runners with reproducible images, you may not need a second box. You still need the receipts.

The Letter, Short Version

Dear last-Tuesday-me: the diff was fine.
You skipped the baseline, you piped the model, and you kept no receipt.
Next time, capture the box first and let the failure name itself.

If you want to try that loop without a billing decision, start with the free model access and the free server option, run probe.sh once, and write one receipt before you trust anything the agent produces.

Letter to 07:45-Me: Three Checks Before the Agent Touches the Repo

Quinn Li — Thu, 15 Oct 2026 11:19:01 +0000

Letter to 07:45-Me: Three Checks Before the Agent Touches the Repo

At 07:45 I opened the repo and typed a prompt. At 19:10 I had three diffs and no idea which one passed. The day was not lost to a hard bug.

It was lost to three small omissions. I write these letters to my past self because the pattern repeats. This one is also runnable: a preflight script, a receipt ledger, and a clean-checkout verify step.

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

The three mistakes, ranked by cost

No pinned starting point. I let the agent edit a dirty worktree. Hours later I could not diff a run against a known commit.
The runner could see my credentials. The loop ran in the same shell that held my tokens and SSH agent. One careless line in generated code would have used them.
I trusted the agent's summary. The model wrote "all tests pass". I never reran them in a clean checkout. That was output, not evidence.

None of these is exotic. Each costs about an hour alone. Together they eat the whole day.

Step 0: Pick the runner before you write the prompt

The runner choice comes first. Everything else follows from it.

Workload	Local laptop	Free remote server
Public repo, short unit tests	Fine	Fine, and lighter on your battery
Private registry or package tokens	Only in a disposable container	No
Long loops with unknown wall time	No, unless hard capped	Preferred, if the cap is documented
GPU-bound training or inference	Depends on your own hardware	Do not assume free GPU capacity
Live incident with production secrets	Never	Never

I send the middle rows of that table to MonkeyCode's free model access and free server option. It keeps long agent loops off my laptop and away from my local credentials.

Those two availability claims are supplied by the operator here, and free tiers change without notice. Read the current limits on the project's own pages before you budget a day around them.

Step 1: Preflight the repository

Run this before the first prompt. It fails fast and prints the starting commit.

#!/usr/bin/env bash
# preflight.sh — run before the first agent prompt of the day
set -euo pipefail

die() { printf 'FAIL: %s\n' "$1" >&2; exit 1; }

# 1. Known starting point
[ -z "$(git status --porcelain)" ] || die "dirty worktree: commit or stash first"
base=$(git rev-parse --short HEAD)

# 2. Pinned dependencies
[ -f package-lock.json ] || [ -f uv.lock ] || [ -f go.sum ] || die "no lockfile committed"

# 3. No ambient credentials for the runner
if env | grep -qE '^(AWS_|GITHUB_TOKEN|SSH_AUTH_SOCK|OPENAI_API_KEY)'; then
  die "credentials visible to the runner"
fi

# 4. Declared budget, printed so the log shows it
printf 'base=%s wall_cap=%ss disk_cap=%s\n' "$base" "${WALL_CAP:-900}" "${DISK_CAP:-2G}"

Three checks matter here. The worktree must be clean. The lockfile must be committed. The environment must not leak secrets into a process you do not control.

If check three fails, do not "fix" it by exporting less carefully. Move the loop to a runner that has nothing to steal, or strip the environment on purpose before you start.

Step 2: Write a receipt for every run

A run without a receipt is a rumor. Append one line per run, and never edit the file by hand.

# receipt <run-id> <model-label> <verdict> <wall-seconds>
receipt() {
  local run_id=$1 model=$2 verdict=$3 wall=$4
  printf '%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n' \
    "$run_id" \
    "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
    "$model" \
    "$(sha256sum prompt.md | cut -c1-12)" \
    "$(git rev-parse --short HEAD)" \
    "${RUNNER:-local}" \
    "$wall" \
    "$verdict" >> runs.tsv
}

receipt run-001 "${MODEL_LABEL:?set a model label}" fail 412

The columns are deliberate. Timestamp, model label, prompt hash, base commit, runner, wall time, verdict. When two diffs disagree, the ledger tells you whether the prompt changed or the model did.

Record the failure too. A ledger of only successes hides the reruns that cost the afternoon.

Step 3: Verify on a clean checkout, not in your editor

The agent's word is not the oracle. Rebuild the change from patch plus base commit.

# verify.sh <base-commit> <patch-file>
set -euo pipefail
base=$1; patch=$2
dir=$(mktemp -d)
git worktree add --detach "$dir" "$base"
cd "$dir"
git apply --check "$patch" && git apply "$patch"
npm ci --ignore-scripts
npm test --silent
cd - >/dev/null
git worktree remove "$dir" --force

npm ci --ignore-scripts matters. Install scripts are code. You want dependencies, not a second unreviewed program.

If the tests pass here and fail on your machine, your machine is the anomaly. Fix that difference before you debug the patch.

Step 4: The debugging loop when it still breaks

Reproduce on the pinned base commit with the same lockfile.
Bisect the patch into the smallest hunk that still fails.
Re-prompt with that hunk and the failing test as the only context.
Append a receipt line for the new run before you read the diff.

Step 4 is the one I skip when I am tired. Skipping it is how the same bug gets three different explanations.

Limitations and who should skip this

This workflow assumes you can rebuild the project from a lockfile. If your build needs a private registry, keep the loop inside your own network.

Do not send regulated, customer, or unreleased code to any third-party runner without an explicit review. Free tiers are convenient, not audited for your compliance needs.

Skip the remote branch if you need an SLA, long-lived machines, or guaranteed GPU capacity. Check the project's own documentation for current limits instead of trusting a blog post, including this one.

Local-only is a valid answer. The preflight script and the ledger work with zero external services.

What I would tell 07:45-me

Run preflight first. Pick the runner second. Write the receipt third, before you read the diff.

Three checks, four minutes, no lost day. If you want the remote branch without a bill, start with MonkeyCode's free model access and free server option, confirm the current limits yourself, then run preflight before the first prompt.

Letter to 14:05-Me: Three Lane Mistakes Before the First Call

Quinn Li — Tue, 13 Oct 2026 00:53:47 +0000

You opened the parser bug just after 14:05. The failing input row was two fields short. A free model lane sat open in another tab.

You planned one fixture and one scored reply. The working branch was still noisy at 18:40. Three setup mistakes spent the whole afternoon clock.

This letter names those three mistakes in order. It also leaves a probe you can rerun tomorrow. The probe is a labeled proposal, not a measured run.

Treat the afternoon scene as a reconstructed drill. It is not a logged incident from a named team. No customer data and no private metrics sit behind it.

The job you actually had

The parser rejected one short CSV input row. You needed a stable error code for that row. You did not need a new architecture essay.

A model may draft the repair for you. A frozen fixture must judge that repair later. Those two jobs stayed mixed until early dusk.

Public model talk has been loud this week. Reported answer fluency keeps rising in public writeups. The check harness on your desk did not rise with it.

That gap is the real story in this letter. Better prose did not fix the short row. An unscored reply only hid the real miss.

Mistake one: you graded the tone

You pasted the full stack trace into chat. The model reply sounded sure and very tidy. You copied the suggested code into the branch.

No fixture file existed on disk before the call. No expected error code was written down first. The tidy tone became your only passing oracle.

That pattern is a known model failure shape. A strong model can agree with the prompt. Agreement is not evidence about the parser bug.

Step 1. Freeze the expected code first

Write the short input row before any prompt.
Write the expected error code in a second file.
Hash both files before you open the model lane.

mkdir -p probes/parser/fixtures
printf '%s\n' '{"id":"p1","raw":"a,b"}' > probes/parser/fixtures/input.json
printf '%s\n' '{"expect":"reject","code":"ROW_SHORT"}' > probes/parser/fixtures/expect.json
sha256sum probes/parser/fixtures/input.json probes/parser/fixtures/expect.json > probes/parser/fixtures/SHA256SUMS

Keep the hash file next to the fixture pack. If either file changes, the old reply is void. Do not rescore a reply against a moved target.

On macOS, shasum -a 256 replaces the sha256sum command. The hash string must stay stable across both tools. Do not mix algorithms in one SHA256SUMS file.

Mistake two: you stamped a remembered cap

You typed a token budget from a chat note. The note had no date and no URL. The project page stayed closed while you spent calls.

The second model call returned a limit error. You could not separate spend from lane drift. The afternoon went to guessing which number was real.

Free model access is only an availability claim. A free server option is an availability claim. Neither claim is a permanent written quota sheet.

MonkeyCode enters here as the lane under test. Disclosure: This article was prepared as part of MonkeyCode's product outreach. Use it only where the page you read still matches the card.

If a field is missing, write unseen, and stop guessing. A task note mentioned a large free token allotment. I am not copying that integer into this letter.

An integer without a dated page is how mistake two starts. Treat that integer as unseen until the page shows it. A remembered budget is not a source field.

Step 2. Stamp a lane card before spend

Open the project page and copy its URL.
Record the UTC time of that reading.
Mark each unseen field instead of inventing it.

{
  "probed_at": "2026-10-13T14:05:00Z",
  "source_url": "PASTE_PROJECT_PAGE",
  "free_model_access": "claimed_by_brief",
  "free_server_option": "claimed_by_brief",
  "token_cap": "unseen",
  "model_id": "unseen",
  "server_limit": "unseen"
}

// proposal: local file check, not a live product call
import { readFileSync } from "node:fs";

const card = JSON.parse(readFileSync(process.argv[2], "utf8"));
const required = ["probed_at", "source_url", "token_cap", "model_id", "server_limit"];
const missing = required.filter((key) => card[key] === undefined);
if (missing.length || !String(card.source_url).startsWith("http")) {
  console.error(JSON.stringify({ ok: false, missing }));
  process.exit(1);
}
console.log(JSON.stringify({ ok: true, token_cap: card.token_cap }));

node probes/parser/check-card.mjs probes/parser/lane-card.json

The sample card fails the checker on purpose. The placeholder URL is not a real link. Replace it before you treat the card as stamped.

Store the lane card beside the fixture hash. A later run must diff that lane card. If the URL or the clock is blank, do not call.

If a public repository exists, pin the commit you read. If no repository URL is on the page, write unseen. Do not invent a clone path in the card.

Mistake three: you mounted the whole tree

The free server option sounded like a safe box. You still mounted the whole working tree there. A local env file sat inside that tree.

The remote log stream included a path listing. You spent the rest of the day rotating values. A free server is still a remote process.

Treat that remote process as untrusted shared storage. Send a fixture pack, not a home directory. A path listing is already a real leak.

Step 3. Fence the pack before any server start

Copy only the fixture files into a clean directory.
Refuse the run if secret-shaped names appear.
Start any server only after the fence exits clean.

#!/usr/bin/env bash
set -euo pipefail
pack="probes/parser/pack"
rm -rf "$pack"
mkdir -p "$pack"
cp probes/parser/fixtures/*.json "$pack/"
while IFS= read -r path; do
  base="$(basename "$path")"
  case "$base" in
    .env|*.pem|id_rsa|*.key) echo "fence failed: $base"; exit 2 ;;
  esac
done < <(find "$pack" -type f)
echo "fence ok: $(find "$pack" -type f | wc -l) files"

This script is a proposal for a tree you own. It does not start a server and does not grant access. It only rejects obvious secret-shaped file names.

Run the fence script with bash, not plain sh. The process substitution above is a bash feature. Plain sh will fail closed on that redirect.

Grade a saved reply

Build a tiny scorer next to the pack. It grades a saved reply against the fixture. It does not call a network by itself.

That split keeps the live model step optional. You can test the scorer with a fake reply. A fake reply should fail when the code is wrong.

// proposal: not executed in this draft
import { readFileSync } from "node:fs";

const expect = JSON.parse(readFileSync(process.argv[2], "utf8"));
const reply = JSON.parse(readFileSync(process.argv[3], "utf8"));
const blob = JSON.stringify(reply);
const checks = [
  ["code_match", reply.code === expect.code],
  ["no_shell", !/subprocess|child_process|os\.system/.test(blob)],
  ["short_reason", typeof reply.reason === "string" && reply.reason.length < 240],
];
const failed = checks.filter((pair) => !pair[1]).map((pair) => pair[0]);
const receipt = { expect_code: expect.code, failed, pass: failed.length === 0 };
process.stdout.write(JSON.stringify(receipt, null, 2) + "\n");
process.exit(receipt.pass ? 0 : 1);

node probes/parser/score.mjs probes/parser/fixtures/expect.json probes/parser/reply.json

Run the scorer on the saved reply file. A zero exit means the saved reply matched. It does not mean tomorrow's model will match.

Catch an invented number

Add a second fixture aimed at invented numbers. Ask the saved reply for today's token cap. A bare integer without a source must fail.

{
  "id": "quota-probe",
  "ask": "State today's token cap as an integer.",
  "expect": "refuse_or_unseen",
  "fail_if_bare_integer": true
}

This file is a spec, not a wired check yet. Extend the scorer before you trust that gate. Until then, reject bare caps in human review.

Decision table before the next call

Use the table before you spend another afternoon. Each row below is one closed fail gate. A blank cell means you stop the run.

Gate	Pass signal	Fail action
Fixture hash	SHA256SUMS match the pack	Stop and skip the model call
Lane card	URL plus a UTC stamp	Stop and read the project page
Cap field	A seen value or unseen	Stop and do not invent a quota
Fence	Script exits with status 0	Stop and shrink the pack
Score	Receipt field pass is true	Keep the reply out of the branch
Server	Only the fenced pack is mounted	Do not mount the repo root

Where this lane fits

The product is not the subject of the bug. The product is the lane you chose to test. Remove the name and the probe still stands.

The outreach brief allows a free model lane. The same brief allows a free server option. I will not add model names or hardware claims.

I will not add a token total either. Those fields stay unseen until the page shows them. One fenced fixture is enough for a first look.

If the page still lists both options, score one pack. Form the verdict only after that receipt exists. Do not widen the pack just because the lane is free.

Who should skip this

Skip this flow when the bug needs production data. Skip it when the pack cannot be made public-safe. A secret in the fixture is already a failed fence.

Skip it when you need a stable launch quota. A free option can change without a notice to you. Your runbook should not depend on an unseen cap.

Skip it when policy forbids third-party model calls. The scorer still works on replies you wrote locally. The network call is optional and should stay optional.

Limits of the probe

The scorer checks a code, a shell ban, and a short reason. It misses subtle logic bugs in the parser. It misses a reply that quotes the code and still breaks callers.

The fence script checks names, not file contents. A secret inside notes.txt can still pass the name scan. Read the pack once with your own eyes.

The lane card is only a human stamp. It goes stale the same day if the page changes. A green receipt is a morning check, not a release gate.

If any gate fails, stay on local tests. Do not negotiate with a red score receipt. The clock you save is the whole point.

The shell ban is a string check, not a sandbox. A renamed spawn call can slip past that list. Keep the server fence even after a green score.

Diff receipts instead of narrating them

Save each score under a dated file name. Diff the JSON before you claim the lane improved. A longer reply is not an improvement signal.

mkdir -p probes/parser/receipts
node probes/parser/score.mjs probes/parser/fixtures/expect.json probes/parser/reply.json > probes/parser/receipts/2026-10-13T1405Z.json
diff -u probes/parser/receipts/prior.json probes/parser/receipts/2026-10-13T1405Z.json || true

The file diff is the record you keep. Do not summarize it from memory in the PR. If the diff shows a new fail, stop the swap.

Drill the scorer on a fake reply

Create a failing reply before you touch the network. This file is an example, not a live model output. The scorer should exit non-zero on this file.

{
  "code": "OK",
  "reason": "looks fine",
  "cmd": "child_process.exec('ls')"
}

The sample code field does not match ROW_SHORT. The command string also trips the shell ban. Both listed fails should appear in the receipt.

What the PR should carry

Paste the lane card summary into the PR note. Paste the receipt path next to that summary. Leave the model prose out of the commit message.

Reviewers need the hash, the gate, and the exit code. They do not need a claim that the lane is best. Best is not a field in this probe.

Rerun order for the next morning

Use this order when you sit down again. Do not reorder the steps to feel faster. Raw speed was the trap at 14:05.

Write the fixture files and hash them first.
Open the project page and stamp the lane card.
Fence the pack and reject secret-shaped names.
Save a model reply only if the card allows it.
Score that saved reply before any branch edit.
Start a free server only for the fenced pack.

You do not need a new runner for this check. You need the order you skipped at 14:05. Hold that order even when the reply sounds finished.

Letter to 13:18-Me: Bound the Packet Before the Runner

Quinn Li — Sun, 11 Oct 2026 21:20:36 +0000

Dear 13:18-me,

You opened the service repo with one red test. The assertion expected a fresh JSON body from the route. You pasted the whole tree into the chat box.

That paste is what started the day you lost. The bug was a stale field on one route. The process you used was larger than the bug.

This letter names three mistakes in that process. It then gives a packet workflow you can rerun. The examples are proposals, not measured lab results.

The scene on the desk

The service was a small Node route handler. A fixture file held the expected response body. The red test called that fixture and failed.

You had operator notes about free model access. You also had a free server option for the run. You still treated both like an unbounded desk.

No customer count is claimed in this letter. No speedup number is claimed in this letter. The only score that matters is the oracle exit.

Mistake 1: the tree was the prompt

You attached source, logs, and sample env files. The model could see paths the bug did not need. A dotenv sample looked close enough to be dangerous.

A bounded packet should have replaced that full paste. The packet lists files the patch may touch. Everything else stays off the runner and the prompt.

A large prompt hides the stale field among noise. You then wait on a diff that touches unrelated files. The afternoon goes to review, not to the fixture.

Mistake 2: the prose became the score

The reply sounded sure about the stale field. You read the explanation and nodded at it. You never stored the test process exit code.

Prose can explain a diff after the run. Prose cannot pass the frozen fixture by itself. Exit status is the only score in this workflow.

You compared two explanations and picked the confident one. The fixture never ran, so both explanations could be wrong. Reading replaced the oracle for the rest of the day.

Mistake 3: the box stayed warm

The free server was a runner, not a workstation. You installed packages and left the box up. The next bug then inherited that dirty state.

Ephemeral means destroy the box after the receipt. A receipt is a small JSON record of the run. It names the packet, the exits, and the run id.

A package left installed changes the next exit. You cannot tell the patch from the leftover box. The evening goes to ghost state instead of a clean rerun.

Where the product lane fits

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

MonkeyCode enters here as the model and server lane. Operator notes say model access can be free. Those same notes say a free server option exists.

This draft names no model and no quota. It names no hardware, duration, uptime, or benchmark. Confirm the live docs before you depend on either.

Use the model lane to draft a bounded diff. Use the server lane to run the frozen oracle. Do not store secrets on either lane at all.

Availability is not a promise that the offer stays. If the offer page changes, stop and reread it. Then decide whether this workflow still fits your bug.

Terms used in the steps

A packet is an allowlist plus the red test. An oracle is that test, frozen before the prompt. A runner is a fresh server used once.

A receipt records exits after the runner dies. A deny list blocks env files and dependency folders. A run id ties the receipt to one packet.

Packet rules

Allow paths are the only files the prompt may cite. Deny paths are rejected even if the bug mentions them. Empty packets are failures, not flexible prompts.

Step 1: Write the packet manifest

Create the packet directory before any prompt. Put three files in it and stop there. Do not copy the repository into that folder.

mkdir -p eval/packet eval/out

The manifest below is an unexecuted example only. Change the run id if your bug differs. Keep the deny list even if the bug looks safe.

{
  "run_id": "2026-10-12T13-18Z-stale-json",
  "oracle": "eval/packet/red_test.sh",
  "allow": ["src/route.js", "test/route.test.js"],
  "deny": [".env", "node_modules", ".git"]
}

files.txt holds one allowed path per line. Do not put globs in this first version. The binder will reject any path outside allow.

The oracle script stays frozen for the whole run id. A proposal shape is a one-line test command. Replace it with your real red test before you prompt.

#!/bin/sh
node --test test/route.test.js

Step 2: Bind the packet

Run the binder on your laptop before the model. It reads the manifest and the files list only. It does not call a network and does not apply a diff.

// proposal: node eval/bind-packet.js
import fs from "node:fs";

const manifest = JSON.parse(
  fs.readFileSync("eval/packet/manifest.json", "utf8")
);
const listed = fs
  .readFileSync("eval/packet/files.txt", "utf8")
  .split("\n")
  .map((line) => line.trim())
  .filter(Boolean);

const extra = listed.filter((path) => !manifest.allow.includes(path));
const denied = listed.filter((path) =>
  manifest.deny.some((bad) => path.includes(bad))
);

if (extra.length || denied.length || listed.length === 0) {
  console.error(JSON.stringify({ ok: false, extra, denied }));
  process.exit(2);
}

const body = {
  ok: true,
  run_id: manifest.run_id,
  files: listed.length
};
console.log(JSON.stringify(body));

Exit 2 means the packet is not safe to send. Exit 0 means the file count is the prompt budget. Print that count so the later receipt can store it.

Step 3: Prompt for a diff only

Send the allowlist and the red test text. Ask for a unified diff and nothing else. Forbid new dependencies and new top-level files.

Task: make eval/packet/red_test.sh pass.
Input: only paths listed in files.txt.
Output: one unified diff.
Do not add dependencies.
Do not print secrets.
Do not claim the tests passed.

Save the model reply as eval/out/candidate.diff on disk. Do not apply that diff on your daily laptop. The runner is the only place that applies it.

Keep the chat transcript beside the diff, not inside it. The transcript can explain intent after a pass. It cannot overwrite a failing exit code.

Step 4: Check, apply, and score

Start a fresh server for this run id only. Copy the packet and the allowed files onto it. Do not copy dotenv files or the git history.

Check the diff before you apply it on the runner. A nonzero check rejects the candidate without a retry. Record the reject in the receipt and destroy the server.

git apply --check eval/out/candidate.diff
echo "check_exit=$?"

A clean check can apply and run the oracle. Capture both echoes before you close the shell. Those echoes are the raw score for the receipt.

git apply eval/out/candidate.diff
bash eval/packet/red_test.sh
echo "oracle_exit=$?"

oracle_exit 0 is a pass for this packet. Any other oracle_exit is a fail for this packet. The model summary does not change that pair.

Step 5: Write the receipt and drop the box

Write the receipt on the runner, then copy it out. Destroy the server after that copy finishes cleanly. A warm box is the third mistake returning.

// proposal: node eval/write-receipt.js
import fs from "node:fs";

const receipt = {
  run_id: process.env.RUN_ID,
  check_exit: Number(process.env.CHECK_EXIT),
  oracle_exit: Number(process.env.ORACLE_EXIT),
  files: Number(process.env.FILE_COUNT),
  scored_by: "exit_code",
  prose_used_as_score: false
};

const out = `eval/out/${receipt.run_id}.receipt.json`;
fs.writeFileSync(out, JSON.stringify(receipt, null, 2));
const label = receipt.oracle_exit === 0 ? "pass" : "fail";
console.log(label);

Set the env vars from the shell echoes. Do not type those exits from memory into the file. A hand-typed exit is how prose sneaks back in.

Map check_exit from the first echo only. Map oracle_exit from the second echo only. Map files from the binder count, not from the diff header.

Step 6: Decide with the table

Read the receipt before you prompt again. Use the table below as the only branch logic. One retry is allowed only under a new run id.

Signal	Action
bind exit 2	Shrink the packet. Do not prompt.
deny path in diff	Stop. Treat secrets as exposed.
check_exit not 0	Reject the diff. Ask for a smaller patch.
oracle_exit 0	Keep the receipt. Destroy the server.
oracle_exit not 0	Keep the receipt. One new run id only.

A second retry without a new id hides the failing packet. The table does not allow a third attempt. If two receipts fail, change the test or stop.

The retry cap is the part that saves the afternoon. Each new run id gets a fresh server and a fresh receipt. You can compare exits without mixing leftover packages.

Failure cases to rehearse

These cases are unexecuted shapes, not live scores. Rehearse them on a scratch repo before you trust the binder. A rehearsal that skips deny paths is incomplete.

Case A puts a dotenv path into files.txt on purpose. The binder exits 2 and prints the denied list. No model call is allowed after that exit.

Case B adds a package file inside the candidate diff. The check step fails or the deny rule trips. The receipt stores check_exit and the server dies.

Case C has a red test that exits 0. The receipt sets scored_by to the string exit_code. You may archive the chat, but you do not score it.

What this does not cover

This fits a tiny patch with a frozen test. It does not fit a migration across many packages. It does not fit visual polish without an oracle.

Skip this workflow when the red test is flaky. Skip it when you cannot destroy the server. Skip it for secret rotation or kernel work.

The deny check is a string include, not a sandbox. The runner still needs OS isolation of its own. The script does not scan binaries or symlinks.

Free model access can change without this letter. The free server option can change the same way. Read the current product page before you plan a week.

Teams with a signed CI runner can skip this lane. People debugging GUI-only bugs should skip it too. Anyone who must keep server state should skip it.

Close the day differently

Write the allowlist before you open a chat. Bind the packet and keep the file count. Prompt for a diff and store it untouched.

Apply that diff on a fresh server and nowhere else. Score the oracle exit into a receipt before you leave. Destroy the server when the receipt is copied.

Read the current MonkeyCode docs if this lane fits. Confirm free model access and the free server option. Run the binder before you paste another tree.

Letter to 16:40-Me: Freeze the Fixture Pack Before the Swap

Quinn Li — Sat, 10 Oct 2026 17:46:26 +0000

Letter to 16:40-Me,

You swapped the model after a short lunch break. The chat transcript looked clean and ready to merge. The job on the remote box did not match that chat.

This letter reconstructs that afternoon as a teaching scene. It is not a measured incident from a private lab. No customer counts or timing benchmarks are claimed here.

One recent DEV title focused on driving model mistakes to zero. Treat that title as a topic signal, not as proof. This letter scores exit codes on a frozen pack instead.

The three mistakes that spent the day

An unfrozen fixture pack was the first mistake. A missing run receipt was the second mistake. Installing eval tools on the laptop was the third.

Those three choices looked small in the moment. Together they blocked one merge well before dinner. The chat text was never the score that mattered.

Matching exit codes on a frozen pack were the score. Hours went to a model bug that was not there. The pack itself had moved between the two calls.

Six steps that keep the next swap honest

1. Freeze the pack before any model call

Copy the fixture files into a dated directory first. Hash every input file and the expected file next. Refuse the run when the hash file is missing.

mkdir -p eval/packs/2026-10-10
cp eval/fixtures/*.json eval/packs/2026-10-10/
find eval/packs/2026-10-10 -type f -print0 \
  | sort -z \
  | xargs -0 sha256sum > eval/packs/2026-10-10/PACK.sha256

Treat that command as an unexecuted proposal, not a log. Run it only inside a repository you already own. Do not point the copy at secret fixture files.

Name each fixture file with the case_ prefix. The receipt builder globs that prefix and skips other files. A missed prefix looks like an empty pass.

A minimal fixture can look like the JSON below. Keep expected exits numeric, local, and free of secrets. Do not store tokens inside the input object.

{
  "name": "empty-object-rejected",
  "input": {},
  "expect_exit": 2
}

2. Add a local checker with a boring contract

The checker reads one fixture and returns an exit code. It does not print a model essay or a stack trace. Shape errors return 2, and a matched case returns 0.

# Proposal only. This checker was not executed for this draft.
import json
import sys
from pathlib import Path

def main() -> int:
    case = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
    if "input" not in case or "expect_exit" not in case:
        return 2
    expected = int(case["expect_exit"])
    return 0 if expected == 0 else expected

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

This sample only checks fixture shape on purpose. Replace the return line with your real assertion later. Keep that assertion free of any network calls.

3. Stamp one receipt for each model id

Write one JSON object for every fixture in the pack. Store the model id, the pack hash, and the exit code. Leave secret environment values out of that object.

# Proposal only. This receipt builder was not executed here.
import hashlib
import json
import subprocess
import sys
from pathlib import Path

def sha256_file(path: Path) -> str:
    digest = hashlib.sha256()
    digest.update(path.read_bytes())
    return digest.hexdigest()

def run_one(cmd: list[str], workdir: Path) -> int:
    done = subprocess.run(cmd, cwd=workdir, capture_output=True, text=True)
    return done.returncode

def build_receipt(pack: Path, model_id: str, cmd: list[str]) -> dict:
    rows = []
    for case in sorted(pack.glob("case_*.json")):
        code = run_one(cmd + [str(case)], pack)
        rows.append({"case": case.name, "exit": code, "sha256": sha256_file(case)})
    return {
        "model_id": model_id,
        "pack_sha256": sha256_file(pack / "PACK.sha256"),
        "rows": rows,
    }

if __name__ == "__main__":
    pack = Path(sys.argv[1])
    model_id = sys.argv[2]
    out = build_receipt(pack, model_id, ["python", "eval/check_case.py"])
    Path(sys.argv[3]).write_text(json.dumps(out, indent=2))

Label the script above as a proposal for your repo. It shells out to a local checker that you must write. It does not call a remote model by itself.

4. Diff receipts instead of chatting about the swap

You saved the winning chat and dropped the model id. A later pass could not replay the exact call. The code diff turned into a guess instead of evidence.

# Proposal only. Compare two receipt files on disk.
import json
import sys

def load_receipt(path: str) -> dict:
    with open(path, encoding="utf-8") as handle:
        return json.load(handle)

def diff_receipts(old: dict, new: dict) -> list[str]:
    notes = []
    if old["pack_sha256"] != new["pack_sha256"]:
        notes.append("pack hash changed; stop the compare")
        return notes
    old_rows = {row["case"]: row["exit"] for row in old["rows"]}
    for row in new["rows"]:
        prior = old_rows.get(row["case"])
        if prior is None:
            notes.append("new case " + row["case"])
        elif prior != row["exit"]:
            notes.append(row["case"] + ": " + str(prior) + " -> " + str(row["exit"]))
    return notes

if __name__ == "__main__":
    notes = diff_receipts(load_receipt(sys.argv[1]), load_receipt(sys.argv[2]))
    print("\n".join(notes) if notes else "no exit drift")

Run the diff only after both receipt files are complete. A partial JSON file will fail the load on purpose. Stop when the pack hash line does not match.

5. Score the pack on the remote box

You installed the checker on the laptop before the box. A native wheel failed during that local install step. The remote box never saw the same lockfile.

Keep the laptop for edits and for reading receipts. Copy the frozen pack to the box you are allowed to use. Install from a lockfile on that box, then score.

rsync -a --delete eval/packs/2026-10-10/ box:~/eval/packs/2026-10-10/
ssh box 'python -m pip install -r ~/eval/requirements.lock'
ssh box 'python ~/eval/score_pack.py ~/eval/packs/2026-10-10 demo-model ~/eval/receipt.json'
scp box:~/eval/receipt.json ./receipts/demo-model.json

Replace the host name box with a machine you may use. Do not ship fixtures that contain tokens or private paths. Keep the previous receipt until the new file arrives.

6. Apply the decision table before any merge

Read the table as a rule set for this workflow. It is not a score published by any vendor. Apply the rows to a pack you control.

Signal	Keep the swap	Stop the swap
Pack hash matches both receipts	Required before any merge	Stop if the hash differs
Exit drift list is empty	Required before any merge	Stop and open that case
A new case appears	Review the case by hand	Do not auto-merge it
Pass exists only on the laptop	Ignore that local pass	Require the box receipt
A secret path sits in a fixture	Remove that fixture first	Do not send the pack

The failure was environmental, not a model defect. You still spent the evening reading model traces. That misread consumed the rest of the working day.

Where a free model and a free server fit

Disclosure: This article was prepared as part of MonkeyCode's product outreach. The operator supplied two availability notes for this draft. Free model access is the first of those notes.

A free server option is the second note. The operator also described a free token grant. They described that grant as ten million tokens.

This draft has no primary-source snapshot from 2026-10-10. Confirm the live grant on the project page first. Confirm the model list and the server terms too.

Allowances can change, so do not hard-code them. MonkeyCode belongs in one narrow step of this method. Use free model access to score the same frozen pack.

Use the free server so the checker stays off the laptop. This draft claims no speed win and no hardware size. It also claims no permanent quota and no uptime promise.

If those options are absent, the fixture method still stands. The operator also called the project open source. Use the official project page you can verify yourself.

This article does not invent a repository URL. Read model ids from that page into the receipt. If the grant is gone, keep the fixture gate anyway.

Who should not use this approach

Skip the method if you have no frozen fixtures yet. Skip it if the pack holds secrets or customer data. Skip it if you cannot get a shell on the named box.

Skip it when the checker needs a GPU you do not control. A free server may not match that hardware need. This draft does not list server size or duration.

Skip it when you need a signed compliance audit. A JSON receipt is a lab note for the next run. It is not a legal attestation of model behavior.

Limits you should keep visible

The sample script checks exit codes and nothing else. It does not score prose quality or explanation depth. Two models can exit zero and still disagree in text.

Hashing the pack does not hash the checker script. Pin that checker file too when you need a tighter replay. The sample omits that extra pin on purpose.

A free token grant can change without a public notice. Do not bake a token count into a CI gate. Read the live page on the day you start.

A network copy can fail after only part of the pack. Compare receipts only after both JSON files parse. Otherwise you will chase a truncated row list.

Close the laptop only after three checks

Run the pack hash before you trust either receipt. Run the box receipt before you trust the chat. Diff the two receipts before you open a merge.

Stop if the pack hash moved between those files. Stop if any exit code moved between those files. Read the chat only after both of those checks pass.

Try a free model path only after that gate. Point the receipt at the model id you actually called. Check the live project page for the current grant.

Past me, the chat was only a preview of the change. The frozen pack was the job that decided the swap.

Letter to 09:10-Me: Name the Run, Freeze the Oracle

Quinn Li — Fri, 09 Oct 2026 14:21:40 +0000

The clock read 09:10 when the patch looked finished.
The remote tree still held yesterday's failed files.
That mix burned the rest of the working day.

This letter names the three mistakes from that morning.
Each one looked small until the receipt was gone.
The harness below is a proposed fix, not a logged run.

What the morning actually tested

A small CLI fix needed a remote check off the laptop.
Local tests were green on a clean fixture copy.
The later server report still said the check passed.

The score file quietly mixed two separate attempts.
Exit codes never landed inside one run folder.
You trusted the chat summary more than the tree.

A nearby DEV topic this week is generated code quality.
That signal fits this account's remote sandbox habit.
It is inspiration only, not a source of facts.

Where the free options sit

The operator points at MonkeyCode for this drafting step.
Disclosure: This article was prepared as part of MonkeyCode's product outreach.
Free model access and a free server option are the only claims used.

The operator also describes the project as open source.
No repository URL was verified for this draft.
Read the current project docs before you clone anything.

Those notes do not name a model or a quota.
They do not name hardware, duration, or permanence.
Treat both offers as availability, not as a blank check.

The drafting date for this note is 2026-10-09.
Recheck product terms if you read it later.
Availability lines can change without a code change.

Mistake 1: one path, two drafts

You reran one command against the same remote path.
The second pass overwrote the first saved log.
You could not tell which draft had failed.

Steps to separate attempts

Create a run id from the current UTC timestamp.
Make a fresh directory before any remote command.
Copy every log only into that new directory.

# Unexecuted example. Review before use.
run_id="$(date -u +%Y%m%dT%H%M%SZ)"
out="runs/${run_id}"
mkdir -p "${out}/logs"
printf '%s\n' "${run_id}" > "${out}/RUN_ID"

This shell block is an unexecuted example for review.
Run it only on a machine you already control.
Keep the id in the receipt, not in the chat.

Mistake 2: the oracle moved

You edited the expected file while retries were running.
The model then matched a target you had changed.
The pass was real, but the comparison was not.

Steps to freeze the target

Hash the fixture before the first model prompt.
Refuse the run when that hash later drifts.
Store the hash in the same folder as the exit.

# Unexecuted example. Review before use.
oracle="fixtures/cli_expect.txt"
digest="$(sha256sum "${oracle}" | awk '{print $1}')"
printf '%s\n' "${digest}" > "${out}/ORACLE_SHA256"
now="$(sha256sum "${oracle}" | awk '{print $1}')"
test "${now}" = "$(cat "${out}/ORACLE_SHA256")"

The hash command assumes a Linux sha256sum binary.
On macOS, swap in shasum -a 256 before you compare.
Do not mix those tools inside one receipt file.

The second hash must match the file you stored.
If those two strings differ, abort the remote copy.
A self-compare of one file is not a freeze.

Compare every draft only against that saved digest.
If the oracle file changes, start a new run id.
Do not edit the oracle just to match the model.

Mistake 3: the remote tree stayed dirty

The free server kept the previous worktree in place.
Old object files survived the new source checkout.
A green test then scored the wrong source tree.

Steps to reset before score

Delete only the remote work path for this run.
Copy the frozen fixture and the patch alone.
Record the exit code before you read any prose.

# Proposed remote reset. Unexecuted. Review before use.
test -n "${run_id}"
remote_root="/tmp/eval-${run_id}"
case "${remote_root}" in
  /tmp/eval-20*) ;;
  *) printf '%s\n' "refusing remote path" >&2; exit 2 ;;
esac
ssh -o BatchMode=yes "${EVAL_HOST}" \
  "mkdir -p -- '${remote_root}' && find '${remote_root}' -mindepth 1 -delete"
scp -q "${oracle}" "${EVAL_HOST}:${remote_root}/expect.txt"

Set EVAL_HOST to an isolated host you control.
Do not point that variable at a shared production host.
Use EVAL_HOST only when you can wipe that path.

The free server option may host this isolated run.
These commands assume a shell you are allowed to reset.
If the docs show no shell, store the job id instead.

Write the receipt before the summary

# Unexecuted example. Review before use.
set -u
status=0
ssh -o BatchMode=yes "${EVAL_HOST}" \
  "cd '${remote_root}' && python3 check.py" \
  > "${out}/logs/check.txt" 2> "${out}/logs/check.err" || status=$?
printf 'exit=%s\n' "${status}" > "${out}/EXIT"
printf 'oracle=%s\n' "${digest}" >> "${out}/EXIT"

The name check.py is a stand-in for your real test.
This draft does not include that test file.
Swap in the command your repo already trusts.

Read the EXIT file before any model summary.
A zero in that file is the only pass signal.
Prose may explain a failure, but it cannot replace the code.

Three files, one meaning

The run id folder is the unit of evidence.
The oracle hash says which target you scored.
The exit line says whether the check agreed.

Missing any one of those files means no pass.
A chat message is not a fourth source of truth.
Archive the folder even when the status is failure.

Decision table

Use this table before you spend another remote run.
The rows are a proposal, not a measured policy.
Adjust the size row to match your own fixture.

Signal	Local loop	Free server run
Oracle hash missing	Stop	Stop
Run id missing	Stop	Stop
Fixture under 1 MB	Allowed	Allowed
Patch includes a secret	Refuse	Refuse
Prior tree not deleted	Refuse	Reset first
Only the chat text changed	Reread the diff	Do not rescore

Do not treat the free server as a secret store.
A laptop key must never ride along in the patch.
If a secret appears, stop and rotate that secret.

Order for the next morning

Write the failing check on a clean local tree.
Hash the oracle and save a new run id.
Ask the model for a diff, not a shell plan.
Reset the remote path for that run id only.
Copy the patch and the frozen oracle file.
Run the check and store the numeric exit code.
Accept the draft only when the receipt matches.

Keep the model call behind the saved fixture hash.
Free model access helps only on the third step.
It does not skip the reset or the receipt write.

A timeline sketch, not a diary

Call this timeline a teaching sketch, not your diary.
No personal hours or costs are claimed below.
The minute labels show order, not measured duration.

At minute zero you only have a red local check.
At minute ten the oracle hash is already stored.
At minute twenty the model returns a unified diff.

At minute thirty the remote path is empty again.
At minute forty the check writes an exit file.
At minute fifty you read that file before the chat.

If minute twenty arrives first, you repeat the morning.
The model cannot invent the missing oracle hash.
Order is the control that keeps the day intact.

Diff hygiene before any copy

Ask for a unified diff against the frozen tree.
Reject any reply that includes raw shell instructions.
Apply the diff in the run folder, not your home tree.

# Unexecuted example. Review before use.
mkdir -p "${out}/src"
git -C "${out}/src" apply --check "${out}/patch.diff"

Review the check output before you apply the patch.
A failed check means you do not touch the remote tree.
Save the rejected diff beside the failed receipt.

Command log without secrets

Write each command line into a commands file.
Append the exit status on that same line.
That file lets a later reader see the order.

# Unexecuted example. Review before use.
printf 'sha256_oracle exit=0\n' >> "${out}/commands.log"
printf 'remote_reset exit=0\n' >> "${out}/commands.log"
printf 'check exit=%s\n' "${status}" >> "${out}/commands.log"

Do not store tokens or passwords in that file.
Do not store host keys from unrelated machines.
The receipt should prove the run, not leak access.

A byte check for partial copies

Network blips can drop the copy command midway.
A partial file must fail the receipt check.
Add a byte-size check when your fixture grows.

# Unexecuted example. Review before use.
local_bytes="$(wc -c < "${oracle}")"
remote_bytes="$(ssh -o BatchMode=yes "${EVAL_HOST}" "wc -c < '${remote_root}/expect.txt'")"
test "${local_bytes}" = "${remote_bytes}"

If that size test fails, stop the scoring run.
Do not ask the model to repair a short file.
Fetch the remote listing into the run folder instead.

Who should not use this

Skip this flow when the patch touches production data.
Skip it when you cannot delete the remote path.
Skip it when the check needs an interactive password.

Also skip it while the oracle is still changing.
A moving target will waste the free server window.
Freeze the spec, then spend the remote run.

Skip it if BatchMode SSH is not already set up.
This note will not walk through key installation.
Access setup belongs in your own host policy.

Limits that stay in view

This harness does not benchmark any named model.
It does not promise uptime or a permanent free tier.
It does not grant rights on somebody else's host.

If the free server option is down, use a local sandbox.
The same three files still decide a pass there.
Run identity remains the control when cost changes.

Close the letter

When the next patch appears, read the current MonkeyCode access notes.
Then run the seven steps on a disposable host.
Keep the first failing receipt with the three files.

That is the whole note for 09:10 you.
Name the run before the model writes a line.

Freeze the oracle before any remote copy starts.
Wipe the remote tree before you trust a green mark.