Phase 13ADLC course

Phase 13. Maintenance: the agent closes the loop

Vitrina is alive in production, taking orders, surviving incidents. The course's last substantive phase isn't about maintenance in the sense of "patch bugs" — it's about how the product evolves: gathering signals, deciding what to do next, and launching the next round. And here the SDLC stops being a line and becomes a ring: the output of phase 13 is the input of phase 1.

Closing the loop is the most radical consequence of the whole course. As long as the cycle is linear, there's still a human somewhere at the start with the idea "let's build this." Close the feedback loop back to the input, and you get a product that initiates its own development on its own. The human stops being the cycle's engine.

The human role today

A product manager, a support engineer, an analyst: gathers feedback, watches usage metrics, prioritizes improvements, deals with technical debt, decides "what do we do next iteration." Classically this is ticket triage, product analytics, next-release planning.

Break it down. Gathering and clustering feedback is mechanical work with a stream. Product analytics is inference from data. Prioritizing improvements is optimization against criteria (the same as in phase 4). But one link is special: the decision to pivot, to change course, to admit that incremental improvements are heading nowhere. That's a judgment about strategy, not about the next ticket.

What we hand to the agent

The agent holds the evolution loop. It gathers production signals (metrics, incidents, support contacts) and marketing signals (conversion, churn, channel response), clusters them, synthesizes improvement hypotheses, prioritizes, and — critically — initiates the next round itself: it updates the opportunity-brief and refills the backlog. It doesn't wait for a human to show up with an idea; it generates the next iteration from accumulated signals.

The loop closes here. The hypothesis the agent proposes at this phase goes back to the input of phase 1 — and the entire pipeline (discovery → marketing → requirements → … → release) runs again, without an external push. The product becomes a self-sustaining process rather than a series of projects with a human deciding "let's continue" between them.

Agent architecture

Phase state-machine

Inputs

postmortems and fix requests (phase 12), product and marketing analytics, user support tickets, the source gtm-plan and prd.

The agent holds the role

Tools: feedback gathering and clustering; product analytics; prioritization; tech-debt detection; hypothesis generation; writing back into opportunity-brief and backlog.

Artifact

updated value hypotheses + a re-weighted backlog + a signal for a new round.

Handoff: back into Ideation (phase 1) and Planning (phase 7) — the loop is closed. The arrow "back to phase 1" is the most important one in the course. Before it, every handoff pointed forward, from phase to phase. This one feeds the system's output back into its own input and turns the pipeline into a ring. From this point on, ADLC has no "start" that a human has to supply — there's a continuously spinning cycle.

Inputs: postmortems and fix requests (phase 12), product and marketing analytics, user support tickets, the source gtm-plan and prd.
Tools: feedback gathering and clustering; product analytics; prioritization; tech-debt detection; hypothesis generation; writing back into opportunity-brief and backlog.
Artifact: updated value hypotheses + a re-weighted backlog + a signal for a new round.
Trigger: signal accumulation / schedule / a metric threshold.
Handoff: back into Ideation (phase 1) and Planning (phase 7) — the loop is closed.

The arrow "back to phase 1" is the most important one in the course. Before it, every handoff pointed forward, from phase to phase. This one feeds the system's output back into its own input and turns the pipeline into a ring. From this point on, ADLC has no "start" that a human has to supply — there's a continuously spinning cycle.

Where it breaks

Local optimum. The agent improves what's measurable, against criteria — and that reliably leads to increments. It'll keep sharpening the existing product, optimizing metrics, and will almost never propose on its own "all of this is a dead end, we need to pivot." A pivot is stepping outside the current optimization function, and by construction the agent optimizes inside it.

Silent churn and what isn't in the data. The agent sees the signals people left behind. Why the people who never filed a ticket or a review simply stopped showing up is often not in the data at all. Whole classes of truth about a product live outside telemetry, and the agent is blind to them.

Accountability for a strategic pivot. The decision to change the product's course is a bet of the same kind as the original bet in phase 1: someone answers for it with money and reputation. The agent can flag that the metrics have hit a ceiling, but authorization for a pivot is human.

What stays human

The pivot decision and strategic course change — pulling out of a local optimum when the loop is stuck. This is the course's most durable remainder alongside priority arbitration (phase 7): this is exactly where the human principal keeps a hand on direction. Everything else — gathering, analytics, prioritization, generating the next round — goes to the agent.

human remainder ≈ 13%

Provocation / thesis

Close the feedback loop back to the input, and you get a product that evolves on its own: conceiving, building, shipping, operating, and improving itself in a circle, with no human engine in the loop. The human role collapses from "the one who drives the product" to "the one who occasionally pulls the pivot lever" when the loop is stuck in a local optimum, sharpening a dead end. The SDLC stops being a sequence someone launches and becomes an autonomous ring that spins on its own. The human above it isn't an operator — it's insurance against the ring spinning the wrong way.

Running case

Vitrina in this phase

Vitrina's feedback agent sees in the data: stores reach the payment step and drop off there en masse — conversion to a paid order is below the gtm-plan hypothesis. Plus, from phase 12 a postmortem arrived about the fragility of the single payment provider. The agent synthesizes a hypothesis: buyers are missing a familiar local payment method, and one provider is a bottleneck. It updates Vitrina's opportunity-brief and opens the epic "local payment methods" — the very one that was deliberately cut to v2 back in phase 4.

And the ring closes: the epic goes to the input — into a new round of discovery (who to ask about payment habits), marketing (is it time to shift the positioning), requirements, and around again. Vitrina's second lap wasn't launched by a human with an idea — it was launched by the product itself, out of its own production signals.

The only thing left to the founder is what the agent, by construction, won't do. If the signals had shown not "fix payment" but "the entire local SMB segment isn't willing to pay for a storefront, we need to pivot into an adjacent market" — the feedback agent wouldn't pull that conclusion out of the local optimum: it optimizes inside the current bet, it doesn't cancel it. The pivot is the principal's lever. Artifact → an updated opportunity-brief + a new epic → back to phase 1.

In practice

How it actually works — engineering breakdowns

Standalone howto from practice, showing this phase on real code and a working artifact.

Git Log as a Dataset for Architectural Retro-AnalysisRetro-analysis of codebase evolution from git history.
Event-tracker Two Ways: The Durability TradeoffCollecting prod signals that close the feedback loop.

Building AI-driven delivery in-house?

Designing the ADLC loop: where the agent holds the role and where the human principal remains — for your team and product.

Email me

The transition engine

Next Move Engine — the system that takes a team to an autonomous delivery loop.

Next Move Engine →