Two etiquette lanes for agents in a shared repo
Every team that lets coding agents commit to a shared repository ends up choosing between two working styles, and the choice shapes everything downstream. In the first lane, the agent drives: a developer gives a broad goal, lets the agent explore the codebase, edit many files, and push a large change set. In the second lane, the agent is a guided pit crew: a human defines a narrow task, hands over a short list of constraints, and expects a small, reviewable diff in return.
Neither lane is wrong on its own. The open driver lane works well for greenfield spikes, prototype branches, and throwaway experiments where nobody else's work depends on the result. The guided lane is what keeps a shared main branch calm when several people, and several agents, are writing to the same code at the same time.
The friction appears at the boundary. An open driver run can quietly rewrite a shared helper, rename a public symbol, or reformat a file a teammate is editing in a parallel branch. A guided run can miss the bigger design problem because the human scoped the task too tightly. Good etiquette is mostly about knowing which lane you are in before the agent starts typing.
Commit hygiene: what each lane leaves in the log
In the open driver lane, the commit log tends to collect whatever the agent happened to finish: a feature, a refactor, a style change, and a couple of unrelated fixes, all in one message. The human reviewer has to reverse-engineer intent from a diff that spans dozens of files. That is where trust erodes, because the reviewer cannot tell which parts were deliberate and which parts were collateral.
The guided lane produces commits that read like a decision: one task, one reason, one review. When the agent is asked to stop after each logical step, the log becomes a sequence a teammate can skim and approve in pieces. Reverts stay cheap too, because a problem change can be undone without dragging three unrelated fixes with it.
- Ask for one task per run. A single goal with a stated 'do not touch' list keeps the diff legible.
- Separate mechanical edits. Renames and formatting belong in their own commit so the real change is easy to read.
- Require a written summary. The agent should say what it changed, what it chose not to change, and what it could not verify.
- Never let an agent push to a protected branch. Push to a short-lived branch and let a human open the request.
Prompt discipline and the blast radius of a run
The two lanes differ most in how they handle instructions. In the open driver lane, the prompt is broad, so the agent fills gaps with its own assumptions. In the guided lane, the prompt carries constraints: the files to touch, the patterns to follow, the tests to keep green, and the places where it must stop and ask. Constraints are the etiquette here; they turn a guess into a contract.
Blast radius is the measure of how much of the repository a single run can disturb, and you can shrink it without adding ceremony. Tell the agent which directories are in scope, point it at the local conventions file, and require it to ask before adding a dependency or changing an interface another team consumes. Routing also helps. Run the agent through SwiftRelay, which works with Claude Code, Codex, Gemini CLI, and any OpenAI-compatible SDK against one API host at api.fastapirelay.com, and your team can switch between a reasoning-heavy model such as Gemini 3.1 Pro and a lighter coding model such as Claude Fable 5.1 while keeping the same etiquette, the same branches, and the same review habits.
One more habit belongs in every prompt: name the failure path. If the agent cannot find the relevant code, if a test fails for a reason outside the task, or if the fix would require a public API change, it should stop and report rather than improvise. That single instruction prevents most of the surprises a teammate finds later.
Review etiquette that respects the humans on the branch
Etiquette is not only about what the agent writes. It is about what the human does with the result before anyone else sees it. A pull request opened straight from an agent run, with no human pass, transfers the reasoning cost to the reviewer. A quick human pass that reads the summary, checks the riskiest file, and runs the tests locally moves that cost back to the person who caused it.
- Read every generated hunk before you request review. You own the code with your name on it.
- Flag agent-authored changes in the description. Reviewers read differently when they know where the text came from.
- Answer the agent's open questions yourself. Do not leave a trail of 'the agent decided' in the discussion thread.
- Keep the conversation on the code. Paste the agent's reasoning only when it explains a choice that looks unusual.
Reviewers owe something back in return. If a generated change is confusing, say which rule it broke and where that rule lives. Agents and humans both learn from a precise correction, and the next run becomes cheaper for everyone.
A checklist to run before the green light
Put the comparison in one line: the open driver lane starts with less planning and costs more to review, while the guided lane asks for a few minutes of scoping and pays it back in readable commits and fewer surprises on shared branches. For a repository that several people and several agents write to every day, that trade is not close.
The recommendation: default to the guided pit crew lane, and reserve the open driver lane for isolated branches. Before you let any agent touch a shared repository, walk this checklist:
- Is the task narrow enough to describe in two sentences?
- Are the in-scope files and the forbidden files written down?
- Is there a short-lived branch named for the task?
- Will the agent stop and ask before changing a public interface?
- Does the run end with a summary of what changed and what was skipped?
- Has a human read the diff, run the tests, and written the description?
Run the checklist once and it becomes habit; run it on every lap and your shared log stays readable even when several agents are working at the same time. If you want one account to reach current models through the tools your team already uses, with per-token billing and no commitment, sign up for SwiftRelay and start with the small gift credit that new accounts receive.