# The Last Human Code Review: Building Trust in AI-Generated Code

Itamar Friedman

AI Engineer World's Fair 2026

[Talk page](https://ai.engineer/talks/s-aixZYJG4c-last-human-code-review-building-trust) · [Video](https://www.youtube.com/watch?v=s-aixZYJG4c)

## The Last Human Code Review: Building Trust in AI-Generated Code

Automating review requires more than finding bugs: it requires team standards, architectural contracts, and accumulated experience that both people and agents can inspect.

Familiarity with pull requests, coding agents, and service API contracts will help you follow the review and governance examples.

### Who verifies the code your agents write?

[0:33](https://www.youtube.com/watch?v=s-aixZYJG4c&t=33s)

If AI can write code faster than your team can review it, who verifies that the changes match your intent, architecture, and engineering standards? Code generation can accelerate while the rest of the software development lifecycle remains constrained. The queue moves downstream to the people responsible for deciding whether the code should ship.

That verification requires knowledge specific to an organization. A model may recognize common programming mistakes without knowing why your team chose a particular architecture or which local practices protect production. Itamar Friedman introduces Qodo—short for quality of development optimization—as a system for bringing codebase knowledge, tribal knowledge, and best practices into review. The premise is that this knowledge does not arrive with an off-the-shelf model: the surrounding system must accumulate and improve it over time.

### Preserve validation and learning

[1:59](https://www.youtube.com/watch?v=s-aixZYJG4c&t=119s)

Before removing human review, separate the two jobs it performs.

| Review function | What it preserves |
| --- | --- |
| Validation | Quality, safety, maintainability, architecture, and best practices |
| Alignment and learning | Shared understanding and guidance from experienced developers |

The pull request is often a senior developer’s last opportunity to explain a design decision before code reaches production. Replacing the quality gate without replacing that exchange would remove part of the team’s learning process.

The question is whether these functions must remain inside human pull-request review. New tools or processes can move them elsewhere, provided both survive. Friedman frames the end of 2026 as a test of that transition: will human review still be mandatory, and will developers still inspect most PRs diff by diff? These are questions about the future workflow, not evidence that human review has already become unnecessary.

### Decide what confidence must mean

[3:38](https://www.youtube.com/watch?v=s-aixZYJG4c&t=218s)

Conversations with engineering leaders during the previous evening’s drone show revealed two contrasting attitudes toward production bugs. This was an anecdotal split, but it exposes a decision every team must make:

- **Verify before release:** Require confidence in each change, with a human responsible for reviewing it before production.
- **Repair after release:** Accept that bugs will ship, prioritize velocity, and fix problems quickly when they appear.

Most organizations sit somewhere between these endpoints. Their position determines the confidence required to skip human review, the milestones toward automation, and the tools needed to reach them. A team cannot choose a sensible review policy without first deciding which risks it is willing to accept.

### Context makes a finding relevant

[5:17](https://www.youtube.com/watch?v=s-aixZYJG4c&t=317s)

**Useful review depends on knowing what matters in this system.** Friedman argues that model capability is no longer the principal barrier. He describes a visit to an unnamed leading lab where code-review benchmarks had changed little across recent models. No model versions, benchmark details, or scores accompany that observation; it supports his emphasis on context, not a general measured claim that model improvements have stopped.

With the right context, a model can reason about which issues a particular change introduces. Without it, even a strong model may produce generic advice about error handling. Such advice can be correct and still fail to help a reviewer decide what to do: missing error handling may be critical in one location and relatively unimportant in another. The missing capability is not merely recognizing a programming concern. It is judging that concern against the purpose and consequences of the change.

### Bring scattered knowledge under governance

[6:31](https://www.youtube.com/watch?v=s-aixZYJG4c&t=391s)

Today, much of that context is scattered across `AGENTS.md`, `CLAUDE.md`, and `SKILL.md`. Organizations, subteams, and individual developers organize those files differently. Some use the same agent for coding and review; others use separate tools. Instructions alone do not ensure consistent behavior when the tools consuming them differ.

The execution environment is spreading out too. Alongside IDE and CLI agents, teams run coding agents in automated workflows. Friedman reports seeing teams generate more of their shipped code outside IDEs and CLIs than inside them. A governance system therefore has to cover the workflows producing code, not just the developer’s interactive session.

Model Context Protocol, or MCP, integrations and retrieval-augmented generation add further sources of context. They also add questions about visibility: what information did an agent receive, and what changed between reviews? Versioning MCP integrations and maintaining datasets or benchmarks for each change can help, but Friedman describes this as difficult to manage. The missing layer is governance over the context and tools on which review depends.

Some of the most valuable information has never reached an instruction file. It lives in developers’ experience, infrastructure documents, Slack threads, and Teams conversations. Codifying it means recovering the reasons behind a standard or architectural choice, including the knowledge that experienced engineers apply without having to look it up.

### Give humans an inspectable basis for review

[8:53](https://www.youtube.com/watch?v=s-aixZYJG4c&t=533s)

Once knowledge is captured, its representation becomes an interface design problem. Agents benefit from structured, explicit instructions. Developers need material they can read, understand, and maintain, such as a wiki or onboarding guide. A **context engine** must serve both audiences so they can collaborate on the same body of knowledge. An agent-only instruction store leaves people unable to inspect the basis of decisions; human-readable documentation alone may not deliver the relevant knowledge to an agent at review time.

The [Qodo rule system](https://www.qodo.ai/blog/introducing-qodo-rule-system/) provides the human-facing example in the talk. It collects the team’s rules and standards and exposes their use during review. In the Qodo example, many rules are applied and four are reported as violated. The review links to all the rules used, allowing a person to inspect the standards behind the result. That traceability is the mechanism for trust: reviewers can examine the basis of a finding instead of accepting an unexplained judgment. Qodo is the demonstrated tool, but the requirement applies to other review systems as well.

### Turn review findings into an agent handoff

[10:40](https://www.youtube.com/watch?v=s-aixZYJG4c&t=640s)

The agent-facing interface carries the process beyond an explanation. In the demonstrated handoff, an agent-directed Qodo comment reports five issues in the PR. Friedman describes the following sequence:

1. Qodo reviews the original PR and identifies issues.
2. Background tasks use a **Claude Code** harness to prepare fixes.
3. A separate, closed PR holds those fixes.
4. An agent returning to the original PR can cherry-pick the prepared changes, which Friedman describes as satisfying the relevant rules and standards.

The closed fix PR is a source of changes for the returning agent; it is not evidence that those changes have been merged into the original PR or deployed.

The handoff connects the same review context to two consumers: people need understandable findings and their supporting rules, while agents need information and links that let them continue the work. Gathering context is only part of the system. Making it available at the point of review and repair is what allows the workflow to progress.

![Slide titled “Agent to agent discussions,” with “Make it clear for humans, but auditable,” a closed pull request, and a Qodo Fixer comment containing a coding-agent prompt.](https://ai.engineer/api/talk-essay-media/9b734f3f7dff806095cf15cb304e51b6fb9a5398fc1ee172b035700d9d0961d1)

Agent-to-agent discussions pair a closed fix pull request with a prompt for the coding agent.

As this process improves, developers should have fewer additional comments to make. Friedman proposes roughly 100 PRs without further human review contributions as a readiness heuristic for automation, not a measured safety guarantee. The useful signal is whether humans still supply judgment that the system lacks. A declining comment count can motivate examining readiness, but the proposed threshold does not establish that the review system catches every consequential defect.

### Remember contracts and the incidents that exposed them

[12:24](https://www.youtube.com/watch?v=s-aixZYJG4c&t=744s)

Rules, standards, and skills capture only part of organizational knowledge. The next layer is architecture: how the system fits together and how changes propagate through it. Consider the recent P0 outage an experienced developer remembers—a change to one microservice’s contract broke another microservice. That incident may matter more to the next review than a general coding guideline. Friedman says this architectural knowledge is difficult to build into a review system and is available in some specialized review tools.

The graph shown in the talk represents a microservice, its related repositories, and their connections. An edge records the contract between software components. Relevant graph elements also link to developer discussions and the root-cause analysis from earlier failures. The graph therefore records more than dependency: it preserves evidence about why a relationship needs protection.

For a concrete representation of that mechanism, suppose an order service returns an `order_id` that a fulfillment service consumes. A compact JSON record could keep the contract and the reason for preserving it together:

```json
{
  "nodes": [
    { "id": "orders", "repository": "orders-service" },
    { "id": "fulfillment", "repository": "fulfillment-service" }
  ],
  "edges": [
    {
      "id": "order-response",
      "provider": "orders",
      "consumer": "fulfillment",
      "contract": {
        "requiredFields": { "order_id": "string" }
      },
      "history": [
        {
          "incident": "INC-42",
          "discussion": "RCA-42",
          "lesson": "Renaming order_id broke fulfillment."
        }
      ]
    }
  ]
}
```

These example service names and records illustrate the representation. The important placement is the incident lesson on the affected relationship: a reviewer examining an order-response change can retrieve both the consumer’s dependency and the experience that makes it consequential.

### Apply explicit policies across concurrent changes

[13:38](https://www.youtube.com/watch?v=s-aixZYJG4c&t=818s)

With architectural context in place, automated approval and blocking become policy questions. The system needs to learn when the team approves a change and when it refuses one. Friedman calls for **semantic rules** that express those decisions, rather than allowing an AI reviewer to choose without explicit criteria. In the order-service example, a proposed rule could block removal of `order_id` while fulfillment still requires it. This is a policy applied to a dependency, not simply a warning that a line changed.

The proposed review surface then expands from an isolated PR to a graph of work in progress. Multiple PRs can appear together with the contracts they may breach. A change that looks acceptable on its own may interact badly with another pending change. The purpose of the graph is to make those relationships visible while the work is still in flight; Friedman presents this as the direction of software governance, rather than demonstrating a completed deployment of every part of it.

That graph must remain open to human audit and control while its context evolves. PR history, accepted and rejected outcomes, developer discussions, and production failures all supply new knowledge. Merely accumulating more files is insufficient: the context needs a meaningful location so an agent can determine where it applies. Governance infrastructure then exposes the overall state of the PRs and software, including the context behind decisions.

### Measure the rules and automate gradually

[15:47](https://www.youtube.com/watch?v=s-aixZYJG4c&t=947s)

If AI-generated code already arrives faster than humans can review it, the bottleneck is present, not hypothetical. More generation does not remove the need to decide what can safely ship. Friedman invokes promised 10× velocity as a motivation for governance infrastructure, not as a measured result. His operational prescription begins with owning the rules and standards and collecting evidence about how they work.

The feedback loop has three parts:

1. **Measure rule use.** Track which rules, standards, and skills participate in review, how often they produce findings, and whether they remain useful or need updating.
2. **Expose contract conflicts.** Show the software graph, its connections, and the contracts affected by pending work. Look for PRs that touch the same edge incompatibly.
3. **Expand automated gates incrementally.** Add rules for blocking and approval over time instead of immediately delegating every decision.

This makes automation a gradual change in the scope of decisions the system can handle. Rule analytics and graph visibility provide the feedback needed to decide what to automate next.

### Move experienced judgment into the system

[17:11](https://www.youtube.com/watch?v=s-aixZYJG4c&t=1031s)

Trustworthy automated review places team rules and standards at the relevant nodes and edges of the software graph. It also preserves the less formal knowledge accumulated in discussions and software history: what to do, what to avoid, and why. Both people and agents need access to that experience.

Friedman calls this move from intelligence to **artificial wisdom**. Experienced developers currently hold much of the judgment about which changes are good or bad. Transferring some of that judgment to tools requires codifying experience in the right form and attaching it to the right part of the system. The final slide brings together team standards, repository relationships and architectural history, tribal knowledge, and that accumulated judgment.

![Slide lists four requirements: the team’s rules and standards; PR history, repository relationships and architecture decisions; tribal knowledge living in engineers’ heads; and artificial wisdom. A footer describes a traceable, auditable, grounded validation report.](https://ai.engineer/api/talk-essay-media/067f94c3091cd44a6176f10643e5c452f24bb3463ccd271215796b3fa26e3625)

Trustworthy automated review requires team rules, repository history, tribal knowledge, and artificial wisdom.

Qodo’s stated ambition for 2027 is zero outages and zero production bugs, qualified to at least critical and high-severity bugs. It is a future target, not a reported achievement. The substantive shift is where responsibility for review lives: developers must be able to maintain and inspect the knowledge and policies that guide automated decisions, even as they spend less time reviewing individual diffs.

## Resources

- [Qodo’s Rule System](https://www.qodo.ai/blog/introducing-qodo-rule-system/) — Explains how Qodo discovers, enforces, measures, and maintains organizational engineering rules.
- [Qodo Agent Skills](https://docs.qodo.ai/agent-skills) — Setup and usage instructions for fetching repository rules and resolving Qodo review findings inside coding agents.
- [How Qodo’s Context Engine Works](https://www.qodo.ai/blog/how-qodo-builds-the-wisdom-to-govern-the-context-engine/) — An August 2026 explanation of contextual evidence retrieval and cross-repository relationship mapping.
- [Qodo’s Code Review Benchmark Methodology](https://www.qodo.ai/blog/how-we-built-a-real-world-benchmark-for-ai-code-review/) — Documents an injected-issue PR benchmark and the precision, recall, and F1 metrics used to evaluate review tools.
- [From Artificial Intelligence to Artificial Wisdom](https://www.qodo.ai/blog/qodo-70m-series-b-shift-to-artificial-wisdom/) — Friedman develops his argument that software governance requires accumulated context, memory, and organizational standards.
- [AI Gave Teams Velocity. The Governance Harness Comes Next.](https://www.qodo.ai/blog/ai-gave-teams-velocity-the-governance-harness-comes-next/) — Friedman argues for treating oversight of coding agents as shared engineering infrastructure.

## Slides

### Why do we review code at all?

Code review validates safety, maintainability and architecture while helping teams align and learn. The speaker asks whether humans and the pull request process remain the best way to do both.

[2:09](https://www.youtube.com/watch?v=s-aixZYJG4c&t=129s) [Two columns list validation and alignment and learning as purposes of code review.](https://assets.ai.engineer/sites/aiecode2025/sha256/2055f638bd1a67bcd49c52639467725aa3fbfa3b23882e2e7166d162a430d00b.webp)

Why do we review code at all?

THE LAST HUMAN CODE REVIEW
qodo

BUCKET 01 — VALIDATION
• Safety
• Maintainability
• Architectural soundness
• ...

BUCKET 02 — ALIGNMENT & LEARNING
• Team coherence
• Leveling up engineers
• Transferring tribal knowledge
• ...

Are humans still the best available instrument for both?

### Human code review will be optional

A 2026-7 forecast asks whether human code review will become optional. The speaker contrasts reviewing every line with shipping faster and fixing bugs in production, while acknowledging positions between those extremes.

[4:01](https://www.youtube.com/watch?v=s-aixZYJG4c&t=241s) [A forecast says human code review will be optional and asks, Yes? No?](https://assets.ai.engineer/sites/aiecode2025/sha256/1000776a1a083f293996ddf4eae48af82fb18a29510a752671e4f208b9092912.webp)

Human code review will be optional.

$ forecast --horizon 2026-7
// like running unit tests manually

Yes? No?

qodo

### This is fine drone show

Drones spell “THIS IS FINE” above a dog, a cup and flames beside a lit clock tower. The speaker considers the tools and confidence needed to skip human code review.

[5:05](https://www.youtube.com/watch?v=s-aixZYJG4c&t=305s) [Drones form an illustration and the words “This is fine” beside a lit clock tower.](https://assets.ai.engineer/sites/aiecode2025/sha256/0eeb9e7d3b732e07cbe070f5db0d65ccd4f85cd42a918af334f75964b2cfa857.webp)

THIS IS FINE

qodo

[5:07](https://www.youtube.com/watch?v=s-aixZYJG4c&t=307s) [Drone lights spell “This is fine” beside an illuminated clock tower.](https://assets.ai.engineer/sites/aiecode2025/sha256/e0a2efac385d8eb2613d131fd5830b71286f4408ede1e02743f81ca4f4936b76.webp)

THIS IS FINE

qodo

### The real split in the room

A bridge illustrates the gap between teams that review rigorously and resource-constrained teams that skip review. The speaker argues that context helps models surface the right issues for a code change.

[5:13](https://www.youtube.com/watch?v=s-aixZYJG4c&t=313s) [A bridge across a gap illustrates the divide between rigorous review and resource-constrained teams.](https://assets.ai.engineer/sites/aiecode2025/sha256/0f0f43da19aec6d1927da4fc967917fcedefdec3e4ce3847f64ff9e593d7ea04.webp)

THE LAST HUMAN CODE REVIEW

The real split in the room

THE GAP

TEAMS DOING RIGOROUS REVIEW
No better trust mechanism yet.

TEAMS RUBBER-STAMPING OR SKIPPING
Not reckless. Resource-constrained.

The gap is not AI capability. The gap is infrastructure that enables trust.

qodo

### The barrier was never model capability

A generic error-handling suggestion illustrates review without team rules or history. The speaker says whether error handling matters depends on context.

[6:14](https://www.youtube.com/watch?v=s-aixZYJG4c&t=374s) [A generic automated review example illustrates the slide’s claim that trust depends on context.](https://assets.ai.engineer/sites/aiecode2025/sha256/bad582b9348c2c6e346ae3ef5a76b88c2858138d379eea4e820ceff66a5f2530.webp)

The barrier was never model capability

THE LAST HUMAN CODE REVIEW
qodo

AI has flagged code issues for 2 years.

That’s not the bottleneck.

Automated review has operated as a stranger’s opinion: generic, stateless, disconnected.

payment.ts
41 function charge(amount) {
42   api.post('/charge', amount)
43 }

ai AUTOMATED REVIEW
Consider adding error handling here.
// generic · no team rules · no history

Trust is a function of context, not model quality.

### The Agentic SDLC is missing governance

Qodo argues that an agent reviewing its own code can share the writer’s blind spots. Across agents, different context and independently applied rules leave standards uneven; MCP and RAG alone do not provide governance.

[7:42](https://www.youtube.com/watch?v=s-aixZYJG4c&t=462s) [Three rows compare agent instruction layers, ad hoc standards, and a single coding and review tool with their governance gaps.](https://assets.ai.engineer/sites/aiecode2025/sha256/826230241b10b79b1073d308d1519fd7dad330e93763788aa39f21a5c1a8f090.webp)

The Agentic SDLC is missing governance.

Teams are managing agents with the tools they have. Those tools weren’t built for governance.

How teams are working with agents | The governance gap

01 Agent instruction layers
AGENTS.md · CLAUDE.md · skills.md
A single repo may work with an AGENTS.md file; a 500-repo enterprise won’t.

02 Ad hoc standards across repos, docs, and tools
Rule repos · cursor rules · wikis
Every agent independently applying rules. Giving agents access to standards does not guarantee those standards are followed.

03 One AI tool for coding and review
Copilot · Cursor
The agent reviewing the code is the same one that wrote it, sharing the same blind spots.

qodo

[8:38](https://www.youtube.com/watch?v=s-aixZYJG4c&t=518s) [Five governance gaps associated with agent development tools and context protocols.](https://assets.ai.engineer/sites/aiecode2025/sha256/af845daad03a9aa18bc43c1a5d41bc38fe35754be90866ee810af60e489d0326.webp)

The Agentic SDLC is missing governance.

Teams are managing agents with the tools they have. Those tools weren’t built for governance.

How teams are working with agents | The governance gap

01 Agent instruction layers
AGENTS.md · CLAUDE.md · skills.md
A single repo may work with an AGENTS.md file; a 500-repo enterprise won’t.

02 Ad hoc standards across repos, docs, and tools
Rule repos · cursor rules · wikis
Every agent independently applying rules. Giving agents access to standards does not guarantee those standards are followed.

03 One AI tool for coding and review
Copilot · Cursor
The agent reviewing the code is the same one that wrote it, sharing the same blind spots.

04 Multiple agents across the SDLC
Code · test · review · security · deploy
Multiple agents using different context sources and enforcing different standards.

05 Context protocols
MCP · RAG
Solves access to context, but not governance. Context is scoped to one repo — PR history, tickets, and org-wide patterns never reach the agent making the decision.

qodo

### What trustworthy automated review requires

The slide pairs team context with judgment about which findings matter, when to block, and when to defer to a human. Together, they turn review output into a traceable, auditable validation report.

[9:16](https://www.youtube.com/watch?v=s-aixZYJG4c&t=556s) [Context and judgment are presented as requirements for a traceable, auditable validation report.](https://assets.ai.engineer/sites/aiecode2025/sha256/5f2c259b7a4911cc4e3619e647d7c24e263a8698ecfb709fa4e4f0a9ac3a0115.webp)

What trustworthy automated review requires

THE LAST HUMAN CODE REVIEW
qodo

01
CONTEXT
Tribal knowledge in engineers’ heads
The conventions, constraints, and prior decisions that no linter encodes, surfaced to the reviewer.

02
JUDGMENT
Artificial wisdom
Not just detection. Knowing which findings matter, when to block, and when to defer to a human.

When both are present, the output becomes a validation report: traceable, auditable, grounded.

### The team’s own rules and standards

Qodo’s example flags a schema removal and cites the team’s earlier agreement on a two-release deprecation cycle. Rules can be written explicitly or mined from past PRs and decisions.

[9:47](https://www.youtube.com/watch?v=s-aixZYJG4c&t=587s) [A code review example illustrates findings linked to team rules and historical decisions.](https://assets.ai.engineer/sites/aiecode2025/sha256/55112ab28c9afc22486c89bbde29e6005725134f62359a96bc862539b4a68925.webp)

The team’s own rules & standards

Write the rule explicitly, or let it be mined from your historical PRs and decision patterns. Either way, every finding cites it.

Code Review by Qodo
Bugs (2) | Rule Violations (4) | Requirement Gaps (1) | Cross-repo conflicts (2)

Issue Findings
Action Required
1. Shared event schema field removed without consumer migration
Cross-repo conflict

Description
user-service removes the legacy_user_id field from the user.updated Avro schema and producer in a single commit, keeping only the new user_id UUID. Four downstream consumers still declare legacy_user_id as required and will fail deserialization on the first event after deploy. The user-events subject is set to BACKWARD compatibility, which validates new schemas against old data but not old consumers against new data, so the registry will accept the change without surfacing the break.

Code
user-service/schemas/user_updated_v3.avsc [R12-34]

Relevance
High
Team previously agreed that event schema field removals follow a two-release deprecation cycle with dual-emit, after a similar single-commit removal in order-events caused a 4-hour outage in the billing reconciliation pipeline.
PR-2841

Interface text:
THE LAST HUMAN CODE REVIEW
qodo
qodo-ai  bot  3 min ago

### Agent to agent discussions

The comment links to a fix PR and supplies a prompt for another coding agent. The fix branch is preserved so its changes can be cherry-picked into the original PR.

[11:41](https://www.youtube.com/watch?v=s-aixZYJG4c&t=701s) [A pull request comment presents an automated fix and a prompt for another coding agent.](https://assets.ai.engineer/sites/aiecode2025/sha256/06d11a33b7af77f52b0bf8243d01973738056a070e2a62a2a05fde0706edbcc0.webp)

Agent to agent discussions

Make it clear for humans, but auditable

Qodo Fixer

Ready to be cherry-picked — Merged (0) · Fixed (2)

Fix PR: #1995

This fix PR was closed automatically. Its branch is preserved so you can cherry pick the changes into the original PR.

Prompt for coding agent

This is an automated fix prepared on a separate branch (#1995). It is NOT applied to this PR.
To use it: review Fix PR #1995 (https://github.com/Codium-ai/codium-ai-platform-client/pull/1995), [illegible]

Process — 2 fixed

Interface text:
THE LAST HUMAN CODE REVIEW
qodo
qodo-pentest-1 Bot mentioned this pull request last week
Fix: [for cherry-picking] Removed disallowed ticket IDs from two commen[illegible] #1995
Closed
qodo-pentest-1 Bot commented last week

### PR history, repo relationships and architecture decisions

The graph maps repository connections. The speaker describes adding contracts and past developer discussions so reviews can account for cross-repo impact and prior decisions.

[13:21](https://www.youtube.com/watch?v=s-aixZYJG4c&t=801s) [A repository relationship graph accompanies a description of using prior decisions and cross-repository context in review.](https://assets.ai.engineer/sites/aiecode2025/sha256/63fff3ec5754d003be01b5cf4ea30a5f6282cd95353ec1a799b86783eac80342.webp)

THE LAST HUMAN CODE REVIEW
qodo

PR history, repo relationships & architecture decisions

The reviewer remembers what your team already decided, understands cross-repo impact, and grounds the objection in it.

Interface text:
Repositories
Installations  Repositories  Relationships
Graph  Table  Filter  Search...
design-system
frontend-app
backend-api
auth-service
payments-service
inventory-service
reporting-api
devops-scripts
Code  Service  Data  Pipeline
[illegible]

### New Abstraction

The speaker proposes review and governance that learns context from PR history, developer discussions, and production incidents, then places it where agents can understand its relevance.

[15:10](https://www.youtube.com/watch?v=s-aixZYJG4c&t=910s) [Slide titled New Abstraction, describing continuous, context-aware and AI-factory-aware software development review and governance.](https://assets.ai.engineer/sites/aiecode2025/sha256/144905ca65a5a7781a3ac29e3743e47174684d3e2d981535831cf5b979f8ac5f.webp)

New Abstraction

2026

Continuous SW dev,
Context-aware,
AI-factory-aware
Review and Governance.

qodo

### Repository relationships graph

The graph maps connections between repositories, including a pipeline link from qodo-platform to helm-charts. Colored outlines highlight several nodes.

[15:26](https://www.youtube.com/watch?v=s-aixZYJG4c&t=926s) [Demo showing repositories connected in a relationship graph, with several nodes highlighted.](https://assets.ai.engineer/sites/aiecode2025/sha256/f8e24466f3537b58b5f094334d4d8e586bafa0d7bc59e7c09d125ce1f54f60be.webp)

Repository nodes:
[illegible]-platform
pr-agent-pro
payments-service
[illegible]-sdk
qodo-platform
helm-charts
[illegible]-platform-client
qodo-engine
qodo-litellm-sdk
[illegible]-gateway
pr-agent-pro

Relationship labels:
Platform Integration
Reviews
Code
Service
Pipeline

Interface text:
qodo
[illegible]elationships Beta
Filters
Search by repository...

### Repository relationship details

The panel shows qodo-engine depending on qodo-litellm-sdk and a demo cross-repository alert. Changes to the SDK’s shared contract propagate to the engine at build/runtime.

[15:29](https://www.youtube.com/watch?v=s-aixZYJG4c&t=929s) [Demo showing a relationship detail panel with an alert and an explanation of how two repositories connect.](https://assets.ai.engineer/sites/aiecode2025/sha256/bbc9e719e0f38bb6b2096cdd56beab6384e30089da10e25d3b5aaf8f40a57283.webp)

qodo-engine → qodo-litellm-sdk
Code
Engine embeds via the LLM SDK

Alerts 1
[demo] cross-repo break #250: qodo-engine → qodo-litellm-sdk
Remediation · Correctness · qodo-engine

Markdown
qodo-engine → qodo-litellm-sdk
Relationship type: Code
Engine embeds via the LLM SDK.

How they connect
• qodo-engine depends on qodo-litellm-sdk through a code boundary.
• Changes to the shared contract in qodo-litellm-sdk propagate to qodo-engine at build/runtime.
• The coupling is exercised on every PR that touches the boundary surface.

What to watch
• Breaking changes to the code interface require a coordinated rollout across both

Interface text:
qodo
[illegible]elationships Beta
Download as markdown
Platform integration
Code
Service

### What has to be true for your team?

The speaker recommends codifying standards and measuring how review rules perform, while building agent context and governance infrastructure so trust can accumulate.

[15:47](https://www.youtube.com/watch?v=s-aixZYJG4c&t=947s) [Three recommendations: codify standards, embrace real-time learning context, and start with governance infrastructure.](https://assets.ai.engineer/sites/aiecode2025/sha256/d4824c78f273ffa469391fa33d3dda0ba2e0deec6035a11068143384ad0bd8e6.webp)

THE LAST HUMAN CODE REVIEW

What has to be true for your team?

01 Invest in codifying your standards, not just adopting a tool
02 Embrace real-time, self-learning context, built for agents
03 Start with governance infrastructure, not with removing humans. Trust accumulates

qodo

### Build trust infrastructure

The slide calls for building trust infrastructure this year and making human review optional by choice. The speaker recommends gradually adding rules for automatic approval and blocking.

[16:37](https://www.youtube.com/watch?v=s-aixZYJG4c&t=997s) [A statement warns that teams shipping AI-generated code faster than humans can review it are already facing the problem.](https://assets.ai.engineer/sites/aiecode2025/sha256/ed4906f7a94c31d63ecb0d6ac412a852e6324194ce21e3331783abac7faee49d.webp)

“If you're already shipping AI-generated code faster than humans can read it, you're not ahead of this problem. You're in it.”

BUILD TRUST INFRASTRUCTURE THIS YEAR
Make human review optional — by choice.

DON'T
Still rubber-stamping PRs in 2028.

qodo

### The team’s rules and standards

Trustworthy automated review starts with the team’s own rules and standards. The speaker describes codifying knowledge from software history and discussions and applying it to the relevant parts of the software graph.

[17:12](https://www.youtube.com/watch?v=s-aixZYJG4c&t=1032s) [The first requirement for trustworthy automated review is the team’s own rules and standards, illustrated by a review standards dashboard.](https://assets.ai.engineer/sites/aiecode2025/sha256/b3afd9a1d349f6bc79892dcf8216449a2a489485d469522fe6369990e6e6cf1b.webp)

THE LAST HUMAN CODE REVIEW

What trustworthy automated review requires?

01 The team’s own rules and standards

Interface text:
qodo
Review standards
Rules  Suggestions  Skills
Last 30 days
Passed: 10.1K
Detected violations: 3K
PRs merged with violations: 100
Filters  Search...  Generate rule

Rule name (32) | Date added | Category | Severity | Source | Scope | Passed | Detected violations
Use parameterized queries for e... | Jan 22, 2026 | Security | Error | Code base pattern | payment-proce... | 847 | 23
Enforce authorization on every r... | Jan 18, 2026 | Security | Error | Qodo library | customer-portal | 1,203 | 87
Review dependency changes; bl... | Jan 18, 2026 | Security | Warning | Code base pattern | inventory-servi... | 156 | 12
Handle errors explicitly; don’t lea... | Jan 15, 2026 | Reliability | Recommended | Import | order-fulfillment | 2,342 | 156
Store passwords with strong, sal... | Jan 11, 2026 | Security | Error | Code base pattern | authentication-... | 67 | 3
Preserve public API function... | Jan 10, 2026 | API Design | Error | Code base pattern | billing-system | 892 | 41
Add new parameters as keyword... | Jan 4, 2026 | API Design | Recommended | Qodo library | analytics-pipeli... | 1,456 | 203
Require type hints for all function... | Dec 19, 2025 | Code Style | Recommended | Code base pattern | notification-ser... | 304 | 41
Require unit tests for every new f... | Dec 12, 2025 | Testing | Warning | Qodo library | checkout-servi... | 81 | 11
Disallow network calls in unit tests | Dec 11, 2025 | Testing | Error | Import | fraud-detection | 534 | 117

### Repository relationships and architecture decisions

A graph connects repositories through code, service, data and pipeline relationships. The speaker calls for placing team rules and standards on the right nodes and edges, codifying experience for agents and humans.

[17:31](https://www.youtube.com/watch?v=s-aixZYJG4c&t=1051s) [The second requirement is PR history, repository relationships, and architecture decisions, illustrated by a software graph.](https://assets.ai.engineer/sites/aiecode2025/sha256/07b9a5a983343ea21352562120f965706d118da9fb3d5a287a320ee4ad08d52d.webp)

THE LAST HUMAN CODE REVIEW
qodo

What trustworthy automated review requires?

02
PR history, repo relationships and architecture decisions

Interface text:
Repositories
Installations  Repositories  Relationships
Graph  Table  Filter  Search...

design-system
frontend-app
backend-api
auth-service
payments-service
inventory-service
reporting-api
devops-scripts

Code  Service  Data  Pipeline
[illegible]

### Access to tribal knowledge

The slide connects a past schema-removal decision to code review, alongside examples of an auto-approved formatting PR and an auto-blocked secret. The speaker calls for codifying that experience for agents and humans.

[17:45](https://www.youtube.com/watch?v=s-aixZYJG4c&t=1065s) [The third requirement is access to tribal knowledge and past decisions, illustrated by automatic approval and blocking examples.](https://assets.ai.engineer/sites/aiecode2025/sha256/045cefde5d4ec5220cb1a0de3de5f06ec2225189ae1620c6fe6c7221a5f9f983.webp)

THE LAST HUMAN CODE REVIEW
qodo

What trustworthy automated review requires?

03 Access to tribal knowledge, past decisions, ways of working

Code Review by Qodo

PR #1487 · formatting + tests    AUTO-APPROVED
All rules pass. No human needed.

PR #1491 · hardcoded secret    AUTO-BLOCKED
Violates SEC-03. Stopped before merge.

Code
[illegible]

Relevance
High

Team previously agreed that event schema field removals follow a two-release deprecation cycle with dual-emit, after a similar single-commit removal in order-events caused a 4-hour outage in the billing reconciliation pipeline.

PR-2841

Interface text:
qodo-ai  bot  3 min ago

### What trustworthy automated review requires

The slide combines team standards, repository history, tribal knowledge and artificial wisdom into a validation report. The speaker describes codifying developer judgment for agents and humans.

[18:10](https://www.youtube.com/watch?v=s-aixZYJG4c&t=1090s) [A summary lists team standards, software history and relationships, tribal knowledge, and artificial wisdom as inputs to a traceable validation report.](https://assets.ai.engineer/sites/aiecode2025/sha256/95cab6a1670dfbe5501b6c4864931e423df351ad795e850378c62e6097b0a16c.webp)

THE LAST HUMAN CODE REVIEW
qodo

What trustworthy automated review requires

01 The team’s own rules and standards
02 PR history, repo relationships and architecture decisions
03 Tribal knowledge living in engineers’ heads
04 Artificial wisdom

When present, the output becomes a validation report: traceable, auditable, grounded.

### AI Engineer World's Fair

[18:48](https://www.youtube.com/watch?v=s-aixZYJG4c&t=1128s) [AI Engineer World's Fair closing slate on a black background, with the event website below.](https://assets.ai.engineer/sites/aiecode2025/sha256/2b2c7e72f0e12fdc568317931131ab58caa609be82cebe71298952e094f1c464.webp)

AI Engineer
World’s Fair

HTTPS://AI.ENGINEER

## Full transcript

[0:00](https://www.youtube.com/watch?v=s-aixZYJG4c&t=0s) [upbeat music] Are you all set up with your AI factory? Everything is smooth?

[0:18](https://www.youtube.com/watch?v=s-aixZYJG4c&t=18s) As you're sitting here, your code is being deployed, ARR growing, right? Is- if it's like that, raise your hand. No? Oh, okay. Two people, great. Um, let us know, like, before and after this talk what the ARR and, and

[0:33](https://www.youtube.com/watch?v=s-aixZYJG4c&t=33s) do you feel like there is a bottleneck, a new bottleneck that is not on writing code, rather somewhere else, else in the SDLC? Is that your biggest thing to tackle if, if you are tackling that right now?

[0:47](https://www.youtube.com/watch?v=s-aixZYJG4c&t=47s) Okay, so you're in the right place. And what about, like, code review, verifying that the code work according to your intent, according to your architecture, standards, best practices, et cetera?

[0:59](https://www.youtube.com/watch?v=s-aixZYJG4c&t=59s) Is this something that you're tackling day to day or week by week? Okay, so you're, you're in the right place. So I'm Itamar Friedman, the CEO and co-founder of Qodo.

[1:09](https://www.youtube.com/watch?v=s-aixZYJG4c&t=69s) Um, I don't share it too much, but Qodo stands for quality of development optimization. Our mission and, and, uh, is to help you all have a code governance, code review platform that understand your code base, your tribal knowledge, your best practices, and that does not come off the shelf from a model.

[1:32](https://www.youtube.com/watch?v=s-aixZYJG4c&t=92s) It requires a system that optimize for you as we go, and that's, uh, why we decided to name our company, uh, this way. Uh, so, uh, I'm gonna talk about the last human code review and what do we need to do in order to get there.

[1:48](https://www.youtube.com/watch?v=s-aixZYJG4c&t=108s) Okay? And, um, c- can you switch, instead of seeing myself, seeing the presentation here? [laughs] Thank you. Um, so I, I think like first of all, we need to agree

[1:59](https://www.youtube.com/watch?v=s-aixZYJG4c&t=119s) on why do we have code review at all. So I think basically these are two buckets that we should agree on, and I think, I think it's quite common.

[2:08](https://www.youtube.com/watch?v=s-aixZYJG4c&t=128s) One is we wanna validate the code that is in high quality, safe, maintainable, the right architecture, according to our best practice, et cetera. The second re- reason is actually alignment and learning, right?

[2:21](https://www.youtube.com/watch?v=s-aixZYJG4c&t=141s) Like where senior developers, for example, have o- one last chance, a gateway, a gatekeeper before, uh, it's being, uh, uh, code is being pushed to production to have that alignment and teaching, right?

[2:34](https://www.youtube.com/watch?v=s-aixZYJG4c&t=154s) So these are the two reasons, and then that's what you need to think if you're trying to automate a code review. Can human still do that? And this, if this is the right place, the, the code review process, the pull request process is that the right place to still doing these two things?

[2:51](https://www.youtube.com/watch?v=s-aixZYJG4c&t=171s) If you have, uh, new tools, new processes that will help you unblock this bottleneck, but let you still do these two buckets of tasks, then you're on the right path.

[3:04](https://www.youtube.com/watch?v=s-aixZYJG4c&t=184s) Uh, so we're here to ask yes, no. Is human code review still optional end of twenty twenty-six? Uh, is it becoming optional or is it still mandatory? Okay? That's, that we're here to answer.

[3:19](https://www.youtube.com/watch?v=s-aixZYJG4c&t=199s) Do you think like every PR or the majority of PRs are gonna be reviewed line by line or, you know, bucket by bucket in the, in the chunks, in the hunks by your developers?

[3:30](https://www.youtube.com/watch?v=s-aixZYJG4c&t=210s) Raise your hand. Or do you think, do you think by end of this year your developers are still going to review diff by diff?

[3:38](https://www.youtube.com/watch?v=s-aixZYJG4c&t=218s) Okay. So try to think why, why is that happening. Now I, I, I wanted to share with you that yesterday night we did a drone show and I had to, uh, opportunity to talk to different people during that drone show, different, uh, engineering leaders, and what I can tell you is that I saw two very different groups

[4:00](https://www.youtube.com/watch?v=s-aixZYJG4c&t=240s) of school of thoughts. Okay? They both agree that bugs [laughs] are coming in different shapes. For some this is fine, [laughs] and we're just going to fix that quickly after it hits the production, and for some not.

[4:15](https://www.youtube.com/watch?v=s-aixZYJG4c&t=255s) So, so actually we do see two teams. Those that are thinking about the room is split into two. The other are thinking like, "Hey, we have to let, make sure that every piece of line is, is trusted, uh, and, and a human must review that."

[4:31](https://www.youtube.com/watch?v=s-aixZYJG4c&t=271s) Or the other group, somewhat [laughs] reckless or so, saying, "Let's, let's like push those bugs into production and we quickly fix that and that's how we actually do things because it's much faster.

[4:47](https://www.youtube.com/watch?v=s-aixZYJG4c&t=287s) Velocity is more important than getting, getting things, uh, right." And I think like you need to think like where do you sit? Of course I put it in two, two sides of the spectrum, but there's some, somewhere in, in between and you, you need to think what, what's your philosophy because that will lead you to different milestones

[5:06](https://www.youtube.com/watch?v=s-aixZYJG4c&t=306s) or different tools that you need to use in order to get that, uh, uh, confidence that you can skip over a, a human review in the pull request, in the code review.

[5:17](https://www.youtube.com/watch?v=s-aixZYJG4c&t=317s) So let's start talking about what is the process, how do we need to start thinking about it. So I claim that models are not, not a barrier anymore. Like it's not a matter of, of the, you know, a model doing a good re- good, good job or not, having the right reasoning or not.

[5:35](https://www.youtube.com/watch?v=s-aixZYJG4c&t=335s) Basically the models are improving, but I'm telling you I just came from one of the leading labs [laughs] where we are inspecting how benchmarks for code review did not change a lot throughout the latest model.

[5:50](https://www.youtube.com/watch?v=s-aixZYJG4c&t=350s) The, the key here is actually context. Okay? Like the models, if you give them the right context, and what is that right context we're gonna talk about, they could already reason pretty well over what- Is the issues that we-- What are the issues that we need to surface for a certain change in the code?

[6:09](https://www.youtube.com/watch?v=s-aixZYJG4c&t=369s) Otherwise, if you don't have the context, even the best model out there, they will give you different types of, of, uh, bugs and issues. Some of them are really good, but in many cases, they will simply tell you, "Hey, did you consider error handling?"

[6:22](https://www.youtube.com/watch?v=s-aixZYJG4c&t=382s) Uh, uh, like, or not. By the way, error handling could be like a really good thing to handle. Depends. In some cases, it's critical, in some cases are not.

[6:31](https://www.youtube.com/watch?v=s-aixZYJG4c&t=391s) And again, the context is what, what matters. Right now, our context is like spread all across. Like, we have AGENTS.md files, CLAUDE.md files, SKILL.md files, and, and the thing is that each, each one of them has like different standards, uh, different org-organization and sub-organization are dealing with diff-differently.

[6:52](https://www.youtube.com/watch?v=s-aixZYJG4c&t=412s) Even within a certain team, you might be using that, that differently. And you're actually maybe using like the same, uh... One, one team is using, uh, the same agent to do code review and-- Sorry.

[7:05](https://www.youtube.com/watch?v=s-aixZYJG4c&t=425s) Co-coding and code review. The other might be using something else. And all of that does not bring you the trust and consistency that you're looking, uh, towards. Um, by the way, like you also might have like coding agents that are running in your IDE, but you're probably building the AI factory that running those agents like in workflows

[7:26](https://www.youtube.com/watch?v=s-aixZYJG4c&t=446s) to automate some of the coding. I see teams that are already, uh, having more lines of code being, uh, shipped that are not generated from the CLI or, or the IDE.

[7:37](https://www.youtube.com/watch?v=s-aixZYJG4c&t=457s) So how do you control all that? Like that's, that's missing, uh, like in-- right now, like in our, in our, uh, tools, in our infrastructure. A-and let alone if you add those MCPs and, and, and RAG like, uh, style, uh, context, I, I don't know if you have like great visibility.

[7:57](https://www.youtube.com/watch?v=s-aixZYJG4c&t=477s) There are ways to tackle that. There's great talks out there. Check how you could have like MCP versioning and have datasets for every M-- Uh, like a benchmark for every MCP change, but that's hard to manage.

[8:09](https://www.youtube.com/watch?v=s-aixZYJG4c&t=489s) We're missing like a governance layer for us to move to the next level, okay? Like, where we can actually trust the code without human reviewing it. So where, where is that context?

[8:21](https://www.youtube.com/watch?v=s-aixZYJG4c&t=501s) Where is that context? Basically, I would say experience, tribal knowledge,

[8:28](https://www.youtube.com/watch?v=s-aixZYJG4c&t=508s) wisdom of your developers is a lot in their heads. They are in some documents. There are documents, infrastructure documents, um, but a lot-- By the way, a lot of them is our Slacks or, or Teams or, or so, um, the, the data is there, but a lot of the information are, are in your developer heads, and we

[8:47](https://www.youtube.com/watch?v=s-aixZYJG4c&t=527s) need like to, to codify them. Now, um,

[8:53](https://www.youtube.com/watch?v=s-aixZYJG4c&t=533s) I think like, basically, another thing that I'm saying, like when I'm saying that we need to codify human knowledge, what we're actually saying is that we're trying to build an interface for agents and interface for humans to collaborate each other on that, on that knowledge.

[9:11](https://www.youtube.com/watch?v=s-aixZYJG4c&t=551s) And that's a very important conte-- Uh, um, a very important point. When you want to extract that information, the tribal knowledge from your s-- Uh, like, uh, senior developers, et cetera, and codify that, do you codify that only in agent's language, uh, which is very maybe verbose and structured, or you wanna codify that in a wiki style,

[9:34](https://www.youtube.com/watch?v=s-aixZYJG4c&t=574s) uh, get started and all that, what developers love, love doing? And the answer is that you probably need to build your context lake, your context engine. As I mentioned, that's the s-- The, the, the real like goldmine here to, to get the code review, uh, like auto-automated.

[9:51](https://www.youtube.com/watch?v=s-aixZYJG4c&t=591s) You have to have it fitting for both. So what you're seeing here, for example, is that Qodo, as an example, but you can use other tools, help you collect all the rules and standards that your team own, that your team is using day to day, and then it will provide that information during the review for humans.

[10:16](https://www.youtube.com/watch?v=s-aixZYJG4c&t=616s) Hey, notice that Qodo used four rules... Uh, sorry. Uh, used, uh, uh, many rules and four are violated, and that includes a link to all the rules that are, were being used.

[10:29](https://www.youtube.com/watch?v=s-aixZYJG4c&t=629s) That's for human in order to trust, okay? In order to trust the results that are coming from your code review tool, et cetera, you have to build that interface for, for human.

[10:40](https://www.youtube.com/watch?v=s-aixZYJG4c&t=640s) You have to accumulate that knowledge and have an interface for human. But you also want to have an interface that is dedicated for agents. What you're seeing here, uh, for example, is a com-comment, for example, by Qodo, that is speaking to another agent.

[10:56](https://www.youtube.com/watch?v=s-aixZYJG4c&t=656s) "Hey, dear agent, Qodo just reviewed this, uh, PR and has found five different issues." Qodo already spawned, uh, like, uh, some back-background task and use Claude Code, for example, harness, in order to do fixes, and there is a closed PR, like you can see here on the top right, there is some closed PR with all the fixes.

[11:20](https://www.youtube.com/watch?v=s-aixZYJG4c&t=680s) And now, when an agent is coming to review this PR once again, then it has like a cherry-picking moment, uh, with everything that all the code that is actually is passing your rules, your standard, uh, and everything like we're, like more a-architectural decision that we're gonna talk about.

[11:39](https://www.youtube.com/watch?v=s-aixZYJG4c&t=699s) So what, what I said so far is that

[11:43](https://www.youtube.com/watch?v=s-aixZYJG4c&t=703s) just to, to ca-- Uh, like recap so far, if you want to trust and you want to get to a point where you're trusting the code is being shipped, you need to have the right context that is being gathered and being used during the code review process.

[11:59](https://www.youtube.com/watch?v=s-aixZYJG4c&t=719s) Then you will see that this code review process have links and information for human and have links and information for, for agents, okay? And when that is in place-

[12:11](https://www.youtube.com/watch?v=s-aixZYJG4c&t=731s) You will see that developers are writing less and less comments in the pull request, and then after one hundred of these pull requests, there's human-- no hu- more human review, you know that you're ready for, for automation.

[12:24](https://www.youtube.com/watch?v=s-aixZYJG4c&t=744s) Okay? Now, back to, back to the context. So far, I talked about relatively simple context. I talked about, uh, rules and standards and skills, but actual, the human knowledge that the tribal knowledge in your organization sits in understanding the system architecture.

[12:43](https://www.youtube.com/watch?v=s-aixZYJG4c&t=763s) What are the P0s, the, the bugs that actually made an outage, outage for, for you, unfortunately, in the last like three months or so? When a microservice, uh, one changed its contract and broke a microservice two, right?

[12:57](https://www.youtube.com/watch?v=s-aixZYJG4c&t=777s) That is-- does not exist in most code review and, and like if you try to build yourself, it's really hard to build, but it is available in some of the, those like code review, uh, solutions that is dedicated for that.

[13:09](https://www.youtube.com/watch?v=s-aixZYJG4c&t=789s) For example, what you're seeing here is the graph being built for a certain microservice and all the repos and, and their connection. And in each node and edge, there is-- what is the con-- if it's an edge, what is the contract between two, uh, piece of your software?

[13:26](https://www.youtube.com/watch?v=s-aixZYJG4c&t=806s) But also links to history of discussions between developers that they had when they fixed an issue because a root cause analysis, and now you need to codify that, okay?

[13:38](https://www.youtube.com/watch?v=s-aixZYJG4c&t=818s) And when you get to, to that level of a context engine, now you're ready to start approving and blocking PRs automatically. And you want to do that not just by letting AI some like choose by itself, rather giving some semantic rules that, that, for example, when you-- when do you guys

[14:03](https://www.youtube.com/watch?v=s-aixZYJG4c&t=843s) approve or, or, or block a PR? And that knowledge also needs to be accumulated as part of your, your context. What I'm actually saying is that software development, at least code governance, is going to change from reviewing your pull request to actually reviewing your entire software development from a graph abstraction,

[14:28](https://www.youtube.com/watch?v=s-aixZYJG4c&t=868s) where you're seeing your PRs as bubbles with all the issues that might, uh, happen, even with three different PRs are in on the fly, when they-- which, which contract they might breach, they, they might ruin,

[14:43](https://www.youtube.com/watch?v=s-aixZYJG4c&t=883s) okay? And that's how the software development, uh, uh, future is gonna look like. What you need to do in order to get there is to codify your standards. It needs to be built in a way that humans can trust and audit and control.

[15:01](https://www.youtube.com/watch?v=s-aixZYJG4c&t=901s) You need to build real-time, self-learning context, learning from PR history, learning from accepted and unaccept, learning from discussions between, between developers, learning between, uh, learning like from those cases that broke your production.

[15:18](https://www.youtube.com/watch?v=s-aixZYJG4c&t=918s) And that context needs to be not just like thrown into files. It needs to f- to, to, to sit and located in a place that agent understand where is that context fitting.

[15:30](https://www.youtube.com/watch?v=s-aixZYJG4c&t=930s) And then you need the governance infrastructure that gives you that visibility of what's happening. Rather the graph I presented, but there is more to that. Okay, I'm gonna show you very soon another vi- uh, visualization that helps you understand the overall status of your PRs and software.

[15:47](https://www.youtube.com/watch?v=s-aixZYJG4c&t=947s) If you are already shipping AI-generated code faster than your human can review, I'm actually saying that you are in the problem. You're not like ahead of the problem. You, you-- if you put the infrastructure, if you gather the context, if you start accumulating how code review can be automated for you, then that's where you're gonna get the

[16:08](https://www.youtube.com/watch?v=s-aixZYJG4c&t=968s) ten x velocity that you're being promising your CEO or yourself or, or your developers, because otherwise it's a bottleneck. You need to own your rules and standards and codify them and get analytics and statistics about each one of them.

[16:23](https://www.youtube.com/watch?v=s-aixZYJG4c&t=983s) How many times they're being caught? Which rules and standards and skill is actually being used during the review process? And is it useful or not, or does it need to get an update?

[16:33](https://www.youtube.com/watch?v=s-aixZYJG4c&t=993s) You need to have visi- full visualization of your software graph. What is the connection? What are the contracts? What is working? What is not working? What are two PRs are gonna crash very soon because they're touching the same edge and they don't, and they don't know?

[16:48](https://www.youtube.com/watch?v=s-aixZYJG4c&t=1008s) And you need to start learning how to auto-approve and auto-block. That won't happen in like immediately. That needs to gradually being automated for you step by step by adding more rules for blocking and more rules for, for, for approving over time.

[17:11](https://www.youtube.com/watch?v=s-aixZYJG4c&t=1031s) So trustworthy automated review, your rules, your standards in your software graph placed in the right edge and the right node of your software. Learning from the tribal knowledge of discussions, of history of your software and codifying that.

[17:30](https://www.youtube.com/watch?v=s-aixZYJG4c&t=1050s) There's so much tribal knowledge what to do and not to do, and that needs to be codified as well, both for the agents and for the humans. And basically, you need to accumulate that experience and codify that.

[17:44](https://www.youtube.com/watch?v=s-aixZYJG4c&t=1064s) And sorry for the buzz or whatever you wanna call it. That's moving from artificial intelligence to artificial wisdom. Because right now, you know better than I that your developer holds the judgment of what's bad and what's good.

[17:59](https://www.youtube.com/watch?v=s-aixZYJG4c&t=1079s) It's not your, your software, not your AI tools. If you wanna get to a point where judgment is moving to your AI tools, that's AI wisdom, where that experience needs to be codified in the right way, the right place for agents and humans.

[18:16](https://www.youtube.com/watch?v=s-aixZYJG4c&t=1096s) And that's why we are here, Qodo, to help you, and our

[18:21](https://www.youtube.com/watch?v=s-aixZYJG4c&t=1101s) vision and mission is not far away from now. We wanna reach in twenty twenty-seven to a place where you have zero outages, zero bugs in production, at least the critical and the high ones.

[18:33](https://www.youtube.com/watch?v=s-aixZYJG4c&t=1113s) That's why we're here. Thank you so much for having me. [audience clapping] [upbeat music]
