TLDR: Agentic AI represents the second major transformation in software engineering in five decades, moving beyond simple code generation to autonomous decision-making across various software tasks. The core challenge is deciphering developer intent, which is addressed by approaches like AutoCodeRover that use program analysis. This shift necessitates a focus on “programming with trust” and the development of AI-based verification and validation for the increasing volume of AI-generated code.
The world of software engineering is undergoing its second major transformation in five decades, driven by the emergence of agentic AI. This shift, as highlighted in a recent research paper by Abhik Roychoudhury, moves beyond simple code generation to envision AI agents as integral members of development teams, capable of autonomous decision-making across various software tasks. You can read the full paper here: Agentic AI for Software: thoughts from Software Engineering community.
For many, the term AI in software brings to mind Large Language Models (LLMs) generating code from prompts. However, software engineering encompasses a much broader spectrum of activities, from code-level tasks like testing and program repair to design-level challenges such as architecture exploration and requirements understanding. Agentic AI aims to tackle these complex tasks by making micro-decisions autonomously, often aided by program analysis tools.
The Core Challenge: Deciphering Developer Intent
At the heart of successful, trustworthy agentic AI-based software workflows lies a fundamental difficulty: deciphering and clarifying developer intent. This process, known as specification inference, is crucial for many software tasks, including maintenance and program repair. The paper emphasizes that making conceptual progress in intent inference via agents is key to their successful deployment in software engineering.
Historically, the software industry has seen only two major shifts since the first “Hello World” program in the early 1970s. The first was the rise of Software-as-a-Service (SaaS) in the late nineties, transforming software delivery. Now, in 2025, we are experiencing the second major shift with agentic AI, which automates the engineering of software itself to a significant degree. This increased automation, while easing code writing, introduces a new central concern: programming with trust, rather than just programming at scale.
Beyond Co-pilot: Autonomous Agents and Intent Inference
Early AI automation, like GitHub Co-pilot, focused on providing code completions. Agentic AI, however, goes further by allowing agents to exercise autonomy and make informed decisions, much like a human software engineer. Recent developments have seen the emergence of LLM agents for software that can invoke external tools and work on program representations to conduct program analysis.
The challenge of automated issue resolution has spurred significant innovation. Open datasets like SWE-bench have encouraged the development of agents such as Devin, SWE-agent, and OpenHands. These approaches empower agents with tool capabilities like shells, web browsers, and access to online communities, mimicking a human developer’s toolkit.
However, the paper argues that simply invoking external tools is not enough. Human software engineers also understand and reason about code semantics, performing implicit intent inference to grasp the intended behavior of software. Learning from past lessons in automated program repair, where generalizing tests to infer intent helped combat overfitting, the paper advocates for agentic AI approaches that work on program representations and employ program analysis for explicit intent inference.
AutoCodeRover, an agent discussed in the paper, embodies this approach. It extracts specifications of intended behavior from program structure via code search, starting from elements mentioned in an issue and progressively refining its understanding. A follow-up, SpecRover, makes this intent inference even more explicit. The benefit of agents working on program representations is their ability to infer intended program behavior, which enhances trust and allows for explanations of the agent’s actions. AutoCodeRover’s integration into SonarQube, a widely used static analysis tool, demonstrates its promise in providing production-grade support for critical code.
Also Read:
- Navigating the Landscape of Automated Code Review: A Comprehensive Analysis
- AI-Driven Automation Transforms Software Testing Efficiency
Trust and Verification of AI-Generated Code
As automation in software development grows, so will the volume of AI-generated code. This explosion necessitates robust verification and validation (V&V) processes. The paper highlights a potential “trust deficit” in AI-generated code, noting that even trustworthy agents can create new trust issues when their code is integrated with existing codebases. Looking ahead, agentic AI itself could be used to combat this deficit, clarifying requirements, understanding implementations, and even flagging and fixing policy violations. Future directions also include using agentic AI for formal verification of code, where agents could interpret formal proof representations and interact with theorem provers.
