Run the Triage Demo With the Network Off

Saturday hits, and the issue list is still messy. You promised a working triage demo before dinner. Forty leftover titles still sit in the tracker.

A full board app will not fit this afternoon. You need three labels and one reliable command. Anything heavier than that waits until Monday.

Cut the job to three labels

Name the job in one plain sentence first. Each leftover title becomes keep, park, or drop. That is the whole product for this afternoon.

Keep means you will touch it next week. Park means it is real, but not this weekend. Drop means it does not earn a slot.

Park the extra ideas

Write a cut list before you create the first file. You skip a web UI and a login flow. You skip a database and a hosted dashboard.

You also skip a live model beauty contest. One draft pass is enough for this demo. A second vendor does not make the demo safer.

You also skip embeddings, queues, and background workers. You skip charts that praise a score you never ran. You skip any feature that needs a secret in the repo.

Lock the row contract

Put the rules in a file you can diff later. Input is a title string plus a short note. Output is one label plus a short reason.

Reject empty titles before you make any model call. Reject any label outside the three allowed words. Reject any reason that runs past twelve words.

Require a stable id on every single row. Never match rows by title text alone later. Titles can repeat, while row ids should not.

1. Hand-label eight gold rows

You label eight sample rows by hand first. Do this before you ask any model for help. Your labels are the contract, not a suggestion.

Pick boring titles from your own issue tracker. Include one ambiguous title in the set on purpose. Include one title that should clearly be dropped.

Write each reason in your own plain words. If you cannot justify a label, park the row. Do not let haste invent a fourth label.

2. Take one model draft

Now you may ask a model for a single draft. Disclosure: This article was prepared as part of MonkeyCode's product outreach. MonkeyCode offers free model access and a free server option.

Treat both as current availability, not as a quota promise. Use the free model access for this one draft pass. Do not send private customer data in the prompt.

Paste only titles you already cleared to share. Save the raw draft beside the gold file. If the two files disagree, the gold file wins.

Do not edit gold labels to flatter the draft. Do not rerun the model until the labels match. A demo that needs retries is not ready.

3. Diff labels before you accept them

Run a small checker before you trust any row. The checker compares only the label field on each row. A reason mismatch is a note, not a hard failure.

Count matches, mismatches, and any missing row ids. Stop if any gold id is missing from the draft. Stop if any label falls outside the allowed set.

Print the mismatched ids in a plain list. Read each miss before you accept a fixture row. Acceptance is a human step, not a script step.

4. Freeze the rows you accept

Copy only accepted rows into the demo fixture. The demo command reads that fixture, not the network. Your Saturday audience then sees one stable result.

Name the fixture with the date you froze it. Add a header note that the file is a recording. Ban live model calls while demo mode is on.

Keep rejected rows in a separate scratch file. Do not delete them, because they teach the next cut. Do not show scratch rows in the dinner demo.

5. Print the demo from disk

Give yourself one demo command for the room. That command prints the fixture as a short table. It must succeed with the network fully unplugged.

If the command tries to call a model, fail it. If the fixture file is missing, fail the run. If a row label is unknown, fail the run.

Print the fixture date at the top of the output. Print the row count next to that date. A silent success can hide a stale fixture file.

6. Serve a link only if someone is remote

A laptop demo does not need any server. Use a free server only when a remote person must open a link. Even then, serve the frozen fixture, not a live model.

The free server option can host that static demo. Read the current product docs before you depend on it. Do not assume hardware, duration, or a fixed token quota.

Put the fixture file behind a read-only path. Do not expose a prompt box on that page. A prompt box invites a live call you banned.

Use this decision table

Use the table when you feel tempted to add scope. Each row names the temptation, the safer keep, and the stop. Follow the stop column when your time is short.

Temptation	Safer keep	Stop now
Live model during the demo	One draft saved beside gold	Any call while demo mode is on
Web UI before dinner	Plain table from the fixture	Login, routing, or a CSS framework
Server for a solo laptop demo	Local command on your machine	A host when nobody is remote
Accuracy number in the README	Printed list of mismatched ids	Any percent you did not measure
Fourth label for odd titles	Park the unclear row	A new label name

Proposed checker

Treat the script below as a proposal, not a lab report. It has not been executed in this writeup. Run it locally before you trust the output.

Start with the gold file present and valid. Confirm the checker exits zero on a perfect copy. Then break one label and confirm a nonzero exit.

Unplug the network and run the demo command. Confirm the same table prints a second time. Confirm no outbound call appears in the process log.

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

ALLOWED = {"keep", "park", "drop"}

def load_payload(path):
    file_path = Path(path)
    if not file_path.exists():
        raise SystemExit(f"missing file: {path}")
    payload = json.loads(file_path.read_text())
    rows = payload["rows"]
    seen = set()
    for row in rows:
        if row["id"] in seen:
            raise SystemExit(f"duplicate id: {row['id']}")
        seen.add(row["id"])
        if row["label"] not in ALLOWED:
            raise SystemExit(f"bad label: {row['id']}")
        if not str(row["title"]).strip():
            raise SystemExit(f"empty title: {row['id']}")
    return payload

def diff_labels(gold, draft):
    draft_by_id = {row["id"]: row for row in draft}
    misses = []
    for row in gold:
        other = draft_by_id.get(row["id"])
        if other is None:
            raise SystemExit(f"missing id: {row['id']}")
        if other["label"] not in ALLOWED:
            raise SystemExit(f"bad draft label: {row['id']}")
        if other["label"] != row["label"]:
            misses.append(row["id"])
    return misses

def main():
    mode = sys.argv[1]
    if mode == "check":
        gold = load_payload(sys.argv[2])["rows"]
        draft = load_payload(sys.argv[3])["rows"]
        misses = diff_labels(gold, draft)
        if misses:
            print("mismatch", ",".join(misses))
            raise SystemExit(1)
        print("match", len(gold))
        return
    if mode == "demo":
        payload = load_payload(sys.argv[2])
        print("source", "fixture")
        print("frozen_on", payload.get("frozen_on", "missing"))
        print("rows", len(payload["rows"]))
        for row in payload["rows"]:
            print(row["id"] + " | " + row["label"] + " | " + row["title"])
        return
    raise SystemExit("use check or demo")

if __name__ == "__main__":
    main()

{
  "frozen_on": "2026-10-12",
  "source": "hand-accepted fixture",
  "rows": [
    {
      "id": "t1",
      "title": "Fix flaky login test",
      "label": "keep",
      "reason": "Breaks the Monday build."
    },
    {
      "id": "t2",
      "title": "Rename button color token",
      "label": "park",
      "reason": "Real, but not this weekend."
    },
    {
      "id": "t3",
      "title": "Rewrite app in a new framework",
      "label": "drop",
      "reason": "Too large for the slot."
    }
  ]
}

python triage_fixture.py check gold.json draft.json
python triage_fixture.py demo fixture.json

Save the model draft yourself, outside this script. Do not hide an API call inside demo mode. If you need a draft, make that call once, then stop.

The date inside the sample file is only an example. The three titles are stand-ins, not a real tracker. Replace them with titles you are allowed to share.

Know the limits

Free access can change without a public warning. A fixture goes stale when title meanings change. A model draft is untrusted text, not a decision.

This flow does not measure real model quality. Eight gold rows cannot prove a general classifier. Do not quote a score you did not measure.

The free server option is not a capacity plan. It is only a way to show a static file. If the offer is gone, the laptop demo still stands.

Who should not use this

Skip this flow for live production incident routing. Skip it when a wrong label can page a person. Skip it when titles hold secrets or personal data.

Skip it if you need an audited trail of model calls. Skip it if the demo must show live model output. In that case, say plainly that the result can change.

Skip it if you cannot hand-label even eight rows. Without gold labels, you only have a hunch. A hunch is not a weekend demo you can defend.

Leave a Monday note

On Monday, reread the cut list before you expand scope. Add a UI only after the fixture test still passes. Add a live call only behind a flag you can disable.

If that flag is on, keep the fixture as fallback. Print which source served each row in the table. Never hide a live call inside the demo script.

You leave Saturday with a command, a fixture, and a cut list. That is a demo you can rerun on Monday. The model helped once, then left the stage.

If you want the draft pass there, read the current MonkeyCode docs. Keep the public demo pinned to the fixture.