Weekend Build Log: Two Keep Rows and a Hard Stop

You sit down with a messy side project. Twelve notes fight for one short Saturday afternoon. A friend asked to see a demo before dinner.

You will not build the full app today. You will build a scorecard that cuts scope. The demo is one command and one text file.

Name the afternoon constraint

Saturday has a hard stop you cannot move. You can test one path, not a platform. Every extra screen steals time from the path that matters.

Pick one specific reader for the afternoon demo. A friend who can run a script is enough. A public signup flow is out of scope.

Ship a scorer, not a product

The artifact is a small local scorer script. It reads a backlog file that you control. It prints keep, defer, or cut for each line.

You can rerun it after every small edit. The output is plain text, so diffs stay readable. No database sits between you and the result.

Do not demo a pile of generated files

A generated repo can look finished and still hide scope. Your friend cannot review twelve half pages in one sitting. The scorecard gives them one command and a skip list.

Use hosted help only for ties

Some backlog lines stay too vague to score. A model can propose a score, but it must not own the merge. Local rules still decide the default cut label.

Disclosure: This article was prepared as part of MonkeyCode's product outreach. This draft uses two operator-supplied availability claims only. Those claims are free model access and a free server option.

Do not treat this post as a quota sheet. It states no model names, token caps, hardware sizes, or end dates. Check the current docs before you rely on any limit.

Use the free server only as a place to run this tiny checker. Use free model access only to break scoring ties. If either option is down, the local rules still finish the demo.

1. Put the backlog in a file

Create the backlog file with four plain columns. Use id, idea, hours, and demo value fields. Keep hours as a single integer you believe today.

id  idea    hours   demo_value
1   score each idea from a file 2   5
2   render a dashboard  8   2
3   add user accounts   6   1
4   print skipped items 1   5
5   deploy a multi-tenant API   10  1
6   split one parser idea   3   4

Hours are your estimate, not a measured result. Demo value is a rank from one to five. Five means a friend can see it in the demo.

Add a sixth row only if you can defend it. A long list feels productive and hides the cut. Stop at the rows you might actually touch today.

2. Score with local rules first

Save this checker script locally as scope_score.py today. It is an unexecuted example until you run it. It needs only Python 3, with no extra packages.

#!/usr/bin/env python3
"""Score a weekend backlog. Local rules always run."""

import sys

def score_row(idea_id, idea, hours, demo_value):
    hours = int(hours)
    demo_value = int(demo_value)
    if hours > 4 or demo_value < 3:
        decision = "cut"
        reason = "too long or weak demo value"
    elif hours <= 2 and demo_value >= 4:
        decision = "keep"
        reason = "short and visible"
    else:
        decision = "defer"
        reason = "possible, but not this demo"
    return {
        "id": idea_id,
        "idea": idea,
        "decision": decision,
        "reason": reason,
    }

def load_rows(path):
    rows = []
    with open(path, encoding="utf-8") as handle:
        header = handle.readline()
        if not header.startswith("id\t"):
            raise SystemExit("expected TSV header")
        for line in handle:
            line = line.strip()
            if not line:
                continue
            parts = line.split("\t")
            if len(parts) != 4:
                raise SystemExit("bad row")
            rows.append(parts)
    return rows

def main():
    path = sys.argv[1] if len(sys.argv) > 1 else "backlog.tsv"
    kept = 0
    for idea_id, idea, hours, demo_value in load_rows(path):
        row = score_row(idea_id, idea, hours, demo_value)
        print(
            f"{row['id']}\t{row['decision']}\t{row['reason']}\t{row['idea']}"
        )
        if row["decision"] == "keep":
            kept += 1
    if kept == 0:
        raise SystemExit("no keep rows; shrink an idea")
    if kept > 2:
        raise SystemExit("too many keep rows; cut more")

if __name__ == "__main__":
    main()

The script refuses an empty keep list outright. It also refuses more than two keep rows. That hard cap is the real scope cut.

Read the reasons printed on each result line. A cut for weak demo value is not an insult. It is a time box you chose this morning.

3. Check the rules before you code

You do not need a separate test framework. A shell check is enough for this demo. Run it from the same folder as the script.

python3 scope_score.py backlog.tsv
echo "exit=$?"

Expect ids 1 and 4 to print keep. Expect row 6 to print defer, not keep. A non-zero exit means you fix the file first.

This check is a plan, not a recorded lab result. Run it on your machine before you trust the output. Change the numbers only when your afternoon budget changes.

Break the sample file on purpose one time. Delete a column and confirm the script exits. That failure proves the parser is guarding the demo.

4. Ask for a smaller slice on defer rows

Local rules already labeled the obvious hard cuts. A model is useful when a row says defer and you cannot decide. Paste one defer row, not the whole product wish list.

Ask for a smaller version that fits two hours. Ask which part a friend can see quickly. Reject any answer that adds a new screen.

If you use MonkeyCode here, send only that one row. Keep private secrets out of the model prompt. Store the reply beside the TSV so the choice stays visible.

The free server can host the same script if you want a shared URL. Copy the file, run the same command, and compare the text. Do not add login before the text demo works.

No endpoint, model id, or client flag is specified here. Follow the docs that match your account today. If the docs and this post disagree, follow the docs.

Treat the model note as a comment, not a commit. You still edit the TSV file by hand. You still rerun the local command after the edit.

5. Write the skip list before you build

Open a skipped notes file and list every cut. Write the reason in one short clear line. This file is part of the demo, not an apology.

Read this decision table out loud one time. If a row still feels exciting, it stays cut anyway. Excitement is not an acceptance test for Saturday.

6. Show the command, then stop

Run the scorer and show the keep lines. Then show the skip file without extra slides. Stop talking when those two artifacts are clear.

python3 scope_score.py backlog.tsv > score.txt
wc -l skipped.md score.txt

A passing demo has two keep lines or fewer. It has a skip file with real cuts. It has no new dependency and no secret in the repo.

If you deploy at all, deploy this command only. A free server is a host, not a reason to add queues. Take the process down when the weekend ends if you will not maintain it.

When the command fails

Read the exit text before you edit code. The exit message names the gate that fired. Fix the TSV, then rerun the same command.

Do not silence the exit with a broad exception. A green run that hides a bad file is not a demo. Keep the hard stop inside the checker script.

What you skipped on purpose

You skipped the web interface and its empty states. You skipped accounts, password reset, and email flows. You skipped billing, teams, and a background worker.

You skipped model shopping across a public leaderboard. You skipped benchmarks you did not run yourself. You skipped any claim about speed, uptime, or token balance.

That written skip list is the actual point. A weekend demo fails when leftover work stays invisible. Write the leftovers down so Monday can ignore them.

Limits you should say out loud

The hour numbers are guesses you made quickly. A bad guess can keep a task that still blows the afternoon. Re-score the row after the first failed run.

Model text can sound sure and still be wrong. Do not let it raise demo value above your own rank. You own the TSV and the final label.

Free access can change, pause, or differ by account. This article is not a promise of capacity or duration. Read the live plan before a friend depends on it.

The script trusts the TSV file you wrote. It is not a security boundary for uploads. Do not point it at files from strangers.

Python version drift can still break a one-file demo. Pin the command you actually ran in the note. If python3 is missing, install it before you blame the rules.

Who should not use this cut

Skip this flow if you need a service level tonight. A side-project checker is not an on-call system. Use a supported host with an owner if others depend on it.

Skip it if your notes cannot leave the laptop. Do not paste private issues into a hosted model. Keep the local rules and omit the hosted step.

Skip it if the real job is a visual review. A text scorecard will not answer layout questions. Build the screen only after the cut list is honest.

Skip it if you need measured throughput numbers. Nothing in this build log is a benchmark. Do not publish figures you did not collect.

Close on the same small commit

Commit the TSV, the script, the skip file, and the score output. Leave a one-line note on how to run the command. That note is the handoff to your future self.

You can split one defer row next weekend. Until then, the local gate is enough for the friend demo. The demo is the cut, not the pile you hoped to build.

If you already have a MonkeyCode login, use it for one defer row only. Keep the sample TSV in version control either way. The command should still pass with the network turned off.