GenAI is already reshaping software development — but not primarily through chatbots or code autocomplete. The most consequential shift is the emergence of agentic software development (ASD): a new way of building software in which AI systems do real development work, not just assist humans. ASD deserves to be treated as a distinct category, with its own practices, tools, and implications for the software development workforce.
What Is Agentic Software Development?
Agentic software development is the use of AI agents (aka TuringBots) that can plan, generate, modify, test, and explain software artifacts across multiple stages of the SDLC — working alongside human developers with a degree of autonomy. Three aspects matter:
Agency, more than assistance. ASD systems can take on tasks, decompose them, execute steps, and iterate — often asynchronously — rather than merely responding to prompts.
SDLC breadth, not just coding. Code generation is central, but ASD also spans design artifacts, documentation, refactoring, unit testing, review, and engages delivery workflows.
Professional developers as the target. The tools for ASD are built for software engineers working in complex codebases — not for low‑code pro-devs or citizen‑developer scenarios.
In short, agentic software development is about delegating meaningful development work to AI agents, while keeping humans accountable for intent, review, and outcomes. As a result, developers are already using agents to explore and understand large codebases, implement features from natural language intent, refactor and modernize legacy systems, generate and maintain documentation, create and review pull requests, diagnose bugs, and explain failures. But the real disruption goes beyond making these tasks more productive. ASD changes how development work is organized. As I described in my report AI Is Evolving The Development Workforce In Dramatic Ways, agentic AI forces teams to rethink roles, workflows, and expectations. Questions that used to be implicit now become explicit:
What work should be delegated to agents vs. done by humans?
How much autonomy is appropriate, and where are guardrails required?
How is architectural intent captured so agents can reuse it?
Where does human judgment add the most value?
These are operating‑model questions, not just tooling details.
Evaluating The Emerging Landscape Of Agentic Software Development Tools
We’ll be soon reaching out to ASDT tool vendors to kick off a Forrester vendor Landscape 2026 on ASDT. A Forrester Wave™ evaluation(s) will follow in the second half of the year. Although this is a fast moving market, and everyone is challenged by how quickly ASD tools evolve, a few clear patterns are emerging. ASDTs started by offering autocompletion, they now generate large portions of code and the credible ones go well beyond code generation, although that is a core capability they must have. They share some additional common capabilities as well as some differentiated ones, including:
Code generation and modification across multiple files.
Understanding large codebases, not just the current file.
Refactoring and modernization with intent preservation.
Documentation generation and maintenance.
Chat-based interaction grounded in real project context.
Integration with developer workflows (IDEs, CLIs, Git, CI/CD).
Human-in-the-loop review through diffs, pull requests, and logs.
Some tools focus on the IDE experience. Others operate asynchronously via repositories and pipelines. Some emphasize autonomy; others emphasize control and governance. But just as important is what falls outside the ASD definition. I will not be evaluating the following in this Forrester Wave™:
Low-code or no-code app builders.
AI development tools for citizen developers, such as Lovable.
Pure copilots limited to autocomplete.
DevOps automation tools that don’t generate or modify application code.
ASD is about building and evolving software through code, not abstracting code away. To be clear, ASD tools are targeted to professional high coders and software engineers.
The ASDT Call To Action
I am expecting this research to help consolidate the definition and understanding of the ASDT and capture eventual evolutions coming soon, in the following weeks and months.
I am expecting this research to help refine our definition and understanding of tools and capture eventual evolutions. If you believe you have an agentic software development tool that targets professional software engineers, generates and modifies code, operates across multiple SDLC stages, and goes beyond prompt response interaction, I want to hear from you. The criteria is evolving, and the landscape is still being shaped.
To engineers, if you have strong opinions — positive or negative — about the ASDTs you’ve used, your perspective matters. What builds your trust in the tools? What breaks it? Where do agents genuinely help, and where do they fail?
Agentic software development will not be defined by marketing claims and future state alone. It will be defined by practice.
Forrester clients can schedule inquiries and guidance sessions with me for help understanding ASDTs and evaluating vendors. ASDT vendors who believe they fit this market definition should request a briefing and email me at [email protected]. Engineers and others who want to share feedback can email me directly.
