Shared coding stays safe only when three seats stay named. The owner, the scribe, and the closer must not share one chat. A one-page wiki run shows that split before any model call.
Teams lose hours when a draft arrives with no named owner. The diff looks finished, yet nobody may merge it. Treat that gap as a process bug, not a model bug.
Why the sheet comes first
A clean patch still fails when the handoff stays vague. Review needs a sealed brief, a bounded draft, and a verdict. Those three artifacts belong to three roles, even on a small team.
The sheet is a gate, not a status meeting. The next person should read it in one minute. A blank required field means the run has not started.
The three seats
The brief owner writes the task and the acceptance checks. That person also writes the out-of-scope list. The owner does not paste model output onto the branch.
The draft scribe runs the agent and posts the diff. The scribe records the prompt, the files, and the commands. The scribe does not approve the merge under any case.
The merge closer reads the diff against the checks. The closer may accept, return, or reject the draft. A missing closer means the ticket stays open.
One person may hold two seats on a tiny team. That person still signs both lines on the sheet. Hidden overlap is how a bad merge slips through.
Where a free lane fits
Practice work should not touch production hosts or live secrets. A separate server lane keeps a bad draft cheap to drop. Keep that lane off the production path while the brief stays soft.
Disclosure: This article was prepared as part of MonkeyCode's product outreach. The brief states that free model access and a free server option exist. This playbook uses both only as a practice lane.
It assumes no fixed quota, named model, or hardware size. It also assumes no lasting price and no uptime promise. Recheck both options before any long batch of tickets.
The scribe starts only after the owner seals the brief. The free server holds the workspace for that draft. The closer still decides what may leave the lane.
The one-page run
Paste the block below into the team wiki before work starts. Fill every required field before the scribe opens a session. A TBD on a required line means the run waits.
# Shared coding run
- Run id:
- Date:
- Repo:
- Ticket:
- Brief owner:
- Draft scribe:
- Merge closer:
- Practice lane:
- Model access:
- In scope:
- Out of scope:
- Acceptance checks:
- Secrets allowed: none
- Prompt summary:
- Files touched:
- Commands run:
- Draft link:
- Closer verdict:
- Verdict note:
- Promoted commit:
That page is the whole SOP for this lane. Roles sit at the top and the verdict sits at the bottom. A new teammate can follow it without a meeting.
Handoff from owner to scribe
The owner seals scope before any prompt is sent. In-scope lines name files or behaviors the draft may touch. Out-of-scope lines name what the agent must not touch.
Acceptance checks are commands or observable results, not opinions. A good check reads like a test command. The words looks fine do not count as a check.
The scribe may refuse a brief that has no command. The owner posts the sheet link in the ticket. The scribe replies with the run id before work starts.
Handoff from scribe to closer
The scribe keeps the agent inside the practice lane. Live credentials stay off that lane for the whole run. The draft link points at a branch or a patch file.
The prompt summary stays short and skips secret dumps. Files touched must match the diff a closer will read. Commands run must be ones a closer can repeat.
If a command failed, the sheet says so in plain text. The scribe does not write the closer verdict. A verdict filled by the scribe is a process miss.
Handoff from closer to the branch
The closer reruns the acceptance checks on the practice lane. A green guess on a laptop is not enough. The closer also compares the diff with the out-of-scope list.
Extra files mean a return, not a long debate. Accept means a promoted commit hash lands on the sheet. Reject means the branch stays unmerged and the ticket stops.
Return means the scribe gets a note and a new draft link. The closer owns the merge button on the shared branch. Neither the agent nor the scribe may press it.
A checker for the sheet
Prose rules fade after a busy week on the team. A small script does not fade in the same way. The checker fails when a required field is empty or TBD.
It does not score the patch or call a model. It only guards the handoff before the scribe starts. The script below is an unexecuted example, not a measured result.
#!/usr/bin/env python3
"""Validate a shared-coding role sheet before the scribe starts."""
from pathlib import Path
import sys
REQUIRED = [
"Run id",
"Brief owner",
"Draft scribe",
"Merge closer",
"In scope",
"Out of scope",
"Acceptance checks",
"Secrets allowed",
]
def fields(text):
found = {}
for line in text.splitlines():
if not line.startswith("- ") or ":" not in line:
continue
key, value = line[2:].split(":", 1)
found[key.strip()] = value.strip()
return found
def main():
path = Path(sys.argv[1] if len(sys.argv) > 1 else "run-sheet.md")
data = fields(path.read_text())
missing = []
for key in REQUIRED:
if data.get(key, "") in ("", "TBD"):
missing.append(key)
if data.get("Secrets allowed", "") != "none":
missing.append("Secrets allowed must be none")
if missing:
print("sheet blocked:")
for item in missing:
print(" - " + item)
return 1
print("sheet ready for scribe")
return 0
if __name__ == "__main__":
raise SystemExit(main())
Keep the filled sheet as docs/run-sheet.md in the repo. Run the check from that folder before the session opens. A zero exit means the scribe may start.
python3 check_sheet.py docs/run-sheet.md
echo "exit=$?"
A non-zero exit means the owner still owes a field. Do not bypass the script with a chat message. Update the sheet and run the check again.
The secrets rule is strict on purpose for this lane. Practice code may enter, and keys may not. A ticket that needs a secret does not belong here.
A dry run on fake fields
Use a sample sheet before the real ticket lands. The sample proves the field rules, not the model. Replace the names with people who will sign the run.
cat > /tmp/run-sheet.md << 'EOF'
# Shared coding run
- Run id: RUN-2041
- Date: 2026-09-25
- Repo: example/widgets
- Ticket: WID-88
- Brief owner: Avery Chen
- Draft scribe: Jordan Hale
- Merge closer: Sam Ortiz
- Practice lane: free server
- Model access: free practice access
- In scope: add a retry cap in client.py
- Out of scope: billing, auth, migrations
- Acceptance checks: python3 -m unittest tests.test_client
- Secrets allowed: none
- Prompt summary: TBD
- Files touched:
- Commands run:
- Draft link:
- Closer verdict:
- Verdict note:
- Promoted commit:
EOF
python3 check_sheet.py /tmp/run-sheet.md
Read against the required list, that sample meets the start rule. Prompt summary may stay TBD until the scribe writes it. The required set covers roles, scope, checks, and secrets.
Add a second check before merge if the team wants one. Require the draft link, the commands, and the verdict then. Keep the first check small so empty end fields do not block.
MERGE_REQUIRED = ["Draft link", "Commands run", "Closer verdict"]
def ready_to_merge(data):
bad = []
for key in MERGE_REQUIRED:
if data.get(key, "") in ("", "TBD"):
bad.append(key)
verdict = data.get("Closer verdict", "")
if verdict not in ("accept", "return", "reject"):
bad.append("Closer verdict must be accept, return, or reject")
return bad
Label that helper as a proposal until a real sheet is tested. It reads fields and does not open a server. That split keeps the SOP testable on a laptop.
What this playbook will not do
The sheet does not turn a weak brief into a good patch. It only stops an unnamed merge from landing quietly. A vague check still wastes the scribe session.
Write the check before blaming the model for a miss. Free model access is not a capacity plan for the queue. This page states no token count, rate, or end date.
If the free lane is gone, keep the same three roles. Any other practice host can hold the same sheet. The seats matter more than the vendor name on the lane.
The free server option is not a production stand-in. Do not point it at customer data or long-lived credentials. A green practice run is not a release approval.
The checker trusts the sheet text a human typed. A lying field can still pass this small script. Pair the script with a human closer, not with blind trust.
Who should skip it
Skip this playbook during a live incident response. Incident command already has roles and a clock. A wiki sheet will slow the first fix.
Write the sheet after the service is stable again. Use it then only if a follow-up patch needs an agent. The incident channel is the wrong home for this page.
Skip the lane when work touches regulated or payment data. Customer secrets are also out of scope for this sheet. The practice rule assumes secrets allowed stays none.
Skip it for a solo experiment with no shared branch. Three signatures are wasted motion in that case. Use the sheet when a second person must trust the draft.
Skip it when nobody will act as closer. An agent plus a scribe is not a review. Wait until a closer is named, then start the run.
Keep the page boring
The value sits in repeated fields, not in a clever prompt. Same seats and same checker should greet every ticket. New tickets should change the scope lines only.
Store the sheet next to the ticket, not in a chat scroll. Chat fades by the next shift, and the wiki page remains. The promoted commit on that page is the receipt to trust.
Teams with a wiki can paste this page onto the next practice ticket. The free server lane stays optional for that trial. The three named seats do not stay optional.
Top comments (0)