Generative artificial intelligence is transforming the software development process, not only through its ability to produce code from natural-language instructions, but above all because it can take on more complex tasks, such as analyzing existing applications, reorganizing architectures, detecting anomalies, and verifying functional behavior.
The term Vibe Coding has helped make this change recognizable, describing an approach in which a significant part of programming is delegated to artificial intelligence, while the person focuses on describing goals and evaluating results. However, if we look at what AI agents are now able to do within a software project, it becomes clear that code generation is just one of the activities that can be automated.
The most interesting question, then, is not just how quickly an application can be developed, but how to use these capabilities to improve the entire process, from understanding the system to verifying that it actually works.
Understanding an application before changing it
Anyone who works on applications developed over the years is familiar with a recurring difficulty: the system in front of you rarely matches an architecture that was designed and built in a unified way. Successive changes, integrations of different components, new requirements, and maintenance work can produce duplication, structural inconsistencies, and functionality distributed according to logic that is not always immediately understandable.
Under these conditions, even before touching the code, it becomes necessary to reconstruct how the application works, comparing documentation, component structure, change history, and the behaviors that are actually available.
Intelligent agents can make a significant contribution to this work because they make it possible to explore a repository, analyze the relationships between components, and identify possible inconsistencies, connecting pieces of information that would normally require numerous manual search and comparison tasks.
The most interesting aspect emerges when this analysis is carried out not only on the technical structure but also on application behavior. A feature may be present in the code without actually being reachable from the interface, or it may have been implemented several times in different components, creating inconsistent operational paths that make the system difficult to use and maintain.
Artificial intelligence makes it possible to tackle these situations through a broader exploration of the system, formulating hypotheses and proposing reorganization changes that the developer can verify and assess in light of actual needs.
A different kind of collaboration between developer and AI
When the use of artificial intelligence is extended from producing individual functions to transforming a complex application, the way development activities are organized changes as well.
Instead of describing every change in detail, it is possible to define architectural goals, constraints, and conditions to be met, leaving the agent to identify the necessary changes and propose an implementation path.
A request to simplify an application's structure, for example, can be accompanied by instructions to eliminate duplication, distribute responsibilities more coherently, and fully preserve existing behavior. The agent can then work across multiple components, verify the effects of the changes, and document the operations performed, while the developer assesses whether the solutions are consistent with the goals.
This way of working is not simply about delegating the writing of code, but about organizing an iterative collaboration in which the AI's proposals are examined, corrected, and progressively improved.
A technically correct solution may in fact not be the most appropriate for the system, just as an apparently advantageous architectural reorganization may introduce complexity or make certain operations harder to access. The ability to challenge the result, ask for further checks, and redefine constraints is therefore an essential part of the process.
What I consider most relevant is that artificial intelligence allows us to devote more attention to design decisions, without necessarily having to personally work on every single code transformation.
From Vibe Coding to Agentic Testing
One of the most interesting developments of this approach concerns the use of AI agents in software verification activities.
Traditional testing methodologies make it possible to check the behavior of individual components, the integrations between services, and the execution of complete application processes, but the introduction of intelligent agents adds the ability to build and run verification scenarios starting from a natural-language description of the goals.
This approach can be placed within the field of Agentic Testing, in which AI agents take part in planning, executing, and analyzing tests, using the available tools to interact with the application and gather evidence of the results.
The difference becomes particularly evident when, instead of asking to verify a specific function, you describe a task that a user should be able to complete, leaving the agent to identify the necessary path, perform the operations, and check that the result has actually been achieved.
In this way, verification is not just about the technical correctness of a component, but involves the overall behavior of the application, including the relationships between interface, application logic, and data persistence.
During an experience of reorganizing and validating an existing system, this kind of approach made it possible to gradually shift attention from the mere presence of features to their actual usability, showing how some operations could be correctly implemented yet difficult to find or reach through the interface.
The result was a broadening of the verification process, in which technical analysis began to include the quality of operational paths and the coherence of the application experience.
When a feature exists but is not really usable
The distinction between technical availability and usability is one of the most significant aspects of validation assisted by intelligent agents.
An application can successfully pass the tests associated with a given operation and, at the same time, present an interface that makes it hard to find the command needed to perform it. In other cases, the required path may be overly convoluted, or the operation may return a positive response without producing the change that was actually expected.
From the code's point of view, the behavior may look correct, but from the user's point of view the result remains unsatisfactory.
One interesting method is to give the agent a goal without revealing the solution, asking it to work out on its own how to complete the task and to document any obstacles it encounters. This approach forces the verification process to deal with the real organization of the system, rather than merely confirming an already known path.
AI can thus help identify problems in interface organization, redundant steps, and inconsistencies between technical capabilities and their operational availability, turning part of the acceptance testing into a functional analysis activity.
Of course, the behavior of an intelligent agent cannot be considered equivalent to that of a real user, because the ways it interprets information and finds paths may differ. Still, the ability to run repeated, documentable explorations is a tool that complements traditional testing and usability evaluation.
The quality of verification matters as much as its automation
Using artificial intelligence in testing also opens up new opportunities in collecting and organizing evidence, since agents can record the operations performed, compare application states, and produce documentation that makes it easier to reconstruct the changes made and the results obtained.
This is particularly useful in iterative processes, where code is modified frequently and it is necessary to make sure that new changes do not break behavior that previously worked.
It remains essential, however, to distinguish between the correct execution of a procedure and the demonstration of the application result, because a successful build, a positive response from a service, or a passing test run in a simulated environment does not necessarily prove that an entire operational process was completed correctly.
When AI agents are used for both implementation and verification, there is also the possibility that an incomplete interpretation of the requirements will be reproduced in the tests as well, producing results that are consistent with the solution developed but not with the original needs.
Defining explicit acceptance criteria and requiring observable evidence make it possible to address this issue, keeping the benefits of automation without giving up the ability to check and challenge the results.
Not every check needs to be performed manually, but it is important that it is always possible to understand what was actually checked, under what conditions, and with what results.
Toward a continuous development and validation process
Experience with AI agents suggests that their most interesting contribution is not limited to producing code, but lies in the ability to connect activities that are traditionally tackled at different times.
Analyzing a system can lead to defining architectural changes, their implementation can immediately be accompanied by functional checks, and the results of testing can become the starting point for further improvements, within a continuous process in which development and validation influence each other.
From this perspective, the developer keeps a central role in defining goals, evaluating alternatives, and accepting results, while intelligent agents help carry out the tasks and produce the information needed to make decisions.
This is not about replacing human skills, but about using them in a different operating context, in which a growing share of technical work can be automated and attention can focus more on the overall quality of the system.
Artificial intelligence thus makes it possible to rethink the relationship between development and testing, moving beyond a view in which verification is mainly a phase that follows software production.
Moving beyond Vibe Coding might be exactly this: not just using AI to build applications faster, but also employing it to better understand what has been built, verify its behavior, and guide its continuous improvement.