For most of software development history, writing code was expensive.

A developer might spend hours implementing a feature, fixing edge cases, writing tests, and preparing a pull request.

AI coding agents changed that equation.

Today, tools such as Claude Code, GitHub Copilot, Cursor, Codex, and other coding agents can generate surprisingly large changes in minutes.

That sounds like an enormous productivity improvement.

And it is.

But it creates another problem:

What happens when we can generate code faster than we can understand, review, and verify it?

I think this is becoming one of the biggest bottlenecks in AI-assisted software development.

Writing Code Is Getting Cheap

Imagine a developer receives this task:

Add role-based access control to the admin dashboard.

Without AI, the process might look like:

Understand requirements
        ↓
Explore codebase
        ↓
Design solution
        ↓
Write code
        ↓
Write tests
        ↓
Debug
        ↓
Open pull request

That might take hours or days.

A modern coding agent can compress parts of that workflow dramatically.

You can give it the task and potentially receive:

• database changes
• middleware
• API updates
• UI changes
• tests
• documentation

within a relatively short time.

Great.

But now imagine the agent changes 27 files and generates 1,800 lines of code.

The coding took minutes.

The review might still take an hour.

And that creates a strange new equation:

Code Generation
      ↓
    FAST

Code Verification
      ↓
    SLOW

We removed one bottleneck and created another.

GitHub Is Already Responding to This

This isn't only a theoretical problem.

GitHub has been expanding Copilot Code Review so AI can participate more deeply in the review process.

Recent updates allow Copilot Code Review to use additional tools for analysis, including running builds, tests, and targeted checks.

GitHub has also experimented with an ensemble of specialized agents during code review.

In its reported experiments, GitHub said the approach increased the rate at which developers addressed high-severity review comments by 47%.

That tells us something interesting.

AI isn't only being asked to:

Write the code.

It's increasingly being asked to:

Review the code written by AI.

And that creates a much bigger question.

What Happens When AI Writes the Code and AI Reviews It?

Imagine this workflow:

Human describes feature
        ↓
AI writes implementation
        ↓
AI writes tests
        ↓
AI reviews implementation
        ↓
AI suggests fixes
        ↓
AI fixes its own issues
        ↓
Human clicks Approve

At first glance, this looks incredibly efficient.

But there's a danger.

The human developer can slowly become the least informed person in the workflow.

You might approve a pull request containing code you didn't write, tests you didn't design, and a review generated by another AI system.

Everything may be green.

That doesn't necessarily mean everything is correct.

Passing Tests Doesn't Mean the Feature Is Right

Suppose the requirement is:

Only account owners can permanently delete a workspace.

The AI generates:

DELETE /workspace/:id

It writes a test.

The test passes.

The AI reviewer checks the implementation.

No problems found.

But perhaps the real business rule was:

Owner       → Delete
Admin       → Cannot Delete
Member      → Cannot Delete
Suspended   → Cannot Delete

If the original requirement was misunderstood, the implementation and tests can agree with each other while still being wrong.

This is an important distinction:

AI can verify that code matches its interpretation without proving that its interpretation matches reality.

That is where human judgment still matters enormously.

Welcome to AI Technical Debt

Traditional technical debt often comes from developers knowingly taking shortcuts.

AI introduces another possibility:

Code that works today but that nobody on the team properly understands.

Imagine a codebase after one year of aggressive agent usage.

Feature A → AI generated

Feature B → AI generated

Refactor → AI generated

Migration → AI generated

Tests → AI generated

Documentation → AI generated

Now production breaks.

Who understands the system deeply enough to debug the interaction between those pieces?

This is why the conversation around AI technical debt is becoming important.

Sonar describes it as the rework and risk created when AI-generated code arrives faster than teams can properly verify, understand, and maintain it.

Generating more code is not automatically increasing productivity.

Sometimes you're simply generating future work faster.

The Metric We Should Care About Is Changing

Developers have traditionally measured productivity through things like:

• tickets completed
• pull requests merged
• features shipped
• lines changed
• deployment frequency

AI can dramatically increase many of those numbers.

But imagine this team:

Before AI

10 PRs/week
2 bugs
Developers understand changes

Now:

With AI

35 PRs/week
11 bugs
Nobody understands half the changes

Did productivity really improve?

Probably not.

Maybe we need a better metric:

How much verified, maintainable value did we ship?

That's much harder to measure than lines of code.

But it is much closer to what actually matters.

Code Review Has to Change

Traditional review often focuses on lines:

- old code
+ new code

That becomes increasingly difficult when agents can generate huge changes quickly.

Instead of only asking:

"Is this line correct?"

I think developers increasingly need to review at several levels.

Level 1: Requirement

Before reviewing code, ask:

What