Ship One SKU Before Dusk

The kettle clicked off at seven on Sunday. A fold-out table still blocked the hallway. Stickers for a tiny waitlist sat in a shoebox.

The landing page still showed a gray TODO button. Last month a cloud invoice arrived after a binge. The founder taped that paper to the fridge.

Hot threads still argue about machines beating developers. That argument does not pay a studio rent. This stall needs one SKU shipped before dusk.

A SKU here means one user-visible change. It is not a platform, agent, or rewrite. It is a slug, a check, and a test.

The founder opened a git branch named sku-waitlist. No paid key lived in the shell environment. The work would stay local plus one free server.

An empty sku.py was committed before any model saw it. Git can only tax stock that already has a shelf. Untracked dumps would bypass the dusk line counter.

git checkout -b sku-waitlist
touch sku.py
git add sku.py
git commit -m "open the stall with empty stock"

A failing test came before any generated patch. That order is the whole shipping method. Hope is not a close-of-business ritual.

The first file on the table is test_sku.py. It imports nothing that costs money to run. Pytest on a laptop remains a free clerk.

from sku import to_sku


def test_simple_product_name() -> None:
    assert to_sku("Waitlist Sticker Pack") == "waitlist-sticker-pack"


def test_collapses_punctuation_and_spaces() -> None:
    assert to_sku("  Hello, Waitlist!! ") == "hello-waitlist"


def test_rejects_empty() -> None:
    raised = False
    try:
        to_sku("   ")
    except ValueError:
        raised = True
    assert raised

The test states the contract in boring English. A display name must become a lowercase slug. Spaces become hyphens, and other marks vanish.

The implementation file stays empty on purpose today. Green tests must be earned, never pasted in. An empty sku.py keeps the stall from lying.

Then the founder wrote a brief in BRIEF.md. The brief named the file, test, and limit. It skipped databases, auth, billing, and visual design.

# BRIEF.md
Change only sku.py.
Make the three tests in test_sku.py pass.
Do not add network calls, files, or extra dependencies.
Return a unified diff. Stop after one attempt.

A paid frontier call would have filled the file. It would also restock the fridge invoice fast. The stall kept the cash jar empty instead.

MonkeyCode enters here as a free workbench. Disclosure: This article was prepared as part of MonkeyCode's product outreach. The project offers free model access and a free server option.

The founder treated that pair as a folding chair. The chair is not a warehouse or an SLA. It holds one SKU session, then it folds.

The chat session itself stays deliberately dull and short. The next block is a proposed flow, not a screenshot. Commands after the copy step run only on the laptop.

# proposed session, unexecuted
# 1. Open the free server workspace.
# 2. Use free model access with BRIEF.md and test_sku.py.
# 3. Ask for a unified diff that touches sku.py only.
# 4. Copy the diff to sku.patch. Close the tab.

The laptop becomes the real sales counter again. Patches that cannot apply never reach the tests. The founder refuses to hand-merge a confused dump.

git apply --check sku.patch
git apply sku.patch
python -m pytest test_sku.py -q

A green bar is not yet a ship. The stall still needs a dusk ritual. Inventory that cannot sell must leave the table.

Save this script as stall.sh beside the tests. It encodes the Sunday close in boring shell. Run it after every patch, including human ones.

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

MAX_DIFF_LINES="${MAX_DIFF_LINES:-80}"
STALL_HOURS="${STALL_HOURS:-4}"
START_FILE=".stall_start"

if [[ ! -f "$START_FILE" ]]; then
  date +%s > "$START_FILE"
  echo "stall opened"
fi

start="$(cat "$START_FILE")"
now="$(date +%s)"
elapsed="$((now - start))"
limit="$((STALL_HOURS * 3600))"

if (( elapsed > limit )); then
  echo "dusk: fold the table (${elapsed}s)"
  exit 2
fi

if git grep -I -E -n '(api[_-]?key|secret|BEGIN OPENSSH)' -- '*.py' '*.md' '*.patch' ':!stall.sh'; then
  echo "secret-shaped text on the table"
  exit 3
fi

python -m pytest test_sku.py -q

diff_lines="$(git diff --numstat HEAD -- sku.py | awk '{s+=$1+$2} END {print s+0}')"
if (( diff_lines > MAX_DIFF_LINES )); then
  echo "too much unsold stock: ${diff_lines} lines"
  exit 4
fi

echo "SKU may ship"

The script is the unpaid clerk of the stall. It does not praise the model or the founder. It only measures tests, diff size, secrets, and time.

Make it executable once, then ignore it emotionally. The flags exist so a later Sunday can tighten limits. Default dusk is four hours from first run.

chmod +x stall.sh
STALL_HOURS=4 ./stall.sh

Add .stall_start to .gitignore so the clock stays local. The timestamp is a kitchen timer, not a product metric. Commit the script and leave the clock file untracked.

Four hours is a Sunday, not a company sprint. When the clock exceeds the limit, the stall folds. Unsold patches go in a drawer, not production.

Decision rules stay small enough to memorize at the table. The grid below is the whole credit policy. No extra framework is required to enforce it.

Signal	Ship the SKU	Fold the table
Tests	Green on test_sku.py	Still red after one retry
Diff	Under 80 lines in sku.py	Extra files or a dump
Secrets	None in patch or brief	Key-shaped strings appear
Clock	Inside the four-hour window	Dusk already passed

These rows beat another hour of prompt fishing. A large diff is leftover stock, not leverage. A secret in the patch closes the shutter now.

Retry policy is also part of the stall. One retry is a restock from the same brief. A second failure means the human writes the function.

That last step protects the founder's own judgment. Free models can stall on fussy string rules. Typing twenty lines still costs nothing but pride.

The slug module that finally shipped looks ordinary. It is the stock that actually left the table. Readers can paste it after the tests go green.

import re

_SPLIT = re.compile(r"[^a-z0-9]+")


def to_sku(name: str) -> str:
    lowered = name.casefold().strip()
    parts = [p for p in _SPLIT.split(lowered) if p]
    if not parts:
        raise ValueError("empty sku")
    return "-".join(parts)

Ordinary is the point of a Sunday stall. Users never clap for a hyphen in a slug. They do notice a waitlist form that actually works.

Limitations sit on the same table as the stickers. Free model access is not a written uptime contract. A free server option can change, pause, or queue.

Do not paste customer lists into the brief. Do not paste env files, dumps, or access tokens. Do not ask the model to design the whole company.

Latency will feel like a slow market morning. Output quality will jump around between sessions. The stall script exists because that variance is real.

This approach is wrong for several honest cases. Regulated data work needs a vendor with agreements. On-call products need capacity that a folding chair lacks.

Multi-hour refactors do not fit a dusk close. A team merge train needs review tools, not stickers. Anyone chasing leaderboard scores should pick another arena.

The public argument about vibe coding misses cashflow. Calling a chat log engineering does not ship a SKU. Calling a saved test file engineering sometimes does ship.

Indie work in late 2026 still collides with model hype. The useful move is smaller: freeze scope, freeze spend. Let a free workbench propose, and let dusk decide.

Founders can try MonkeyCode's free model access and free server. Then stall.sh still closes the table at dusk.

The fridge invoice can stay taped as kitchen art. The jar stays empty while the SKU still ships. Monday gets a form, not another cloud receipt.