Prove the Saturday Demo With a Skip Manifest

You open the side project at 9:10 on Saturday morning.
A friend wants a working demo before dinner tonight.
The project folder already holds six half-built ideas.

You do not need a full platform tonight.
You need one path that still runs clean.

The trap is the extra folder, not the missing syntax.
Each new idea feels small until the demo clock hits.
Cut the surface before you ask any model for code.

A generated screen is not a demo if the path fails.
Friends can sketch a page before the coffee cools.
They still ask whether the command exits clean.

Name the constraint before the tool

A free model pass can draft a cut list quickly.
It cannot decide what your friend should see tonight.
A free server can run a smoke command for you.
It cannot hold secrets or promise next month's terms.

Disclosure: This article was prepared as part of MonkeyCode's product outreach.
The operator supplied two availability notes for this draft.
Those notes are free model access and a free server option.
This draft does not quote a token quota or a hardware size.
It does not name a model, a region, or an end date.
Open the current project docs before you plan around either note.
Old posts go stale, and a stale quota wrecks the weekend.

MonkeyCode is the open-source assistant named for this workflow.
Use it as a second reader for a short list.
You still write the skip manifest by hand.
You still run the gate on a machine you control.
Confirm the license on the project page before you reuse the code.

Split the weekend into three lists

Ship is the path you will actually show.
Park is real code you refuse to import tonight.
Skip is work you will not even sketch.
If a file is absent from ship, it stays out of the entry.

Keep each list short enough to read aloud.
Four ship files is already a wide Saturday.
Three parked module names are a healthy cut.
A long skip list protects Monday from surprise scope.

1. Freeze the cut in scope.json

Create the scope file in the repository root.
Put the entry file and the smoke command there.
Do not add a fifth idea while you type the file.

{
  "entry": "demo.py",
  "smoke": ["python3", "demo.py", "--check"],
  "ship": ["demo.py", "scope.json", "demo_gate.py"],
  "park": ["billing.py", "accounts.py", "deploy.py"],
  "skip": ["multi-model bakeoff", "custom domain", "analytics"]
}

This file is the contract for the weekend demo.
A model may suggest a sharper cut here.
You accept or reject each line by hand.

2. Add a gate you can read

Save the proposed script below as a file named demo_gate.py.
This is a proposed example, not a measured benchmark.
It uses only the Python standard library here.
Run it once locally before you trust the output.

#!/usr/bin/env python3
"""Proposed weekend scope gate. Not a production auditor."""
import json
import pathlib
import subprocess
import sys

ROOT = pathlib.Path(__file__).resolve().parent

def load_scope(path: pathlib.Path) -> dict:
    data = json.loads(path.read_text(encoding="utf-8"))
    required = ("ship", "park", "skip", "entry", "smoke")
    for key in required:
        if key not in data:
            raise SystemExit("missing key: " + key)
    return data

def missing_ship_files(scope: dict) -> list[str]:
    missing = []
    for rel in scope["ship"]:
        if not (ROOT / rel).is_file():
            missing.append(rel)
    return missing

def parked_imports(scope: dict) -> list[str]:
    entry_path = ROOT / scope["entry"]
    if not entry_path.is_file():
        return []
    entry = entry_path.read_text(encoding="utf-8")
    hits = []
    for rel in scope["park"]:
        stem = pathlib.Path(rel).stem
        token_a = "import " + stem
        token_b = "from " + stem
        if token_a in entry or token_b in entry:
            hits.append(rel)
    return hits

def main() -> int:
    scope = load_scope(ROOT / "scope.json")
    missing = missing_ship_files(scope)
    hits = parked_imports(scope)
    if missing or hits:
        print("gate: fail")
        for item in missing:
            print("missing ship file: " + item)
        for item in hits:
            print("parked import in entry: " + item)
        return 1
    print("gate: scope ok")
    smoke = scope["smoke"]
    if not smoke:
        return 0
    completed = subprocess.run(smoke, cwd=ROOT, check=False)
    return completed.returncode

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

The import check is a plain string search.
That limit is also the reason you can read it.
You can audit the whole rule without a framework.

3. Keep the demo entry boring

Write the entry so it proves one behavior.
A check flag is enough for the smoke path.
Print one line and exit with a clear status.

#!/usr/bin/env python3
import argparse

def main() -> int:
    parser = argparse.ArgumentParser()
    parser.add_argument("--check", action="store_true")
    args = parser.parse_args()
    if args.check:
        print("demo: ok")
        return 0
    print("demo: run with --check")
    return 2

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

Do not import billing, accounts, or deploy here.
Those module names belong on the park list.
The gate should fail if the entry pulls them in.

4. Run the gate before you celebrate

From the repository root, run the two commands below.
You want a scope line and a demo line.
If either line is missing, stop adding features.

python3 demo_gate.py
python3 -m py_compile demo_gate.py demo.py

On Windows, swap python3 for the launcher you actually use.
A scope-ok line means the lists still match the tree.
A demo-ok line means the smoke path exits clean.

A compile check only proves the files parse.
It does not prove the cut is still honest.

5. Ask the model about the cut only

Paste the scope file into the assistant, not the repo.
Ask which ship line is still too wide.
Reject any answer that adds a new product surface.

Accept an answer that moves a file from ship to park.
That is the useful slot for free model access.
The model is a second reader for a short contract.

It is not a license to generate the parked folders.
If the chat starts inventing billing flows, close the tab.

A free server option can host the smoke command.
Use that option only when you can read the logs.
Do not upload keys, private repos, or customer rows.

A Saturday demo should run on toy input you can delete.
If the path needs a secret, keep the run on your laptop.

6. Write the skip note before dinner

Add a skip note before you leave the desk.
Three lines are enough if each line has a reason.
Future you should not recover the cut from guilt.

# Skipped this weekend
- Accounts: no login, because the demo is one local command.
- Billing: no prices, because nothing is sold tonight.
- Deploy polish: no custom domain, because localhost is the demo.

Read that note out loud when you show the demo.
A small working path beats a tour of empty stubs.
Say what you parked, then run the smoke command once.

7. Show only what the lists can defend

Your friend will ask three questions at the table.
Answer each from a ship file, or say it was skipped.
Do not open a parked file to improvise a feature.

The first question asks what the command prints.
That answer lives in the entry and nowhere else.
The second question asks what you refused to build.

That answer lives in the skip note you wrote.
The third question asks how you know it still runs.
That answer is the gate exit code, not a screenshot.

If you cannot map a question to a ship file, park it.
A demo with unmapped questions turns into a tour.
Tours run long, and long tours hide a broken path.

Debug a red gate without widening scope

Use this order when the gate exits with an error.
Do not open a parked file to finish the thought.

1. Read the first fail line and touch only that cause.
2. If a ship file is missing, create it or move it to park.
3. If a parked import appears, delete that import from the entry.
4. If the smoke command fails, fix the entry and nothing else.
5. Run the gate again before you edit any other file.

A commented-out check is not a real fix.
You would be hiding the cut instead of holding it.
The red line is the product for this weekend.

Try this four-row test plan

Label these rows as checks you should run yourself.
This draft does not claim a recorded test log.
Restore the clean tree after you finish each row.

Check	What you change	What you expect
Clean tree	No parked import in the entry	Exit 0 and demo: ok
Park leak	Add import billing to the entry	Exit 1 and a parked-import line
Missing ship	Rename demo.py for one run	Exit 1 and a missing-file line
Smoke fail	Make --check return 2	Gate returns 2 after the scope line

A test that leaves the demo broken is a new bug.
Write the four results in the skip note if you want them.

Choose local or the free server

Question	Stay on your machine	Free server option
Does the path need a secret?	Yes. Keep it local.	No. Do not upload secrets.
Is the input toy data you can delete?	Either place can work.	Fine if you can read logs.
Will you be offline after dinner?	Prefer the laptop copy.	Do not depend on the host.
Do you need a public URL tonight?	Not for this cut.	Recheck terms before you share.
Is the goal a platform launch?	Stop. This gate is too small.	Stop. This gate is too small.

The table is a filter, not a hosting promise.
A free server can throttle, vanish, or change terms.
Your demo must still run from the laptop copy.

Treat the hosted run as a spare, not the source.
Recheck the current terms before you share a hosted URL.
A link that dies after dinner is not a demo.

What the gate does not prove

The string search misses importlib and aliased imports.
A pass is a tripwire, not a security audit.
Read the entry once with your own eyes anyway.

Dynamic imports can still walk around this check.
The gate runs whatever command the smoke list holds.
Put only a command you would type yourself.

The smoke list is passed without a shell.
Pipes and shell operators will not run here.
That keeps a sloppy paste from becoming a surprise.

A command copied from chat is still your responsibility.
The gate does not rank models or vendors.
It does not prove a free tier will last.

If a launch date needs a fixed quota, get it in writing.
Do not paste an old token number into your plan.

Who should not use this cut

Skip this approach if the demo touches payments.
Skip it if the files hold private user data.
Skip it if a teammate needs an audit trail.

Skip it if the weekend is actually a client deadline.
Skip it if you would paste production secrets into a host.
A skip manifest will not save those projects.

Those projects need a slower review, not a dinner demo.
Use the gate for toy side projects with a visible cut.

Leave a Monday trail

Open the repo on Monday before new ideas land.
Run the same two commands before you edit anything.
If the gate fails, you added scope after the demo.

Move the new file to park, or delete it.
Do not bargain with a red gate on a weekday morning.
Then add one fresh line to the skip note.

Name the idea you still refuse this week.
The demo stays small because the list stays honest.

If MonkeyCode is already open, use one free pass.
Spend that pass on the skip list only.
Close the chat right after that single pass.

Run the gate yourself and trust the exit code.
The pass is only a suggestion you can drop.
The local gate is the decision you keep.