The first wave of AI in software development was copilots — IDE-level autocomplete that completed lines, then functions, then routine files. Useful, incremental, easy to evaluate. The second wave is agentic SDLC, where AI agents participate as first-class contributors across the software lifecycle — taking on entire tickets, opening pull requests, running tests, and shipping the work to review. The difference is not just velocity. It is a re-shaping of what each role in the team does.
Below is what we are seeing change in production engineering teams that have adopted agentic SDLC seriously — and what is not changing as much as the marketing might suggest.
What agentic SDLC actually looks like
An agentic SDLC tool — Cursor, Claude Code, Cline, Continue, Aider, Devin, Replit Agent, Goose — works on a real codebase rather than completing single lines. The defining behaviour: it reads the existing code, proposes a plan, edits multiple files, runs tests, fixes its own mistakes, and pushes a branch ready for human review.
The unit of work shifts from “suggestion at the cursor” to “ticket completed to PR.” A senior developer’s day starts to involve queueing 2–3 tickets to an agent in the morning, reviewing PRs at lunch, and spending the afternoon on the hard problems agents cannot yet handle.
What changes — for real
Requirements get written better
Ambiguous tickets that a human engineer would mentally interpolate produce confidently-wrong PRs from an agent. Teams that adopt agentic SDLC quickly tighten their ticket discipline: clear acceptance criteria, explicit constraints, named files to touch, named files to leave alone. Engineering managers report this is the single biggest second-order win — the team starts writing better tickets because the tickets now get used by both humans and agents.
Test discipline improves
Agents iterate against tests. A codebase with sparse tests gives an agent nothing to verify against; it produces plausible code that breaks production. Teams adopting agentic SDLC seriously raise test coverage thresholds and shift from “tests are a chore” to “tests are the contract the agent is held to.”
Code review becomes the bottleneck
When PR throughput goes up 3–5× because agents are doing the work, the review pipeline does not auto-scale. Teams quickly discover that their reviewers are now the constraint. The teams that handle this well change review behaviour: more reliance on automated checks, smaller agent PRs scoped to single concerns, paired-review for the trickier ones.
The skill of writing prompts and plans becomes a real engineering skill
Telling an agent what to do well is non-trivial. The best practitioners we work with treat prompts as artefacts: versioned, reviewed, attached to the ticket. A well-written agent prompt looks like a tight technical design doc with explicit constraints and gotchas. A poorly-written one produces a series of failed PRs.
Junior workload shifts upward
The work that used to fill a junior engineer’s sprint — boilerplate CRUD, basic refactors, repetitive cross-file changes — is exactly the work agents do well. Two consequences:
- Junior engineers need to learn to direct agents quickly — the new core skill.
- The work that defines “junior” vs “senior” shifts. Architecture, judgement, system thinking, and the ability to evaluate generated work all move up the priority list.
Debugging changes shape
When an agent writes the code, the engineer reviewing it does not have the same mental model of why a line is there. Debugging shifts toward reverse-engineering the agent’s logic — sometimes by reading the agent’s execution trace, sometimes by reading the PR’s commit messages, sometimes by re-prompting the agent to explain what it did and why.
What does not change
Architecture is still mostly human
Agents are excellent at executing within an architecture. They are unreliable at choosing one. Decisions about service boundaries, data models, consistency guarantees, and operational tradeoffs still get made by senior engineers — and we expect this to remain true for years.
Production debugging under pressure
When prod is down, agents help with the surface-level investigation but the diagnostic work still requires engineers who understand the system deeply. Agentic systems are not yet trusted to operate under real-time production constraints with consequences.
The hardest 10% of work
Novel algorithms, performance optimisation at the limits, cross-team coordination, security-critical code. Agents help; they do not replace. Senior engineering capacity is still the rate-limiter on these categories.
Operating model changes
Teams that go beyond “one engineer plus a copilot” into team-level agentic SDLC adopt three patterns:
- An agent queue. Tickets get tagged for agent execution, picked up by an agent, and arrive in the PR queue. A rotating “agent steward” engineer handles triage and re-queues failed attempts.
- Specialised agent personas. Different agents for different domains — one tuned for the frontend, one for the API layer, one for tests — each with a curated prompt and tooling configuration.
- Guardrail policies. Agents have restricted toolsets, allowed file paths, required approvers, and automatic CI gates that must pass before review. This is AgentOps applied to engineering.
Productivity numbers
Honest 2026 productivity numbers across the teams we work with:
- 15–30% time savings for routine ticket execution across a typical sprint. Higher in test-rich codebases, lower in legacy ones.
- 30–60% throughput increase for well-scoped feature work where requirements are clear.
- ~0% time savings on architecture, debugging, novel work — and a real risk of negative productivity if agents are forced onto unsuitable work.
- 20–40% increase in code-review load — the work moves rather than disappearing.
Risks worth managing
- Code quality erosion. Agents will pattern-match an existing style — if the codebase has anti-patterns, the agent will spread them.
- Security regressions. Generated code can introduce plausible-looking but unsafe constructs. Static analysis and SAST gates become non-negotiable.
- Knowledge atrophy. Engineers who never write certain categories of code may stop being able to. Counter with deliberate rotation between agent-assisted and manual work.
- Licensing exposure. Verify that your agent does not paste licensed code from training data into your repo. Provider guarantees vary.
Agentic SDLC is real, durable, and changing engineering work in 2026. The teams winning with it are not the teams using the most agents; they are the teams that have adapted their ticket discipline, review process, test coverage, and operating model around agents as first-class participants. The technology is the easy part. The operating model is where the value gets captured.