Your Team Conventions Need Measurable Judgement Criteria

Conventions Fail When They Stay Implicit in Chat

Most engineering teams already have conventions; the problem is that they live in conversation rather than in code. A senior engineer tells an assistant during one session that new endpoints must return structured errors, the assistant complies, and the next session starts with no memory of the exchange. Claude Code inherits what the repository states and what the current prompt repeats, so private agreements evaporate at the edge of a session. The practical move is durable placement: record each convention where the tool reads before it acts, in language that can be applied without guesswork.

This changes the shape of the work. Instead of renegotiating style in every review, the team leaves a standing contract that the assistant consults at the start of each task. Corrections happen once, in writing, instead of once per change, and reviewers spend their attention on design instead of repeating themselves.

A Written Contract Beats Scattered Conversational Advice

A useful contract is short enough to obey and specific enough to violate. Vague instructions such as clean code or sensible naming produce nothing measurable, because two competent engineers will read them differently. State the rule, the reason, and the failure it prevents, then stop. Rationale matters more than volume: one sentence explaining that consistent error shapes let clients branch once is worth more than a page of abstract principles.

Keep the contract close to the code and let it grow by exception. When a reviewer repeats the same note for the third time, that note belongs in the contract rather than in the review. A compact set of rules usually covers the habits that matter most:

• Naming and directory shape for new modules, including singular and plural choices.
• Error and response conventions, including the fields clients depend on.
• Testing expectations, including which behaviours require coverage before merge.
• Dependency policy, including approval rules for anything that adds a runtime package.

Side-By-Side Reading Makes Ambiguity Visible to Everyone

Reading two candidate changes side by side is the fastest way to discover which rules are real and which are folklore. Take one modest task, let one draft proceed with only the prompt and let a second proceed with the contract, then place the two results next to each other under the same criteria. The differences show exactly where the contract is silent: naming that drifted, tests that were skipped, a comment style that changed without cause.

The pairing also settles arguments quickly. When two reviewers disagree about whether a rule deserves enforcement, ask each side to write the criterion they would apply, then read both drafts again. If the criterion cannot separate the drafts, it is taste, and taste should be marked as preference rather than law. Teams that run this comparison on a handful of changes each quarter end up with a shorter, sharper contract and a shared vocabulary for critique.

Explicit Criteria Turn Preference Into Reproducible Decisions

Criteria convert opinion into something an assistant can satisfy and a reviewer can verify. Each criterion should name an observable property, the acceptable range, and the evidence expected. The same list serves a human review and a machine pass, which keeps both audiences honest with one another.

• Behaviour: the change does what the request states, with no silent scope creep.
• Conformance: naming, structure, and error shapes match the contract exactly.
• Scale: the edit touches only what the task requires, and diff size is proportionate to the change.
• Evidence: tests cover the new behaviour and the existing suite still passes.
• Reviewability: a colleague can follow the reasoning without asking for a walkthrough.

Criteria work best when they are applied in order and phrased as questions. Order matters because behaviour first keeps a polished but wrong change from scoring well, and questions keep the reader testing rather than admiring.

Scope, Precedence, and Edit Triggers Keep Rules Alive

Contracts decay when their boundaries are unclear. Say which rules apply everywhere and which apply only to particular areas, and say what happens when two rules pull in opposite directions. A clear precedence order, general style below architectural safety below security and data handling, removes most of the hesitation that shows up as vague commentary.

Give each rule a trigger as well: the moments that should make the assistant reread it. Adding a route, touching a shared type, introducing a dependency, or changing an interface are good triggers because they are easy to recognise during the work. Rules with triggers outlive rules without them, since they are re-read at the moment they matter instead of once at the beginning of a project.

Measure Adherence Before You Trust the Behaviour

Adoption deserves measurement like any other change. Sample a batch of recent merges and count the edits that violate the contract, track the review notes that repeat, and watch whether the contract shrinks as taste separates from law. If violations cluster around one rule, rewrite that rule rather than blaming the model.

Keep the evaluation loop independent of the transport so that model choice stays a variable you control. BestRelay is a quality-first API relay that forwards each request to the official model named in it, with no substitution, and it works with Claude Code, Codex, Gemini CLI, and any OpenAI SDK. Billing is pay-as-you-go from the token counts the provider reports, cache reads and writes are priced separately, and members earn a referral commission when the people they invite top up. Running the same side-by-side pass on Claude Sonnet 5.5 and on a smaller model tells you whether your contract carries the behaviour or the model does. Create a BestRelay account and run the comparison on your next change.