An Intake Card for Free AI Coding Sessions

Most free AI bench failures are intake failures.

The model is rarely the first problem. Missing scope, missing owner, and missing handoff cause the rework. A short intake card fixes more than another model trial.

The current AI fatigue discussion often focuses on tool overload. The operational cause is simpler. Teams start sessions without a definition of done. They hand off a chat transcript instead of a reproducible state. A two-role SOP makes the bench boring, and boring is useful.

The bench, stated plainly

MonkeyCode is an open-source AI coding project with a free model allowance and a free server option. Disclosure: This article was prepared as part of MonkeyCode's product outreach. The operator states a 10 million-token free allowance. Treat that number as time-sensitive. Verify current terms and limits on the project page before a team depends on them.

The free server option matters for the SOP. It gives the team a shared sandbox without a local setup race. The SOP still applies if the team uses another bench. The artifact is portable.

Roles and handoffs

Two roles are enough for a small team. The Driver runs the session and keeps the run log. The Reviewer checks the diff, test output, and rollback path. A Maintainer owns credentials, bench configuration, and allowance tracking.

The handoff rule is strict. The Driver never asks for a review in chat alone. The Driver posts the run directory path and the acceptance command. The Reviewer never approves from a summary. The Reviewer runs the acceptance command and records the result.

The Maintainer does not review every change. The Maintainer audits the intake cards weekly. The audit checks missing owners, missing expiry dates, and stale branches. This keeps the bench from becoming a shared junk drawer.

The intake card

Paste this card into the team wiki. Keep it short enough to fill in two minutes. Every field has a job.

# Bench Intake Card

- Goal:
- Non-goal:
- Repo and commit:
- Branch:
- Driver:
- Reviewer:
- Expiry:
- Bench:
- Model or route:
- Token budget:
- Acceptance command:
- Rollback command:
- Data class:

The non-goal field prevents scope drift. The expiry field prevents abandoned branches. The data class field keeps secrets out of the bench. The acceptance command turns opinion into a runnable check.

A card without an acceptance command is not ready. A card without a reviewer is a solo experiment. A solo experiment belongs in a personal sandbox, not the team bench.

A reproducible intake script

The following script creates a run directory and a filled card. It uses bash, git, and GNU date. It refuses to overwrite an existing run. Run it from the repository root.

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

usage() {
  echo 'usage: bench-intake <slug> <driver> <reviewer> <acceptance-command>'
  exit 64
}

[ $# -eq 4 ] || usage

slug=$1
driver=$2
reviewer=$3
accept=$4
run_dir=bench-runs/$(date -u +%Y%m%dT%H%M%SZ)-$slug

[ -e $run_dir ] && { echo run exists: $run_dir >&2; exit 65; }
mkdir -p $run_dir

commit=$(git rev-parse --short HEAD)
branch=$(git branch --show-current)

cat > $run_dir/intake.md <<EOF
# Bench Intake Card

- Goal: TODO
- Non-goal: TODO
- Repo and commit: $(basename $PWD)@$commit
- Branch: $branch
- Driver: $driver
- Reviewer: $reviewer
- Expiry: $(date -u -d '+2 days' +%Y-%m-%d)
- Bench: free server sandbox
- Model or route: TODO
- Token budget: TODO
- Acceptance command: $accept
- Rollback command: git restore --source=$commit -- .
- Data class: public or synthetic
EOF

cat > $run_dir/runlog.md <<EOF
# Run Log

## Baseline
Command: $accept
Result: TODO

## Session notes
- Change:
- Evidence:
- Observed usage:

## Review
- Reviewer:
- Decision: pending
- Command output:
EOF

cat > $run_dir/handoff.md <<EOF
# Handoff

- Run directory: $run_dir
- Open question:
- Next action:
- Owner:
EOF

echo $run_dir

The script captures the commit before the session starts. That single line saves hours later. The rollback command uses the same commit. The reviewer can reproduce the baseline without guessing.

The script does not call a model. It does not consume tokens. It creates the paper trail around the session. That separation is deliberate.

The one-page run

The team pastes this sequence into the wiki. Keep it adjacent to the intake card.

# 1. Confirm a clean tree and create a branch.
git status --short
git switch -c bench/<slug>

# 2. Create the run card before touching code.
run_dir=$(./bench-intake <slug> <driver> <reviewer> 'npm test -- --runInBand')

# 3. Record the baseline.
npm test -- --runInBand | tee $run_dir/baseline.txt

# 4. Run the session in the free server sandbox.
# Keep prompts and diffs inside the run directory.

# 5. Reviewer reproduces the acceptance command.
git diff --stat
git diff
npm test -- --runInBand | tee $run_dir/review.txt

# 6. Close the card or expire it.

The baseline command is an example. Replace it with the repository's real check. The principle matters more than the tool. A review needs a before state and an after state.

The free server option changes the setup cost, not the review standard. A team should still pin the commit and run the acceptance check. A shared sandbox without a run card becomes an anonymous chat room.

The 10 million-token allowance is enough to encourage practice. It is not a reason to skip intake. Token budget belongs on the card because it makes waste visible. Record observed usage from the provider dashboard when available. Do not invent a number when the dashboard is silent.

Decision table

Change type	Reviewer	Handoff
Docs or comments	One reviewer	Run card only
Test-only change	One reviewer	Run card plus test output
App code, small diff	One reviewer	Run card plus rollback proof
Auth, billing, data migration	Two reviewers	Run card, rollback proof, Maintainer sign-off
Secrets or production data	Not on the free bench	Use the approved environment

The table is a floor, not a ceiling. A team can add stricter rules. It should not add softer ones without a written exception.

Limitations and fit

This SOP fits small teams with git discipline and a named reviewer. It fits prototypes, test repairs, documentation, and internal tools. It also fits training sessions because the run card makes the work inspectable.

It does not fit production hotfixes under time pressure. It does not fit regulated data without an approved environment. It does not fit teams that cannot name a reviewer. It does not replace code review, threat modeling, or least-privilege access.

The free allowance and free server are availability claims, not permanence claims. Terms can change. The team should verify them before making the bench part of a delivery process. The SOP survives a change in provider because the artifact is plain Markdown and shell.

Close

The useful response to AI fatigue is less ceremony around models and more ceremony around handoffs. A two-role intake card makes the bench legible. It gives the reviewer a command, the driver a boundary, and the Maintainer an audit trail. Teams that want a low-cost place to try the workflow can use MonkeyCode's free allowance and free server option as a sandbox. Check the current terms first.