Write a function, fix a bug, run tests, edit multiple files and open a pull request : the programming agents now go beyond mere code suggestions. But this ability to perform a series of actions is not enough to guarantee a software that is reliable, secure, or tailored to the needs of its users. For the developer, this transformation is less a disappearance than a shift in responsibilities, from coding to design, and the verification and control of automated systems.
From Line-by-Line Code to Agent-Based Development
For a long time, software development revolved around a process of translation: transforming a business need into specifications, choosing an architecture, writing code, testing its behavior, and then maintaining the application. However, a developer does more than simply produce text in a programming language. They must understand constraints—which can sometimes be contradictory—anticipate how the system will be used, protect data, and evolve the system without compromising its existing functionality.
Artificial intelligence-powered assistance was first popularized in the form of suggestions within the editor: completing a statement, suggesting a function, or explaining an error message. The recent breakthrough stems from the rise of programming agents, which—when equipped with the appropriate permissions and tools—can browse a code repository, modify files, run commands, execute tests, and submit changes to a team. GitHub, for example, documents a cloud agent that can be tasked with an issue and will prepare a pull request for review. OpenAI presents Codex as an agent capable of working on software engineering tasks in an isolated environment. [1] [2]
In this article, “autonomous” refers to limited operational autonomy: the agent can organize and execute several steps within a defined scope. This term does not imply that the agent understands all of the company’s challenges, bears professional responsibility, or should be able to deploy a change to production without oversight.
The contrast between adoption and trust is telling. In its 2025 survey, Stack Overflow reports that 84% of respondents use or plan to use AI tools in their development process, but 46% say they do not trust the accuracy of the tools’ responses, compared to 33% who do trust them. These are statements gathered from survey respondents, not a universal measure of the quality of the code produced. [3]
Automating the writing of a program is not the same as automating the understanding of the problem it is meant to solve.
How AI Is Transforming Developer Practices
Agent-based tools can be incorporated at various stages of the software development cycle. However, their value depends on the project context, the quality of the tests, and the ability to monitor the actions taken.
Understanding existing code
An agent can explore a repository’s structure, locate the functions related to a feature and summarize how they interact. That summary is a working hypothesis to be checked, especially when the business logic is not explicitly documented.
Building features
Starting from an issue or a specification, it can propose several coordinated changes, add files and prepare a diff. GitHub explicitly describes the path from an issue to a pull request, which is then submitted for team review[1].
Debugging and maintenance
The agent can reproduce an error, look for a likely cause, change an implementation and rerun tests. A passing test, however, does not prove that every business or security scenario is covered.
Testing and quality
Generating unit tests, identifying edge cases, running linters and type checks. The Codex documentation lists these actions within a controlled execution environment[2].
Documentation and refactoring
Writing function descriptions, preparing migrations or restructuring modules. The changes still have to be checked against the project’s conventions, performance requirements and technical debt.
Asynchronous work
Several well-scoped tasks can be delegated in parallel. This way of working requires rigorous management of branches, conflicts, traceability and acceptance criteria.
Let’s take a hypothetical example. A team wants to add a search filter to a booking application. The developer identifies the relevant components, modifies the interface, adapts a query, and creates tests. The developer then verifies the correctness of the behavior, response times, the form’s accessibility, access rights, and the effects on other user flows. The result cannot be considered ready for deployment simply because the agent says they’re done.
The developers of these tools highlight numerous use cases, but their documentation primarily serves as a description of product capabilities. It does not demonstrate that each feature will function correctly within a complex system. The value of agent-based work is measured by the validated result, not by the number of files modified.
A New Role for Developers
Developers may spend a larger share of their time framing the problem, defining acceptance criteria, reviewing changes and handling the situations the agent deals with poorly. This shift is neither uniform nor automatic: some tasks are still faster to do directly, and not every team has a test infrastructure robust enough to delegate effectively.
Turning needs into testable requirements
The first change concerns how the need is expressed. An agent works better when it is given a well-defined goal, a set of files, explicit constraints and a definition of the expected outcome. The skill is not just “good prompting” but turning a vague request into testable requirements. An instruction such as “improve performance” is not enough if it specifies neither the metric, nor the threshold, nor the acceptable trade-offs.
Reviewing changes with a critical eye
The second change affects code review. Reviewing a diff produced in a few minutes can demand as much attention as a human-written change. Developers must reconstruct the implicit reasoning, check the assumptions and reject unnecessary changes. Review must not be reduced to a superficial approval just because the automated tests are green.
Orchestrating tasks and setting limits
The third change concerns orchestration. Assigning several tasks in parallel can speed up independent work, but it can also multiply conflicts, design inconsistencies and verification costs. The team must decide which operations stay local, which require prior approval and which must never be carried out by an agent.
Taking responsibility for the software delivered
Finally, responsibility remains with the people and organizations that design, validate and operate the software. GitHub explicitly states that code generated by its agent must be reviewed and tested before merging, in particular to detect errors, vulnerabilities and intellectual property issues[4].
What Skills Do Developers Need in the Age of Generative AI?
A solid understanding of programming languages, data structures, and architectural principles remains essential. A developer who is unable to evaluate a generated result would lose precisely the oversight capability on which the system’s reliability depends. These new skills therefore build upon the traditional foundation rather than replacing it.
Technical and analytical skills
- Architecture and system understanding: reading dependencies, anticipating the effects of a change, identifying critical interfaces and keeping services consistent with one another.
- Specification and breakdown: turning a business request into well-scoped tasks with verifiable acceptance criteria.
- Testing and evaluation: writing meaningful tests, telling coverage apart from quality, building sets of edge cases and interpreting failures rather than relying on an automated verdict.
Security and data governance
- Secure development: applying the principle of least privilege, protecting secrets, checking dependencies and controlling command execution and system access.
- Data management and privacy: knowing which repository information may be sent to an external provider and complying with internal and contractual rules and, where applicable, the GDPR.
Collaboration and knowledge sharing
- Collaboration and knowledge sharing: documenting decisions, explaining trade-offs, ensuring critical peer review and keeping junior developers’ skills up to date.
One cross-cutting skill becomes particularly important: knowing when to stop the automation. When an agent keeps retrying, touches components outside its scope or proposes a fix nobody can understand, the right decision may be to return to a slower but more controlled human analysis.
The learning risk is real: a junior developer who accepts changes without understanding the underlying mechanisms may get better at using the tool without improving at the same pace in design and debugging. Learning should therefore combine thoughtful use of AI, code reading, unassisted exercises and peer review.
Can Artificial Intelligence Make Software Development More Reliable?
We must distinguish between three outcomes: producing code more quickly, producing correct code, and producing a system that is reliable in production. These aspects are not interchangeable. A developer may reduce the time required for a simple change while introducing an access control flaw or a regression that is difficult to detect.
The available data calls for caution. In the 2025 Stack Overflow survey, approximately 69% of bot users reported perceiving a productivity gain. This is a perceived outcome, not a causal measure. Conversely, a randomized study published by METR in July 2025, involving 16 experienced developers and 246 tasks in familiar open-source projects, observed an average 19% increase in completion time when the AI tools available at the time were permitted. The authors themselves point out that this study does not represent all projects or subsequent generations of tools. [3] [5]
These results are not necessarily contradictory. The benefit depends on the type of task, the available context, the level of expertise, the cost of verification, and the quality of the tools. An isolated, thoroughly tested function does not present the same challenges as a critical data migration or an architectural overhaul.
From a security perspective, agents create an additional attack surface: they can read files, execute commands, and use connected services. In its guidelines on agent-based applications, OWASP identifies risks such as misuse of purpose, misuse of tools, abuse of privileges, and unexpected code execution. [6]
A control measure involves limiting the agent’s permissions to what is strictly necessary, isolating its environment, requiring human review for significant changes, analyzing dependencies, and maintaining execution logs. A prompt asking the agent to exercise caution is no substitute for a technical restriction on permissions.
Reliability is not simply a matter of the number of successful tests, either. Tests generated by the same system as the code may reproduce its erroneous assumptions. Therefore, independent requirements, security checks, and—for critical components—thorough human evaluations are necessary.
The relevant criterion is quality as measured after integration: detected defects, incidents, maintenance time, regressions, performance, security, and user satisfaction. At this stage, there are no general conclusions that would allow us to assert that agent-based development systematically makes software more secure.
MSc Generative
and Agentic AI
Become an expert in generative and agentic AI: LLMs, transformers, enterprise deployment. Silicon Valley learning trip included. RNCP Level 7 certification (Bac+6).
What Will the Role of a Developer Look Like Tomorrow with AI?
- Several paths are emerging. The first is the integration of agents into the software lifecycle, from release to change requests. The second is the development of workflows in which multiple agents work on separate tasks under the supervision of a professional responsible for managing their interactions. The third is the increase in governance requirements regarding access, traceability, and validation.
- Developers could take on greater responsibility for problem definition, architecture, evaluation, and security, without giving up programming. Repetitive and well-defined tasks are good candidates for automation; decisions that require business understanding, compromise, and operational responsibility are less amenable to complete delegation.
- However, the term “augmented developer” should not obscure the potential impacts on employment and training. Certain tasks traditionally assigned to junior staff may be automated, forcing companies to rethink on-the-job training. Conversely, the increase in the volume of software produced could create new needs for review, integration, and maintenance. The net impact on employment remains uncertain and will depend on the sector, work organization, and demand.
- Changes in performance measured by programming benchmarks are not enough to predict this transformation. Solving a coding problem in a testing environment does not guarantee an understanding of a company’s unspoken requirements or the ability to handle a real-world incident. Metrics will need to account for oversight costs and software quality after delivery.
- In a plausible scenario, a team defines a task, the agent proposes an implementation on an isolated branch, the continuous integration pipeline runs the checks, and then a developer verifies the behavior and approves the merge. This scenario is already similar to the workflows documented by some vendors, but its effectiveness at scale remains to be evaluated on a case-by-case basis.1, 4
Code Is Becoming Increasingly Automated, but Still Under Human Control
Generative AI has reached a new milestone: it is no longer limited to suggesting a line of code. It can handle a sequence of technical tasks, explore a repository, run tests, and submit a proposal. This advancement is changing the way the profession operates and is forcing teams to specify exactly what they want to delegate.
But software is not valued solely for its ability to run. It must fulfill a purpose, serve users, protect data, be resilient to errors, and be maintainable. These requirements involve decisions that go beyond simply producing computer instructions.
The developer, therefore, does not simply become the passive supervisor of a machine that would write code in their place. They remain the interpreter of requirements, the architect of trade-offs, the person responsible for verification, and a key point of contact for the business teams. When the agent speeds up a task, that speed is only valuable if the result remains understandable and manageable.
AI can write code. The developer remains responsible for its understanding, reliability, and consequences.
Perhaps the central question is no longer whether AI can write code, but who will still be able to explain, test and take responsibility for that code once it is operating at the heart of organizations.
To learn more
To learn more about the challenges of assisted programming, AI agents and technical professions , check out these additional analyses from the aivancity blog.
References
[1] GitHub Docs. Get started with Copilot agents on GitHub. Product documentation. View documentation
[2] OpenAI. Introducing Codex (2025); Codex is now generally available (2025). Documentation and publisher announcements. View source
[3] Stack Overflow. (2025). 2025 Developer Survey, “AI Tools” and “AI Agents” sections. Self-reported survey. View the survey
[4] GitHub Docs. Application card: GitHub Copilot Agents. Responsible use and limitations. View the documentation
[5] METR, Becker et al. (July 10, 2025). Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity. Randomized study. View the study
[6] OWASP Gen AI Security Project. (December 9, 2025). Top 10 for Agentic Applications. Risk Repository. View the repository