Two years ago, "AI in software development" meant autocomplete. Today, AI coding agents plan multi-file changes, write and run tests, open pull requests, and triage production incidents. The software development lifecycle hasn't been abolished — every phase still exists — but the shape of the work inside each phase has changed dramatically. Here is a phase-by-phase walk through what's different, based on how our own delivery teams work every day.
Requirements: from documents to executable clarity
LLMs are exceptional at the grunt work of requirements: turning meeting transcripts into structured user stories, spotting contradictions between two documents, and generating the "what about this edge case?" questions a good analyst would ask. In our experience, a product manager working with an LLM produces a first-draft requirements document in hours instead of days — and it's more complete, because the model tirelessly enumerates edge cases humans skip.
The deeper shift: because AI agents will later implement from these documents, ambiguity is now immediately expensive. Requirements are drifting toward precise, testable specs — a topic we cover in depth in our piece on spec-driven development.
Design: faster options, same judgment
Architecture used to mean one senior engineer sketching one design and defending it. Now the same engineer can ask an LLM to generate three candidate architectures with trade-off analyses, poke holes in each, and pressure-test the favorite against failure scenarios — all in an afternoon. The model widens the option space; it does not pick the winner. Choosing between "boring and operable" and "elegant and risky" requires knowing your team, your traffic, and your budget — context the model doesn't have.
Implementation: the agent writes, the engineer directs
This is where the change is most visible. With tools like Claude Code, an engineer describes the change, the agent explores the codebase, plans the edit across files, writes the code, runs the tests, and iterates on failures. The engineer's job shifts from typing to directing: scoping tasks well, reviewing the plan before the diff, and catching the places where the agent's confident output diverges from the actual intent.
- Well-scoped tasks fly. A clearly bounded change with existing tests is often done in minutes.
- Vague tasks flail. "Make it better" produces plausible-looking churn. The bottleneck moved from writing code to specifying it.
- Codebase hygiene pays compound interest. Consistent patterns, good naming, and a working test suite make agents dramatically more effective.
Code review: two layers instead of one
AI review bots now catch the mechanical layer — style drift, obvious bugs, missing null checks, insecure patterns — before a human ever looks. That frees human review for what it was always supposed to be: does this change do the right thing, in the right place, in a way we can live with for five years? In our teams, human review of AI-written code focuses hard on interfaces, data flows, and failure modes, because that's where plausible-but-wrong code hides.
The rule we enforce: AI can write the code and AI can review the code, but a named human approves the merge. Accountability doesn't get delegated to a model.
Testing: coverage stops being expensive
Test writing was always the first thing cut under deadline pressure because it was slow and dull. Agents changed the economics: generating unit tests, property-based tests, and realistic fixtures is now nearly free. Legacy modules with zero coverage can be backfilled in days. The human contribution moves up a level — deciding what to test (the risk model) and reviewing whether generated tests assert meaningful behavior rather than merely locking in current bugs.
Deployment and operations: explanation on tap
CI/CD pipelines, infrastructure-as-code, and runbooks are text — which means LLMs are good at writing, reviewing, and explaining them. On the operations side, agents summarize incidents from logs and traces, draft post-mortems, and propose remediations. We still gate production changes behind human approval, but the time from "alert fired" to "we understand what happened" has collapsed.
Maintenance: the quiet revolution
Maintenance is arguably where AI delivers the most value, because it's dominated by comprehension: reading unfamiliar code to answer "what does this do and what breaks if I touch it?" An agent that has indexed the codebase answers in seconds what used to take a day of spelunking. Dependency upgrades, framework migrations, and dead-code cleanup — the chores that starve roadmaps — become tractable background work. This is the engine behind modern application modernization.
What stays stubbornly human
- Product judgment. Deciding what's worth building — and what to say no to — requires understanding users and business strategy.
- Architecture trade-offs. Models argue every side persuasively; someone has to own the bet.
- Accountability. When production breaks or a security review is signed, a person answers for it.
- Taste. Knowing when generated code is technically correct but strategically wrong for this codebase.
How we run AI-assisted delivery at Dillo
Every Dillo engineer — whether embedded in your team through staff augmentation or on a managed outsourced project — works AI-assisted by default: agentic coding tools for implementation, AI review as the first pass, generated tests held to human-defined standards. The result, in our experience, is small senior teams shipping what used to require teams twice the size, with quality gates that are stricter, not looser. You can see the pattern in our case studies.
Key takeaways
- Every SDLC phase survives, but the human role in each shifts from producing artifacts to directing and judging them.
- The bottleneck has moved from writing code to specifying it — precise requirements and specs are the new leverage point.
- Testing and maintenance see the biggest economic change: coverage and comprehension are now cheap.
- Product judgment, architecture trade-offs, and accountability remain human — a named person approves every merge.
- Small senior teams with strong AI tooling outperform large teams without it.
Want a delivery team that already works this way? Talk to us — we'll show you what AI-assisted delivery looks like on a real backlog.