Professional Software Developers Don't Vibe, They Control: AI Agent Use for Coding in 2025
This paper investigates how experienced software developers in 2025 utilize AI agents, revealing that rather than fully delegating work, they strategically control agent behavior and selectively collaborate with them to maintain high software quality and design integrity.
Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer
In the world of software creation, a new kind of helper has arrived. For years, programmers have used tools that act like advanced autocomplete, suggesting the next word or line of code as they type. But recently, these tools have evolved into something more autonomous. They are now agents capable of reading entire projects, making changes, running tests, and fixing their own mistakes without constant human typing. The promise of these agents is seductive: that a person could simply describe a software idea in plain language and watch as the machine builds it entirely on its own. This idea has sparked a wave of excitement, with some claiming that the future of coding involves "vibe coding"—a state where the developer trusts the machine completely, letting it flow through the work while the human steps back to enjoy the ride. Yet, as these tools become more powerful, a critical question remains: does this vision of total delegation actually work for the people who build the software that runs our modern world?
To find the answer, a team of researchers turned their attention to experienced software developers. They wanted to see how real professionals, those with years of training and responsibility for complex systems, actually interact with these new agents. The team conducted two distinct studies to get a clear picture. First, they watched thirteen seasoned developers as they worked on real tasks, observing how they used the tools in their natural environment. Then, they surveyed ninety-nine other experienced developers to gather a broader view of their habits and feelings. The researchers were looking for the truth behind the hype: are these experts letting the machines take the wheel, or are they steering the ship themselves?
The findings were clear and consistent. Despite the allure of letting an agent do everything, professional developers do not "vibe code." They do not hand over control and hope for the best. Instead, they treat these powerful tools as collaborators that require strict supervision. The developers in the study valued the agents for one main reason: speed. The tools helped them write code faster and handle tedious, repetitive tasks that would otherwise slow them down. However, this desire for efficiency never came at the cost of quality. The developers remained deeply concerned with the reliability, safety, and structure of the software they were building. Because they knew that a small mistake could cause a major failure, they refused to let the agents work blindly.
The way these professionals controlled the agents was methodical and deliberate. Before asking an agent to write a single line of code, they would often create a detailed plan, breaking the work down into small, manageable steps. They did not ask the machine to build a whole system at once. Instead, they gave it one specific instruction, waited for the result, and then checked the work carefully. If the agent tried to install a tool the developer didn't want, or if the code looked messy, the developer would stop it and correct the course. They treated the agents like a very smart but inexperienced assistant who knew the rules of the language but didn't understand the specific context of the project. The developers provided that context, offering clear instructions, pointing to specific files, and explaining exactly what was needed.
This careful oversight extended to how the developers verified the work. They did not simply accept the code the agents produced. They read through the changes, ran tests to see if the software actually worked, and used debugging tools to trace any errors. In many cases, the developers found that the agents would try to do too much or get stuck in loops, requiring the human to step in and fix the direction. The researchers found that the developers were most successful when they used the agents for straightforward tasks, such as writing basic tests, creating standard code structures, or updating documentation. These were areas where the rules were clear and the risk of a major error was lower. However, when it came to complex tasks, such as designing the overall architecture of a system, handling sensitive business logic, or fixing deep-seated bugs in old code, the developers stepped back. They knew that these areas required human judgment and a deep understanding of the specific situation that the machine did not possess.
The sentiment of the developers was surprisingly positive, but with a crucial condition. They enjoyed working with the agents and found the process less stressful than coding alone, but only because they remained in charge. They described the experience as a partnership where the human provided the vision and the direction, while the agent handled the heavy lifting of writing the code. They felt a sense of relief knowing that the machine could handle the boring parts, but they also felt a strong sense of responsibility to ensure the final product was correct. They did not view the agents as replacements for their own expertise, but rather as tools that amplified their own abilities. One developer compared the experience to driving a high-performance car: it was fast and exciting, but the driver still had to keep their hands on the wheel and their eyes on the road.
Ultimately, the study reveals that the future of professional software development is not about letting machines take over. It is about a new kind of collaboration where humans remain the architects and the agents serve as the builders. The idea that a developer could simply describe a project and walk away while the machine builds it is not how experienced professionals work today. They know that software quality depends on human oversight, clear planning, and the ability to catch mistakes before they become problems. As these tools continue to improve, the role of the developer is shifting from a writer of every line of code to a manager of intelligent systems. The machine may be getting smarter, but the human remains the one who decides what gets built and how it gets done.
Drowning in papers in your field?
Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.