In less than two years, AI in software engineering has moved from autocomplete to agents that read a repository, plan a change, edit dozens of files, run the test suite and open a pull request on their own. Almost every engineering team now uses some form of AI assistance, yet many leaders see a confusing picture: individual developers report big productivity gains while delivery metrics barely move, review queues grow and incidents creep up. The problem is rarely the model. It is that a software development lifecycle (SDLC) designed around human typing speed is now being fed by machines that write code far faster than humans can verify it. This article explains what is actually changing, what the best research says, and how to rebuild your delivery process so agentic coding produces reliable software rather than faster technical debt.
From Assistants to Agents: What Changed in 2025–2026
The first generation of AI coding tools worked inside the editor and suggested the next few lines. The current generation works at the level of tasks. A developer, or increasingly a ticket, describes an outcome such as “add pagination to the orders API and update the client,” and an agent decomposes the work, searches the codebase, makes coordinated edits, runs builds and tests in a sandbox, iterates on failures and proposes a reviewed change. Some teams run several agents in parallel on separate branches, with one agent reviewing another’s work before a human sees it.
Anthropic’s 2026 agentic coding trends research captures the gap between usage and trust well: developers in its studies use AI in roughly 60% of their work but say they can fully delegate only a small fraction of tasks. That gap is the defining management problem of this period. Agents are good enough to produce large volumes of plausible code and not yet good enough to be left alone on anything that matters. The organizations getting value are the ones that redesign the surrounding workflow to close that gap, not the ones that simply buy more seats.
Three shifts matter most for engineering leaders:
- The unit of work changes. Instead of lines or functions, agents deliver whole changes. Specifications, acceptance criteria and test oracles become the real input to development.
- The bottleneck moves downstream. Code generation is no longer scarce. Review, integration testing, security analysis and release management become the constraint.
- Agents become actors in your systems. An agent with repository write access, CI credentials and the ability to call tools is a new kind of identity that needs permissions, audit trails and guardrails like any service account.
What the Evidence Says: AI Is an Amplifier
The most rigorous public data comes from Google Cloud’s DORA program. Its 2025 State of AI-assisted Software Development report, based on a survey of nearly 5,000 technology professionals, found that 90% of respondents use AI at work and more than 80% believe it has improved their productivity. For the first time, DORA also found AI adoption associated with higher software delivery throughput. But the same research continued to associate AI adoption with higher delivery instability, meaning more change failures and rework. Trust remains limited: about 30% of respondents reported little or no trust in AI-generated code.
DORA’s central conclusion is that AI acts as a mirror and a multiplier. In cohesive organizations with solid engineering foundations, it amplifies strengths. In fragmented ones, it magnifies existing dysfunction. To make this actionable, DORA published an AI Capabilities Model listing seven capabilities that determine whether AI helps or hurts performance:
- A clear and communicated AI stance, so teams know what is allowed, expected and off-limits.
- Healthy data ecosystems with high-quality, accessible data.
- AI-accessible internal data, connecting tools to internal documentation, code and conventions (what DORA calls context engineering).
- Strong version control practices, including frequent commits and reliable rollback.
- Working in small batches, so AI-generated changes remain reviewable and testable.
- A user-centric focus, because AI accelerates whatever direction a team is already heading.
- Quality internal platforms that provide automated, secure paths to production.
Notice that only one of these items is about AI tools directly. The rest are classic engineering disciplines. This is the most important strategic insight for 2026: the return on agentic coding is determined by the quality of your delivery system, not by which model you choose.
Redesigning Each Stage of the Lifecycle
Agentic coding touches every phase of the SDLC. The practical question is how each stage must change when a significant share of code is machine-written.
Requirements and Specification
Agents perform best with precise, testable intent. Vague tickets that a senior engineer could interpret from context produce confident but wrong implementations. Teams adopting agents successfully are moving toward lightweight specification: a short problem statement, explicit acceptance criteria, constraints such as performance budgets or backward compatibility, and examples of expected inputs and outputs. Spec-driven development, where a structured specification is reviewed before any code is generated, has become a popular pattern precisely because it shifts human judgment to the cheapest point in the lifecycle.
Design and Architecture
Agents tend to solve the problem in front of them, sometimes by introducing a new library, duplicating an abstraction or bypassing a layer. Architecture guardrails therefore need to be explicit and machine-readable. Keep architecture decision records, module boundaries and approved dependency lists in the repository, and reference them in the instructions or context files your agents read. Static checks for forbidden imports and dependency rules catch drift automatically.
Implementation
Implementation becomes a loop of delegation, inspection and correction. The developer’s role shifts toward breaking work into agent-sized tasks, supplying context and making judgment calls. Small batches matter more than ever: an agent can produce a 3,000-line change in minutes, but no reviewer can meaningfully evaluate it. Set explicit limits on change size per pull request and ask agents to split work into a sequence of reviewable commits.
Code Review
Review is now the critical control point. Two patterns are emerging. First, AI-assisted review, in which a separate agent or tool checks every change for defects, security issues and convention violations before a human looks at it. Second, risk-tiered human review, where changes touching authentication, payments, data deletion or infrastructure always require a senior reviewer, while low-risk changes such as documentation or test additions can follow a lighter path. Reviewers should evaluate intent and design, not just syntax; the question is whether this is the right change, not only whether it compiles.
Testing and Verification
Because agents can generate tests as easily as code, test volume is no longer a useful signal. A model that writes both the implementation and its tests can encode the same misunderstanding twice. Strengthen independent verification: contract tests owned by consuming teams, property-based tests for core logic, mutation testing to check whether tests actually detect faults, and production-like integration environments. Track change failure rate and rework rate alongside throughput so speed gains do not hide quality losses.
Release and Operations
Progressive delivery practices such as feature flags, canary releases and automated rollback are the safety net that makes high change volume tolerable. If a team cannot roll back a change in minutes, it should not increase the rate at which agents produce changes. Observability must also attribute changes: you want to know which deployments, and which agent-assisted pull requests, preceded an incident.
Security and Governance for Agents That Act
An agent that only suggests code is a quality concern. An agent that executes commands, installs packages, calls APIs and pushes to branches is a security principal. In December 2025 the OWASP GenAI Security Project published the OWASP Top 10 for Agentic Applications for 2026, a peer-reviewed list of the most critical risks for autonomous AI systems. Several categories map directly onto coding agents, including agent goal hijack, tool misuse and exploitation, identity and privilege abuse, agentic supply chain vulnerabilities, unexpected code execution and memory and context poisoning.
In practice, these risks show up in concrete ways. A malicious instruction hidden in an issue description, a README or a dependency’s documentation can redirect an agent. A hallucinated package name can be squatted by an attacker. An agent with broad cloud credentials can make destructive changes while trying to fix a failing deployment. A practical baseline looks like this:
- Run agents in isolated, ephemeral sandboxes with no production credentials and restricted network egress.
- Give each agent its own identity with least-privilege, short-lived tokens; never reuse a developer’s personal credentials.
- Require human approval for destructive operations, infrastructure changes and anything that touches secrets.
- Pin and verify dependencies, block unknown registries and scan every agent-introduced package.
- Treat all external content an agent reads, including tickets, web pages and third-party docs, as untrusted input.
- Log every tool call and file change so actions are attributable and auditable.
Governance also covers intellectual property and data. Decide which repositories may be exposed to which tools, whether code may leave your tenancy, and how generated code is licensed and attributed. Publish this as a short, clear AI usage policy; DORA’s research suggests that a clear stance accelerates adoption rather than slowing it, because developers stop guessing.
Agentic coding does not remove the need for engineering discipline; it raises the price of not having it. Invest in small batches, independent verification and secure platforms first, and the agents will pay off.
A Practical Operating Model: Six Steps
For most organizations, a staged rollout works better than a big-bang license purchase. The following sequence reflects patterns that work well in mid-sized and large engineering organizations:
- Baseline your delivery metrics. Capture deployment frequency, lead time, change failure rate, recovery time and rework before broad rollout. Without a baseline you cannot tell whether agents help.
- Publish an AI stance. One or two pages covering approved tools, data boundaries, review requirements and accountability. The human who merges a change owns it, regardless of who or what wrote it.
- Engineer context. Add repository instruction files, architecture notes, coding conventions and runbooks that agents can read. Connect agents to internal documentation through governed interfaces rather than ad hoc copy-paste.
- Harden the pipeline. Enforce change-size limits, mandatory automated review, security scanning, dependency policies and progressive delivery before increasing agent autonomy.
- Start with bounded use cases. Test generation for legacy modules, dependency upgrades, documentation, and well-specified feature work in non-critical services are good first targets. Expand autonomy as metrics confirm stability.
- Review and adjust quarterly. Compare metrics to the baseline, examine incidents involving agent-authored changes and refine policies, tools and training.
Worked Example: A Mid-Sized Product Team
Consider a hypothetical product organization with six squads maintaining a customer portal, a set of microservices and a mobile app. After rolling out an AI coding agent to all developers, pull request volume rises sharply within a month. Lead time initially improves, but review queues lengthen, two regressions reach production and senior engineers complain that they spend their days reviewing large, loosely scoped changes.
The team responds in three moves. First, it introduces a change-size budget of about 400 changed lines per pull request, excluding generated files, and asks agents to split larger tasks. Second, it adds an automated review stage that flags missing tests, risky patterns and dependency changes, and routes changes that touch authentication or billing to designated reviewers. Third, it writes a lightweight specification template for any ticket that will be delegated to an agent, including acceptance criteria and a list of files that should not be modified.
Within a quarter, the profile changes. Throughput stays higher than before adoption, but the change failure rate returns to its baseline, and senior engineers spend less time on line-by-line review and more on design reviews of specifications. The lesson is not that the agent got smarter; the delivery system was adjusted so that its speed could be absorbed safely.
Skills, Roles and Team Design
Agentic development changes what good engineers do all day. Writing code by hand remains essential for learning and for the hardest problems, but more time goes into decomposition, specification, review and system thinking. Leaders should watch for two risks. The first is a hollowing out of junior development: if agents absorb all the routine tasks, new engineers lose the practice that builds judgment. Pair juniors with agents deliberately, ask them to explain and critique generated code, and rotate them through review duties. The second risk is reviewer burnout among senior staff. Make review capacity an explicit planning input and invest in automated review to filter noise.
New responsibilities are also appearing. Platform teams increasingly own the agent toolchain: sandboxes, context servers, policy enforcement and usage telemetry. Security teams need expertise in prompt injection and agent permissions. Product managers who write clear acceptance criteria become more valuable, because their specifications now feed machines as well as people.
Outlook: Where Agentic Development Is Heading
Over the next two years, expect three developments. Multi-agent workflows, with specialized agents for implementation, testing, security review and documentation, will become standard inside CI pipelines. Agentic coding will spread beyond engineering, as analysts and operations staff build internal tools with agents, which makes platform guardrails and governance even more important. And regulation and customer due diligence will increasingly ask how AI-generated code is controlled, especially in regulated sectors where software supply chain assurance is already scrutinized.
The organizations that benefit most will treat agents as a force multiplier for a well-run delivery system, not as a substitute for one. They will measure outcomes rather than adoption, keep humans accountable for what ships, and keep investing in the unglamorous foundations of version control, testing, platforms and security.
Conclusion
AI coding agents are real, capable and here to stay, but they change where the hard work in software delivery lies. Generation is cheap; verification, integration and governance are now the constraint. Leaders who rebuild the SDLC around that reality, with clear policies, engineered context, small batches, independent testing and secure agent identities, will turn agentic speed into durable business value. Those who simply add agents to an unchanged process will mostly get more code, more review fatigue and more incidents. Start with your delivery foundations, roll out in measured stages and let the metrics tell you when to grant more autonomy.
How Hanoi Technology Can Help
Hanoi Technology helps engineering teams adopt AI coding agents safely, from AI usage policies and secure sandboxes to CI guardrails and delivery metrics, through projects or dedicated teams.
Further Reading
- How are developers using AI? Inside our 2025 DORA report – Google
- AI Doesn’t Fix What’s Already Broken: What DORA’s New Model Tells Us – Techstrong.ai
- State of DevOps 2025: Review of the DORA Report – Splunk
- Eight trends defining how software gets built in 2026 – Anthropic
- OWASP Top 10 for Agentic Applications for 2026 – OWASP GenAI Security Project