Stamp a Scope Ribbon Before Practice Shifts

A practice shift without a roster becomes shared debt. Free model access lowers the cost of a draft. It does not lower the cost of a bad merge.

Teams can now sketch an interface before lunch ends. Those sketches still touch repos, logs, and keys. Speed without a named owner creates quiet drift.

The useful fix is a one-page shift sheet. Three seats sign it before the first prompt. The sheet lives in the team wiki, not in chat.

This playbook fits small product teams with shared repos. It also fits platform groups that keep a sandbox. It does not fit a solo weekend experiment.

Name the failure before any tool

A generated patch can look finished and still be wrong. The wrong part is often scope, not syntax. A button works while the data path leaks.

Reviewers then argue about taste instead of bounds. The draft already sits on a shared host. Rollback talk starts after other people see it.

A roster slip stops that sequence one step earlier. It names who prompts, who checks, and who discards. It also names what the shift must never touch.

Public talk about easy generated sites makes this failure common. A portfolio draft and a service draft share one risk. Both can escape the practice lane if nobody owns the close.

Keep free capacity on a practice lane

Disclosure: This article was prepared as part of MonkeyCode's product outreach. MonkeyCode offers free model access for this kind of practice. It also offers a free server option for throwaway hosts.

Both claims come from the operator, not a lab test. Quotas, model names, and uptime are not assumed here. A free option can change without a team vote.

The lane stays practice, and never becomes a promise. The team uses that access only after the slip is complete. Prompts stay on a practice branch, not on main.

The host name must not look like production. Live tokens stay out of the brief and the prompt. Customer rows stay out of the prompt as well.

Synthetic fixtures are the only safe sample for this shift. The team stores fixtures in the practice repo only. A real data export never enters this shift.

Three seats and one clock

The prompter writes the task in one short brief. The checker owns diffs, tests, and secret scans. The discarder owns shutdown, branch delete, and the note.

One person may hold two seats on a tiny team. One person must not hold all three seats. A missing discarder is how practice becomes production.

The clock is wall time, not a feeling. Ninety minutes is a suggested cap, not a benchmark. When the cap hits, the discarder closes the host.

The cap is a team rule, not a product limit. An extension needs a new slip and a new deadline. A silent extension is the same as no clock.

Handoffs stay short on purpose

The prompter hands a brief with inputs and forbidden paths. The checker hands a pass, a fail, or a block. The discarder hands a closed host and a deleted branch.

Each handoff must fit inside four short lines. Chat history must never replace the wiki page. A missing line means the shift is still open.

The prompter does not declare the draft done. The checker does not declare the host closed. Those sentences belong to different seats for a reason.

A pass means the diff matches the ribbon. A fail means the diff missed the brief. A block means the diff touched a forbidden path.

Paste this page, then fill blanks

The artifact below is a proposal, not a captured log. The team copies it into the wiki before the shift. Every blank stays filled, or the shift does not start.

Practice shift slip
Shift id: PS-____
Date: ____
Prompter: ____
Checker: ____
Discarder: ____
Scope ribbon: ____
Forbidden: prod hosts, customer data, live tokens, main
Branch: practice/____
Host label: ____
Deadline UTC: ____
Fixture rule: synthetic only
Prompter line: brief filed, inputs listed, forbidden copied
Checker line: pass | fail | block - note ____
Discarder line: host closed, branch deleted, time ____
Stop: blank seat means no prompt
Stop: second fail means discard
Stop: any block means discard, plus a note if secrets appeared

A checker that fails closed

A small script guards the slip before any prompt. It does not call a model or a remote API. It only reads a local env file on disk.

This script is an unexecuted example for local use. The team runs it on a throwaway clone first. It does not belong on a release repository.

#!/usr/bin/env bash
# Proposal only. Unexecuted example for a throwaway repo.
set -euo pipefail

SLIP="${1:-shift-slip.env}"
test -f "$SLIP" || { echo "missing slip: $SLIP"; exit 2; }

set -a
# shellcheck disable=SC1090
source "$SLIP"
set +a

require() {
  local name="$1"
  local value="${!name-}"
  if [[ -z "${value}" ]]; then
    echo "blank field: ${name}"
    exit 3
  fi
}

require PROMPTER
require CHECKER
require DISCARDER
require SCOPE
require FORBIDDEN
require BRANCH
require HOST
require DEADLINE

if [[ "$PROMPTER" == "$CHECKER" && "$CHECKER" == "$DISCARDER" ]]; then
  echo "one person holds every seat"
  exit 4
fi

case "$BRANCH" in
  practice/*) ;;
  *) echo "branch must start with practice/"; exit 5 ;;
esac

case "$HOST" in
  *prod*|*production*|*live*)
    echo "host label looks like production"
    exit 6
    ;;
esac

if git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
  git check-ignore -q .env || echo "warn: .env is not ignored"
fi

echo "slip ok: ${BRANCH} until ${DEADLINE}"

A matching example file holds names only. Tokens and customer rows never belong in that file. The filled copy stays untracked.

# shift-slip.env.example — proposal template, no secrets
PROMPTER="ava"
CHECKER="sam"
DISCARDER="rui"
SCOPE="readme draft for the practice repo only"
FORBIDDEN="prod hosts, customer data, live tokens, main branch"
BRANCH="practice/readme-draft"
HOST="practice-host.example"
DEADLINE="2026-10-10T16:30:00Z"

Commands for open, check, and close

The commands below are examples, not a captured session. Each one assumes a throwaway clone with no secrets. A failed command stops the shift until a human reads it.

The prompter creates the practice branch before any prompt. The filled slip stays next to that work. The checker runs the script before any editor opens.

git checkout -b practice/readme-draft
cp shift-slip.env.example shift-slip.env
bash check-slip.sh shift-slip.env

The checker records a short line without pasting secrets. A stat line is enough for this handoff note. Raw diffs that may hold secrets stay out of chat.

git diff --stat
printf '%s\n' "checker: pass" "note: readme only" >> handoff.txt

The discarder closes with local git commands and a stamp. Host shutdown still happens in the provider console. The stamp only proves the local half is finished.

git checkout main
git branch -D practice/readme-draft
printf '%s\n' "host: closed in console" "branch: deleted" "time: $(date -u +%FT%TZ)" >> handoff.txt

Filled slip files stay out of the git history. The team commits the example, not the filled file. A filled file can hold names that should stay internal.

printf '%s\n' "shift-slip.env" "handoff.txt" >> .gitignore
git check-ignore -q shift-slip.env && echo "filled slip ignored"

Read the three marks as policy

When the checker marks fail, the prompter may revise once. A second fail ends the shift at once. The discarder still closes the host that day.

When the checker marks block, nobody pushes code. A block means secrets, prod names, or scope creep. The brief returns to the wiki, not the model.

When the checker marks pass, work may enter normal review. That review uses the team's ordinary release pipeline. The practice host never becomes the release host.

A pass is not a deploy approval by itself. A pass is only a match against the ribbon. Release still needs the team's existing review gates.

Limits of the sheet and the script

The checker script cannot judge real product sense. It cannot prove a free server is isolated. It cannot see a secret typed into a prompt.

Free model access can shift without prior notice. Free server capacity can shift in the same way. This page claims no quota, chip type, or duration.

No benchmark result sits behind these process steps. No customer count sits behind these steps either. The value is a cleaner handoff, not a miracle.

String checks on the host label are shallow. A host can be dangerous without the word prod. Humans still read the name before the first prompt.

The script trusts the slip file on purpose. A liar can type a fake discarder name. Social trust sits outside what bash can prove.

Who should leave this playbook unused

Teams skip this approach when the data is regulated. They skip it when the only host is production. They skip it when nobody can stay for the discard.

They skip it for a silent overnight agent. Unattended prompts break the three-seat rule every time. A human discarder must remain awake for the close.

They skip it for a demo that cannot be deleted. Practice means the artifact can die without ceremony. A launch candidate needs the normal release train.

They skip it when counsel owns the prompt text. This sheet is an engineering habit, not legal advice. Regulated text still needs the team's counsel path.

Rehearse the failure before the real brief

The rehearsal starts on an empty practice repo. The slip gets real names and only fake data. The checker expects a short ok line from the script.

The rehearsal script below is also an unexecuted proposal. It expects the checker file in the same folder. It never contacts a model or a remote host.

#!/usr/bin/env bash
# Proposal only. Local rehearsal. No model calls.
set -euo pipefail

tmp="$(mktemp -d)"
cp check-slip.sh shift-slip.env.example "$tmp/"
cd "$tmp"
cp shift-slip.env.example shift-slip.env
bash check-slip.sh shift-slip.env | grep -q "slip ok"

sed 's/^DISCARDER=.*/DISCARDER=""/' shift-slip.env > shift-slip.blank
if bash check-slip.sh shift-slip.blank; then
  echo "expected failure on blank discarder"
  exit 1
fi

echo "rehearsal ok"

The next run blanks the discarder field on purpose. The script should exit on that blank field. The name returns before any further prompt work.

The host field then uses a name that contains prod. The script should refuse that unsafe host string. The host label changes before the shift continues.

The prompter supplies a diff that touches only the readme. The checker reads the stat line, not the tone. A pass still waits for human eyes on the diff.

The close deletes the practice branch and writes the time. The slip stays in the wiki as history. Practice notes do not enter the main readme.

The ribbon outranks the model

Scope works like a ribbon tied around the task. Outside that ribbon, the shift has no authority. Inside the ribbon, the checker may say no.

A stronger model does not replace that ribbon. A cheaper server does not replace it either. The ribbon is a social control with a small script.

The slip covers one shift, not the whole quarter. It expires when the discarder writes the close line. The next shift starts from a blank page.

Old notes stay as evidence, not as a prompt seed. Fresh scope stops yesterday's exception from growing again. That habit matters more than any single draft.

A boring close is a feature of this playbook. The discarder stops the host and deletes the branch. No victory speech belongs on the shift slip.

A team that wants those free options starts on a throwaway repo. The team pastes the sheet and runs the checker first. That order keeps the experiment smaller than the codebase.