How to review AI-generated code
When agents write most of the code, a modern review checks two things: the code itself - secure, tested, maintainable - and how the team steers the agents that wrote it.
AgenticReview upgrades your code review to an agentic review: it scores the same things code review always has - security, dependencies, tests - plus what decides when agents write the code: how your team steers them.
What is AI code review - and what is a review of AI-generated code?
AI code review usually means AI reviewing code: a language model reads each pull request and comments on correctness, security and style. A review of AI-generated code asks a different question - whether the code agents produce is steered by the team. A modern review needs both: the classic checks on the code, and the steering behind it.
How a modern review works: from pull request to merge
Before the agent starts, the team sets guardrails - instruction files, conventions, tests. Before it builds, someone writes the plan. When the pull request opens, automated checks and AI reviewers look at the change; a human reviews, corrects and decides. After merge, the history shows whether that loop actually happened - which is what AgenticReview reads.
What classic and AI code review tools check
Classic and AI code review tools check the change in front of them: security issues, dependency risks, test coverage, style and readability. That is the core of traditional code review, and AgenticReview scores the same hygiene - secrets kept out, dependencies current, tests written, commits that explain themselves.
What they miss when agents write the code
A diff cannot show the pattern behind it. When agents write most of the code, the risk sits in the structure: the same rule defined in five places, components copied instead of shared, guardrails missing, work only one person can hand over. These do not show in today's change - only later, when the system has to scale or change hands.
Next-gen code review: the code plus the steering
Next-gen code review keeps everything classic review scores and adds the part that decides with AI-generated code: whether the team steers its agents and keeps the architecture composable. AgenticReview scores both from the git history, per project, over time and against comparable companies - and your code never leaves GitHub.
Code review for distributed teams
When a team is spread across time zones, the review becomes the main place where knowledge is shared - and the first thing to slip. AgenticReview shows whether reviews, plans and handovers keep up as agents add volume, per product and over time, so distributed teams see where steering is thinning out.
Claude Code review: steering the agent, not just the diff
Claude Code can write, test and refactor at a pace no reviewer can follow line by line. The useful question shifts from 'is this diff right?' to 'is the agent being steered?': instruction files, plans before it builds, review and correction after it delivers. AgenticReview measures exactly that - whether you use Claude Code, Codex, Cursor or Copilot.
Why now ends with one question: is this team steering the machine - or just accepting it? Four dimensions answer it. Each replaces something the old way of measuring got wrong. Built from 34 signals, combined into eight meters and four composite indices.
Capacity
Then: headcount and years of experience. Now: what the team actually delivers when agents do the typing - Execution Power - and how wide its technical range is - Tech Versatility. Experience no longer predicts output. Delivery does.
Composable
Then: does it work? Now: can it be changed? Agents duplicate logic at machine speed. Composability shows whether every business rule has one authoritative home - Architectural Order - and whether components are shared rather than copied - Component Community. This is the judgement that decides if software can scale.
Craftsmanship
Then: passing the linter. Now: holding up when code volume explodes. Dependency Hygiene and Security Hygiene show whether the foundation survives the next due diligence - or becomes the reason it fails.
Cooperation
Then: obedience - follow the rules, match the template. Now: proactive human-in-the-loop. Agentic Stewardship measures the intervention itself: guardrails set before the agent starts, plans written before it builds, review and correction after it delivers. Test & Commit Hygiene shows whether that work is documented well enough for someone else to take over.
Two shifts
From what code review has traditionally measured to what decides in the AI era. The model reads two ways. Across, it runs from then to now. Down, it runs from the system level - what is built - to the team level - how it is built.
The top row is how Capacity and Composable act on each other. Composable is the modern way to maximise capacity, with or without AI - and above all with it: one definition consumed by many makes every new feature cheaper instead of more expensive.
The bottom row is how Craftsmanship and Cooperation act on each other. Cooperation - within and between human and machine agents - is the modern way to maximise good craft: review, tests and steering catch what both tools and people miss.
The grey column is what code review and engineering analytics have traditionally measured. Capacity as throughput, lead time and activity, measured by code review tools since the mid-2010s. Craftsmanship as static analysis of bugs, vulnerabilities, dependency risks and test coverage, in most traditional tools since the 2000s. That is what code quality has traditionally meant.
The green column is where measurement thins out. Composable is measured, if at all, as duplication and code smells. Cooperation is measured as review flow - how long a pull request waits - not whether the work can be taken over. Oversight of agents is barely measured at all. Nobody measures either where it actually happens - in the people doing the work. The method behind AgenticReview is validated at exactly that level, and AgenticReview applies it to teams and companies. That is where the agentic economy opens a new era - and where AgenticReview has the greatest effect.
When it is strong - and when it is missing
Ideas ship within weeks.
Agents deliver volume on demand.
Every feature costs less than the last.
Agents reuse instead of duplicate.
Years without a crisis.
Agent changes land tested and secure.
Anyone - person or agent - can take over.
The team steers agents like colleagues.
The later a gap shows, the more it has cost. That is why traditional code review underestimates three of the four: they do not show in today's code - only once they are already expensive. Agents make Capacity cheap. The other three are the filter that separates the winners.
Simultaneous, not sequential
Form, durability and collaboration are not steps after the code is written. They happen in every iteration - architecture is agile, everything is craft, everything is collaboration. Each of them can boost the power or drag it down, and a weak dimension drags the whole result down. Capacity says how much, not how. Composable says how, not how long. Craftsmanship says how long, not who can take over. Cooperation says who else - human or agent.
See how the dimensions act on each other
| Acts on → | Capacity | Composable | Craftsmanship | Cooperation |
|---|---|---|---|---|
| Capacity | How much. Doing, weeks, the contributors | Gives material to shape. Without form, volume becomes debt. Tension: speed now vs abstraction that pays off later. | Increases exposure: more code means more dependencies and more surface to protect. Tension: speed vs care. | Creates what will be handed over. Tension: tests and commits take time from delivery. |
| Composable | Multiplies capacity: what is reused makes every new feature cheaper. | How. Shaping, months, the system | Makes craft possible: one definition is one place to patch, one upgrade instead of five. | The precondition for handover: order makes the system understandable to the next person and agent. |
| Craftsmanship | Protects capacity from disruption: incidents and dependency debt eat delivery time. | Keeps the form intact over time: stable dependencies and secure contracts let the structure live. | How long. Protecting, years, the life cycle | Makes it safe to let others in: secrets outside the code and narrow permissions, agents included. |
| Cooperation | Extends capacity beyond the person: stewardship turns agents and colleagues into capacity. | Tests protect the shared contracts, and commits explain why the structure looks the way it does. | Review catches what craft misses: tested and reviewed agent changes are safety in the flow. | Who else. Sharing, beyond the person, the organisation |
Seen from every level
For each project and for the company as a whole. Compare projects against each other to see which teams are pulling ahead and which need support.
Over time
Six months of history from the first review, and a new point every time you run one.
Against the market
Benchmark against companies in your region, your industry and your size.
What it means for the business
- Improvement potential found before it hardens into technical debt
- Risk areas spotted early - before a due diligence does it for you
- The strategic wake-up call, when it is needed
- Reasons to celebrate: internal success stories and role-model teams worth learning from