The Rule Your Reviewer Remembers
Codex can bring a repository’s unwritten warnings into review, provided we turn them into concise, scoped rules with a safe path.

A one-line rename can compile cleanly and still break the client waiting for yesterday’s event name. The diff looks harmless; the missing fact lives in the memory of the reviewer who has seen the failure before.
OpenAI says Codex Code Review can use custom repository rules in `AGENTS.md`. The opportunity is not to document everything. It is to put the few consequential warnings beside the code, where they can meet the relevant change.
Review Knowledge Is the Bottleneck
As code arrives faster, the scarce resource is often the local context that tells us which tidy changes are unsafe.

OpenAI says its weekly pull-request volume has more than doubled since Q4 and reports similar trends for many customers. That is an attributed observation, not evidence that every team has seen the same increase.
The practical pressure is familiar: more changes compete for the judgement of people who remember old integrations, fragile boundaries and decisions that never became executable checks. Codex can carry some of that context into review, but only after we express it clearly.
What OpenAI Actually Found
The strongest number comes from OpenAI’s own primary evaluation suite, with important limits on how far we can take it.


The gap between 98% and 58.3% is meaningful within the evaluation OpenAI describes. It suggests that explicit repository guidance can help Code Review recover findings the baseline misses.
It does not establish universal production performance. Without the underlying sample size, confidence interval, raw results or independent replication, the responsible reading is narrower: the reported evaluation supports testing scoped rules in our own repositories.
Repository Rules Reach the Review
OpenAI’s announcement connects `AGENTS.md` guidance directly to Codex Code Review findings.

A root `AGENTS.md` can hold repository-wide guidance, while nested files can narrow rules to a service or directory. That scope matters: a warning about a public event contract should follow the code it governs, not spill across unrelated changes.
For the harmless-looking rename, the useful rule explains the invariant and the safe alternative: preserve the existing wire name, or add a backward-compatible event. Codex can then connect the local instruction to the diff and cite the guidance behind its finding.
Codex Code Review can now use custom repository rules in `AGENTS.md` to catch those issues and point authors to the guidance behind a finding.
OpenAI Developers
Proof, With Limits
OpenAI’s evaluation supports a focused test, not a guarantee that repository rules will catch every hidden risk.
These figures belong to OpenAI’s primary suite. The available material does not provide the sample size, confidence interval, raw outputs or an independent replication, so we cannot extend the result to every repository or production change.
The evidence is still useful when kept in proportion. It gives us a reason to test whether a small set of repository-specific rules improves findings on known triggering changes without creating noise elsewhere.
How the Warning Reaches the Diff
A repeated review lesson becomes useful when it is scoped, actionable and connected to the change that activates it.

The starting point is a warning we already repeat: changing `rawResponseItem/*` event names can break clients that listen for the existing wire value. We capture the consequence, define where the rule applies and state a safe route forward.
When a relevant diff appears, Codex can use that instruction to explain the risk and point back to the repository guidance. An unrelated rename should pass untouched; resemblance alone is not a reason to manufacture a finding.
Capture
Scope
Review
Write the Rule That Helps
The best instruction names a real consequence, stays close to its code and offers a safe alternative.

OpenAI says small, scoped sets with an explicit safe path helped Codex focus on what was useful without applying a rule to every nearby change. That makes two or three high-value rules a better starting point than a policy dump.
Formatting, naming patterns and other deterministic checks usually belong in CI. Repository guidance earns its place when it preserves judgement that a mechanical check cannot express cleanly: what can break, where the risk applies and what a safe change looks like.
Name the risk
Draw the boundary
Offer a path
Turn Tribal Knowledge Into a Test
Start with a few consequential rules, then test triggering, safe and unrelated changes before trusting the signal.
A repository rule is valuable when it turns remembered context into a precise review signal without pretending to be enforcement.
AI News synthesis
Choose a warning that an experienced reviewer keeps repeating. Write the smallest rule that preserves its consequence and safe path, then run it against three cases: a change that should trigger, a compatible alternative and an unrelated diff.
If the rule misses the first, blocks the second or comments on the third, refine it before adding more. The aim is not maximum instruction volume. It is a sharper signal where repository history changes the meaning of the code.
Test a repository rule before it becomes noise
Act as a cautious code reviewer for a repository where external clients depend on the wire event name `completed`. Review these three proposed diffs separately: (1) rename `completed` to `done`; (2) add `done` while retaining `completed` as a backward-compatible event; (3) rename an unrelated local variable from `completedCount` to `doneCount`. Apply this repository rule: ‘Do not rename externally consumed event names without preserving backward compatibility. Keep the existing wire name or introduce the replacement alongside it with a documented migration path.’ For each diff, return: Verdict (`flag` or `no finding`), the exact rule condition that did or did not trigger, the downstream risk, and the safest next change. Do not invent repository facts or flag changes merely because they contain similar words.Ready to copy
Make Hidden Context Testable
Take one recurring review warning, give it a clear scope and safe path, then test it against risky, compatible and unrelated changes before expanding the set.
Try the promptKeep the boundary visible
- Trigger quality
- Safe-path quality
- Noise
- Hard enforcement