File a Lane Card Before Sprint Drafts

A contribution sprint stays orderly only when a lane card exists first. Free model time is a shared bench, not a private shortcut. The card names the branch, the host, and the closer.

Unowned drafts collide on the same files before review starts. A practice server then holds stale builds from three people. The closer cannot tell which run still matters.

The card works like a relay baton on a short track. Only the person holding it may advance the branch. A missing baton means the sprint stops, not that someone improvises.

Name the lane before the prompt

MonkeyCode can fill the free model lane and the free server option. Disclosure: This article was prepared as part of MonkeyCode's product outreach. Those two options are availability claims, not a fixed size or span.

The team rechecks both options on the day the sprint opens. A help page can change without a wiki edit. The card stores the check time, not a guessed quota.

Seats for one sprint only

Four seats sit on the card, and none of them is optional. The charter keeper writes the card before any prompt is sent. The draft runner may call the model lane only after the card passes.

The server steward owns the practice host and its cleanup window. The merge reader is the only person who may open the pull request. A runner who also merges has skipped the handoff on purpose.

This card is not a generic role sheet for every coding hour. It binds one sprint, one branch prefix, and one practice host. When the sprint ends, the card is archived with the branch name.

Paste the card, then block the draft

A useful card is short enough to paste above the fold. Long policy text hides the fields that actually gate the run. The fields in the template are the whole contract.

# lane-card.env — proposed template, not a live record
sprint_id=2026-10-contrib-01
branch_prefix=sprint/contrib-01
practice_host=practice.example.internal
model_lane=free-model-access
server_option=free-server
charter_keeper=NAME
draft_runner=NAME
server_steward=NAME
merge_reader=NAME
checked_at=YYYY-MM-DDThh:mmZ
scope=docs-and-tests
forbidden=production-hosts,secrets,force-push
handoff_state=draft

The template above is a proposal, not a record from a finished sprint. Names stay blank until a person accepts the seat. A filled card with invented names is worse than an empty one.

Scope stays narrow on the first run of this playbook. Docs and tests are enough to prove the handoff. Feature work can wait until the card has survived one archive.

The local check is the gate, not a chat reminder. A script reads the card and refuses a draft when a field is blank. The example below is unexecuted proposal code for a wiki.

#!/usr/bin/env bash
# check-lane-card.sh — proposed, not executed in this article
set -euo pipefail
card="${1:-lane-card.env}"
test -f "$card"
set -a
# shellcheck disable=SC1090
source "$card"
set +a
required=(
  sprint_id branch_prefix practice_host model_lane
  server_option charter_keeper draft_runner
  server_steward merge_reader checked_at scope
)
for key in "${required[@]}"; do
  val="${!key:-}"
  if [[ -z "$val" || "$val" == NAME || "$val" == YYYY-MM-DDThh:mmZ ]]; then
    echo "block: $key is unset" >&2
    exit 2
  fi
done
case "$practice_host" in
  *prod*|*production*)
    echo "block: practice host looks production" >&2
    exit 3
    ;;
esac
if [[ "$draft_runner" == "$merge_reader" ]]; then
  echo "block: runner and reader must differ" >&2
  exit 4
fi
echo "pass: ${sprint_id} may draft on ${branch_prefix}"

The runner executes that check from the repository root before the first prompt. A non-zero exit blocks the runner even when the lane is idle. Silence from the script is not a successful gate.

The keeper treats the card as trusted local text, not as model output. Sourcing a file can run shell code if someone tampers with it. A model must never be allowed to rewrite the card.

A passing check still does not grant a production login. The practice host is a rehearsal bench with disposable state. The steward wipes that state when the handoff reaches review.

The runner creates the branch only after the check prints pass. The commands below are examples for a local clone. They assume git is already configured for that clone.

./check-lane-card.sh lane-card.env
git switch -c sprint/contrib-01
git status --short

The draft runner then sends a bounded prompt to the free model lane. The prompt cites the card scope and forbids secrets and production hosts. A prompt wider than the card is a process bug, not a model win.

MonkeyCode enters here only as the lane named on the card. Removing that name leaves the same gate for any other lane. The playbook is about the handoff, not about a vendor ritual.

The runner pastes the model diff onto the branch and does not merge it. The steward then deploys that branch to the practice host. The host name must match the card or the deploy stops.

# Proposed rehearsal commands. Unexecuted example.
test "$practice_host" = "practice.example.internal"
git push origin "$branch_prefix"
ssh "$practice_host" -- 'cd /srv/rehearsal && git fetch origin && git switch sprint/contrib-01 && ./rehearse.sh'

Prove the branch on the practice host

The rehearsal script should prove the branch, not the whole product. It can run tests already in the repo and print the commit. It should refuse to run when the working tree is dirty.

#!/usr/bin/env bash
# rehearse.sh — proposed, not executed in this article
set -euo pipefail
git diff --quiet
git rev-parse --abbrev-ref HEAD | grep -q '^sprint/'
if [[ -f package.json ]]; then
  npm test --silent
elif [[ -f pyproject.toml ]]; then
  python -m pytest -q
else
  echo "block: no known test entrypoint" >&2
  exit 5
fi
git rev-parse --short HEAD

Those entrypoints are illustrations, not a claim about a specific repository. A team replaces them with the command its maintainers already trust. A missing entrypoint is a block, not a cue to skip tests.

The steward records the rehearsal result on the card before leaving the host. A failed rehearsal returns the card to draft, with the error line attached. A passing rehearsal moves the state from draft to ready.

commit: abc1234
practice_host: practice.example.internal
checked_at: 2026-10-08T09:00Z
result: rehearse.sh exited 0
handoff_state: ready

That note is an example shape, not evidence from a completed run. No timing numbers in this article come from a measured sprint. Teams should keep their own notes if they need proof later.

A ready state does not mean the branch is merged. The merge reader reads the diff, the rehearsal note, and the card. Only that reader may open the pull request for the sprint branch.

The handoff note stays short, not a novel. It names the commit, the practice host, and the check time. The reader rejects a note that lacks any of those three.

The card moves through three states, and a later check can guard them. Draft allows a model call on the named branch only. Ready allows the pull request, and closed allows only the archive.

Stop on a boring failure

Failure has a short path, and the path is boring on purpose. A blank seat, a production-looking host, or a shared merge identity stops the script. The runner does not negotiate around an exit code in chat.

Exit codes stay stable so a wiki can document them once. Exit two means a required field is still blank.

Exit three means the host string looks like production. Exit four means the runner and the reader are the same person. A wiki page lists those codes next to the script.

A stale check time is also a failure, even when every name is filled. The keeper refreshes the availability note, then reruns the script. Yesterday's free lane is not authority for today.

This limit matters because free access can shrink, pause, or change terms. The card never stores a token count, a hardware size, or a forever flag. Those figures were not verified for this draft, so they stay out.

Who should leave this card unused

Who should skip this playbook is equally clear. A solo experiment with no second reader does not need a four-seat card. An incident on a production host needs the incident channel, not a sprint template.

Teams that cannot name a human merge reader should not start the lane. People chasing a badge with no repository owner should not invent seats. The card is a coordination tool, not a costume for missing ownership.

Security testing sits outside this sprint lane card. The practice host must already be a host the team may use. Nothing here grants access or covers a system the team does not own.

Review remains human even when the draft came from a model. The reader looks for secret leaks, license mistakes, and scope drift. A green rehearsal script does not replace that read.

License and contribution rules still come from the target repository. The card does not override a maintainer guide or a code of conduct. If those documents conflict with the card, the repository wins.

A model draft can copy code the team may not ship. The reader checks license headers before the pull request opens. The lane card does not grant a copyright exception.

The archive step is part of the run, not an afterthought. The keeper sets the state to closed and stores the card. A later sprint starts a new card instead of editing the old one.

One rehearsal, then stop

A wiki team can paste this card beside its review checklist. One rehearsal branch can try the free model lane without a wide rollout. The same page should state that availability was rechecked that morning.

The closing rule for this playbook stays strict. No lane card means no free draft and no practice deploy. A passed card means one branch, one host, and one closer.