Weekend Build Log: Freeze the Scope Card First

You sit down on Saturday with a side project idea.
The idea is a helper that reviews a local git diff.
You want comments, a summary, and a patch suggestion.

Two hours later the notes include a web UI.
You still have no command that runs on your laptop.
Scope grew faster than the demo you promised yourself.

You fix that with a scope card on disk.
The card is a small JSON file you write first.
No model call is allowed before that file exists.

This is a plan you can run this weekend.
It is not a report of measured results.

What you are actually building

You are building a weekend gate, not a product.
The gate answers three questions in one file.
What stays in scope for this single demo.

What did you cut on purpose this weekend.
Which single step is allowed to call a model.
You keep the tool local and boring on purpose.

A Python script writes the card to disk.
A second command checks the card before you continue.
You can read that file in any text editor.

The scene you already know

You told yourself the demo needed a dashboard.
Then you added login, because dashboards need users.
Then you added a queue, because login needs jobs.

None of that helps you judge a diff today.
Cut the dashboard before you write more code.
Cut login, queues, and streaming from the plan.

Keep one input path and one output file.
That is enough for a Sunday afternoon demo.
You can add surfaces later, after the gate works.

Step 1: Put the card on disk

Create a file named scope_card.py in an empty folder.
The script below is a proposal you can run locally.
It was not executed as part of this draft.

Treat the sample paths as examples, not as your repo.
The script only writes JSON and checks required keys.
It does not read secrets and it does not open a network socket.

#!/usr/bin/env python3
"""Write a weekend scope card before any model call."""

import json
import sys
from datetime import datetime, timezone
from pathlib import Path

REQUIRED = ("goal", "in_scope", "cut", "model_step", "skip_until")

def build_card(goal: str) -> dict:
    return {
        "goal": goal,
        "in_scope": [
            "read a unified diff from stdin",
            "write one scope card",
        ],
        "cut": [
            "web UI",
            "auth",
            "job queue",
            "multi-file patch apply",
        ],
        "model_step": "summarize the diff in one paragraph",
        "skip_until": "card file exists and checks pass",
        "written_at": datetime.now(timezone.utc).isoformat(),
    }

def main() -> int:
    if len(sys.argv) != 3:
        print("usage: scope_card.py write|check CARD.json", file=sys.stderr)
        return 2
    command, raw_path = sys.argv[1], sys.argv[2]
    path = Path(raw_path)
    if command == "write":
        card = build_card("Review one local diff this weekend.")
        path.write_text(json.dumps(card, indent=2) + "\n", encoding="utf-8")
        print(f"wrote {path}")
        return 0
    if command == "check":
        card = json.loads(path.read_text(encoding="utf-8"))
        missing = [key for key in REQUIRED if not card.get(key)]
        if missing:
            print("missing: " + ", ".join(missing))
            return 1
        print("scope card ok")
        return 0
    print("unknown command", file=sys.stderr)
    return 2

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

Run the write command before you open a chat window.

python3 scope_card.py write ./scope-card.json
python3 scope_card.py check ./scope-card.json

You should see a write line, then a pass line.
If the check fails, you do not call a model yet.
Fix the card, then run the check command again.

A missing card file raises an error from the script.
Treat that error as a failed check, not a surprise.

Step 2: Freeze the cut list

Open the JSON file and edit the cut array.
Write the features you will not build this weekend.
Be specific, or the list will not hold you.

Good cuts name a surface you were tempted to add.
Bad cuts say polish, or later, without a boundary.
Your demo is the check command plus one summary.

Everything else stays in the cut list until Monday.
If you feel a new idea, append it to cut.
Do not promote it into scope during the same sitting.

Step 3: Place the free option behind the gate

Disclosure: This article was prepared as part of MonkeyCode's product outreach.

MonkeyCode matters only after the check command passes.
The operator describes free model access for that step.
The operator also describes a free server option.

Outreach notes also mention a large free token pool.
Some of those notes say ten million tokens.
This draft does not verify that number, or any quota.

Do not plan the weekend around an unverified allowance.
Model names, hardware, and duration are also unverified here.
Read the current project docs before you rely on a limit.

The operator presents the project as open source.
Confirm the license in a repository you actually trust.
This article does not link a repo and does not quote a license.

Use the table as a stop rule, not as a benchmark.
No timing numbers were measured for this article.
No quality scores were collected for this draft either.

Your constraint	Stay local	Free model or free server	Stop
Card file missing	Write the card	Do not call yet	Stop
Diff is short enough to read yourself	Optional dry run	One summary call	Stop after one call
Prompt would include a secret	Redact first	Only after redaction	Stop if you cannot redact
You want a hosted run, not a local GPU	Skip GPU plans	Free server option may fit	Stop if docs show no fit
You need a named model or a fixed quota	Do not invent one	Check live docs	Stop if docs disagree

The free server option is a convenience claim, not a spec.
This log does not name a region, a size, or a duration.
If the docs do not match your need, keep the script local.

The scope card still works with no network at all.
That is the fallback when a free tier is unclear.
You do not lose the demo if the signup page changes.

Step 4: Unlock one model step

After the check passes, you may send the diff once.
Send the diff text, not your whole repository.
Ask for one paragraph, not a rewritten project.

Save the reply next to the card, in a file you choose.
Do not paste the reply back into a second prompt.
One pass is the contract you wrote in the card.

python3 scope_card.py check ./scope-card.json && echo "model step unlocked: one summary, then stop"

That shell line does not contact any service.
It only shows the gate you should keep in front.
Wire your own client after the check command succeeds.

If the client errors, stop and read the error text.
Do not add retries, a queue, or a second prompt.
A failed call is a stop, not a new feature request.

Step 5: Write down the skips

Add a short note under the card before you close the laptop.
List what you skipped, in the same words as the cut field.
This is the part future you will thank yourself for.

You skipped the web UI on purpose this weekend.
You skipped auth and the job queue entirely.
You skipped applying a patch to the work tree.

You skipped streaming tokens into a browser pane.
You skipped comparing providers on speed or price.
Those skips are the point of this weekend build.

A working demo is the card plus one summary file.
A larger demo can wait until the cut list changes.
Changing the list is a new weekend, not a midnight edit.

Step 6: Run the local test plan

You can run these checks without creating an account.
They prove the gate, not a model quality score.
Run them in the same empty folder as the script.

First, run write, then check, and expect a zero exit code.
Second, delete the goal key and expect the check to fail.
Third, restore the goal key and expect the check to pass.

Fourth, run the sample shell line and read the unlock text.
Fifth, confirm no command in this log sends your diff out.
If a check fails, fix the script before any signup.

Do not treat a green check as a product test.
It only means the card has the required keys.
Model quality is outside the scope you froze.

Limits that stay in force

This workflow will not review a huge diff well.
A few hundred lines is a judgment call, not a measured cap.
The script does not parse git, and it does not call git.

You still produce the diff yourself and paste with care.
Secrets in that diff are your problem to remove first.
Never put tokens, keys, or private URLs into the prompt.

Free model access can change without this article updating.
Free server access can change in the same way.
This page is not a status board and not a contract.

If a current doc contradicts a sentence here, trust the doc.
If a quota page is missing, assume you do not have that quota.
The card workflow does not depend on either free claim.

Who should skip this

Skip this approach if your demo needs a hosted UI today.
Skip it if you must apply patches without a human review.
Skip it if the diff holds secrets you cannot redact.

Skip it if you need a guaranteed quota for a public launch.
Skip it if you wanted a benchmark of model quality.
This log has no quality scores and no latency numbers.

Use the gate if extra features keep eating your Saturday.
Use it if one local JSON file will keep you honest.
Use it if you can stop after a single summary.

What you should leave with

You leave with a command that writes a scope card.
You leave with a check that blocks the model step.
You leave with a written list of cuts you can defend.

That is a demo, even without a fancy screen.
If you already have MonkeyCode access, keep it behind the check.
One summary after a passing card is enough for this weekend.