Hide Unchecked Lines Before the Sunday Demo

You sit down at two on Saturday afternoon. Your friend wants a demo before Sunday dinner.

The model draft sounds tidy, but no line is proven. You freeze scope before you write another prompt.

The room you actually have

You have one laptop and one local fixture file. You do not have a reviewed UI or a shared host.

The demo must run from one command in the repo. If that command fails, you show the friend nothing.

The cut you make first

You keep three jobs, and you name them out loud. You parse the fixture, stamp each row, and print a card.

You park retries, a web view, and multi-file search. Those parked jobs wait until Monday, not Sunday night.

Why a stamp beats a longer draft

Fluent text is not the same thing as a checked fact. A weekend demo fails when you read unchecked lines aloud.

The stamp blocks that slide before your friend arrives. You can still explain the parked list after the card.

The fixture you freeze

Each row is one JSON object on its own line. The text field holds the sentence you might say aloud.

The source field must read fixture before a row can show. A model draft can sit in the file, but it stays hidden.

Step 1: Write the fixture

Create a folder named fixtures in the repo root. Save the four rows below as fixtures/saturday.jsonl in the repo.

Keep the file small so you can read every line yourself. Do not paste secrets, customer logs, or private paths.

{"text": "Parser reads JSONL from a local path.", "source": "fixture"}
{"text": "Stamp hides rows that did not come from the fixture.", "source": "fixture"}
{"text": "Demo card prints at most three checked lines.", "source": "fixture"}
{"text": "The model also suggested a live retry loop.", "source": "model"}

Step 2: Add the stamp script

Save this file as demo_stamp.py beside the fixtures folder. Treat it as an unexecuted example until you run it locally.

The script does not call a network and does not score a model. It only sorts rows you already placed on disk. Use Python 3.9 or newer for the list type hints.

from pathlib import Path
import json
import sys

SKIP = ("retry_loop", "web_ui", "multi_file_search", "remote_host")

def load_fixture(path: Path) -> list[dict]:
    rows = []
    for line in path.read_text(encoding="utf-8").splitlines():
        if not line.strip():
            continue
        rows.append(json.loads(line))
    return rows

def stamp(row: dict) -> dict:
    text = str(row.get("text", "")).strip()
    source = str(row.get("source", "")).strip()
    checked = bool(text) and source == "fixture"
    return {
        "text": text,
        "source": source or "missing",
        "stamp": "checked" if checked else "hold",
    }

def demo_card(rows: list[dict]) -> list[dict]:
    stamped = [stamp(row) for row in rows]
    return [row for row in stamped if row["stamp"] == "checked"][:3]

def main() -> int:
    if len(sys.argv) != 2:
        print("usage: python demo_stamp.py fixtures/saturday.jsonl")
        return 2
    path = Path(sys.argv[1])
    if not path.is_file():
        print("demo blocked: fixture file is missing")
        return 1
    card = demo_card(load_fixture(path))
    if not card:
        print("demo blocked: no checked lines")
        return 1
    for item in card:
        print(f"CHECKED {item['text']}")
    print("skipped:", ", ".join(SKIP))
    return 0

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

Step 3: Run one command

From the repo root, run the script against the fixture. You should see three CHECKED lines and one skipped footer.

The model row must not appear in the CHECKED list. If it appears, stop the demo and fix the stamp rule.

python demo_stamp.py fixtures/saturday.jsonl

A clean run prints the three fixture sentences first. Then it prints the parked names in a single skipped line.

That pair is the whole Sunday demo, and nothing more. You do not open a browser, and you do not retry a call.

Step 4: Lock the rule with a test

Create tests/test_demo_stamp.py before you treat the demo as ready. The test checks the card length and the hidden model row.

It also checks that an empty text row never becomes checked. Run it from the repo root so the import resolves. Use the standard library only, so you add no dependency.

import unittest
from demo_stamp import demo_card, stamp

class DemoStampTest(unittest.TestCase):
    def test_card_hides_model_rows(self):
        rows = [
            {"text": "One checked line.", "source": "fixture"},
            {"text": "A fluent guess.", "source": "model"},
        ]
        card = demo_card(rows)
        self.assertEqual(len(card), 1)
        self.assertEqual(card[0]["source"], "fixture")

    def test_empty_text_stays_on_hold(self):
        row = stamp({"text": "  ", "source": "fixture"})
        self.assertEqual(row["stamp"], "hold")

if __name__ == "__main__":
    unittest.main()

python -m unittest discover -s tests -t .

You want two tests and an OK line before you share the room. If a test fails, you fix the rule, not the fixture story.

Do not delete a failing test to make Sunday feel smoother. A red test is a better demo than a fake green card.

Read the decision table

Use this table when a new row shows up late. Read the signal, apply the stamp, then take one action.

Do not add a fourth action during the Saturday window. If a row does not match, you hold it and move on.

Signal	Stamp	Action
Non-empty text and source fixture	checked	Print it, up to three lines
Source is model	hold	Hide it from the demo card
Empty text or missing source	hold	Hide it and keep going
Work sits in the skip tuple	parked	Name it once in the footer

A checked stamp means you marked the source yourself. It does not mean an outside reviewer proved the sentence.

Say that limit out loud if your friend asks for certainty. The card is a gate, not a certificate.

What you skipped on purpose

You skipped a retry loop because Sunday does not need one. A retry hides a bad fixture behind another model draft.

You skipped a web UI because the command already fits the room. You skipped multi-file search because one file is easier to audit.

You also skipped a remote host for this particular demo. The laptop command is enough for one friend at one table.

A shared host can wait until the card stays green locally. Shipping the host first would only add a new failure point.

Where a free lane can help later

You can draft the next fixture row with free model access. Disclosure: This article was prepared as part of MonkeyCode's product outreach.

Paste that draft into the file with source set to model. The stamp hides it until you rewrite it as a fixture fact.

Do not plan Sunday around a quota you have not verified. This note does not name models, hardware, or a time limit.

Keep the demo on the laptop until the two tests pass. After the local gate is green, try the free server option.

Limits you should say aloud

The script trusts the source field you typed by hand. A wrong source label can smuggle an unchecked line through.

Read the fixture once before you run it live. If you cannot read it, you are not ready to demo it.

Broken JSON stops the script with a traceback, not a card. Fix the line, then run the unit test again from the root.

The three-line cap hides extra checked rows on purpose. Add a fourth spoken line only after Monday, not during dinner.

This pattern is a poor fit for private customer data. It is also a poor fit for a live incident bridge.

It will not tell you which model is smarter this month. Use it for a small side demo, not for a production gate.

Who should leave this on the shelf

Skip this build if you need a reviewed security control. Skip it if the fixture would contain secrets or personal data.

Skip it if your friend needs live data from another system. Skip it if you cannot show the parked list without embarrassment.

You should also skip it when the scope is already one command. A second gate will only slow a demo that is already honest.

Use the table when model prose is trying to widen Saturday. That is the failure this build log is meant to catch.

Monday, after the friend leaves

Copy any held row you still believe into a new note. Rewrite it in your own words, then set source to fixture.

Add one parked job back only after the two tests stay green. Leave the other parked jobs on the list until you have time.

That keeps the weekend promise small enough to finish. Your friend saw three checked lines and an honest skip line.

You did not pretend a draft was a finished tool. Next Saturday can start from the note, not from a blank repo.