AVANYSYS

Research · Agentic Engineering

The AI Development Life Cycle: A Spec-Driven Loop for Shipping Production AI

Why most AI projects fail quietly between the notebook and production — and the seven-stage, spec-driven loop we use to close that gap.

Avanysys Research TeamPublished 9 min read
See the ADLC in a client engagement →

In our engagements, we keep seeing the same failure shape: a model performs well in the notebook, clears a demo, and then quietly drifts from what the business actually needed somewhere between training and production. Nobody shipped a bug, exactly — the model does what it was trained to do. It just was never told, in a form that survived the handoff, what it was actually supposed to do for the business.

That gap is not a model-quality problem. It's a specification problem, and it behaves like every other specification problem we've seen in software: it's invisible until the system is live, expensive to trace back to its source, and completely preventable if something holds the requirement in place from the start. The AI Development Life Cycle (ADLC) is the loop we use to hold it in place — seven stages, each one reading from and writing back to a single Specification Document (SDD), so that nothing ships that document doesn't account for.

Why conventional AI delivery drifts

Most AI delivery we've inherited from clients runs two tracks that don't talk to each other. One track is software delivery: tickets, code review, CI/CD, the usual discipline. The other is model development: a notebook, a dataset somebody pulled together, and a metric that got optimized until it looked good. The two tracks merge only at deployment — by which point the model's actual behavior and the business's actual requirement have had months to drift apart, with no shared document either side was checking against.

This isn't a tooling gap. MLOps platforms solve versioning, reproducibility, and deployment mechanics well. What they don't solve is the upstream question: who wrote down what the system was for, and did every later decision get checked against it? Without an answer, "the model works" and "the model does what the business needs" quietly become two different claims, and only one of them gets tested.

What "spec-driven" means here

The discipline that closes this gap is the same one spec-driven development (SDD) brings to software: write down what the system must do and must never do — user needs, business constraints, non-functional requirements like latency or compliance — as a real document before implementation starts, and treat that document as the thing every later stage is judged against, not a slide deck nobody revisits.

The distinction that matters is timing and authority. A requirements doc written up after the model is built is documentation. A specification written before, and treated as the gate every stage has to clear, is a constraint. The seven ADLC stages below are what it looks like to apply that constraint across an entire AI delivery lifecycle rather than just the model-training step.

The seven stages

1. Define & plan. The SDD gets written first: what the system has to do, what it must never do, and the non-functional requirements — latency budgets, compliance obligations, failure behavior — that tend to get treated as someone else's problem later. If a requirement isn't in the SDD, it doesn't ship, no matter how reasonable it sounds in a later meeting. This stage is where most of the "but we assumed..." failures we see would have been caught, had anyone written the assumption down.

2. Specify the data before touching it. Before a line of model code exists, the data itself gets specified: quality thresholds, formats, expected volume, provenance, required transformations. Most of the data problems we inherit from clients trace back to skipping this step and specifying the model before specifying the data it depends on — by the time the model exists, the data's actual shape has already been locked in by whoever happened to pull it first.

3. Implement & validate data. The pipeline gets built against the spec from stage two, then verified against it — not eyeballed for plausibility. Nothing moves to modeling until it passes a real check against the document. This is the stage that turns "the data looks fine" from an opinion into a pass/fail result.

4. Model implementation & verification. Only now does training happen. The model is verified against the KPIs defined back in stage one, not against whatever the model happens to produce. A model that performs well on its own terms but misses the spec's KPIs isn't finished — it's a model that needs more work, even if the loss curve looks great.

5. Deploy & validate integration. Deployment runs through the same CI/CD discipline as any other production software, and then the integration itself — not just the model — gets validated against the original specification. In our experience, production AI fails from integration gaps (a schema that changed upstream, a latency budget the serving layer didn't actually meet) as often as it fails from model quality.

6. Monitor & measure compliance. Once live, production performance gets measured against the specification that was written in stage one — not against generic uptime or latency dashboards borrowed from an unrelated project. The question in production is the same one the team started with: is the system still doing what the SDD says it should?

7. Analyze, review & refine specs. Production metrics, real user feedback, and the edge cases nobody predicted get reviewed, and what's learned feeds back into the specification itself — not into a backlog nobody prioritizes. New requirements get written down, models get retrained where the spec demands it, and the SDD gets revised. Then the loop runs again, from a better starting point than it started from last time.

Why the loop, not just the document

A specification that nobody checks anything against degrades into the same shelfware a requirements doc becomes. The reason ADLC is a loop rather than a one-time gate is stage seven: production reality always surfaces requirements nobody thought to write down in stage one, and a system with no mechanism for feeding that back into the spec will just drift again, the same way it drifted before anyone introduced a spec at all.

This is the same lesson software engineering already learned from code review and incident postmortems — a static process document doesn't prevent drift; a closed feedback loop does. ADLC is that lesson applied to the part of AI delivery that conventional MLOps tooling doesn't cover: the requirement itself, and whether the system still matches it six months after launch.

Where this connects

The data half of this loop — stage two and three's data specification and validation — is exactly the governed pipeline we cover in Lakehouse Architecture Patterns for AI-Ready Data Platforms: a spec for the model is only as reliable as the data contract underneath it. The two are meant to be read together, not as separate concerns that happen to both involve AI.

Changelog

  • Initial publication.

Want this run on your own AI roadmap?

We'll walk your team through the ADLC loop against a real project, not a hypothetical one.