# The AI Leverage Saturation Point: When More AI Stops Creating More Engineering Value

*More AI can accelerate coding. But what happens when the rest of engineering cannot keep up?*

- Published: 2026-11-16
- Canonical: https://www.gitdotme.com/blog-ai-leverage-saturation-point

Imagine an engineering organization that has spent a year expanding AI-assisted development.

At first, the improvements are obvious.

Developers complete repetitive tasks faster. Boilerplate takes less time. Tests and documentation become easier to produce. Coding agents handle increasingly complex implementations.

Encouraged by these results, leadership expands AI access across the organization.

AI participation rises. More developers use assistants. More tasks are delegated to agents. The amount of code being produced increases.

But eventually, something unexpected happens.

The number of completed features stops improving at the same pace.

Review queues grow. Integration takes longer. Senior engineers spend more time validating generated changes. Some implementations require additional corrections before they are ready for production.

The organization is using more AI than ever.

**But is it getting more engineering leverage from that additional AI?**

This is where a useful question emerges:

**Does AI Leverage have a saturation point?**

## The Difference Between More AI and More Leverage

AI adoption and AI Leverage describe different things.

Adoption tells us how extensively an organization uses AI tools.

Leverage asks how much productive engineering output is achieved relative to the human effort required.

Those two variables can move together, but they do not have to. [AI usage is not AI Leverage](https://www.gitdotme.com/blog-ai-usage-is-not-ai-leverage).

When AI tools are first introduced, they may remove obvious sources of friction. Developers delegate repetitive work, receive assistance with unfamiliar APIs, and accelerate bounded implementation tasks.

At that stage, additional AI participation may deliver substantial benefits.

But as adoption expands, the next tasks may be harder to automate effectively.

They may depend on architectural knowledge, ambiguous requirements, security constraints, legacy dependencies, or careful integration with existing systems.

Human effort does not disappear. Some of it moves.

Instead of writing code directly, engineers may spend more time directing agents, reviewing changes, checking assumptions, debugging behavior, or correcting generated output.

This raises a critical distinction:

**The marginal value of additional AI assistance may decline even while total AI-assisted output continues to grow.**

That is the idea behind AI Leverage saturation.

It does not imply that AI stops being useful.

It means that increasing its use may eventually stop producing proportional improvements in productive capacity.

## Research Shows That Coding Gains Do Not Fully Reach Production

A 2026 NBER working paper, [*Writing Code vs. Shipping Code: Productivity Effects Across Generations of AI Coding Tools*](https://www.nber.org/papers/w35275), provides a compelling reason to look beyond coding activity.

Mert Demirer, Leon Musolff, and Liyuan Yang studied data from more than 500,000 GitHub developers, combined with information about their use of AI coding tools.

Their September 2026 revision reports that successive generations of AI assistance are associated with large estimated increases in coding activity.

For autonomous coding agents, the estimated cumulative effect reaches approximately **240% for commits**.

But the corresponding effect is substantially smaller further along the software production process.

The researchers report approximately **80% for the number of projects** and **30% for releases**.

These percentages describe different outcomes within the study's matched event-study design. They should not be interpreted as a simple conversion rate from commits into releases.

Nevertheless, the pattern is striking.

**AI can accelerate an upstream activity much more than the downstream outcome it is supposed to support.**

The authors describe the importance of human bottlenecks in the production chain.

Code still needs to be understood, integrated, tested, reviewed, and released.

Making code generation dramatically faster does not automatically make every other engineering activity equally fast.

This working paper does not establish a numerical saturation point for AI adoption or GitMe's AI Leverage metric.

It demonstrates why improvements at one stage of engineering can be attenuated before reaching final output.

That distinction is central to measuring productivity in the AI era.

## The Work Doesn't Disappear. It Changes Shape.

Another 2026 study provides an explanation for what may be happening inside engineering teams.

In [*The Impact of AI Coding Assistants on Software Engineering: A Longitudinal Study*](https://arxiv.org/abs/2605.23135), Annie Vella and Kelly Blincoe examined professional software engineers' experiences across two questionnaires administered six months apart, with 95 participants completing both.

The researchers identified a shift from code creation toward verification activities.

They also introduced the concept of **supervisory engineering work**.

This encompasses directing AI systems, evaluating their output, and correcting problems.

It is broader than traditional code review.

A developer may need to clarify a task for an agent, inspect intermediate decisions, correct implementation assumptions, validate tests, and integrate the result.

These activities can be necessary even when the agent is generating code very quickly.

The study is based on reported experiences rather than direct measurements of all engineering work, so its findings should not be treated as proof of an organization-wide productivity slowdown.

But it identifies an important mechanism.

As AI takes over more implementation activity, human work can shift toward supervision.

And if supervisory capacity does not increase alongside generation capacity, the benefits of additional AI may become harder to realize.

**More code-generation capacity is useful only when the engineering system can absorb it.**

## The Next AI Tool May Deliver Less Than the First

Diminishing returns can also depend on what tools a team already uses.

A separate study presented at MSR 2026, [*AI IDEs or Autonomous Agents? Measuring the Impact of Coding Agents on Software Development*](https://arxiv.org/abs/2601.13597), investigated the effects of autonomous coding agents in open-source repositories.

The researchers found that productivity gains differed depending on whether projects had already adopted AI IDE assistance.

Projects introducing agents as their first observable AI coding tool showed substantial early velocity gains.

Projects with existing AI IDE usage generally saw more limited or short-lived throughput benefits from adding autonomous agents.

The study also identified persistent maintainability concerns in the evaluated repositories.

These findings do not mean coding agents lack value for experienced AI users. The observations are tied to the study's repositories, adoption definitions, and measured outcomes.

They do, however, support a useful management hypothesis:

**The additional value of a new AI capability depends partly on the capabilities already in place.**

The first assistant may eliminate hours of repetitive work.

A second or more capable tool might improve complex tasks.

But introducing yet another agent does not necessarily remove the remaining bottleneck.

In some organizations, the limiting factor may already have shifted from implementation to review, architecture, testing, or delivery. [Coordination across multiple coding agents](https://www.gitdotme.com/blog-coordination-tax-multiple-coding-agents) can add its own demands.

## What Would AI Leverage Saturation Look Like?

Consider a hypothetical engineering team tracking AI participation and modeled leverage over several months.

Initially, AI participation grows and AI Leverage rises with it.

Developers achieve more modeled engineering output relative to their estimated human effort.

As adoption continues, however, the leverage multiplier begins to flatten.

The team still uses more AI, but the additional participation no longer produces proportional gains.

At the same time, reviewers report more validation work, and some AI-assisted changes require additional corrections.

This would be consistent with a possible saturation effect.

It would not prove one.

Changes in project complexity, team composition, task distribution, release practices, measurement coverage, or engineering priorities could produce similar patterns.

A stable AI Leverage value can also be a positive result if a team is maintaining strong productivity while taking on more difficult work.

And a plateau in AI Effort Share is not the same thing as a plateau in AI Leverage.

We should therefore distinguish three different situations.

**Adoption saturation:** AI participation stops increasing because most suitable opportunities are already covered.

**Workflow saturation:** Additional generated work meets a limiting stage, such as review, integration, or validation.

**Leverage saturation:** Additional AI participation no longer delivers meaningful marginal improvement in modeled productive capacity.

These phenomena may interact, but they are not interchangeable.

A useful saturation analysis must examine the whole engineering system rather than assume that one flattening metric tells the entire story.

## Finding the Point Where More AI Stops Helping

Engineering leaders do not need a universal AI utilization target.

They need a method for evaluating whether additional AI usage is helping their particular teams.

### 1. Establish a meaningful baseline

Compare engineering performance across periods with consistent measurement definitions.

Account for team size, repository scope, work categories, task complexity, and other relevant changes.

A team performing complex migrations should not be directly compared with the same team performing routine feature work without acknowledging the difference.

### 2. Track AI participation separately from leverage

Measure where AI is being used and how participation changes.

Then examine whether modeled output per unit of estimated human effort is improving.

Increasing AI participation without increasing leverage is a signal worth investigating, not an automatic failure.

### 3. Look for displaced effort

Examine the work that happens after code generation.

Are pull requests requiring more review iterations?

Are CI failures, integration corrections, or follow-up changes increasing?

Are senior engineers spending more time validating output produced elsewhere?

Repository metrics provide some signals. Review systems, CI telemetry, and direct developer feedback provide additional context.

No single source captures every part of the process.

### 4. Compare similar kinds of work

Some tasks are naturally suited to AI assistance.

Others require more judgment, context, or coordination. [Agent scope problems](https://www.gitdotme.com/blog-ai-coding-agents-scope-problem) are one reason to examine the work being assigned.

Comparing leverage within reasonably similar work categories can reveal whether additional AI use is beneficial in one area but ineffective in another.

The objective is not to produce a perfect experiment from ordinary repository history.

It is to avoid mistaking a change in the type of work for a change in tool effectiveness.

### 5. Examine what happens over time

An initial productivity gain can be weakened by later correction or replacement work.

Review rework patterns and the persistence of earlier engineering effort over longer periods. [Engineering productivity needs a half-life](https://www.gitdotme.com/blog-engineering-productivity-needs-a-half-life).

A strong multiplier at the moment of implementation is more convincing when the resulting contributions remain useful.

### 6. Investigate before scaling further

If leverage stops improving, adding more AI licenses or agent capacity may not be the highest-value response.

The next improvement could come from clearer specifications, better automated tests, stronger integration practices, more reliable context, or different task allocation.

Sometimes improving the human and organizational workflow creates more leverage than introducing another coding tool.

## How GitMe Helps Evaluate the Saturation Hypothesis

GitMe approaches AI productivity through modeled engineering effort rather than raw activity counts.

This makes it possible to examine several complementary dimensions.

**AI Effort Share** indicates AI participation within modeled engineering effort. It establishes the adoption context.

**AI Leverage** is a modeled multiplier relating engineering output to estimated human effort. It helps evaluate whether AI assistance is associated with greater productive capacity.

**Real Effort Value (REV)** represents modeled baseline engineering effort. It provides an effort-based foundation for comparing contributions without treating lines of code or commit counts as productivity; it is not a verified measure of business value or actual working hours.

**Rework and refactoring signals** help teams examine what happens after the initial implementation. They can reveal patterns of correction, replacement, and restructuring, although such changes are not necessarily waste.

**Effort Survival Cohort** follows how modeled engineering effort from earlier periods persists as the codebase evolves. This adds a longer-term perspective to the initial leverage measurement, without establishing that every surviving contribution delivers business value.

Together, these metrics can support a useful investigation.

Suppose an organization observes rising AI Effort Share, flattening AI Leverage, increasing rework, and weaker effort survival.

That combination would not prove that the organization had crossed a particular saturation threshold.

But it would provide a stronger reason to examine its AI workflow than rising adoption alone.

Conversely, if AI participation increases while leverage improves and downstream work remains controlled, there may be a strong case for further adoption.

**The point is to measure the relationship, not to maximize one variable.**

GitMe does not automatically identify an optimal level of AI usage, measure all human supervisory effort, or establish the causal effect of an additional AI agent.

Its metrics help make the resulting engineering patterns visible.

Interpreting those patterns still requires engineering judgment, delivery context, and, when possible, controlled comparisons.

## Saturation Is Not the Same as Failure

There is another important consequence of this approach.

The goal should not be to force AI Leverage to increase indefinitely.

Every engineering process has constraints.

A team may already be extracting substantial value from AI. Further improvement might require solving problems that are outside the coding assistant itself.

That does not make the original investment unsuccessful.

It means the organization has discovered where its next bottleneck may be.

In fact, understanding when additional AI use stops delivering proportional benefits can be as valuable as understanding where AI works exceptionally well.

It helps leaders decide where to deploy more capable tools, where to improve engineering workflows, and where human expertise continues to create the greatest impact.

There is no reason to assume that every task should involve more AI or that every developer should achieve the same multiplier.

The objective is sustainable productive capacity, not maximum automation.

## The Next Competitive Advantage Is Knowing When to Stop

The first wave of AI-assisted development focused on adoption.

The next wave increasingly focuses on more capable coding agents and greater automation.

But the organizations that benefit most may not be those that continuously maximize AI participation.

They may be those that understand where additional AI creates value, where the returns begin to diminish, and which parts of the engineering system must improve next.

That requires measuring more than generated code.

It requires examining modeled human effort, the engineering output achieved, the correction work that follows, and the durability of what was delivered.

**The goal is not to maximize AI usage. It is to discover where AI creates the greatest sustainable leverage—and recognize when additional AI assistance stops improving the outcome.**

That is the question engineering leaders should be asking.

And it is the kind of question GitMe is built to help them investigate.

[Explore GitMe](https://panel.gitdotme.com/signup) to understand AI Leverage, engineering effort, and the value that lasts.

## Sources

1. Demirer, M., Musolff, L., & Yang, L. (2026). [Writing Code vs. Shipping Code: Productivity Effects Across Generations of AI Coding Tools](https://www.nber.org/papers/w35275). NBER Working Paper 35275, May 2026, revised September 2026. Working paper, not peer-reviewed. DOI: [10.3386/w35275](https://doi.org/10.3386/w35275).

2. Vella, A., & Blincoe, K. (2026). [The Impact of AI Coding Assistants on Software Engineering: A Longitudinal Study](https://arxiv.org/abs/2605.23135). ACM Transactions on Software Engineering and Methodology. DOI: [10.1145/3861343](https://doi.org/10.1145/3861343).

3. Agarwal, S., He, H., & Vasilescu, B. (2026). [AI IDEs or Autonomous Agents? Measuring the Impact of Coding Agents on Software Development](https://arxiv.org/abs/2601.13597). Proceedings of MSR 2026. DOI: [10.1145/3793302.3793589](https://doi.org/10.1145/3793302.3793589).
