Artificial intelligence is changing the way software is built, and this shift is happening faster than most people expected.
Over the past few months, a quiet movement has been gaining momentum among developers around the world: AI-generated code is going straight to production without ever passing through a human’s eyes in a traditional code review.
This isn’t an exaggeration. It’s a real trend backed by hard numbers, and it raises a question the software development industry will need to answer soon: how far are teams willing to trust machines to make decisions on their own?
What’s driving this isn’t carelessness or laziness from devs. It’s actually something more interesting than that. Coding agents are delivering increasingly consistent output, and professionals are noticing it in their day-to-day work. When the code AI produces starts working well, over and over again, the natural tendency is to cut back on manual verification steps. And that’s exactly what the latest data is showing. 👇
What Cursor’s numbers reveal about this turning point
One of the most revealing data points about this transformation came directly from Cursor, one of the fastest-growing AI-assisted coding tools in recent times. According to information shared by the company, the share of AI-generated code reaching production without a separate manual review step jumped from just 7% in early 2026 to a staggering 36.3% by mid-May of the same year. In just a few months, that number more than quintupled, which shows the incredible speed at which developers are changing their behavior.
This jump isn’t just a statistical footnote. It tells a story about trust. Cursor, led by CEO Michael Truell, makes it clear the company doesn’t directly measure the quality of fully autonomous code. But it observes something equally important: AI-generated code is surviving at higher rates than before. Surviving, in this context, means it’s not being reverted, it’s not breaking in production, and it’s not requiring emergency fixes. When code holds up and keeps running, that’s a strong signal that developers are finding increasingly reliable output.
Receive the best innovation content in your email.
All the news, tips, trends, and resources you're looking for, delivered to your inbox.
By subscribing to the newsletter, you agree to receive communications from Método Viral. We are committed to always protecting and respecting your privacy.
We’re not talking about some experimental minority or startups living on the edge. We’re talking about real teams, with products in production, that have started placing growing trust in what language models deliver. That number alone would be enough to spark debate. But there’s more to this story.
The self-reinforcing trust cycle
When you look at the behavior of teams that have adopted coding agents more deeply, the pattern repeats: the more the agent gets it right, the less the developer feels the need to review every line. It’s a self-reinforcing trust cycle. The agent delivers well, the dev reviews less, the agent keeps delivering, and the practice becomes standard within the team.
The problem is that this cycle can also hide flaws that only show up later, in production, when the cost of fixing them is much higher. That’s where the concern lies. The growing trust is justified by results, but it also creates blind spots that can get expensive if they’re not handled carefully.
Why devs are letting go of manual review
The most honest answer to this question has less to do with blind faith in technology and more to do with the accumulated experience of people who use these tools every day. A developer who works with a coding agent for weeks or months starts building a mental map of what that agent does well and where it tends to fall short.
This is something UX literature calls a mental model, and it deeply shapes the behavior of anyone using any tool, digital or otherwise. When the mental model says the AI is reliable for a certain type of task, review starts to feel redundant, and it gradually gets trimmed back without any formal decision or team policy.
There’s also a speed pressure component that can’t be ignored. The software development market is more competitive than ever, and teams that ship faster have a real advantage. When a team discovers it can speed up the development cycle by reducing manual review steps without seeing an immediate drop in quality, the economic logic speaks louder than any best-practice recommendation.
This isn’t irresponsibility. It’s the rational response from teams trying to survive and grow in a high-pressure environment with limited resources and ever-tightening deadlines.
On top of that, coding agents themselves have evolved significantly in recent times. Advanced models have shown the ability to generate functional, well-structured code with few obvious bugs across a huge variety of contexts. This has shifted how many developers think about trusting AI for coding tasks. It’s no longer about believing the AI is perfect. It’s about calculating that the risk of missing a minor error is acceptable given the speed gains, especially when automated tests cover a good chunk of the system’s expected behavior.
The reliability of AI-generated code is still a point of concern
Even with all this progress, the reliability of code generated by artificial intelligence still raises legitimate questions the industry can’t sweep under the rug. Multiple studies have already pointed out that a considerable portion of code snippets suggested by AI tools can contain security vulnerabilities when evaluated in specific contexts.
The core point still stands: AI can generate code that works perfectly from a functional standpoint and still introduce risks that only a security-trained eye can catch. Injection vulnerabilities, sensitive data exposure, authentication issues. These are exactly the kind of things human review was designed to catch.
What makes this scenario even more delicate is that most automated tests weren’t designed to cover security vectors. A unit test checks whether a function returns the right value. It doesn’t check whether that function exposes an endpoint without proper authentication or handles user input in an unsafe way.
This means that by removing human review and relying only on existing tests, teams may be creating an invisible risk window that only shows up when someone exploits that vulnerability in production. And at that point, the cost, both financial and reputational, can be far greater than any speed gains achieved in the process.
That said, the problem isn’t with artificial intelligence itself, but with the lack of a clear strategy to complement what it still can’t do on its own. Teams that are navigating this transition well are the ones that, as they reduce manual review, have invested in other validation layers: static code analysis, automated security tools, focused security reviews by dedicated specialists, and more robust continuous integration pipelines.
The shift isn’t from review to no review. It’s from generalist review to specialized review, with AI handling the more routine tasks and humans focusing on the highest-risk areas.
The horizon of autonomous agents in development
What’s taking shape now is an even faster acceleration of this process, driven by the arrival of next-generation coding agents. Increasingly sophisticated tools point to a future where the agent doesn’t just write the code but also plans the architecture, writes the tests, handles the deploy, and monitors behavior in production. This puts the human developer in a role that looks more and more like a high-level reviewer, responsible for validating strategic decisions rather than checking code line by line.
This shift already has an informal name among researchers: the transition from dev as executor to dev as curator. Instead of writing code, professionals will increasingly direct, validate, and refine what agents produce. It’s a role change with interesting historical parallels, like when programmers stopped writing in assembly and moved to high-level languages. Abstraction increased, productivity exploded, and new layers of complexity emerged on top of that new foundation. With autonomous agents, the logic is similar, but the speed of the transition is much faster.
What Cursor’s numbers show is just the visible tip of this iceberg. When more than a third of AI-generated code is already reaching production without a separate manual review, it’s clear we’re looking at a deep reconfiguration of how software gets made. And this reconfiguration isn’t waiting for some collective industry decision. It’s already happening, company by company, team by team, pull request by pull request.
The question that really matters isn’t whether human code review will lose ground, because it already is. The question is how to make sure that, as that ground shrinks, the reliability of code reaching production doesn’t shrink along with it. And that’s a question that blends technology, process, engineering culture, and above all, clarity about what AI still can’t do without help. 🚀
