Agentic Data & Software Engineering

AI has moved the bottleneck, not removed it

By Xavier Franco, CEO de Elternativa · Grupo Zemsania
· 7 min read

Written with the help of AI and reviewed by Xavier Franco

Aerial view at dusk of a many-lane motorway whose fast traffic piles up at a single toll booth.
In this article

We lived it ourselves before anyone else. You give your development team AI, the code starts coming out twice as fast and, a few weeks later, someone tells you deliveries have not sped up that much. The bottleneck has not gone away: it has moved. If you lead technology, you want to know where to, because that is the difference between having AI and having AI that scales.

Writing code is no longer the problem

For years, the bottleneck of the SDLC, the software development lifecycle, was writing code. There were not enough hands. AI has solved that part better than we expected: according to the 2025 Stack Overflow survey, with more than 49,000 responses, 84% of developers already use or plan to use AI tools.

But the cycle does not end with writing. Afterwards you have to review, test, integrate, document and audit. And those phases still run at the same pace as before, with the same people.

The result is easy to imagine: everyone produces twice as much and the person reviewing is still the same. The queue builds up exactly where we already had the fewest people.

In practice: look at your pull requests from the last month. On average, how long passes between one being opened and being approved? If that time has grown since you started using AI, you already know where your new bottleneck is.

Engineers want to understand everything, and that is reasonable

Here is a point I find important, because it is sometimes framed as an attitude problem and it is not. Engineers want to understand everything the AI does before accepting it. That is reasonable: they are not in control.

The data confirms it. In the same Stack Overflow survey, 46% of developers say they do not trust the accuracy of what AI tools generate, up from 31% the year before. And for 45%, one of the main frustrations is that debugging AI-generated code takes a lot of time.

On top of that comes the disorder that appears when everyone works with their own AI in their own way:

  • the same thing done two ways in two parts of the system;
  • what was learned stays in a conversation that nobody will read again;
  • nobody knows who wrote what: a person or a model.

With all this, reviewing line by line is not distrust. It is the only form of control we have left to engineers.

In practice: ask your team what worries them when reviewing AI-generated code. They will tell you where the method is missing.

Control lives in the contract, not in reading every line

The way out is not reviewing faster. It is moving control to the start of the cycle. If, before the AI writes a single line, it is already fixed what it has to do, within what limits and with what tests, review stops being a full read and becomes a check against something concrete.

This is how we approach it, phase by phase:

  1. Requirement and plan. Every task is born with its acceptance criteria fixed in advance. They do not change afterwards.
  2. Development. Several AI instances work in parallel, without anyone having to chase them.
  3. Testing. Run by a different instance from the one that wrote the code. Nobody validates their own work.
  4. Review and validation. A person on your team validates the closure against the criteria, and their sign-off is recorded.
  5. Pull request and deployment. The AI opens the pull request and respects your Git and your CI/CD.
  6. Enhancements and support. In the same queue, with what was learned turned into rules that the next task already receives.

The engineer stops chasing the AI. They define, validate and decide.

In practice: take the next feature you are going to build and write its acceptance criteria before you start. That alone changes the review.

Integrating, documenting and auditing are also part of the cycle

The other three phases that get stuck need the same thing: method, not more hours.

  • Integrate. One method and the same rules for every AI, and each task reserves the resources it needs, so two parallel jobs do not step on each other.
  • Document. Project knowledge (standards, decisions and meetings) lives in a system the AI consults, not in one person’s head or in a lost conversation.
  • Audit. Everything is traced: who asked, who did it, who validated and how much it cost.

When these phases work, the effect of AI shows up in deliveries and not only in writing speed.

In practice: find an important technical decision in your last project. Is it written down somewhere the next person, or the next AI, can find it?

What to measure to know whether AI scales

There is a risk I see a lot: measuring AI by the feeling of speed. “We are going faster” is a perception, not data. Google’s 2025 DORA report, with almost 5,000 technology professionals, puts it in numbers: 90% use AI at work and more than 80% believe it has boosted their productivity. But 30% have little or no trust in the code it generates.

And there is a finding in the same report that I think every technology director should keep in mind: AI adoption is now associated with higher delivery throughput, but is still associated with lower stability. More changes, faster, and more things that break if there are no solid tests, mature version control and short cycles. DORA sums it up in one sentence: AI does not fix a team, it amplifies what is already there.

So, if you want to know whether your AI scales, measure on your repository, not with internal surveys:

  • deliveries per week and time to production;
  • review time of each pull request;
  • rework, that is, how much of what was delivered has to be touched again;
  • failures after deploying;
  • what share of deliveries comes out of the AI flow and what share is still done by hand.

In practice: pull those five figures today, before changing anything. Without a picture of the before, you will never know whether the after is better.

Where to start

My advice is not to try to change the whole cycle at once:

  1. Measure the current bottleneck: review time, rework and open pull requests.
  2. Choose one team and one type of work that is bounded and repeatable: enhancements, technical debt or testing.
  3. Fix the criteria before you start and separate whoever builds from whoever tests.
  4. Let a person validate, against the criteria, not against their gut feeling.
  5. Compare for a few weeks deliveries, rework and time to production, on your own repository.

If the numbers improve, you have the argument to scale. And if not, you will know exactly which phase to look at.

How we help

At Agentic Data & Software Engineering we orchestrate the development AIs you already have, such as Claude Code, Cursor, Codex or Copilot, across the whole SDLC: several instances in parallel, tests run by a different instance and a person on your team who validates every closure. The code stays in your Git and the knowledge in a database of your own. On the website we publish what we measure on our customers’ code: up to 2 times more data and software engineering capacity with the same team.

We do it with Agentagile, our methodology for developing with AI: your AI develops, tests and documents; your team decides. Nothing moves forward without your approval.

Frequently asked questions

What is the SDLC?

It stands for software development lifecycle: the phases that run from the requirement to deployment and maintenance, through development, testing and review.

How does the SDLC change with AI?

AI mostly speeds up writing code. If the other phases do not change, the bottleneck shifts to review, testing and integration.

Can AI review code written by another AI?

It can test it, as long as it is a different instance from the one that wrote it and the criteria were set beforehand. The final decision is made by a person.

Do I need to switch AI tools for this?

No. The method works with the tools you already have.

Keep reading