The work of programmers in 2025: real impact of AI tools and scenarios toward 2030

Abstract

By the end of 2025, software development has become an activity deeply mediated by artificial intelligence (AI). 90% of developers already use AI tools in their daily work, a 14‑percentage‑point increase over the previous year, indicating virtually universal adoption in the professional ecosystem [1]. This white paper analyzes, from a comparative perspective (2018–2020, 2021–2023 and 2024–2025), how the tasks, skills and risks of programming work have actually changed. It examines four layers: the tool ecosystem (AI‑enabled IDEs, assistants, agentic platforms), the impact on individual and team work, the organizational implications for governance, security and talent, and plausible scenarios for 2026–2030. The analysis is based on global developer surveys, consulting firm studies, product technical documentation and recent academic literature. It argues that AI has improved perceived productivity (over 80% report this) and code quality for 59% of professionals [2], but has also created new forms of dependency, technical debt and security risk. Finally, it proposes concrete recommendations for developers, technical leaders and large organizations.

Background

Between 2018 and 2020, software development was dominated by traditional IDEs (Visual Studio Code, JetBrains, etc.) with syntactic autocomplete, linters and increasingly but relatively limited automation in CI/CD. AI applied to code existed in the form of statistical suggestions (for example, n‑gram‑based completers) and some recommendation systems, but had not massively penetrated the workflow. Productivity depended largely on manual expertise and the quality of engineering processes: human code reviews, hand‑written unit and integration tests, manually maintained documentation and branch and deployment management supported by handcrafted scripts. Organizations seeking efficiency relied more on agile methodologies, DevOps and architecture standardization than on intelligent automation.

In 2021–2023, the first major inflection point occurred with the emergence of tools such as GitHub Copilot, which popularized the use of large language models (LLMs) to autocomplete and generate code blocks from local context and comments. At the same time, the arrival of ChatGPT and similar tools normalized the idea of conversing with an AI system to resolve technical questions, generate code examples, refactor snippets and translate between programming languages. The developer shifts from writing all the code to “co‑writing” with a predictive assistant capable of proposing entire functions, design patterns and tests. Even so, at this stage AI remains mainly a complement: architecture, design decisions and integration are still driven by human judgment.

The 2024–2025 period marks a second qualitative inflection. Adoption is no longer limited to extensions within existing IDEs; instead, development environments explicitly conceived as “AI‑first” or even “agent‑first” emerge. Platforms such as Cursor and Google Antigravity consolidate their position as market leaders by offering AI‑integrated development environments that facilitate complex tasks, understand the entire repository, modify multiple files in cascade and orchestrate autonomous agents capable of executing task chains asynchronously [1]. Instead of autocompleting a function, AI is now able to take a ticket (“add SSO authentication with OpenID Connect”) and produce not only the code, but also the migrations, tests and configuration changes required.

This shift from localized assistance to task delegation reshapes expectations about the developer’s role. On the one hand, over 80% of professionals perceive productivity gains, and 59% see improvements in the quality of generated code [2]. On the other hand, concerns arise about excessive dependency, loss of fundamental skills and new security vulnerabilities. The discussion is no longer just about “whether to use AI or not,” but about how to govern its use, how to measure its real effects on business value and how the competencies that define a software professional evolve.

Evolution of the AI tool ecosystem for development

From traditional IDEs to AI‑first environments

The traditional IDEs of 2018–2020 were based on rules, static analysis and relatively simple statistical patterns. Their “intelligence” consisted of offering name autocomplete, highlighting syntactic errors, suggesting imports and running linters. These capabilities were useful but did not transform the nature of the work: the developer still mentally composed the solution and wrote it out explicitly.

With the arrival of Copilot, Tabnine and other assistants trained on large corpora of open‑source code, IDEs began to incorporate models capable of inferring intent. When writing a comment such as // sort users by last login desc, the assistant immediately generates the corresponding code snippet. The line between “specification” and “implementation” becomes blurred: many routine tasks (parsing, database queries, controller boilerplate) become delegable.

From 2024 onward, the trend intensifies with AI‑first editors such as Cursor. Based on Visual Studio Code, Cursor adds repository‑level understanding, the ability to answer questions about the code, apply complex refactorings and coordinate edit sequences through agents [1]. The developer can select a module and request “remove duplication between these three services while maintaining compatibility,” and the agent proposes a coherent refactoring across multiple files, accompanied by changes in tests and configuration.

At the same time, agent‑first platforms emerge, such as Google Antigravity, announced in November 2025 together with Gemini 3. Antigravity is built as a fork of Visual Studio Code, but the priority is not the editor itself, it is the orchestration of specialized autonomous AI agents. The platform makes it possible to delegate complex coding tasks to agents powered by Gemini 3 Pro, but also supports third‑party models such as Claude Sonnet 4.5 or open variants of OpenAI models [1]. This multi‑model architecture allows the environment’s behavior to be adapted according to data sensitivity, programming language or regulatory constraints.

Categories of tools in 2025

In 2025, four broad categories of AI tools for programming can be distinguished:

1. IDEs with integrated AI.
   In this category, environments such as Cursor and Google Antigravity stand out, not only embedding an assistant but redesigning the development experience around AI. They incorporate semantic search across the repository, large‑scale context understanding, batch change generation and panels for observing and controlling agents. Their goal is for the developer to spend more time formulating high‑level intentions and less time writing low‑level code.

2. Extensions/assistants in existing IDEs.
   Tools such as GitHub Copilot or Tabnine remain widespread. They integrate seamlessly into VS Code, IntelliJ, JetBrains and other IDEs, offering contextual autocomplete, unit test generation and explanation of code snippets. They remain the most common entry point for teams beginning to experiment with AI, since they entail a smaller change to established tools.

3. Agent‑first / autonomous development platforms.
   Solutions such as Google Antigravity take automation a step further. In addition to the traditional editor view, they offer an “administrator view” where teams can orchestrate multiple agents running in parallel on different workspaces. These agents can take on tasks such as updating dependencies across dozens of services, applying security patches throughout a monorepo or implementing simple features in a nearly autonomous way. Asynchronous execution and the ability to pause, review and resume tasks extend the range of use from the individual developer to the tech lead coordinating a team.

4. AI‑powered auxiliary tools.
   Beyond the editing core, specialized agents proliferate: automatic code reviewers, regression test generators, security vulnerability detectors, living documentation generators and guided refactoring tools. These agents can be integrated into CI/CD pipelines, act as “pre‑filters” before human reviews or continuously monitor code quality in active branches.

The following table summarizes the relative positioning of some representative examples in 2025:

Table 1. Examples of AI tools for software development in 2025 [1].

Maturity, successes and frustration zones

By 2025, productive tools in production, such as Cursor and the first Antigravity deployments, are already perceived as mature in real‑world environments [1]. Organizations with good engineering discipline report significant reductions in feature delivery times, improvements in test coverage and greater consistency in code styles. Use cases such as framework version migrations, mass dependency updates or log pattern standardization benefit from agents’ ability to apply systematic changes quickly and repeatably.

However, the experience is not uniform. Some teams face difficulties integrating these tools into existing workflows. Common sources of frustration include:

• Code suggestions that are syntactically correct but disconnected from business context.
• Massive changes proposed by agents that are hard to review humanly within reasonable time frames.
• Integration problems with internal systems, very large monolithic repositories or restrictive network and security configurations.
• The learning curve associated with crafting effective prompts and understanding model limitations.

These tensions help explain why, despite the high level of adoption, many organizations are still in experimentation stages, pilots or deployments limited to certain teams [1][2].

Profile and status of programmers in 2025

Adoption by experience level and specialization

AI adoption is not homogeneous across profiles. Recent studies indicate that younger developers tend to incorporate AI tools more quickly, while senior developers show more gradual and selective adoption [1]. Juniors see AI as a way to accelerate their learning curve, generate examples and obtain instant explanations for unfamiliar code. For many of them, starting in the industry already comes with the expectation of having “a copilot” always available.

Experienced developers, for their part, typically adopt a more critical stance: they value the ability to automate repetitive tasks but are wary of delegating architectural or quality decisions to opaque models. They tend to use AI as an “editorial assistant” that speeds up tasks they already master, while closely monitoring the coherence of generated solutions relative to the overall technical vision. This heterogeneity of attitudes creates new dynamics within teams: code reviews where seniors correct excessive dependency patterns in juniors, or hybrid human‑AI pair programming where one developer guides agent use while another oversees architectural impact.

In terms of specialization, adoption also varies. Backend profiles typically leverage AI to generate boilerplate, endpoints, database queries and standard business logic. Frontend developers use it intensively for rapid layout, component generation, complex CSS styling adjustments and framework migrations. Data and MLOps engineers apply it to building pipelines, job orchestration and query optimization, while security specialists use it for initial code audits and incident response playbook generation.

In this context, a skills table emerges illustrating the transition from 2018 to 2025:

Table 2. Evolution of developer skills between 2018–2020 and 2025 [2].

In addition, new hybrid roles have emerged such as the “AI productivity engineer” or the “AI tooling integration specialist,” responsible for selecting models, configuring usage policies, designing assisted workflows and measuring productivity impact [2]. These professionals act as a bridge between platform teams, product teams and compliance areas.

Regional variations in adoption

AI adoption in software development also shows significant regional differences. In the United States, investment in AI is very high: institutions and companies produced around 40 noteworthy models in 2024 and private AI investment reached 109.1 billion dollars [1]. However, the AI deployment rate in companies is only 33%, suggesting a mismatch between research capabilities and practical adoption. Many organizations take a cautious stance, limiting use to pilots or non‑critical areas due to concerns about data privacy and regulatory compliance.

In Europe, the region accounts for approximately 12% of global AI investment, fueling concerns about competitiveness vis‑à‑vis the United States and Asia [1]. Institutions such as the European Investment Bank advocate more robust support policies, while the EU AI Act introduces transparency, risk assessment and governance requirements that directly affect AI‑driven development tools. As a result, European teams tend to experiment with self‑hosted models or solutions with strong privacy guarantees, which in some cases slows the adoption of public cloud services.

In Latin America, the situation is different. The region accounts for about 14% of global visits to AI solutions, exceeding its share of internet users, indicating intense interest [1]. Countries such as Chile, Brazil and Uruguay stand out as pioneers in national AI strategies, while Colombia, Ecuador, Costa Rica and the Dominican Republic are closing the gap thanks to improvements in connectivity and talent. For development teams in these countries, AI tools represent an opportunity to offset resource constraints, increase productivity and position themselves in global value chains, although infrastructure challenges and access to cutting‑edge platforms persist.

India shows the highest enterprise AI deployment rate in the world, around 59% [1]. Indian companies stand out for their agility in rapidly adopting AI platforms and orienting them toward solving practical problems (logistics efficiency, financial inclusion, process automation). In the software domain, this translates into rapid incorporation of agents in BPOs, offshore development centers and startups, with an emphasis on measurable results and reducing operating costs.

Despite the differences, a common pattern across all regions is the gap between experimentation and effective integration. Many pilot projects fail to achieve measurable results due to difficulties in technological adaptation, lack of customization to specific contexts, integration problems with legacy systems, traceability shortcomings and regulatory compliance challenges [1]. This leads to a dual perception among developers: enthusiasm for the technical capabilities of the tools, but frustration with organizational obstacles to fully leveraging them.

Agent‑first platforms and paradigm shift: the Antigravity case

Google Antigravity exemplifies the shift toward agent‑centered platforms. Announced on November 18, 2025, it is designed as an AI‑powered integrated development environment whose priority is agent coordination rather than manual code editing [1]. Built as a fork of Visual Studio Code, it maintains compatibility with familiar extensions and workflows but incorporates a dedicated sidebar for agent interaction and an administrator view to orchestrate their work.

Antigravity’s architecture assumes that multiple specialized, configurable agents can work in parallel on different workspaces or branches. One agent can focus on refactoring services, another on generating additional tests, a third on reviewing security issues and a fourth on updating documentation. From the administrator view, a tech lead can launch tasks, monitor progress, pause execution, review proposed changes and approve merges. Asynchronous, distributed execution allows developers to focus on design, coordination with the business and resolving edge cases while agents handle low‑level tasks.

Antigravity also supports multiple models: Gemini 3 Pro as the main engine, but also third‑party models such as Claude Sonnet 4.5 and open variants of OpenAI models [1]. This responds to many organizations’ need to balance performance, cost, privacy requirements and vendor lock‑in. Highly regulated teams may prefer self‑hosted models for certain repositories, while others may leverage cutting‑edge commercial models for rapid prototyping.

The potential of agent‑first platforms is significant. Enterprise productivity studies indicate that intelligent automation of development tasks can quickly improve code quality and reduce cycle times by enabling real‑time error detection, bottleneck identification and continuous optimization of team workflows [1][2]. However, the industry is aware that large‑scale adoption of new technologies entails risks. Historically, between 50% and 70% of new digital products fail, underscoring the importance of carefully planning pilots, managing cultural change and establishing clear metrics before committing to broad deployment [1].

In Antigravity’s specific case, it is still too early to have a large body of documented success or failure stories [1]. Nonetheless, its launch crystallizes trends already underway: the vision of the developer as orchestrator of systems (human and artificial), the importance of interfaces to oversee autonomous work and the need for governance frameworks that define which tasks are appropriate to delegate and under what conditions.

Risks, governance and ethical challenges

The massive integration of AI in software development brings challenges that go beyond the purely technical. One of the most cited is the risk of algorithmic bias. Models suggesting code are trained on large corpora of repositories, documentation and technical content that reflect structural inequalities: from the under‑representation of certain languages and communities to design patterns that prioritize majority scenarios and neglect accessibility or inclusion cases. Without critical review, teams can inadvertently incorporate discriminatory practices, exclusion patterns or specific cultural assumptions.

To mitigate this phenomenon, data audits, periodic evaluation of model outputs and the inclusion of ethics and social science experts in technical processes are recommended [1]. This entails shifting from a purely functional view of the tool (“does it generate code that compiles?”) to a socio‑technical view (“what implications do the patterns it proposes have?”). Moreover, diversity within development teams themselves—in terms of gender, origin, discipline—helps detect biases that might go unnoticed in homogeneous groups.

A second challenge is the opacity of many models, often described as “black boxes.” In contexts where traceability and explainability are regulatory requirements—such as finance or healthcare—the inability to explain why AI suggested a particular implementation can lead to rejection. In response, interpretability techniques, interfaces that show relevant training examples or compare alternative solutions, and standard documentation frameworks for AI systems are being developed.

Data protection and privacy are another critical front. AI applied to code often requires access to private repositories, configuration information and test data that may contain sensitive information. If handling of this data does not respect anonymization, encryption and granular access control principles, it opens risk vectors for information leakage or regulatory non‑compliance [1]. For this reason, many organizations opt for hybrid architectures in which the model runs on controlled infrastructure, or for solutions that strictly limit logging and context retention.

In cybersecurity specifically, concern is twofold. On the one hand, AI is a powerful tool for detecting anomalies, generating patches and responding to incidents. On the other, excessive reliance on generative tools can create a false sense of security. A Sophos study indicates that 89% of companies using generative AI in cybersecurity fear failures that compromise their security, and 87% worry about possible overreliance and blurred responsibilities [1]. The lesson is clear: AI should complement, not replace, human expertise and well‑designed security processes.

To address these challenges, AI‑specific governance frameworks are emerging. The “hourglass” model proposed by Mäntymäki et al. offers a way to translate high‑level ethical principles into concrete organizational practices, connecting regulations such as the EU AI Act with internal procedures, developer guidelines and evaluation metrics [1]. Global governance initiatives such as the United Nations’ Global Digital Compact, in turn, seek to establish shared principles to ensure an open, free and secure digital future, in which AI development and use aligns with human rights and sustainability [1].

In day‑to‑day software teams, these frameworks translate into policies such as:

• Defining which repositories can be accessed by which types of models.
• Establishing logs and audit trails of AI contributions for traceability.
• Requiring mandatory human reviews for agent‑generated changes, especially in critical environments.
• Documenting in readmes and internal manuals which tasks are recommended or prohibited to delegate to AI.

Impact on productivity, quality and engineering practices

Available data indicates that most developers perceive tangible improvements: over 80% report increased productivity, and 59% see improvements in code quality [2]. Sources of productivity include reduced time on repetitive tasks, rapid template generation, immediate explanation of legacy code and accelerated resolution of syntax or API questions. In terms of quality, test generation, early vulnerability detection and code style standardization help reduce defects.

However, actual productivity at an organizational level does not always grow at the same pace as perceived productivity. Several reasons explain this:

• Part of the time saved on coding is invested in reviewing AI suggestions, adjusting prompts or fixing subtle errors.
• Review cycles can lengthen when agents generate extensive changes that require meticulous inspection.
• The ease of generating code can encourage rapid creation of features without sufficient architectural reflection, increasing medium‑term technical debt.

In response, engineering practices are evolving. Mature teams incorporate specific metrics to evaluate AI’s impact: average cycle time before and after adoption, defect ratio in code generated with and without AI, test coverage levels achieved via agents, etc. They also adjust agile processes to integrate agent work as “virtual team members,” with assigned tickets, specific acceptance criteria and their own reviews.

Technical debt takes on a new dimension. The ability to generate functional solutions almost instantly can mask deep design problems: unwanted couplings, lack of modularity, subtle duplication. The role of the software architect becomes more important, responsible for setting guardrails and accepted patterns that AI should respect, as well as defining which kinds of refactorings are allowed and which require conscious redesign.

Plausible scenarios 2026–2030

Looking ahead to 2026–2030, AI is expected to continue transforming software development, with several plausible scenarios:

1. Consolidation of specialized agents.
   We will likely see ecosystems of highly specialized agents (security, performance, accessibility, localization) collaborating within the same environment. The developer will act as coordinator of a “mixed team” where humans and agents are assigned tasks according to their competencies.

2. Standardization of governance practices.
   As regulatory frameworks mature and experience accumulates, de facto standards will emerge for responsible AI use in development: labels indicating which parts of the code were generated by AI, common formats for logs and evidence, certifications for tools that meet certain transparency and privacy requirements.

3. Reconfiguration of the professional profile.
   Demand for purely syntactic skills will decline, while the value of the ability to model problems, design robust systems, communicate requirements and supervise