Sunday Demo Gate: Keep a Skip Log or Overbuild

You sit down Saturday with a long feature list.
Your coding agent treats every idea as in scope.
You need a Sunday demo, not a half-built platform.

This is a scope cut, not a launch plan.
You freeze one user path before any code lands.
You keep a skip log so extra work stays extra.

The Saturday overbuild scene

You paste a vague goal into the agent chat.
It replies with auth, dashboards, queues, and extra APIs.
You asked for a working demo. It planned a company.

That habit is the current agent default, not a bug.
Models can draft almost any feature in minutes.
Minutes are cheap. Sunday night is not cheap.

You do not win by generating more files.
You win by naming what the demo is not.
Write that refusal down before the first patch.

Artifact: the weekend one-path card

Create WEEKEND.md in the repository root tonight.
Keep the file short, brutal, and mechanically checkable.
If a task is not on the card, you skip it.

# Weekend one-path card

## Demo path (only this)
Visitor opens /receipt.html
Visitor sees the frozen one-path sentence
Visitor sees a skip count greater than zero

## Skip log lives in SKIPLOG.md
Every rejected idea gets one table row.
Rows are not tickets for this weekend.

## Demo gate
./scripts/demo_gate.sh must exit 0
No second HTML page. No new dependency.

Paste the card into every later prompt.
Do not renegotiate it after the agent gets excited.
Excitement is how weekend scope dies.

Step 1: freeze the path in one sentence

Write one sentence you can click on Sunday.
"A visitor can open /receipt.html and see the cut."
That sentence is the whole product this weekend.

Put the sentence at the top of the prompt.
Tell the agent to refuse work outside it.
Ask for a skip list, not a backlog of extras.

Use this labeled starter prompt:

Read WEEKEND.md first.
Build only the demo path in that file.
Do not add files for skipped items.
After the plan, print a skip log table.
Do not implement any row from that table.
Stop when ./scripts/demo_gate.sh exits 0.

If the plan mentions login, you stop the run.
If the plan mentions a second route, you stop.
Point the agent back at the one sentence.

Step 2: write the skip log before code

Skipped work is a deliverable, not a footnote.
Agents hide extra scope inside "while we are here."
A table makes that visible on Saturday morning.

Create SKIPLOG.md with this shape:

# Skip log — 2026-09-09

| Idea | Why it sounds useful | Why it waits |
| --- | --- | --- |
| JWT login | Receipt looks more "real" | Demo has no private data |
| Postgres | Skip count might need history | A static number is enough |
| Email digest | Feels like a real product | There are no users yet |
| Component kit | Page looks unfinished | One HTML file is a demo |
| Extra /admin page | You might edit skips later | Sunday is for the gate |

Review the table before any generate step.
If a row is not the demo path, it stays skipped.
Do not delete the row to soothe the agent.

Step 3: define working demo as a command

A screenshot is not a demo this weekend.
A passing command is the only done definition.
If the command fails, you are not finished.

Create scripts/demo_gate.sh as a labeled starter:

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

root="$(cd "$(dirname "$0")/.." && pwd)"
cd "$root"

port="${PORT:-8787}"
log="$(mktemp)"
pid=""

cleanup() {
  if [[ -n "${pid}" ]] && kill -0 "${pid}" 2>/dev/null; then
    kill "${pid}" 2>/dev/null || true
    wait "${pid}" 2>/dev/null || true
  fi
  rm -f "${log}"
}
trap cleanup EXIT

test -f public/receipt.html
test -f SKIPLOG.md
test -f WEEKEND.md

python3 -m http.server "${port}" --directory public >"${log}" 2>&1 &
pid="$!"
sleep 0.4

html="$(curl -fsS "http://127.0.0.1:${port}/receipt.html")"

echo "${html}" | grep -q "Demo path"
echo "${html}" | grep -q "Skipped:"

rows="$(grep -c '^|' SKIPLOG.md || true)"
if [[ "${rows}" -lt 3 ]]; then
  echo "skip log is too thin" >&2
  exit 1
fi

echo "demo gate passed"

The script is intentionally shallow.
It checks the one path. It ignores polish.
Do not grow it into a full suite this weekend.

Then run:

chmod +x scripts/demo_gate.sh
./scripts/demo_gate.sh

Failing output is useful. Passing output means stop.
You do not add a second page after a pass.
The gate is a brake, not a trophy.

Step 4: give the agent a hard stop rule

"Looks good" is not an exit condition.
"We can add this quickly" is not an exit condition.
demo_gate.sh exiting 0 is the exit condition.

Add this block under the path sentence:

Stop when all of these are true:
1. public/receipt.html shows the frozen path.
2. ./scripts/demo_gate.sh exits 0.
3. SKIPLOG.md lists every rejected extra.
4. git diff --name-only stays on the card files.

Check the file list yourself after each run:

git diff --name-only
git status --short

If a new stylesheet framework appears, revert it.
If a second HTML file appears, revert it.
The skip log already explained why it waits.

Step 5: keep the laptop free with a remote run

Local setup can burn half of Saturday.
Port clashes, language versions, and leftover processes stack up.
A free server is useful when that noise starts winning.

MonkeyCode fits this step if you lack spare hardware.
Disclosure: This article was prepared as part of MonkeyCode's product outreach.
It provides free model access and a free server option.
Use both as a quiet place to run the same gate, not as extra product scope.

Same WEEKEND.md. Same skip log. Same script.
If the gate fails on the remote box, the demo failed.
If you want that isolated weekend run, try those free options on this card.

A labeled remote check looks like this:

# labeled example — replace host and path
ssh weekend-box 'cd ~/receipt-demo && ./scripts/demo_gate.sh'

You still read the diff. The box does not ship for you.
Free compute does not unlock a second feature.
It only lets the gate fail before Sunday panic.

A starter page that matches the gate

Label this HTML as an unexecuted starter example.
Put it in public/receipt.html and stop there.

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="utf-8" />
  <title>Weekend receipt</title>
</head>
<body>
  <h1>Demo path</h1>
  <p>Visitor opens /receipt.html and sees the cut.</p>
  <p>Skipped: 4 items on purpose</p>
</body>
</html>

Run the gate after the file exists.
If it passes, the weekend build is complete.
Do not "just add" an edit form after that.

What you skip on purpose

Skip auth. The receipt page is public on purpose.
Skip a database. A skip count does not need tables.
Skip a design system. One HTML file can prove the path.

Skip extra routes. /receipt.html is the product.
Skip notifications. Nobody is on call for this demo.
Skip coverage theater. The gate is the only proof.

Write future tickets if that calms you down.
Do not let those tickets leak into Sunday's diff.
A passing demo plus a skip log is the ship.

Limitations

This method is rude to product ambition.
It will reject good ideas that miss the path.
That rudeness is the two-day constraint working.

The gate is shallow. It does not prove security.
It does not prove load. It does not prove taste.
It only proves the one path still responds.

Free model access can still invent extra files.
A free server can still host an overbuilt tree.
The card and the skip log remain the control.

Do not use this for production authentication work.
Do not use this when you need compliance evidence.
Do not use this if the demo path is still fuzzy.

Close

Saturday is for cutting. Sunday is for the gate.
You ship one path. You publish the skip log.
That pair is a finished weekend side project.