Run Free AI Shifts With Three Named Roles

Most free-tier AI work fails at handoff, not at the model. A shift ends, the context leaves with one person, and the next driver restarts from zero. Three named roles and one wiki page keep that state where the whole team can reach it.

Name the roles before the first prompt. The Driver holds the keyboard and the intent. The Scribe owns the run page and the exit note. The Gatekeeper runs the smoke suite and decides promotion.

Ownership decays when it stays implied. An unnamed scribe is a conversation without a transcript. Named roles turn a session into a shift that someone can inherit on Monday.

The one-page run

Paste this into the team wiki and fill it at the start of every shift.

# Shift Run - <date> - <shift_id>
Driver:      <name>
Scribe:      <name>
Gatekeeper:  <name>

Entry:       make bench-up
Last green:  make test-smoke @ <utc timestamp> @ <short sha>
Gate:        open | held | blocked
Threads:     max 2, each with an owner and one next command
Exit note:   one past-tense sentence naming the next action

Two threads is a cap, not a target. Anything beyond two becomes a ticket and leaves the page. The page has to stay short enough to read once, out loud, during a handoff.

The Scribe writes the page, not the Driver. Separation matters because the person deep in a change cannot see which thread is still open. The Scribe asks one question per thread: who owns it and what is the next command.

Smoke before you claim the shift

The Driver runs this before touching the task. It proves the environment, not the change.

#!/usr/bin/env bash
# shift-smoke.sh - run at the start of every shift
set -euo pipefail

SHIFT_ID="${SHIFT_ID:-$(date -u +%Y%m%dT%H%MZ)}"
BRANCH="$(git rev-parse --abbrev-ref HEAD)"
SHA="$(git rev-parse --short HEAD)"

need() { command -v "$1" >/dev/null || { echo "missing: $1"; exit 2; }; }
need git
need make

echo "shift=$SHIFT_ID branch=$BRANCH sha=$SHA"
make bench-up
make test-smoke 2>&1 | tail -n 5
echo "last_green=$(date -u +%FT%TZ) sha=$SHA"

The final line is the contract. Copy it into the run page verbatim. A missing last-green line means the shift has no known-good state, so the Gatekeeper holds the gate closed.

Keep the smoke target small. It should finish in a couple of minutes and touch only the paths a new driver needs. A smoke suite that takes twenty minutes gets skipped, and a skipped gate is worse than no gate.

Handoff in three lines

The exit note is always the same shape. Three lines, past tense, no narrative.

exit:    driver passed 2 threads to the gatekeeper
next:    rerun make test-smoke after the lockfile change
blocked: none

Write it in the run page, not in chat. Chat scrolls away and the next shift never reads it. A wiki page survives the person who wrote it.

The Gatekeeper reads the exit note before reading any code. That order matters. A held gate explains itself in one line, and the next shift knows where to start.

Where the free tier fits

The Driver drafts in free model sessions and the Gatekeeper re-runs the suite on the free server option. That split keeps review on a clean machine instead of the Driver's laptop. Both the free model access and the free server option are availability claims the vendor makes; confirm the current limits and specs on their pricing page before you build a rotation around them, because free-tier terms move.

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

The playbook stands without that tool. Swap in any provider and the roles, the run page, and the smoke contract still apply.

Gate decision table

Proposed defaults, not vendor guidance. Tune the thresholds to your own week.

Signal	Threshold	Action
Threads without an owner	2 or more per week	Add a Scribe, cut to one thread
Gate held across two shifts	48 hours	Shrink the change or split it
Smoke flaky twice in a week	2 failures	Fix the test before new work
Secret pasted into a prompt	Any occurrence	Rotate the key, log it, hold the gate
Run page stale over one day	24 hours	Close it with an exit note

Slow rotation is cheaper than rework. A gate held two shifts usually means the change was too large, not that the reviewer was slow.

Limitations and who should skip this

The playbook adds roughly ten minutes per shift. Solo developers will spend more on the page than they save. Teams with a working CI promotion lane already have the gate, so add roles only if handoff notes are missing.

The smoke suite still has to fit the free server's disclosed specs. If the suite needs heavy memory or a long build, run it elsewhere and keep only the fast checks on the shared box. Nothing here gives you an SLA, and free tiers can change with little notice.

Skip this for regulated code where every prompt needs a retention policy. Skip it when no one on the team can review the output, because a Gatekeeper without authority just stamps approvals. Skip it if your only goal is throughput today; the roles pay off on the second shift, not the first.

Start with one shift

Try the shape once before inviting a second person. Spin a free server, run the smoke script, and paste the last-green line into an empty run page. If that single line is already useful, add the Scribe on the next shift and let the roles grow from evidence.