Most teams adopting AI coding tools bolt them onto a process built for humans. They keep the old life cycle and expect the agent to behave like a faster junior developer. It does not. An agent will generate ten files in the time a junior writes one function, and it will get the wrong abstraction wrong ten times as fast.
The fix is not a better prompt. It is a different life cycle.
I call it AIDLC, the AI Development Life Cycle. It is the method I run on every engagement, and it assumes from the first phase that agents do the heavy lifting while senior engineering and evals hold the boundary.
Why the SDLC breaks under agents
The traditional SDLC puts its weight on design and implementation because that is where humans spend their time. Agents shift the bottleneck. Implementation gets cheap. Specification and verification get expensive, because a vague spec now produces a thousand lines of confidently wrong code, and a missing test now lets a behavioural regression ship in minutes instead of weeks.
So AIDLC front-loads the two things that make agents effective. A precise, executable spec. An eval harness wired in before any feature code exists. Then it puts extra weight on the back end, because an autonomous system needs the observability a human team would otherwise carry in their heads.
The eight phases
The method runs as eight phases. On a first build they run in sequence. In production they run as a loop.
- Frame pins down the problem, the user, and the single metric that proves the system earns its keep.
- Spec turns the frame into something both a human and a coding agent can act on without guessing.
- Scaffold stands up the conventions and the eval harness first, so the structure enforces the rules.
- Generate is where agents write the bulk of the code against the spec, supervised by senior review on every diff.
- Eval guards behaviour with golden datasets and LLM-as-judge suites that run on every change.
- Harden closes the gaps that only appear under load — injection defenses, redaction, audit logs, private deployment.
- Ship releases behind a flag with costs and traces on a dashboard from day one.
- Operate keeps the system improving, with evals on every change and the metric always in view.
Each phase has one job and one set of outputs. No phase ships without the one before it. The full breakdown, with the outputs each phase produces, lives on the AIDLC method page.
The principles underneath
Eight phases are scaffolding. What actually keeps agentic speed from turning into agentic chaos is a short set of principles that run underneath all of them.
Specs are the source of truth, because an agent is only as good as what you point it at. Evals are the gate, because velocity without a safety net is just faster regressions. A senior engineer is accountable on every diff, because the boundary is defined by people and enforced by the harness, never left to the model to police. And observability is not optional, because if you cannot watch it, it does not ship.
If you want to see how this maps to real Claude Code work, the Claude Code Toolkit lists the skills and agents I run inside these phases, and the deep-dive posts behind each phase are linked from the method page.
The takeaway is simple. Agents did not make the software life cycle obsolete. They made the old one the wrong shape. AIDLC is the right one.