Run Free AI Shifts With Three Named Roles

A developer outlined a three-role handoff playbook for free-tier AI work sessions, assigning a Driver, Scribe and Gatekeeper to keep context on a shared wiki run page rather than in chat. The approach pairs a short shift-smoke.sh script that records a last-green commit and timestamp with a fixed three-line exit note, and holds the promotion gate closed when no known-good state exists. The writeup was prepared as part of MonkeyCode's product outreach, and the author notes free-tier limits should be confirmed on vendor pricing pages.

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. 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. The Driver runs this before touching the task. It proves the environment, not the change. bash /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. 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. 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. 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. 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. 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.