>Codex Can Review the Rules Your Repository Never Wrote Down
ALTIOR AI ADVANTAGEWhat to remember
Codex Code Review

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 harmless repository rename passes review before breaking a hidden downstream client.

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.

Why it matters

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.

Fast-moving code converges on a narrow reviewer queue where repository knowledge remains concentrated.
Code production can accelerate while the hidden contracts behind a repository remain concentrated in a few experienced reviewers. The diagram is directional, not a performance measure.

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.

The reported result

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.

An attributed primary-suite comparison shows 98% with custom rules versus 58.3% without them.
OpenAI reports that rule-guided variants recovered 98% of required custom findings in its primary suite, against 58.3% for the baseline control. The source pack includes no sample size, confidence interval, raw results or independent replication.
Provider image: openai-codex-custom-code-review-rules.png
OpenAI’s published chart shows its reported weekly pull-request volume trend. It supports the internal-volume claim, not a universal claim about customer growth.
98%Required custom findings recovered by rule-guided variants in OpenAI’s primary suite
58.3%Required custom findings recovered by the baseline control in the same suite
2×+OpenAI’s reported increase in its own weekly pull-request volume since Q4

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.

The capability

Repository Rules Reach the Review

OpenAI’s announcement connects `AGENTS.md` guidance directly to Codex Code Review findings.

Provider image: openai-codex-pr-volume-trend.svg
OpenAI’s article artwork accompanies its announcement that Codex Code Review can use custom repository rules in `AGENTS.md`.

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
Evidence boundary

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.

The mechanism

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.

A five-stage flow turns repeated reviewer warnings into scoped rules, cited findings and safe alternatives.
Repeated reviewer warning → scoped `AGENTS.md` rule → relevant diff → cited finding → safe alternative. The rule supplies context; the review applies it to the change.

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

Rule quality

Write the Rule That Helps

The best instruction names a real consequence, stays close to its code and offers a safe alternative.

A focused scoped-risk rule and safe path are contrasted with a broad policy dump and mechanical formatting noise.
A useful rule is consequential, scoped and paired with a safe path. A noisy rule is broad, mechanical or detached from the change it is meant to protect.

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

Put it to work

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
ALTIOR AI ADVANTAGE
Try one rule

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 prompt

Keep the boundary visible

  • Trigger quality
  • Safe-path quality
  • Noise
  • Hard enforcement