What is a code steward
What is a code steward?
A code steward is a long-running AI agent that owns one specific dimension of your codebase — auth, billing correctness, accessibility, SOC 2 readiness, telemetry hygiene, your own conventions — across every pull request, forever. Unlike a general AI reviewer that scans the whole diff for anything wrong, a steward is scoped to a single mission, accumulates context over time, and doesn’t just comment: it writes the code and opens the follow-up PR. You don’t install one steward — you build a fleet, one mission at a time.
The shift that makes stewards necessary: agents now write the code and agents filter the review queue. The cost every review tool was built to cut — noise — went to zero. The only cost left is the miss. A steward is how you put an owner on each dimension so nothing slips.
Why review changed: from precision to recall
The precision era — built for human readers
For a decade, the job of review tooling was to cut noise: surface the few comments worth a human’s attention and stay quiet otherwise. When a human read every comment, a false positive was expensive — it burned attention and trust — so every reviewer optimized precision. GitHub Copilot, CodeRabbit, Graphite, Sourcery, and Codacy all converged on aggressive filtering before a developer sees anything. That design is correct, for human readers.
The recall era — what’s true now
Agents write the code and agents triage the queue. Software now sits between the scan and the developer, so a false positive is cheap to discard. A missed bug still reaches production — and a production defect costs an order of magnitude more than one caught pre-merge. When false positives get cheap and misses stay expensive, the metric flips: recall, not precision, is what matters. A clean check isn’t noise — it’s a covered risk.
A code steward vs a general AI reviewer
Recall isn’t a setting you turn up on a reviewer. It requires declaring what matters per dimension and putting an owner on it. That’s the line between a steward and a reviewer.
| Dimension | Code steward | General AI reviewer |
|---|---|---|
| Mental model | An owner for one mission | A reviewer for every PR |
| Optimizes for | Recall — missing nothing on its domain | Precision — high signal across the diff |
| Scope | One declared dimension — auth, billing, a11y, SOC 2 | The whole pull request, generally |
| What it can check | Anything you declare, including repo-specific rules no off-the-shelf tool can name | General correctness — the same lens on every codebase |
| Output | Writes the code and opens a follow-up PR | Inline comments, summaries, suggestions |
| Context | Long-running; accumulates context across every PR | Reviews each PR as it arrives |
| How you scale it | Add stewards as missions — one repo to a fleet | Tune rules and review depth |
| Your role | On the loop — set taste, adjudicate the close calls | In the loop — read and triage every comment |
How a steward works
Before the agent builds
Ask the event reliability steward about a telemetry plan. It spots the part that needs a test before your agent writes the first diff.
After the diff lands
The same steward reads the changed files, raises the concern that still needs you, then clears the check when the agent proves the fix.
Why one smarter reviewer can’t cover you
Coverage doesn’t come from a bigger model — it comes from narrow owners. When a team ran four leading AI reviewers across the same 146 merged PRs for three weeks, their findings barely overlapped. Stacking general reviewers mostly buys copies of the same blind spots. (dev.to benchmark, 2026)
93.4%
of flagged lines were caught by exactly one of four reviewers
0
lines all four reviewers ever agreed on, across 146 PRs
146 PRs
3 weeks, 4 leading reviewers running in parallel
Code steward FAQ
What is a code steward?
A long-running AI agent that owns one dimension of your codebase across every PR — and ships the fix as a follow-up PR rather than just leaving a comment.
How is a code steward different from an AI code reviewer?
A reviewer optimizes precision across the whole diff and hands you comments. A steward is scoped to one mission, optimizes recall on that mission, and writes the code to close the gap.
Why does recall matter more than precision now?
Because agents both write code and filter the review queue. False positives became cheap to discard; missed bugs still reach production. When the cost of noise drops to near-zero, the only cost left is the miss — so recall becomes the metric.
Does a steward replace human reviewers?
No. Humans move from in the loop (reading every comment) to on the loop — setting the standard and adjudicating the close calls. Research on review agents finds human oversight stays critical; CRA-only PRs merge far less often than human-reviewed ones.
Can a steward check things a general reviewer can’t?
Yes — that’s the point. General reviewers can only check what matters in every codebase. A steward checks what matters in yours: your conventions, accessibility rules, analytics hygiene, compliance posture — whatever you declare.
How do you start using stewards?
Install the GitHub App, point one steward at a single mission, and let it ship the fix on the next PR. Add more stewards as missions over time.
Put an owner on the dimension you keep missing
Install the GitHub App, point a steward at one mission, and watch it ship the fix on the next PR. Add stewards as you grow, from one repo to a fleet.