DEV Community: Morgan Xu

A Handoff Contract for a Shared AI Bench

Morgan Xu — Tue, 27 Oct 2026 13:29:15 +0000

Most handoffs lose evidence, not enthusiasm. A shift ends, someone types "almost done", and the next person rebuilds context from chat scrollback. The fix is a contract, not a template.

This post gives one small contract you can paste into a team wiki. It covers three roles, two enforced transitions, and a validator that refuses handoffs with missing artifacts. The code is a reference sketch, not a battle-tested tool. Run it on a throwaway repo before you trust it.

Three roles, three artifacts

The dispatcher owns the queue. That role decides what enters the bench and what waits outside it. A dispatcher who also builds is a dispatcher who quietly reorders the queue.

The runner owns the diff. This person runs the model, saves the output, and records the command that produced it. The artifact here is a path plus a log, not a summary.

The checker owns the verdict. This person reads the diff against the stated goal and writes pass or fail. A checker who rewrites the code has become a second runner, and the review is gone.

Three roles, three artifacts. Goal, diff, verdict. Everything else is commentary.

Because capacity is shared, the shift boundary matters more than the shift length. A free bench is not a fixed server. Latency moves, queues move, and a runner who was fast at 09:00 may crawl at 17:00. Contracts survive that variance. Verbal notes do not.

This bench runs on MonkeyCode, which the operator describes as offering free model access and a free server option. Disclosure: This article was prepared as part of MonkeyCode's product outreach. Treat both claims as starting assumptions and check the current limits on the site yourself before you plan a shift around them.

The task record

One JSON file per task. No database, no schema migration, no service to keep alive. The record is the handoff.

{
  "id": "T-014",
  "state": "queued",
  "goal": "Add retry with backoff to the ingest client",
  "owner": "morgan",
  "deadline": "2026-10-28T10:00:00Z",
  "diff_path": null,
  "run_log": null,
  "reviewer": null,
  "verdict": null,
  "trail": []
}

Five fields matter at the start. Goal, owner, deadline, state, trail. The rest stay null until someone earns them.

The validator

#!/usr/bin/env python3
# handoff.py — untested reference sketch, Python 3.11
# Enforces a three-role handoff contract on a JSON task record.
import json
import pathlib
import sys

FIELDS = {
    "queued": {"goal", "owner", "deadline"},
    "built": {"goal", "owner", "deadline", "diff_path", "run_log"},
    "checked": {"goal", "owner", "deadline", "diff_path", "run_log",
                "reviewer", "verdict"},
}
ORDER = ["queued", "built", "checked"]


def advance(path: str, target: str) -> str:
    rec = json.loads(pathlib.Path(path).read_text())
    current = rec.get("state", "queued")
    if target not in ORDER:
        return f"refused: unknown state {target}"
    if ORDER.index(target) != ORDER.index(current) + 1:
        return f"refused: {current} -> {target} is not a legal step"
    missing = FIELDS[target] - {k for k, v in rec.items() if v}
    if missing:
        return f"refused: missing {sorted(missing)}"
    if target == "checked" and rec["verdict"] not in {"pass", "fail"}:
        return "refused: verdict must be pass or fail"
    rec["state"] = target
    rec.setdefault("trail", []).append({"to": target, "by": rec["owner"]})
    pathlib.Path(path).write_text(json.dumps(rec, indent=2))
    return f"ok: {path} is now {target}"


if __name__ == "__main__":
    print(advance(sys.argv[1], sys.argv[2]))

Run it like this.

python handoff.py tasks/T-014.json built
# refused: missing ['diff_path', 'run_log']

python handoff.py tasks/T-014.json checked
# refused: queued -> checked is not a legal step

The first refusal is the useful one. It tells the runner that a status is not an artifact. The second one keeps a tired person from marking work as reviewed by a reviewer who never existed.

Fill the fields, then rerun. The record moves forward exactly once per command, which makes the trailing trail readable in a diff.

jq -r '.state, (.trail | length)' tasks/T-014.json
# built
# 1

When the transition stalls

A contract is only useful if the failure path is boring. Use a table, not a meeting.

Condition	Action	Owner	Timebox
Missing diff or log	Return to runner, keep state	Checker	15 min
Log present, goal ambiguous	Rewrite goal, restart from queued	Dispatcher	20 min
Verdict fail, cause unclear	Freeze task, open a probe task	Dispatcher	30 min
Bench unresponsive	Park task, note timestamp, rotate	Runner	10 min

Every row ends with a person and a clock. Rows without a clock become opinions.

The fourth row deserves a note. Free capacity is shared capacity, so unresponsiveness is a normal event, not an incident. Park the task with a timestamp and let the next shift decide. Do not sit and retry for an hour while the queue backs up.

The one-page run

Paste this into the wiki above the table.

BENCH RUN — SHARED FREE TIER
1. Dispatcher opens the shift: list queued tasks with owner and deadline.
2. Runner builds one task at a time. Save diff path and command log.
3. Runner advances to built. Refusal means the artifact is missing.
4. Checker reviews against the goal. Write pass or fail, then advance.
5. On shift end: park open tasks, note the time, hand the queue over.

Five lines, one owner per line. A new teammate can follow it without asking which channel to use.

Limits worth stating

The validator checks presence, not truth. A runner can paste a log from a different task. Only the checker catches that, and only by reading.

The contract costs about two minutes per task. On a solo project that overhead is pure loss. Below roughly three people sharing a bench, skip the script and keep the five-line run.

This is not audit-grade provenance. If you need signed artifacts, use signed commits and CI attestations instead. Nothing here replaces a security review.

Free tier behavior changes. The script assumes nothing about quota, model names, or server lifetime, and neither should your plan.

Who should not use this

Solo developers. Teams with a single reviewer and no queue. Anyone whose tasks finish in one sitting, because a handoff that never happens needs no contract.

Use it when two or more people share one bench across shifts. Use it when the queue outlives the people in it. Use it when "where did we leave off" is a real question.

A small contract plus a boring script beats a long postmortem. Hand over artifacts, not adjectives. If you want a bench to test the run on, MonkeyCode offers free model access and a free server option, and the five-line run above is enough to try it for one shift.

Ship a Resume Bundle When the Free Lane Stalls

Morgan Xu — Mon, 26 Oct 2026 12:06:30 +0000

A stalled free session costs nothing when the next person resumes it in one command. It costs a full day when the next person needs a briefing first. The difference is a bundle, not a better document.

Free tiers stop mid-task for boring reasons. Context fills up. An allowance drains. A laptop sleeps at the wrong moment. The driver knows what was tried, what failed, and what comes next. Nobody else does.

Most teams patch this with prose. They write a handoff note and hope it survives contact with a fresh reader. Prose loses fidelity at every hop, and it cannot be executed. A checksummed tarball can.

This playbook defines three roles, one lane card, and two scripts. Paste it into the team wiki and run it at the next stall. It assumes git, bash, and Node, and nothing else.

Three roles on one page

The driver owns the live session and stops at the first hard block. The driver does not quietly keep fixing things for another twenty minutes. That silent tail is exactly where handoffs rot.

The packager turns the stopped session into a tarball. This takes roughly four minutes and needs no model access at all. Any teammate who can run make can do it.

The reviewer replays the tarball on a second lane and reports pass or fail. The reviewer never reads the driver's chat log. The bundle is the entire message.

Commit before you pack anything

The bundle should carry the work, so commit to a scratch branch first.

git switch -c wip/session-2026-10-26-a
git add -A
git commit -m 'wip: stop point before handoff'

Scratch branches are cheap and disposable. Losing an hour of edits is not.

The packer

Save this as tools/lane-bundle.sh and make it executable.

#!/usr/bin/env bash
# tools/lane-bundle.sh - pack a stalled session into a resumable bundle
set -euo pipefail

SESSION_ID="${1:?usage: lane-bundle.sh <session-id>}"
OUT="bundles/${SESSION_ID}"
mkdir -p "$OUT"

git bundle create "$OUT/repo.bundle" --all
git log -1 --format='%H %ad %s' --date=iso > "$OUT/head.txt"
git status --porcelain > "$OUT/dirty.txt"

jq -n --arg sid "$SESSION_ID" \
      --arg head "$(cat "$OUT/head.txt")" \
      --arg node "$(node -v)" \
      '{session:$sid, head:$head, node:$node}' > "$OUT/env.json"

cp "${PROMPT_LOG:-.lane/prompts.jsonl}" "$OUT/prompts.jsonl" 2>/dev/null || true

( cd "$OUT" && sha256sum $(ls) > SHA256SUMS )
tar -czf "$OUT.tar.gz" -C bundles "$SESSION_ID"
echo "wrote $OUT.tar.gz"

Each file earns its place. repo.bundle carries real history, not a zip of files. head.txt pins the exact commit so the reviewer starts where the driver stopped. dirty.txt lists leftovers the driver forgot to commit. env.json records the runtime that produced the failure. prompts.jsonl preserves the exact asks, which matter when output looks wrong.

The checksum line is the load-bearing one. On macOS, swap in ( cd "$OUT" && shasum -a 256 $(ls) > SHA256SUMS ) and adjust the check later.

Run it once into a clean directory. Re-running into a dirty one will self-hash the old manifest.

chmod +x tools/lane-bundle.sh
tools/lane-bundle.sh 2026-10-26-a

The lane card

A bundle without context is a mystery. A five-field card fixes that, and it fits in a YAML file at the repo root.

# .lane/card.yaml
session: 2026-10-26-a
driver: priya
packager: sam
reviewer: jo
lane_in: free-models
lane_out: free-server
stopped_because: context exhausted at step 6 of 9
resume_with: make verify BUNDLE=bundles/2026-10-26-a.tar.gz
open_questions:
  - fail fast on 429, or retry with backoff
do_not_touch:
  - src/billing/**
  - migrations/**

The stopped_because line is the most valuable sentence in the whole file. "Context exhausted at step 6 of 9" tells the reviewer to start at step 6. "It got weird" tells them nothing and costs an hour.

The do_not_touch list prevents a well-meaning reviewer from rewriting billing while chasing a test failure.

The verify run

The reviewer runs one command. If it exits zero on a clean machine, the bundle is valid and the session is resumable.

#!/usr/bin/env bash
# tools/verify-bundle.sh - prove the bundle resumes on a clean machine
set -euo pipefail

TARBALL="${1:?usage: verify-bundle.sh bundles/<session>.tar.gz}"
WORK="$(mktemp -d)"
tar -xzf "$TARBALL" -C "$WORK"

cd "$WORK/$(basename "${TARBALL%.tar.gz}")"
sha256sum -c SHA256SUMS

git clone repo.bundle work
cd work
git checkout "$(cut -d' ' -f1 ../head.txt)"
npm ci --ignore-scripts
npm test

A failing checksum means the tarball was edited in transit. Stop and re-pack; do not debug around it.

A failing npm ci means the runtime drifted between the two lanes. Compare env.json against the reviewer's machine before touching code.

A failing npm test is the useful outcome. That is a real, reproducible failure the next person can attack with a fresh context window.

The handoff run, in prose

The driver hits a block, commits to wip/, and runs the packer. Nobody debates whether the block is worth a bundle; a stop is a stop, and the decision belongs to the packager. The packager fills the card, drops the tarball in bundles/, and posts one line in the channel with the path and the resume_with command. The reviewer pulls, runs verify-bundle.sh, and replies with a single word plus the exit code. If it fails at checksum, the packager re-packs from a clean directory. If it passes, the reviewer starts at the step named in the card and owns the session from there.

The driver is now free. That is the point. A stalled session stops being a hostage.

Why a second lane

Some stalls are allowance problems, not comprehension problems. The work is fine; the budget is not.

That is where a second lane earns its keep. MonkeyCode provides free model access and a free server option, which makes it a plausible second lane for replaying a bundle. The operator states a free allowance on the order of ten million tokens; confirm the current figure and terms at signup rather than trusting a blog post, including this one.

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

The bundle workflow benefits from that lane without depending on it. Because the reviewer resumes from a pinned commit and a checked runtime, a different model on a different box is a fair test. Model variance becomes signal instead of noise.

A cheap rehearsal costs little. Push the tarball to the free server, run verify-bundle.sh, and record the exit code next to the one from the original lane.

scp bundles/2026-10-26-a.tar.gz bench:~/bundles/
ssh bench 'cd ~ && bash verify-bundle.sh bundles/2026-10-26-a.tar.gz; echo exit=$?'

Two matching exit codes mean the failure is real and portable. Two different codes mean the lanes disagree, and the env.json diff is the first place to look.

What the bundle cannot carry

It cannot carry uncommitted file contents, only their names. Anything valuable must be committed to the scratch branch before packing.

It cannot carry secrets, and it should not try. Scrub .env files, tokens, and customer data before the tarball leaves a laptop. Treat every bundle as if it will be forwarded, because it will.

It cannot guarantee identical model output. Hosted models drift, and free tiers drift faster. The bundle pins code and runtime, never inference.

It cannot rescue a slow clone. Repos with large binaries or long histories make repo.bundle unwieldy. Above a few hundred megabytes, pack a shallow bundle and record the base commit instead.

Who should skip this

Solo developers should skip the roles and keep the packer. The tarball is still the fastest way to resume your own work tomorrow morning.

Teams working on regulated code should skip the second lane entirely. If code cannot leave a machine, the bundle stays local and the reviewer walks down the hall.

Teams without a test command should fix that first. A bundle proves resumability only when there is something deterministic to run at the end.

Start with one stall

Add the two scripts, add the card, and wait for the next block. One session is enough to learn whether the run fits your team.

The first bundle takes fifteen minutes. The second takes four. The one after an allowance runs dry takes none, because the answer already exists as a tarball with a checksum and a next command.

Measure Rework Before You Add a Teammate to the AI Bench

Morgan Xu — Tue, 20 Oct 2026 10:09:47 +0000

Free-model benches feel free until rework shows up. A two-person team absorbs sloppy output through slack. A third person turns that slack into a queue.

This playbook adds one measurement step before headcount. It runs for a single week on git history. The cost is a commit convention and a small script.

The bench this assumes

The setup is a shared repo, free model access for drafting, and the free server option for the test loop. Both availability claims here are operator-supplied, not benchmarks. Limits and hardware change without notice. Check the product page on the day you commit a team to them.

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

A bench is only shared if work is visible. Output that never lands in commits cannot be measured. So the first move is a naming convention, not a tool.

Step one: make AI work visible in git

Tag every assist-assisted commit with a scope. Use feat(ai):, fix(ai):, test(ai):, or refactor(ai):. Human-only work keeps its normal scope.

Rework gets its own prefixes. A correction inside the same day is fix(ai):. A rollback is revert:. Untagged fixups are invisible to every later measurement.

feat(ai): add pagination to invoice list
fix(ai): correct off-by-one in page cursor
test(ai): cover empty page boundary
revert: feat(ai): add pagination to invoice list

The convention only survives if review enforces it. A trailer does that cheaply. Require one sign-off line per AI-tagged commit in the pull request history.

# Fail the PR when AI-tagged commits arrive without a checker.
set -e
missing=$(git log --format=%B origin/main..HEAD \
  | awk 'BEGIN{RS=""} /commit|AI/ && !/Checked-by:/ {c++} END{print c+0}')
[ "$missing" -eq 0 ] || { echo "$missing AI commit(s) need Checked-by:"; exit 1; }

That gate is crude on purpose. It is readable in a code review and breaks loudly. Nobody needs a parser to trust it.

Step two: run the rework clock

The script below reads one week of history. It counts AI-tagged commits and the subset that were later corrected or reverted. It prints a share, not a verdict.

#!/usr/bin/env python3
# rework_clock.py - share of AI-tagged commits that needed correction in one week.
import datetime as dt
import re
import subprocess

WINDOW_DAYS = 7
AI_TAG = re.compile(r"^(feat|fix|refactor|test)\(ai\):|^ai:", re.I)
REWORK = re.compile(r"^fix\(ai\):|^revert:|^fixup!|^squash!", re.I)


def git(*args):
    out = subprocess.run(["git", *args], capture_output=True, text=True, check=True)
    return out.stdout


since = (dt.datetime.now(dt.timezone.utc) - dt.timedelta(days=WINDOW_DAYS)).isoformat()
rows = git("log", f"--since={since}", "--pretty=%H%x1f%s").splitlines()

ai_total = ai_rework = 0
for row in rows:
    sha, subject = row.split("\x1f", 1)
    if AI_TAG.search(subject):
        ai_total += 1
        if REWORK.search(subject):
            ai_rework += 1

share = "n/a" if ai_total == 0 else f"{ai_rework / ai_total:.0%}"
print(f"ai_commits={ai_total} rework_commits={ai_rework} rework_share={share}")

Run it on a Friday and append the result to the bench log. An illustrative output looks like this, not a measurement of any real bench:

$ python3 rework_clock.py
ai_commits=37 rework_commits=11 rework_share=30%

One number is noise. Four weekly numbers show a direction. Compare the same week against the previous one, never against a different project.

Sometimes the useful signal is smaller than rework. Count touched files per AI commit as a size proxy:

git log --since="7 days ago" --grep="(ai)" --numstat --pretty=format:%h \
  | awk 'NF==3 {f[prev]+=1} NF==1 {prev=$1} END {for (k in f) print k, f[k]}' | sort -k2 -nr | head

Wide commits and a high rework share usually travel together. Fix the brief before adding a person.

Step three: read the number together

The clock exists to support one decision. Use the share as a brake, not a scoreboard.

Rework share	Reading	Next move
Under 15%	The bench absorbs corrections fine	Add the third person and keep the convention
15% to 30%	The brief is thin, not the people	Rewrite the intake brief, re-measure one week
Over 30%	Review is the bottleneck	Freeze headcount, use the free server for the test loop only

Those cutoffs are starting points. A team of two with a shaky test suite will run hot. A team with strong CI will run cold.

The one-page run for the wiki

Paste this block into the team wiki and date it. Three roles, one week, one number.

BENCH REWORK CLOCK - week of YYYY-MM-DD

Roles
  Driver   drafts with the free model tier, tags every commit
  Checker  reviews AI-tagged commits, adds Checked-by: trailer
  Scribe   runs rework_clock.py Friday, posts the number

Monday    Driver confirms the commit convention in the repo README
Daily     Checker blocks untrailered AI commits at review
Friday    Scribe runs the clock, appends the row to the bench log
Friday    All three read the share, pick one next move from the table
Handoff   Scribe posts role names and the week number for the next run

Stop rule
  Two weeks above 30% pauses new bench members until the brief changes.

The handoff line matters more than the script. Rotating scribes keeps the number honest and stops one person from owning the narrative.

Where this breaks

Commit messages are self-reported. A team that squashes pull requests hides its rework history. Measure at the PR level instead, or accept a blind spot.

The clock counts corrections, not reading time. Review effort is the real cost and stays invisible here. Pair it with a simple timer if that cost matters.

Small samples mislead. Twenty commits in a week cannot separate a bad brief from a bad Tuesday. Run four weeks before you act on a percentage.

Skip this approach if you work alone. Skip it if your team has no commit convention and no appetite for one. Skip it if AI output is merged by a bot without human sign-off, because the trailer gate has nothing to check.

A closing note

Cheap drafting is easy to buy and hard to amortise. The rework clock is the cheapest way I know to ask whether the bench is paying for itself. If you want to test the setup described here, start with MonkeyCode's free model access and its free server option, and confirm the current limits on the product page before your first Monday.

An Intake Card for Free AI Coding Sessions

Morgan Xu — Mon, 19 Oct 2026 08:53:30 +0000

Most free AI bench failures are intake failures.

The model is rarely the first problem. Missing scope, missing owner, and missing handoff cause the rework. A short intake card fixes more than another model trial.

The current AI fatigue discussion often focuses on tool overload. The operational cause is simpler. Teams start sessions without a definition of done. They hand off a chat transcript instead of a reproducible state. A two-role SOP makes the bench boring, and boring is useful.

The bench, stated plainly

MonkeyCode is an open-source AI coding project with a free model allowance and a free server option. Disclosure: This article was prepared as part of MonkeyCode's product outreach. The operator states a 10 million-token free allowance. Treat that number as time-sensitive. Verify current terms and limits on the project page before a team depends on them.

The free server option matters for the SOP. It gives the team a shared sandbox without a local setup race. The SOP still applies if the team uses another bench. The artifact is portable.

Roles and handoffs

Two roles are enough for a small team. The Driver runs the session and keeps the run log. The Reviewer checks the diff, test output, and rollback path. A Maintainer owns credentials, bench configuration, and allowance tracking.

The handoff rule is strict. The Driver never asks for a review in chat alone. The Driver posts the run directory path and the acceptance command. The Reviewer never approves from a summary. The Reviewer runs the acceptance command and records the result.

The Maintainer does not review every change. The Maintainer audits the intake cards weekly. The audit checks missing owners, missing expiry dates, and stale branches. This keeps the bench from becoming a shared junk drawer.

The intake card

Paste this card into the team wiki. Keep it short enough to fill in two minutes. Every field has a job.

# Bench Intake Card

- Goal:
- Non-goal:
- Repo and commit:
- Branch:
- Driver:
- Reviewer:
- Expiry:
- Bench:
- Model or route:
- Token budget:
- Acceptance command:
- Rollback command:
- Data class:

The non-goal field prevents scope drift. The expiry field prevents abandoned branches. The data class field keeps secrets out of the bench. The acceptance command turns opinion into a runnable check.

A card without an acceptance command is not ready. A card without a reviewer is a solo experiment. A solo experiment belongs in a personal sandbox, not the team bench.

A reproducible intake script

The following script creates a run directory and a filled card. It uses bash, git, and GNU date. It refuses to overwrite an existing run. Run it from the repository root.

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

usage() {
  echo 'usage: bench-intake <slug> <driver> <reviewer> <acceptance-command>'
  exit 64
}

[ $# -eq 4 ] || usage

slug=$1
driver=$2
reviewer=$3
accept=$4
run_dir=bench-runs/$(date -u +%Y%m%dT%H%M%SZ)-$slug

[ -e $run_dir ] && { echo run exists: $run_dir >&2; exit 65; }
mkdir -p $run_dir

commit=$(git rev-parse --short HEAD)
branch=$(git branch --show-current)

cat > $run_dir/intake.md <<EOF
# Bench Intake Card

- Goal: TODO
- Non-goal: TODO
- Repo and commit: $(basename $PWD)@$commit
- Branch: $branch
- Driver: $driver
- Reviewer: $reviewer
- Expiry: $(date -u -d '+2 days' +%Y-%m-%d)
- Bench: free server sandbox
- Model or route: TODO
- Token budget: TODO
- Acceptance command: $accept
- Rollback command: git restore --source=$commit -- .
- Data class: public or synthetic
EOF

cat > $run_dir/runlog.md <<EOF
# Run Log

## Baseline
Command: $accept
Result: TODO

## Session notes
- Change:
- Evidence:
- Observed usage:

## Review
- Reviewer:
- Decision: pending
- Command output:
EOF

cat > $run_dir/handoff.md <<EOF
# Handoff

- Run directory: $run_dir
- Open question:
- Next action:
- Owner:
EOF

echo $run_dir

The script captures the commit before the session starts. That single line saves hours later. The rollback command uses the same commit. The reviewer can reproduce the baseline without guessing.

The script does not call a model. It does not consume tokens. It creates the paper trail around the session. That separation is deliberate.

The one-page run

The team pastes this sequence into the wiki. Keep it adjacent to the intake card.

# 1. Confirm a clean tree and create a branch.
git status --short
git switch -c bench/<slug>

# 2. Create the run card before touching code.
run_dir=$(./bench-intake <slug> <driver> <reviewer> 'npm test -- --runInBand')

# 3. Record the baseline.
npm test -- --runInBand | tee $run_dir/baseline.txt

# 4. Run the session in the free server sandbox.
# Keep prompts and diffs inside the run directory.

# 5. Reviewer reproduces the acceptance command.
git diff --stat
git diff
npm test -- --runInBand | tee $run_dir/review.txt

# 6. Close the card or expire it.

The baseline command is an example. Replace it with the repository's real check. The principle matters more than the tool. A review needs a before state and an after state.

The free server option changes the setup cost, not the review standard. A team should still pin the commit and run the acceptance check. A shared sandbox without a run card becomes an anonymous chat room.

The 10 million-token allowance is enough to encourage practice. It is not a reason to skip intake. Token budget belongs on the card because it makes waste visible. Record observed usage from the provider dashboard when available. Do not invent a number when the dashboard is silent.

Decision table

Change type	Reviewer	Handoff
Docs or comments	One reviewer	Run card only
Test-only change	One reviewer	Run card plus test output
App code, small diff	One reviewer	Run card plus rollback proof
Auth, billing, data migration	Two reviewers	Run card, rollback proof, Maintainer sign-off
Secrets or production data	Not on the free bench	Use the approved environment

The table is a floor, not a ceiling. A team can add stricter rules. It should not add softer ones without a written exception.

Limitations and fit

This SOP fits small teams with git discipline and a named reviewer. It fits prototypes, test repairs, documentation, and internal tools. It also fits training sessions because the run card makes the work inspectable.

It does not fit production hotfixes under time pressure. It does not fit regulated data without an approved environment. It does not fit teams that cannot name a reviewer. It does not replace code review, threat modeling, or least-privilege access.

The free allowance and free server are availability claims, not permanence claims. Terms can change. The team should verify them before making the bench part of a delivery process. The SOP survives a change in provider because the artifact is plain Markdown and shell.

Close

The useful response to AI fatigue is less ceremony around models and more ceremony around handoffs. A two-role intake card makes the bench legible. It gives the reviewer a command, the driver a boundary, and the Maintainer an audit trail. Teams that want a low-cost place to try the workflow can use MonkeyCode's free allowance and free server option as a sandbox. Check the current terms first.

A One-Page SOP for a Shared Free AI Bench

Morgan Xu — Sun, 18 Oct 2026 07:28:43 +0000

A shared free AI bench rarely dies from an empty allowance. It dies from an unowned next step.

The developer conversation this week mixed two moods. There is fatigue with AI tooling, and there is a sprint to ship open-source work. Both push teams toward the same move: pool a free tier, share it, and hope nobody hogs it. Hope is not a handoff.

MonkeyCode is an open-source coding agent project. The operator states that it offers free model access and a free server option. Treat both as availability, not as a contract.

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

The failure this SOP prevents

A free bench has no queue and no billing alarm. Two people start long runs, a third retries a failure, and the window closes mid-task. Nobody can say which run burned the last of it.

The fix is small and boring. Name three roles, write one card per run, and keep a local token ledger you control. The ledger is yours, so it survives quota changes and product changes.

Three roles, one handoff

The Bench Steward owns the budget line and the ledger file. This person approves a run before it starts and closes it after. The Steward does not write code during a shift.

The Runner owns a single run card at a time. One card equals one goal, one model, one output artifact. A second goal needs a second card, even when the first is nearly done.

The Reviewer owns the accept or reject call. This person reads the diff and the card, never the chat history. If the card cannot explain the change, the change is not ready.

Handoffs move in one direction. Runner hands a filled card to Reviewer. Reviewer hands a verdict to Steward. Steward writes the next slot. No role skips forward, and no role edits another role's section.

Artifact one: the token ledger

Put this file at bench/ledger.sh and keep the data in plain TSV. It reads the usage block from a saved response, so it never guesses.

#!/usr/bin/env bash
# bench/ledger.sh — count tokens per run card, refuse to start over budget
set -euo pipefail

BENCH_DIR="${BENCH_DIR:-bench}"
LEDGER="$BENCH_DIR/token-ledger.tsv"
BUDGET_FILE="$BENCH_DIR/budget.txt"

[[ -f "$BUDGET_FILE" ]] || { echo "missing $BUDGET_FILE" >&2; exit 2; }
BUDGET=$(tr -dc '0-9' < "$BUDGET_FILE")
[[ -n "$BUDGET" ]] || { echo "budget file has no number" >&2; exit 2; }

[[ -f "$LEDGER" ]] || printf 'run_id\towner\tmodel\ttokens\n' > "$LEDGER"

spent() { awk -F'\t' 'NR>1 {s+=$4} END {print s+0}' "$LEDGER"; }

check() {
  local now left
  now=$(spent)
  left=$(( BUDGET - now ))
  printf 'budget=%s spent=%s left=%s\n' "$BUDGET" "$now" "$left"
  (( left > 0 )) || { echo 'FENCE: no headroom left, stop' >&2; return 1; }
}

record() {
  local run_id="$1" owner="$2" model="$3" payload="$4" tokens
  tokens=$(jq -r '.usage.total_tokens // empty' "$payload")
  [[ -n "$tokens" ]] || { echo "no usage block in $payload" >&2; return 1; }
  printf '%s\t%s\t%s\t%s\n' "$run_id" "$owner" "$model" "$tokens" >> "$LEDGER"
  echo "recorded $tokens tokens for $run_id"
}

case "${1:-}" in
  check)  check ;;
  record) shift; record "$@" ;;
  *) echo 'usage: ledger.sh check | record <run_id> <owner> <model> <response.json>' >&2; exit 64 ;;
 esac

The run loop is three commands. Check headroom, do the work, then record.

mkdir -p bench
cat > bench/budget.txt <<'EOF'
400000
EOF

./bench/ledger.sh check
# ... run the agent, save the raw response ...
./bench/ledger.sh record r-2026-10-18-a morgan swe-review response.json

The number in budget.txt is your own planning line, not the provider's quota. Set it below whatever the project currently documents, and re-read that page before each planning cycle. Free quotas move.

Artifact two: the handoff card

Paste this block into the team wiki and copy it per run. The card is the artifact a reviewer reads.

### Run card r-2026-10-18-a
- Owner: morgan
- Slot: 09:00-11:00 UTC
- Goal (one sentence): add retry jitter to the fetch wrapper
- Model: as listed by the project today
- Files touched: src/fetch.ts, test/fetch.test.ts
- Test command: npm test -- fetch
- Ledger line: recorded, 8,412 tokens
- Open risk: jitter default may break timing test
- Reviewer verdict: pending

A card with a missing test command is a block. A card with no ledger line is a block. A card with two goals is split before review, not after.

Artifact three: a bench smoke test

The free server option deserves the same suspicion as any demo host. Four cheap checks answer the only question that matters: can the team rely on it for the next two hours?

#!/usr/bin/env bash
# bench/smoke.sh — cheap checks before a shift on the free server
set -euo pipefail
BASE="${BENCH_BASE_URL:?set BENCH_BASE_URL}"

probe() {
  local label="$1" want="$2" path="$3" ttl="$4" code
  code=$(curl -s -o /dev/null -w '%{http_code}' --max-time "$ttl" "$BASE$path" || true)
  if [[ "$code" == "$want" ]]; then
    printf '%-22s ok (%s)\n' "$label" "$code"
  else
    printf '%-22s FAIL (want %s, got %s)\n' "$label" "$want" "$code"
  fi
}

probe reachable     200 /healthz 5
probe unauth-reject 401 /v1/models 5
probe cold-start    200 /v1/models 30
probe metrics       200 /metrics 5

The paths above are placeholders. Swap in the endpoints the project documents, keep the timings, and log the output next to the card. A cold start above thirty seconds is a scheduling fact, not a bug report.

When to use the bench, and when not to

Situation	Shared free bench	Paid key
Exploratory refactor, reversible diff	Yes	Optional
Work with a hard deadline today	No	Yes
Any customer data in the prompt	No	Only with a reviewed path
Long batch generation	No	Yes

Limits worth stating plainly

The free allowance and the free server are operator statements, not service guarantees. Quotas, model lists, and uptime can change without notice, so re-read the project page before you plan a sprint. The ledger only counts what you save to disk; a run that skips the record step is invisible to the fence. The smoke test proves reachability, not output quality.

Skip this playbook if you are the only person using the bench. A solo user needs a budget note, not three roles. Skip it too if the work touches regulated data, because a shared free host is the wrong place for that conversation.

Start with the ledger. Run it for one week before you invite a second person onto the bench.

Rotate a Shared Free Allowance Without Losing Work

Morgan Xu — Sat, 17 Oct 2026 06:29:24 +0000

A shared free allowance rarely fails from capacity. It fails at handoff. Two people draw from one pool. Neither owns the last hour of it. Work stalls at the shift change, not at the hard limit.

That pattern repeats on every team that treats a free tier as infrastructure. The allowance is real. The coordination around it is missing. A one-page rotation card removes most of the friction.

The last hour carries the risk

Free tiers attract small, bursty jobs. A migration dry run. A batch of test generations. A refactor across four files. Each job is cheap in isolation. Together they drain the pool before the next person looks.

The usual fix is a shared spreadsheet. The spreadsheet is stale by noon. Nobody edits a row while a build is failing.

A ledger beats a spreadsheet because the gate runs in the same shell as the job. The check happens at claim time. The record is a side effect, not a chore.

Three roles on a four-hour rotation

The Budget Keeper owns the cap. Only the Keeper approves a job above the per-job ceiling. That authority travels with the shift, not with seniority.

The Bench Runner owns the queue. The Runner starts jobs, watches them, and cancels early when output quality drops. Early cancellation is the cheapest saving available.

The Handoff Clerk writes the card at shift end. The card is ten lines, not a report. It names what finished, what is running, and what remains.

One person may hold two roles on a small team. Nobody holds all three for more than one shift. The separation exists to make the transfer visible.

A ledger that runs locally

The script below stores spend in SQLite. It makes no network calls. Any team can rehearse it against a free tier without touching product APIs.

#!/usr/bin/env python3
"""ledger.py - local token bookkeeping. No network calls."""
import argparse, sqlite3, sys, time

DB = "allowance.db"
CAP = 10_000_000  # stated free allowance; confirm on the project site

def con():
    c = sqlite3.connect(DB)
    c.execute("""CREATE TABLE IF NOT EXISTS spend(
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        shift TEXT NOT NULL,
        job TEXT NOT NULL,
        tokens INTEGER NOT NULL,
        ts INTEGER NOT NULL)""")
    return c

def total(c):
    return c.execute("SELECT COALESCE(SUM(tokens),0) FROM spend").fetchone()[0]

def check(cost):
    with con() as c:
        used = total(c)
        return used + cost <= CAP, used

def record(shift, job, tokens):
    with con() as c:
        c.execute(
            "INSERT INTO spend(shift,job,tokens,ts) VALUES(?,?,?,?)",
            (shift, job, tokens, int(time.time())),
        )

def report():
    with con() as c:
        return c.execute(
            "SELECT shift, SUM(tokens) FROM spend GROUP BY shift"
        ).fetchall()

if __name__ == "__main__":
    p = argparse.ArgumentParser()
    sub = p.add_subparsers(dest="cmd", required=True)

    chk = sub.add_parser("check")
    chk.add_argument("--cost", type=int, required=True)

    rec = sub.add_parser("record")
    rec.add_argument("--shift", required=True)
    rec.add_argument("--job", required=True)
    rec.add_argument("--tokens", type=int, required=True)

    sub.add_parser("report")
    a = p.parse_args()

    if a.cmd == "check":
        ok, used = check(a.cost)
        print(f"used={used} cap={CAP} cost={a.cost} ok={ok}")
        sys.exit(0 if ok else 1)
    if a.cmd == "record":
        record(a.shift, a.job, a.tokens)
    if a.cmd == "report":
        for shift, tokens in report():
            print(f"{shift}\t{tokens}")

The constant CAP is bookkeeping, not enforcement. A team that edits the file can lie to itself. That is acceptable when the same team owns the pool.

Wire the gate into the job script first. Order matters more than elegance.

python3 ledger.py check --cost 4200 && ./run_job.sh

A failed check returns exit code 1. The shell stops. Nothing is spent.

python3 ledger.py check --cost 900000 || echo "escalate to keeper"
python3 ledger.py record --shift 06-10 --job job-42 --tokens 4180

Close the loop after each job. The record step is manual in this version. Automation can read usage from the job logs instead.

A nightly rollup keeps the wiki honest.

sqlite3 allowance.db \
  "SELECT shift, SUM(tokens) FROM spend GROUP BY shift ORDER BY 2 DESC;"

The decision table

The table below is the whole policy. Post it next to the rotation schedule.

Remaining allowance	Action	Owner
More than 3x job cost	Run immediately	Bench Runner
Between 1x and 3x job cost	Split in half, re-check after part one	Bench Runner
Less than job cost	Park the job, notify next shift	Budget Keeper
Less than job cost and urgent	Move to a paid path or reschedule	Budget Keeper

The split rule matters most. Halving a job usually reveals a cheaper prompt or a smaller batch. The information arrives before the allowance is gone.

The handoff card

Ten lines. Paste them into whatever wiki the team already reads.

SHIFT:      2026-10-17 06:00-10:00 UTC
KEEPER:     <name>
RUNNER:     <name>
SPENT:      <n> tokens this shift
REMAINING:  <n> tokens (source: ledger.py report)
RUNNING:    <job id, started, owner>
FINISHED:   <job id, quality note>
PARKED:     <job id, reason, next check>
RISK:       <one known unknown>
NEXT:       <one sentence, imperative>

The RISK line is not optional. It carries the thing the next shift would otherwise learn the hard way. A half-finished refactor. A test suite that only passes once. A queue that quietly grew.

Test the rotation before trusting it

Three checks take ten minutes. All of them run locally.

Simulate exhaustion by inserting a fake row, then confirm the gate closes.

sqlite3 allowance.db \
  "INSERT INTO spend(shift,job,tokens,ts) VALUES('test','burn',9999999,0);"
python3 ledger.py check --cost 4200; echo "exit=$?"
sqlite3 allowance.db "DELETE FROM spend WHERE job='burn';"

Expect exit=1. If the gate stays open, the cap or the SQL is wrong.

Kill a job mid-flight and confirm the ledger survives.

timeout 2 ./run_job.sh; python3 ledger.py report

Each row commits on its own. The report never shows a torn write.

Run two claims in the same second from two shells.

for i in 1 2; do python3 ledger.py check --cost 5000000 & done; wait

Both calls may pass. This version has no lock and no reservation. Two keepers writing at once will overrun the cap. Mitigate with a single writer, a flock wrapper, or by recording reservations before jobs instead of after.

That gap is the honest boundary of the artifact. Bookkeeping after the fact cannot throttle a provider.

Where MonkeyCode fits

The operator states two facts that matter here: free model access and a free server option. The same operator states a free allowance of roughly ten million tokens at the time of writing. Quotas, model lists, and server limits should be confirmed on the project site before planning around them. Assume nothing about permanence.

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

The rotation card is provider-agnostic. It matters more when the pool is finite and shared. A free tier is a reasonable place to rehearse the roles before a team commits budget to anything.

If the card fits a team's habits, the free tier is a low-cost place to try it once.

Limitations and who should skip this

Teams with committed paid spend do not need a rotation. Their provider meters usage for them. The card adds ceremony without savings.

Latency-sensitive work should skip free pools entirely. A queue that waits on a shared allowance is not a queue anyone can promise against.

Regulated data should not land on a free server without a reviewed retention policy. Nobody in this workflow can answer that question. The security owner must.

Single developers can replace the whole structure with one shell alias and a number in a notes file. Three roles for one person is theatre.

A free pool is a shared resource. The handoff, not the limit, is the design problem.

Run Free AI Tiers Through a Provenance Gate

Morgan Xu — Fri, 16 Oct 2026 05:31:41 +0000

Run Free AI Tiers Through a Provenance Gate

A free model tier is safe for bounded work. It is dangerous for unattributed work.

That distinction decides whether a team ships faster. Every free endpoint removes the invoice, and the invoice was the thing that made someone watch the clock.

The recent DEV debates about AI fatigue and shrinking software quality share one root cause. The tools improved faster than the paper trail did. A service can now hold a stated free allowance, a free server option, and no memory of what it generated last Tuesday.

This playbook fixes the memory problem. MonkeyCode appears here because its operator describes free model access and a free server option, plus a stated free allowance of 10 million tokens. Treat those as operator-supplied availability claims. They are not independently benchmarked here, and quotas change without notice.

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

The failure is memory, not money

A free tier fails in three quiet ways. The quota runs dry mid-afternoon. The model behind a name changes under you. A shared server naps between requests and returns a cold start.

None of those break CI. They break the story you need six weeks later.

So the rule is simple: no artifact enters a shared branch without a provenance line. The line costs eight seconds. The investigation it prevents costs an afternoon.

Four roles, three handoffs

A small team needs four names. One person requests the change. One runs the model. One verifies the result by hand. One owns the tier and the budget of attention around it.

Call them Requestor, Runner, Verifier, Steward. One engineer can hold two roles on a quiet day. The Verifier must never be the Runner.

Handoff one: Requestor writes the intent in plain text. Handoff two: Runner returns a diff plus a provenance block. Handoff three: Verifier reproduces one behavior without the model, then approves.

The Steward resolves conflicts. When two people drain the shared allowance in one morning, the Steward decides who keeps the free tier and who waits.

The tier gate

Not every change deserves the same scrutiny. Route work through a table before anyone opens an editor.

Change type	Free tier	Gate before merge
Docs, comments, typos	yes	CI only
Test scaffolding, fixtures	yes	Verifier runs the suite once
Refactor inside one module	yes	Diff read line by line
Auth, payments, migrations	no	Human author, standard review
Production data paths	no	Separate threat review

The table is the whole policy. Everything below is bookkeeping.

Stamp every diff

Add one script to the repository. It appends a machine-readable block to the pull request body after the last push.

#!/usr/bin/env bash
# scripts/ai_stamp.sh <pr-number>
# Appends an [ai-provenance] block to the PR body. Run after the final push.
set -euo pipefail

PR="${1:?usage: ai_stamp.sh <pr-number>}"
: "${ENDPOINT_HOST:?set ENDPOINT_HOST}"
: "${MODEL_ID:?set MODEL_ID}"
: "${RUNNER:?set RUNNER}"
: "${VERIFIER:?set VERIFIER}"

DIFF_SHA="$(git diff origin/main...HEAD | sha256sum | cut -c1-16)"
PROMPT_SHA="$(printf '%s' "${PROMPT_TEXT:-}" | sha256sum | cut -c1-16)"

printf '%s\n' \
  '[ai-provenance]' \
  'tier: free' \
  "endpoint: ${ENDPOINT_HOST}" \
  "model: ${MODEL_ID}" \
  "diff: sha256:${DIFF_SHA}" \
  "prompt: sha256:${PROMPT_SHA}" \
  "runner: ${RUNNER}" \
  "verified-by: ${VERIFIER}" \
  "verified-when: $(date -u +%Y-%m-%dT%H:%MZ)" \
  | gh pr comment "$PR" --body-file -

Run it with the environment exported first.

export ENDPOINT_HOST='free-endpoint.example'
export MODEL_ID='whatever-the-server-reports'
export RUNNER='@you' VERIFIER='@peer'
export PROMPT_TEXT='summarize the failing test and propose a fixture'
bash scripts/ai_stamp.sh 412

A diff hash plus a prompt hash gives you a replay anchor. When the model under that name changes, the old blocks still point at the old behavior.

Probe before you trust

Free servers sleep. Prove the endpoint is awake and consistent before a work block starts. The script below is a proposal, not a run I performed.

#!/usr/bin/env bash
# scripts/probe.sh — smoke test a free-tier endpoint. Proposal, not executed here.
# macOS note: date +%3N is GNU-only; use gdate or perl for milliseconds.
set -euo pipefail
: "${BASE_URL:?set BASE_URL}"

BODY='{"model":"'"${MODEL_ID:-server-default}"'","messages":[{"role":"user","content":"reply with the single word ok"}]}'

for i in 1 2 3; do
  start=$(date +%s%3N)
  code=$(curl -sS -o /tmp/probe.json -w '%{http_code}' \
    -H 'content-type: application/json' -d "$BODY" \
    "$BASE_URL/v1/chat/completions")
  end=$(date +%s%3N)
  printf 'attempt=%s http=%s ms=%s\n' "$i" "$code" "$((end - start))"
done

grep -q 'ok' /tmp/probe.json && echo 'content ok' || echo 'CONTENT DRIFT'

Three attempts expose cold starts. A content mismatch on the last line means the name you call is not the model you tested.

A one-page runbook for the wiki

Paste this block into the team wiki. Edit the names, keep the shape.

# Free-tier AI runbook (one page)

1. Requestor writes intent, test to satisfy, and the tier-gate row.
2. Steward confirms the row; auth, payments, and data paths stop here.
3. Runner probes the endpoint, then generates the diff.
4. Runner stamps the PR with ai_stamp.sh before review.
5. Verifier reproduces one behavior by hand and signs the block.
6. Steward logs daily allowance use and rotates waiters.
7. Anything unstamped is reverted, not debated.

Seven lines cover a workday. The Steward reviews the log each Friday and moves heavy work off the free tier.

Failure modes that survive week one

The allowance drains faster than expected when long contexts repeat. Cache the prompt text and cap the diff size before generation.

Model drift shows up as confident nonsense, not errors. The probe catches it only when the content check runs.

Cold starts masquerade as slow reasoning. Measure milliseconds before you measure quality.

Finally, a stamp without a human signature is decoration. The Verifier's name in the block is the load-bearing part.

Limits and who should skip this

Skip this if your work touches regulated data, secrets, or customer records. A free tier is not the place for that, and a stamp does not make it safe.

Skip it for air-gapped environments and for teams with no second reviewer. The gate collapses when one person holds every role.

Skip it for deep performance work. Benchmarks need controlled hardware, and a shared free server cannot provide that.

The method also assumes the endpoint is reachable and OpenAI-compatible. If your provider differs, rewrite the probe, keep the gate.

Try the runbook on one repository before you widen it. The stamp script is the part worth copying first.

Fill a Retry Docket Before the Second Pass

Morgan Xu — Tue, 13 Oct 2026 02:53:30 +0000

A second model pass should wait for a written docket. Cheap retries hide the real defect under fresh wording. Review time disappears when nobody names the stop rule.

That rule belongs in the team wiki before the next generation. The page stays short enough to read during a handoff. The gate stays stricter than the prompt that failed.

Public developer threads keep returning to retries and weak checks. A second generation can sound cleaner while the assumption stays wrong. Agreeable wording is not evidence that the patch is safe.

This playbook treats the second pass as a controlled shift. The model does not judge its own repair. A free practice host does not become the production lane.

Disclosure: This article was prepared as part of MonkeyCode's product outreach. The operator describes free model access and a free server option. MonkeyCode is described here as an open-source project. This draft does not freeze quotas, names, hardware, or duration. Those terms can move between one week and the next. A squad reads the live project notes before it relies on them.

The free lane still changes how a retry feels. A second pass looks cheap when no personal invoice appears. A free server can hold the practice checkout off the main branch.

Cheap is not the same thing as harmless. Noise still lands in review and in the shared log. The docket exists to make that cost visible.

A ferry will not leave the dock without a paper slip. The slip names the cargo, the dock, and the last safe turn. No slip means the boat stays tied to the pier.

The retry docket is that slip for a failed patch. It records the failing check before anyone asks for new words. It also records the one condition that ends the loop.

The docket works like a library hold slip, not like a new book. The slip points at one title and one pickup window. It does not let the reader reorder the whole shelf.

Three roles keep the slip from turning into theater. The Patch Author owns the failing change and the first check. The Docket Clerk refuses a second pass until every field is present.

The Host Steward runs the practice host and returns logs. The steward does not return a verdict on the design. Logs travel better than opinions across a shift change.

The author does not approve their own retry. The clerk does not edit the patch during the field check. The steward does not merge anything from the practice host.

Those walls stop a friendly loop from becoming a silent rewrite. A missing field sends the work back to the author. A vague failure reason sends the work back as well.

A bare request to try again is not evidence. The return trip is the control, not a delay for its own sake. One complete docket buys one second pass, not a series.

Handoff one starts when a named check fails. The author files the docket in the wiki or on the pull request. Handoff two starts when the clerk marks that page complete.

Handoff three starts only on the practice host. The steward runs the same failing command before any generation. The steward runs that same command again after the second pass.

The clerk then closes the docket with one of three outcomes. The outcomes are fixed, still failing, or human rewrite. The steward removes the practice checkout on the same day.

The page below is a proposal for the wiki, not a measured rollout. Names in the sample are placeholders, not a real rotation. The names change to people who can actually refuse a pass.

# Retry Docket — one-page run

Status stays draft until the clerk marks it complete.
Scope is one failing patch, one second pass, and one practice host.

Docket id, patch author, and failing check name sit on separate lines.
The first failing command, expected result, and actual result follow.
The next lines name what must change and what must stay unchanged.
Secrets present must read no.
Practice host must name the free server lane, not production.
Stop rule must read one second pass, then a human rewrite.
Clerk and steward names close the header.

The author attaches the failing command output.
The clerk rejects blank fields and secret-looking values.
The steward checks out the patch on the practice host only.
The steward runs the same failing command before any generation.
The author may request one second pass if the failure still matches.
The steward runs the same command after that second pass.
The clerk closes the docket as fixed, still failing, or human rewrite.
The steward deletes the practice checkout on the same day.

The wiki page is the human copy of the same gate. The flat file is the machine copy the checker reads. Both copies must name the same failing check.

The checker below is a proposed gate for the wiki. It is not a measured control from a live fleet. It reads a flat text file and rejects blank required fields. It also rejects a docket where the author clerks their own retry.

#!/usr/bin/env python3
"""Proposed docket check. Not executed as a fleet control."""

import sys
from pathlib import Path

REQUIRED = [
    "docket_id",
    "patch_author",
    "failing_check",
    "first_command",
    "expected",
    "actual",
    "must_change",
    "must_stay",
    "secrets_present",
    "practice_host",
    "stop_rule",
    "clerk",
    "steward",
]

def parse_simple(text: str) -> dict:
    data = {}
    for raw in text.splitlines():
        line = raw.strip()
        if not line or line.startswith("#") or ":" not in line:
            continue
        key, value = line.split(":", 1)
        data[key.strip()] = value.strip()
    return data

def main() -> int:
    if len(sys.argv) != 2:
        print("usage: python3 retry_docket.py docket.txt")
        return 2
    data = parse_simple(Path(sys.argv[1]).read_text(encoding="utf-8"))
    missing = [key for key in REQUIRED if not data.get(key)]
    if missing:
        print("reject: missing " + ", ".join(missing))
        return 1
    if data["secrets_present"].lower() != "no":
        print("reject: secrets must be no")
        return 1
    if data["stop_rule"] != "one-second-pass-then-human":
        print("reject: stop rule drifted")
        return 1
    if data["patch_author"] == data["clerk"]:
        print("reject: author cannot clerk their own docket")
        return 1
    print("complete: second pass may be queued once")
    return 0

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

The clerk runs it from the repository root before the steward queues work. A nonzero exit means the second pass stays parked. A zero exit means one pass may start, not that the patch is correct.

python3 retry_docket.py docket.txt
printf '%s\n' "docket_exit=$?"

The sample invoice case is fictional and unexecuted in this draft. Half-up rounding is only a stand-in for a named failing check. The author swaps in the real test name before the file goes live.

docket_id: RD-2026-10-13-014
patch_author: dev.a
failing_check: test_invoice_rounds_half_up
first_command: python3 -m unittest tests.test_invoice
expected: half-up rounding on 1.005
actual: half-even result 1.00
must_change: prompt must cite the rounding test name
must_stay: public function signature
secrets_present: no
practice_host: free-server-lane
stop_rule: one-second-pass-then-human
clerk: dev.b
steward: dev.c

The shell capture is also a proposal for the practice host. It stores the command, the time, and the exit code beside the output. The clerk compares the before log and the after log before closing.

#!/bin/sh
# Proposed log capture. Not executed in this draft.
set -eu
label="${1:?need before-or-after}"
shift
mkdir -p .retry-logs
log=".retry-logs/${label}.log"
tmp="$(mktemp)"
set +e
"$@" >"$tmp" 2>&1
code=$?
set -e
{
  echo "label=${label}"
  echo "utc=$(date -u +%Y-%m-%dT%H:%M:%SZ)"
  echo "cmd=$*"
  echo "exit=${code}"
  cat "$tmp"
} > "$log"
rm -f "$tmp"
echo "wrote ${log} exit=${code}"
exit "$code"

sh capture_retry_log.sh before python3 -m unittest tests.test_invoice
sh capture_retry_log.sh after python3 -m unittest tests.test_invoice
diff -u .retry-logs/before.log .retry-logs/after.log || true

The diff command may exit nonzero when the logs differ. That nonzero state is information, not a failed capture. The clerk reads the hunks before anyone calls the retry a fix.

That script stays off production data and off secret files. Tokens, keys, and customer rows stay out of the wiki page. The secrets field exists so the clerk can reject the page early.

Free model access participates only after the docket is complete. The author may use it for that single second pass. The prompt must cite the failing check and the must-stay line.

The free server option participates as the practice host label. The steward follows the current setup notes rather than a frozen recipe. This article does not invent machine size, region, or lifetime.

A vanished lane stops the shift and forces a rewritten plan. Yesterday's pool is not assumed to exist this morning. A docket that cites a vanished host is incomplete.

The stop rule is the part teams try to soften. One second pass is the whole allowance in this playbook. A third generation needs a new docket and a human rewrite plan.

Still failing after the second pass is a successful use of the gate. The gate did its job by ending the loop. The author then repairs the code by hand or files a narrower task.

This approach will not fit every team desk. It does not fit when one person owns the toy project and the review. It does not fit when the change already sits in an incident channel.

It does not fit when the work needs an audited model contract. A free lane is a practice lane, not a compliance story. It does not fit when the failing check cannot be named in one line.

It also does not fit when the patch touches secrets, billing, or production data. The sample checker cannot see intent hiding inside a diff. A human still has to read the change before any merge.

The limits sit in the open on purpose. The script does not score quality, speed, or model taste. No benchmark in this draft claims a win over another tool.

The clerk can rubber-stamp fields without reading the failure. The steward can leave a practice process running overnight. The author can change three things while the docket names one.

Those failures are process failures, not model mysteries. The page makes them easier to see during the next handoff. It does not remove the need for tests that already exist.

The clerk pins the live access notes beside the wiki page. The pin happens on the day the team adopts the docket. If the notes and the page disagree, the live notes win.

A squad reviews MonkeyCode's current free-access notes, then pins this docket beside them.

A Drift Ledger for the Shared Bench

Morgan Xu — Sun, 11 Oct 2026 22:13:35 +0000

A shared bench lies when the handoff has no name. The model can shift between two quiet nights. The free server can drop its scratch disk.

The ticket still looks finished to the next reader. A one-page wiki run catches that lie early. The run is a relay, not a fresh platform.

This playbook carries one prompt from pin to close. The baton is a hash of the fixture file. A changed hash voids the recorded time at once.

Teams blame the model when the retry was new. The prompt grew one quiet sentence before dawn. The server label changed without a fresh pin.

The note field stayed blank on the close. The second result cannot teach the first run. A drift ledger keeps those facts on one line.

A lab fridge shared by a night crew shows the gap. Someone moves the sample cup to a new shelf. The paper label peels in the cold air.

The morning reader trusts the shelf, not the cup. A dated tape strip fixes that trust gap fast. The wiki run is that strip, not a new fridge.

Four beats

The clock keeper opens the shift on the wiki. That person reads the project page the same day. Old grant notes stay off the run card.

A pasted token count from last month is stale. The keeper writes the page date beside the shift id. A missing date means the shift stays shut.

The prompt clerk freezes one fixture in the repo. Edits during the run start a new shift. A retry is not a license to edit.

The clerk hashes the file and pins the digest. The runner may not touch that fixture file. The pin is the baton pass, not a suggestion.

The runner executes only on the practice server. Live product hosts stay dark for this drill. Logs, keys, and customer text stay off the bench.

The runner records the exit code and the server label. The reader compares output with the fixture note. A pass needs the same hash and the same server.

A fail needs a reason before any retry starts. Silence is not a reason on this card. The reader closes the line and stops the relay.

Disclosure: This article was prepared as part of MonkeyCode's product outreach. MonkeyCode is the open-source bench named for this drill. The operator states two availability facts for practice.

Free model access is the first stated fact. A free server option is the second stated fact. Model names and quotas stay off this page.

Hardware, duration, and permanence stay off it too. Those details move and go stale in a wiki. The clock keeper reads them again on shift day.

A blog number is not a license term. The ledger script is a local proposal only. It does not ship as a claimed product feature.

A local gate

A team pastes it beside the wiki run. It refuses a retry that changed the prompt hash. It refuses a close that skipped the reason note.

The script is a gate, not a model score. A second pin with a new hash fails the audit. The reader then opens a new shift id.

#!/usr/bin/env python3
"""Local drift ledger. A proposal, not a product feature."""
import argparse
import hashlib
import json
import sys
from datetime import datetime, timezone
from pathlib import Path

LEDGER = Path("drift_ledger.jsonl")


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


def append(row: dict) -> None:
    with LEDGER.open("a", encoding="utf-8") as handle:
        handle.write(json.dumps(row, sort_keys=True) + chr(10))


def load() -> list:
    if not LEDGER.exists():
        return []
    rows = []
    for line in LEDGER.read_text(encoding="utf-8").splitlines():
        if line.strip():
            rows.append(json.loads(line))
    return rows


def pin(args: argparse.Namespace) -> int:
    digest = sha256_file(Path(args.prompt))
    append(
        {
            "event": "pin",
            "shift_id": args.shift,
            "prompt_hash": digest,
            "server_label": args.server,
            "page_seen": args.page_seen,
            "at": datetime.now(timezone.utc).isoformat(),
        }
    )
    print(digest)
    return 0


def close(args: argparse.Namespace) -> int:
    pins = [
        row
        for row in load()
        if row.get("shift_id") == args.shift and row.get("event") == "pin"
    ]
    if not pins:
        print("missing pin", file=sys.stderr)
        return 2
    if not args.note.strip():
        print("empty note", file=sys.stderr)
        return 2
    last = pins[-1]
    append(
        {
            "event": "close",
            "shift_id": args.shift,
            "prompt_hash": last["prompt_hash"],
            "server_label": last["server_label"],
            "exit_code": args.exit,
            "note": args.note.strip(),
            "at": datetime.now(timezone.utc).isoformat(),
        }
    )
    return 0


def audit(_: argparse.Namespace) -> int:
    if not LEDGER.exists():
        print("missing ledger")
        return 1
    bad = 0
    grouped = {}
    for row in load():
        grouped.setdefault(row["shift_id"], []).append(row)
    for shift_id, rows in grouped.items():
        hashes = {row["prompt_hash"] for row in rows if "prompt_hash" in row}
        servers = {row["server_label"] for row in rows if "server_label" in row}
        closes = [row for row in rows if row.get("event") == "close"]
        pins = [row for row in rows if row.get("event") == "pin"]
        if len(hashes) != 1 or len(servers) != 1 or not closes:
            print("drift " + shift_id)
            bad += 1
        elif any(not row.get("note") for row in closes):
            print("blank note " + shift_id)
            bad += 1
        elif any(not row.get("page_seen") for row in pins):
            print("missing page date " + shift_id)
            bad += 1
    return 1 if bad else 0


def main() -> int:
    parser = argparse.ArgumentParser()
    sub = parser.add_subparsers(dest="cmd", required=True)
    pin_cmd = sub.add_parser("pin")
    pin_cmd.add_argument("--shift", required=True)
    pin_cmd.add_argument("--prompt", required=True)
    pin_cmd.add_argument("--server", required=True)
    pin_cmd.add_argument("--page-seen", required=True)
    pin_cmd.set_defaults(func=pin)
    close_cmd = sub.add_parser("close")
    close_cmd.add_argument("--shift", required=True)
    close_cmd.add_argument("--exit", type=int, required=True)
    close_cmd.add_argument("--note", required=True)
    close_cmd.set_defaults(func=close)
    audit_cmd = sub.add_parser("audit")
    audit_cmd.set_defaults(func=audit)
    args = parser.parse_args()
    return args.func(args)


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

The clerk pins the fixture before any model call. The page date is a required flag on that pin. A missing page date fails the habit, not the model.

python3 drift_ledger.py pin \
  --shift S-41 \
  --prompt fixtures/retry_case.txt \
  --server practice \
  --page-seen 2026-10-12

python3 drift_ledger.py close \
  --shift S-41 \
  --exit 0 \
  --note "same hash and same practice server"

python3 drift_ledger.py audit

The close line demands a note with real words. An empty note returns a failure to the reader. A missing ledger file fails the audit on contact.

Mixed hashes or mixed servers print a drift mark. A clean audit means the relay held one baton. It does not mean the model answer was wise.

A tiny fixture keeps the drill cheap and repeatable. One file holds a short coding task and a check. The stand-in only proves the fixture still exists.

mkdir -p fixtures
cat > fixtures/retry_case.txt << 'EOF'
Write a function add(a, b) that returns a + b.
Do not add I/O.
EOF
python3 - << 'PY'
from pathlib import Path
text = Path("fixtures/retry_case.txt").read_text()
assert "add(a, b)" in text
print("fixture-ok")
PY

The real call belongs on the free practice server. The runner swaps that stand-in for the team command later. The clerk keeps the same shift id when the hash stays put.

The wiki page is one screen and four names. Blank names mean the shift has not started. The page holds no token count and no slogan.

# Shift run S-__

Clock keeper: ____
Page seen: ____
Prompt clerk: ____
Fixture path: ____
Runner: ____
Server label: practice
Reader: ____
Close note: ____

Pin the fixture before the call.
Run once on the practice server.
Do not edit the fixture mid-shift.
Close only with a written note.
Audit the ledger before the next crew starts.
A new hash means a new shift id.

A keeper who finds a stale count strikes it. The next crew inherits the ledger line, not a vibe. Handoff is a file, not a chat scroll.

Limits of the tape

This drill does not rank models or claim a winner. A green audit can still hide a wrong function. Human review of the diff remains the real gate.

Free servers can reset disks between two shifts. The ledger cannot restore a file the host forgot. Scratch space stays rented space, not owned storage.

Secrets do not belong in the fixture or the note. A public practice server is a poor vault for keys. The clerk strips identifiers before a prompt lands there.

Production incidents need a different on-call path entirely. This run is practice, not a live rescue. Regulated text should stay off a shared free server.

Teams with no named reader should skip the drill. A solo spike with no handoff can skip it too. Guaranteed uptime sits outside this playbook on purpose.

Better model output does not repair a loose handoff. Software around the bench still needs a named baton. A retry without a frozen prompt is a new experiment.

The ledger makes that difference visible in one file. A crew confirms free-model and server terms on shift day. That check happens on the project page before the pin.

Then the same four beats can run on a practice server. The wiki copy is the whole invitation this page offers. No second pitch belongs after a closed ledger line.

Stamp a Scope Ribbon Before Practice Shifts

Morgan Xu — Sat, 10 Oct 2026 18:48:44 +0000

A practice shift without a roster becomes shared debt. Free model access lowers the cost of a draft. It does not lower the cost of a bad merge.

Teams can now sketch an interface before lunch ends. Those sketches still touch repos, logs, and keys. Speed without a named owner creates quiet drift.

The useful fix is a one-page shift sheet. Three seats sign it before the first prompt. The sheet lives in the team wiki, not in chat.

This playbook fits small product teams with shared repos. It also fits platform groups that keep a sandbox. It does not fit a solo weekend experiment.

Name the failure before any tool

A generated patch can look finished and still be wrong. The wrong part is often scope, not syntax. A button works while the data path leaks.

Reviewers then argue about taste instead of bounds. The draft already sits on a shared host. Rollback talk starts after other people see it.

A roster slip stops that sequence one step earlier. It names who prompts, who checks, and who discards. It also names what the shift must never touch.

Public talk about easy generated sites makes this failure common. A portfolio draft and a service draft share one risk. Both can escape the practice lane if nobody owns the close.

Keep free capacity on a practice lane

Disclosure: This article was prepared as part of MonkeyCode's product outreach. MonkeyCode offers free model access for this kind of practice. It also offers a free server option for throwaway hosts.

Both claims come from the operator, not a lab test. Quotas, model names, and uptime are not assumed here. A free option can change without a team vote.

The lane stays practice, and never becomes a promise. The team uses that access only after the slip is complete. Prompts stay on a practice branch, not on main.

The host name must not look like production. Live tokens stay out of the brief and the prompt. Customer rows stay out of the prompt as well.

Synthetic fixtures are the only safe sample for this shift. The team stores fixtures in the practice repo only. A real data export never enters this shift.

Three seats and one clock

The prompter writes the task in one short brief. The checker owns diffs, tests, and secret scans. The discarder owns shutdown, branch delete, and the note.

One person may hold two seats on a tiny team. One person must not hold all three seats. A missing discarder is how practice becomes production.

The clock is wall time, not a feeling. Ninety minutes is a suggested cap, not a benchmark. When the cap hits, the discarder closes the host.

The cap is a team rule, not a product limit. An extension needs a new slip and a new deadline. A silent extension is the same as no clock.

Handoffs stay short on purpose

The prompter hands a brief with inputs and forbidden paths. The checker hands a pass, a fail, or a block. The discarder hands a closed host and a deleted branch.

Each handoff must fit inside four short lines. Chat history must never replace the wiki page. A missing line means the shift is still open.

The prompter does not declare the draft done. The checker does not declare the host closed. Those sentences belong to different seats for a reason.

A pass means the diff matches the ribbon. A fail means the diff missed the brief. A block means the diff touched a forbidden path.

Paste this page, then fill blanks

The artifact below is a proposal, not a captured log. The team copies it into the wiki before the shift. Every blank stays filled, or the shift does not start.

Practice shift slip
Shift id: PS-____
Date: ____
Prompter: ____
Checker: ____
Discarder: ____
Scope ribbon: ____
Forbidden: prod hosts, customer data, live tokens, main
Branch: practice/____
Host label: ____
Deadline UTC: ____
Fixture rule: synthetic only
Prompter line: brief filed, inputs listed, forbidden copied
Checker line: pass | fail | block - note ____
Discarder line: host closed, branch deleted, time ____
Stop: blank seat means no prompt
Stop: second fail means discard
Stop: any block means discard, plus a note if secrets appeared

A checker that fails closed

A small script guards the slip before any prompt. It does not call a model or a remote API. It only reads a local env file on disk.

This script is an unexecuted example for local use. The team runs it on a throwaway clone first. It does not belong on a release repository.

#!/usr/bin/env bash
# Proposal only. Unexecuted example for a throwaway repo.
set -euo pipefail

SLIP="${1:-shift-slip.env}"
test -f "$SLIP" || { echo "missing slip: $SLIP"; exit 2; }

set -a
# shellcheck disable=SC1090
source "$SLIP"
set +a

require() {
  local name="$1"
  local value="${!name-}"
  if [[ -z "${value}" ]]; then
    echo "blank field: ${name}"
    exit 3
  fi
}

require PROMPTER
require CHECKER
require DISCARDER
require SCOPE
require FORBIDDEN
require BRANCH
require HOST
require DEADLINE

if [[ "$PROMPTER" == "$CHECKER" && "$CHECKER" == "$DISCARDER" ]]; then
  echo "one person holds every seat"
  exit 4
fi

case "$BRANCH" in
  practice/*) ;;
  *) echo "branch must start with practice/"; exit 5 ;;
esac

case "$HOST" in
  *prod*|*production*|*live*)
    echo "host label looks like production"
    exit 6
    ;;
esac

if git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
  git check-ignore -q .env || echo "warn: .env is not ignored"
fi

echo "slip ok: ${BRANCH} until ${DEADLINE}"

A matching example file holds names only. Tokens and customer rows never belong in that file. The filled copy stays untracked.

# shift-slip.env.example — proposal template, no secrets
PROMPTER="ava"
CHECKER="sam"
DISCARDER="rui"
SCOPE="readme draft for the practice repo only"
FORBIDDEN="prod hosts, customer data, live tokens, main branch"
BRANCH="practice/readme-draft"
HOST="practice-host.example"
DEADLINE="2026-10-10T16:30:00Z"

Commands for open, check, and close

The commands below are examples, not a captured session. Each one assumes a throwaway clone with no secrets. A failed command stops the shift until a human reads it.

The prompter creates the practice branch before any prompt. The filled slip stays next to that work. The checker runs the script before any editor opens.

git checkout -b practice/readme-draft
cp shift-slip.env.example shift-slip.env
bash check-slip.sh shift-slip.env

The checker records a short line without pasting secrets. A stat line is enough for this handoff note. Raw diffs that may hold secrets stay out of chat.

git diff --stat
printf '%s\n' "checker: pass" "note: readme only" >> handoff.txt

The discarder closes with local git commands and a stamp. Host shutdown still happens in the provider console. The stamp only proves the local half is finished.

git checkout main
git branch -D practice/readme-draft
printf '%s\n' "host: closed in console" "branch: deleted" "time: $(date -u +%FT%TZ)" >> handoff.txt

Filled slip files stay out of the git history. The team commits the example, not the filled file. A filled file can hold names that should stay internal.

printf '%s\n' "shift-slip.env" "handoff.txt" >> .gitignore
git check-ignore -q shift-slip.env && echo "filled slip ignored"

Read the three marks as policy

When the checker marks fail, the prompter may revise once. A second fail ends the shift at once. The discarder still closes the host that day.

When the checker marks block, nobody pushes code. A block means secrets, prod names, or scope creep. The brief returns to the wiki, not the model.

When the checker marks pass, work may enter normal review. That review uses the team's ordinary release pipeline. The practice host never becomes the release host.

A pass is not a deploy approval by itself. A pass is only a match against the ribbon. Release still needs the team's existing review gates.

Limits of the sheet and the script

The checker script cannot judge real product sense. It cannot prove a free server is isolated. It cannot see a secret typed into a prompt.

Free model access can shift without prior notice. Free server capacity can shift in the same way. This page claims no quota, chip type, or duration.

No benchmark result sits behind these process steps. No customer count sits behind these steps either. The value is a cleaner handoff, not a miracle.

String checks on the host label are shallow. A host can be dangerous without the word prod. Humans still read the name before the first prompt.

The script trusts the slip file on purpose. A liar can type a fake discarder name. Social trust sits outside what bash can prove.

Who should leave this playbook unused

Teams skip this approach when the data is regulated. They skip it when the only host is production. They skip it when nobody can stay for the discard.

They skip it for a silent overnight agent. Unattended prompts break the three-seat rule every time. A human discarder must remain awake for the close.

They skip it for a demo that cannot be deleted. Practice means the artifact can die without ceremony. A launch candidate needs the normal release train.

They skip it when counsel owns the prompt text. This sheet is an engineering habit, not legal advice. Regulated text still needs the team's counsel path.

Rehearse the failure before the real brief

The rehearsal starts on an empty practice repo. The slip gets real names and only fake data. The checker expects a short ok line from the script.

The rehearsal script below is also an unexecuted proposal. It expects the checker file in the same folder. It never contacts a model or a remote host.

#!/usr/bin/env bash
# Proposal only. Local rehearsal. No model calls.
set -euo pipefail

tmp="$(mktemp -d)"
cp check-slip.sh shift-slip.env.example "$tmp/"
cd "$tmp"
cp shift-slip.env.example shift-slip.env
bash check-slip.sh shift-slip.env | grep -q "slip ok"

sed 's/^DISCARDER=.*/DISCARDER=""/' shift-slip.env > shift-slip.blank
if bash check-slip.sh shift-slip.blank; then
  echo "expected failure on blank discarder"
  exit 1
fi

echo "rehearsal ok"

The next run blanks the discarder field on purpose. The script should exit on that blank field. The name returns before any further prompt work.

The host field then uses a name that contains prod. The script should refuse that unsafe host string. The host label changes before the shift continues.

The prompter supplies a diff that touches only the readme. The checker reads the stat line, not the tone. A pass still waits for human eyes on the diff.

The close deletes the practice branch and writes the time. The slip stays in the wiki as history. Practice notes do not enter the main readme.

The ribbon outranks the model

Scope works like a ribbon tied around the task. Outside that ribbon, the shift has no authority. Inside the ribbon, the checker may say no.

A stronger model does not replace that ribbon. A cheaper server does not replace it either. The ribbon is a social control with a small script.

The slip covers one shift, not the whole quarter. It expires when the discarder writes the close line. The next shift starts from a blank page.

Old notes stay as evidence, not as a prompt seed. Fresh scope stops yesterday's exception from growing again. That habit matters more than any single draft.

A boring close is a feature of this playbook. The discarder stops the host and deletes the branch. No victory speech belongs on the shift slip.

A team that wants those free options starts on a throwaway repo. The team pastes the sheet and runs the checker first. That order keeps the experiment smaller than the codebase.

Seal an Envelope Before Free Bench Time

Morgan Xu — Fri, 09 Oct 2026 15:11:29 +0000

Free model seats never replace a written handoff. A free server never replaces a named owner. Teams should seal an envelope before the first prompt.

Many teams now generate code faster than they review it. Speed feels like progress until a shared bench mixes secrets. The quiet failure is an unlabeled run with no exit.

Generated code can look finished before anyone owns the result. A portfolio demo and a shared bench fail in different ways. The bench fails when the next person cannot see the stop rule.

Treat free compute like a borrowed bench

This playbook treats free compute like a borrowed lab bench. The bench stays useful only while the log stays attached. That log is a one-page envelope inside the team wiki.

The envelope holds purpose, data class, stop time, and a close stamp. A missing field keeps the bench dark until someone fills it. A filled field still needs a human name beside it.

Keep a named relay

The Desk Editor accepts or refuses the job before any prompt. The Run Witness watches the session and records what changed. The Closer stamps keep, hold, or discard after the diff.

A small team may let one person wear two hats. The same person must not edit, witness, and close one run. Split the close onto a second engineer when headcount is thin.

Work starts only after the editor files the envelope. Work moves when the witness links the diff and the log. Work ends when the closer stamps that same envelope.

Handoffs fail when chat threads become the only record. Chat scrolls away, while a wiki page stays searchable. Paste the envelope under a stable wiki slug before the run.

The one-page run has four beats and no extra ceremony. The beats are file, check, prompt, and stamp, with names attached. If any beat lacks a name, the relay stops and the bench stays dark.

The witness handoff can read: diff linked, data class unchanged, clock intact. The closer handoff can read: tests rerun, secrets absent, stamp is keep. Hold means the diff stays unmerged until a named person returns.

Stop when the data class drifts

The next scene is a composite failure, not a measured incident. A parser spike starts public, then an internal log gets pasted. The free server then holds data the envelope never allowed.

The witness should stop the moment the data class changes. A class change is a new job, not a quiet continuation. The editor must refile the envelope before the next prompt.

Some teams reach this bench through MonkeyCode. Disclosure: This article was prepared as part of MonkeyCode's product outreach. The operator reports free model access and a free server option.

Those two claims are availability notes, not a capacity contract. This article does not name models, quotas, hardware, or duration. Copy any live limit the product shows into the envelope.

If the product shows no number, write unknown and cap locally. A local cap is a team rule, not a vendor promise. Stop the run when the cap or the clock hits first.

Free access can change without a long public notice. A free server can be shared, slow, reset, or withdrawn. The envelope should say what the team will do if access ends.

Pick a throwaway repository for the first sealed run. Keep production secrets and customer data off that repository. Treat the free server like a hallway whiteboard, not a vault.

Data class belongs on the first line a stranger will read. Use public, internal, or forbidden as the only three labels. Forbidden means the editor refuses the job before any prompt.

Purpose should fit in one sentence a stranger can audit. A bare try-the-model line is not a purpose and should fail. A purpose like rewrite the parser and keep tests green can pass.

Stop time is a clock, not a mood. Write an absolute timestamp in UTC plus a maximum minute count. The witness closes the session when either bound is reached.

Local work and free-server work are not the same risk. Use local mode when the sample never leaves the laptop. Use the free server only when the card names that mode.

A shared server adds neighbors, restarts, and unclear retention. The witness should record restart, timeout, and empty response. Those notes belong on the envelope before the closer stamps it.

Paste a gate, not a slogan

The artifact below is an unexecuted example for a wiki page. Adapt names and paths before anyone trusts the checker. It refuses a run when required envelope fields are blank.

The card format is a flat key file, not a full YAML parser. Values may contain spaces, but each key stays on one line. Do not wrap values in quotes, because this parser keeps them.

#!/usr/bin/env python3
'''Unexecuted example: refuse a free-bench run with a blank envelope.'''

import sys
from datetime import datetime, timezone

REQUIRED = [
    'purpose',
    'data_class',
    'vendor',
    'server_mode',
    'owner_editor',
    'owner_witness',
    'owner_closer',
    'stop_at_utc',
    'max_minutes',
    'repo',
    'secret_policy',
    'fallback_if_access_ends',
]

ALLOWED_CLASS = {'public', 'internal', 'forbidden'}
ALLOWED_SERVER = {'local', 'free_server', 'unset'}


def load_flat_card(path):
    data = {}
    with open(path, encoding='utf-8') as handle:
        for raw in handle:
            line = raw.strip()
            if not line or line.startswith('#') or ':' not in line:
                continue
            key, value = line.split(':', 1)
            data[key.strip()] = value.strip()
    return data


def refuse(message):
    print('REFUSE:', message)
    return 1


def main(path):
    card = load_flat_card(path)
    missing = [key for key in REQUIRED if not card.get(key)]
    if missing:
        return refuse('missing ' + ','.join(missing))
    if card['data_class'] not in ALLOWED_CLASS:
        return refuse('data_class must be public, internal, or forbidden')
    if card['data_class'] == 'forbidden':
        return refuse('forbidden data never reaches the bench')
    if card['server_mode'] not in ALLOWED_SERVER:
        return refuse('server_mode must be local, free_server, or unset')
    if card['owner_editor'] == card['owner_closer']:
        return refuse('editor and closer must be different people')
    if card['secret_policy'] != 'no_secrets_in_prompt_or_repo':
        return refuse('secret_policy must block prompts and the repo')
    if len(card['purpose'].split()) < 6:
        return refuse('purpose is too thin to audit')
    try:
        stop = datetime.fromisoformat(card['stop_at_utc'].replace('Z', '+00:00'))
    except ValueError:
        return refuse('stop_at_utc must be ISO-8601')
    if stop.tzinfo is None:
        return refuse('stop_at_utc must include a timezone')
    if stop <= datetime.now(timezone.utc):
        return refuse('stop_at_utc is already past')
    try:
        minutes = int(card['max_minutes'])
    except ValueError:
        return refuse('max_minutes must be an integer')
    if minutes < 10 or minutes > 90:
        return refuse('max_minutes must stay between 10 and 90')
    stamp = card.get('close_stamp', 'open')
    if stamp != 'open':
        return refuse('a new run must start with close_stamp open')
    print('PASS: envelope is complete; a human closer is still required')
    return 0


if __name__ == '__main__':
    if len(sys.argv) != 2:
        print('usage: python3 check_envelope.py envelope.card')
        sys.exit(2)
    sys.exit(main(sys.argv[1]))

purpose: Rewrite the sample parser and keep the tests green
data_class: public
vendor: MonkeyCode
server_mode: free_server
owner_editor: desk.editor
owner_witness: run.witness
owner_closer: close.reviewer
stop_at_utc: 2026-10-10T18:00:00Z
max_minutes: 40
repo: example/throwaway-parser
secret_policy: no_secrets_in_prompt_or_repo
fallback_if_access_ends: stop and finish locally or wait
close_stamp: open

date -u +%Y-%m-%dT%H:%M:%SZ
python3 check_envelope.py envelope.card
cat > blank.card << 'EOF'
# empty on purpose
EOF
python3 check_envelope.py blank.card
echo blank_exit:$?
sed 's/^data_class: .*/data_class: forbidden/' envelope.card > forbidden.card
python3 check_envelope.py forbidden.card
echo forbidden_exit:$?

Save the checker beside the wiki export or inside the repo. Run it in trusted CI before a shared bench job starts. A failing check is a hard stop, not a note for later.

The minute bounds in the checker are team policy, not a product limit. Change 10 and 90 if the team already has a tighter rule. Do not treat those integers as a vendor quota or a promise.

The first test uses a blank card and expects a non-zero exit. The second test uses a full card and a future stop time. That complete card should return a zero exit from the checker.

The third test marks data class forbidden and expects refusal. A past stop time should fail even when the other fields look fine. These checks are the minimum before a shared bench opens.

The sample card uses a fake repo and fake owner names. Replace both before the first real session on a free server. Edit the stop time so it still sits in the future.

Read the checker output as a gate, not as a score. Pass means the envelope is complete, not that the code is safe. A human closer still reads the diff before any merge.

The sample commands stay small so a new teammate can audit them. Python 3 is enough for the field check shown here. No network call belongs inside this local checker.

A checker that phones home can leak the envelope itself. Keep validation on the laptop or in the trusted runner. Do not paste live keys into the card or the script.

Build the stop clock with a UTC command before the edit. Paste that timestamp into stop_at_utc and then add the minute cap. If the date command is missing, take UTC from a trusted clock.

Leave these jobs outside the envelope

Limitations sit next to the benefit, not in a buried footnote. The card cannot detect a prompt that smuggles a secret later. The card cannot prove a free server isolated the workload.

Reviewers can rubber-stamp a close after a long day. Rotate the closer when the same pair ships every shared run. A weekly sample of closed envelopes keeps the habit honest.

Skip this playbook for a solo notebook with no shared server. Skip it when legal counsel already owns the data path. Skip it if a public wiki would leak the card contents.

Also skip it when the task needs a named production runtime. Unknown model identity is acceptable only for a throwaway spike. Production merges need a pinned runtime the team can retest.

The method is slower than pure chat-driven coding on purpose. That slowness matters when several people share one bench. A sealed envelope costs minutes and can prevent a bad merge.

A team with a wiki can trial the reported free path next. Use a throwaway repo and wait for a pass from the checker. Keep that first run inside the stop time written on the card.

Free Bench Drafts Need a Merge Captain

Morgan Xu — Thu, 08 Oct 2026 10:46:21 +0000

A free coding bench can draft a patch in minutes. That speed does not sign the merge decision. A named captain still owns every diff that lands.

Contribution weeks reward visible pull requests over careful ownership. Shared repos then fill with polished diffs and thin context. The failure looks like speed, yet the gap is custody.

A loaner workbench helps a carpenter shape a board. The shop stamp still belongs to the lead on shift. Free model access deserves the same shop rule during a rush.

MonkeyCode offers free model access and a free server option. Disclosure: This article was prepared as part of MonkeyCode's product outreach. Those two claims come from the operator for this draft.

This draft relies on operator notes rather than a public quota page. A reader should recheck terms on the day of any real trial. Stale numbers do not belong in a desk log.

This runbook does not assume quotas, hardware, or lasting availability. It also avoids invented model names and benchmark scores. The useful part is the custody ritual around the bench.

Two names, one log

The desk names one accountable human, not a crowd of equal pens. The drafter may use the free bench to propose a patch. The merge captain accepts, trims, or rejects that patch.

A log file watches the run and never edits the tree. That log is the witness for the whole desk run. It records scope, commands, and the captain stamp.

Handoff is a short walk between seats, not a long thread. The drafter leaves a scope slip beside the proposed diff. The captain reads that slip before opening the patch.

The slip names the repo, the branch, and the allowed files. It also names tests that must pass on a clean tree. Missing lines stop the handoff like a locked shop door.

Practice room, not the floor

The free server is a practice room, not the production floor. Drafts may run there when that option is actually available. Secrets, customer data, and deploy keys stay off that room.

A team that cannot separate those rooms should skip this desk. A solo maintainer who is also the only reviewer should skip it. Regulated trees need a second human outside this sketch.

The one-page run below is a proposal for a team wiki. It is not a record of a finished production rollout. A team can paste it and adapt seat names to the real roster.

# Merge desk - one-page run

Purpose. Keep a free-bench draft from landing without a named captain.

Drafter. May use free model access on the bench branch. May edit only files named in the slip.

Merge captain. Owns the diff, the push decision, and the final stamp. Must be a human.

Desk log. Holds the slip, the test output, and the stamp time. It is a file, not a third reviewer.

Start. The drafter creates desk/scope.md on the bench branch. The captain is named before the first model call.

Handoff. The drafter runs the tests and saves desk/test.log. The captain checks the slip, the log, and the branch. The captain then writes PASS or HOLD.

Stop. No push when the captain field is empty. No secrets on the free server. No claim of a fixed quota, a fixed machine, or permanent free access.

A door card, then a gate

The page is short on purpose, like a door card in a shop. People ignore long manuals during a contribution rush. A door card stays visible when the queue gets loud.

The local gate is also a proposal, not a hosted control plane. It checks that the slip, the log, and the branch agree. It does not judge code quality or license risk.

#!/usr/bin/env bash
# Proposal only. Does not push, and does not call a remote API.
set -euo pipefail

slip="desk/scope.md"
log="desk/test.log"

test -f "$slip" || { echo "missing scope slip"; exit 2; }
test -f "$log" || { echo "missing test log"; exit 2; }

captain=$(awk -F': ' '/^captain: /{print $2}' "$slip")
branch=$(awk -F': ' '/^branch: /{print $2}' "$slip")

if [ -z "${captain}" ] || [ "${captain}" = "UNSET" ]; then
  echo "captain unset; hold the diff"
  exit 3
fi

current=$(git rev-parse --abbrev-ref HEAD)
if [ "${current}" != "${branch}" ]; then
  echo "branch mismatch: ${current} != ${branch}"
  exit 4
fi

echo "desk ready for captain review on ${branch}"

The gate runs from the repository root after the tests finish. A missing slip exits with code two and a plain message. An unset captain exits with code three and holds the diff.

The slip exists before the first model call on the branch. The captain field stays UNSET until a human accepts the seat. That empty field is the lock, not a decorative label.

ticket: BENCH-104
repo: example/widgets
branch: bench/BENCH-104
captain: UNSET
allowed_files:
  - src/widgets/parse.py
  - tests/test_parse.py
forbidden:
  - secrets
  - deploy keys
  - production urls
tests:
  - python -m unittest tests/test_parse.py

Allowed files should stay narrow, like a marked cutting area. A parser fix does not need a license edit in the same slip. Wide slips hide drive-by changes inside a friendly diff.

A dry-run helper

The captain can check the diff against that file list. The helper below is pseudocode for a local dry run. It was not executed against a live remote in this draft.

#!/usr/bin/env python3
"""Proposed dry-run helper. Unexecuted in this article."""
from pathlib import Path
import subprocess
import sys

def allowed_paths(slip: Path) -> set[str]:
    paths = set()
    in_list = False
    for line in slip.read_text().splitlines():
        if line.startswith("allowed_files:"):
            in_list = True
            continue
        if in_list and line.startswith("  - "):
            paths.add(line[4:].strip())
            continue
        if in_list and line and not line.startswith(" "):
            break
    return paths

def changed_paths() -> list[str]:
    out = subprocess.check_output(
        ["git", "diff", "--name-only", "HEAD"],
        text=True,
    )
    return [p for p in out.splitlines() if p]

def main() -> int:
    slip = Path("desk/scope.md")
    if not slip.exists():
        print("HOLD missing slip")
        return 2
    allow = allowed_paths(slip)
    extra = [p for p in changed_paths() if p not in allow]
    if extra:
        print("HOLD outside slip")
        for path in extra:
            print(path)
        return 3
    print("READY for captain review")
    return 0

if __name__ == "__main__":
    sys.exit(main())

The helper prints HOLD when a changed path leaves the slip. It prints READY only when every path stays inside the list. READY still means the captain must read the diff.

The helper sees tracked diffs and misses untracked files. A captain still lists the working tree before PASS. Running git status remains part of the human read.

A sample command sequence keeps the ritual concrete. The sequence below assumes a toy repo that already has that test module. Nothing in the sample is a customer result or a measured score.

git switch -c bench/BENCH-104
mkdir -p desk
cp docs/scope.example.yaml desk/scope.md
python -m unittest tests/test_parse.py | tee desk/test.log
bash desk/merge-desk.sh
python3 desk/check_slip.py

The tee line saves the test log beside the slip. The gate then refuses to bless a mismatched branch. That refusal is a pause, not a verdict on the patch.

A sample walk

A sample ticket shows the walk without pretending it shipped. The ticket is BENCH-104 on a toy parser in a sample repo. Nothing in that sample is a customer result or a benchmark.

The drafter asks the free model only about the listed parser bug. The prompt stays inside the slip, like a work order above the bench. The model may suggest a fix, and the drafter may edit it.

The drafter copies the command line into the desk log. The log names the test module and the exit status text. The captain then opens the diff and looks for extra files.

If the diff touches a changelog outside the slip, the stamp is HOLD. The drafter trims the extra file or widens the slip with a reason. Widening after the call is allowed only before any push.

Push remains a human command, not a hook this page installs. The bash gate prints a ready line and then stops. It does not call git push, and it should stay that way.

That limit matters on a shared machine with stored credentials. A ready line can tempt a tired captain to ship too fast. The page tells the captain to read the diff anyway.

Quiet failures

Failure usually starts when the drafter skips the slip. The diff looks complete, so the captain trusts the polish. Later the tree holds a change nobody meant to own.

Another failure is a captain named after the push. The stamp then records history instead of controlling it. The captain is named before the bench spends any model call.

A third failure is treating the free server as a vault. Availability is not the same thing as a security boundary. Tokens and production URLs stay on an approved secret store.

Free model access can still emit insecure or unlicensed code. The captain reads for both behavior and license fit. The captain records the license read in the desk log.

This desk is not a cover for bulk generated changes. The desk is not a tool for private repos or private data. Ordinary maintenance on a permitted tree is the whole scope.

Who should wait

Teams without a second reviewer should not adopt the page. Teams that need a fixed token quota should not invent one here. Teams that cannot keep secrets off the bench should wait.

The script can be wrong if the slip uses a loose glob. A glob that matches the whole tree defeats the cutting area. Explicit paths are safer until the team has reviewed the helper.

Time on the free server is not described in this runbook. Hardware shape and model choice are also left unnamed. Those facts belong to current product terms before any trial.

This page is a merge custody run, not a shift schedule. It does not assign on-call hours or batch quiet times. Those topics belong in other notes if the team needs them.

The captain stamp is a short line in the desk log. PASS means the captain read the diff and accepts the push. HOLD means the diff stays on the bench branch overnight.

Overnight is a figure of speech, not a measured service level. The team sets its own review delay outside this page. The page only insists that delay happens before the push.

Other tools can fill the drafter seat if the team prefers them. The custody rule does not depend on a single vendor name. The vendor mention here only marks where the free option fits.

Readers who already keep a wiki can paste the one-page run. They can trial the gate on a throwaway branch this week. That small trial teaches the custody gap better than a slogan.