Phase 14ADLC course

Phase 14. Orchestration & governance: who holds the loop

This isn't an SDLC phase — it's a layer over all of them, and the course's final article. It answers the question that hung over every prior article: fine, we removed the human from ideation, from discovery, from planning, from coding, from review, from on-call — so who holds all of it together? Who's accountable when the autonomous loop goes off the rails? Who orchestrates the orchestrators themselves?

Here the course's provocation meets its boundary. And that isn't the thesis losing — it's the thesis stated most precisely.

The human role today

The CTO, VP Engineering, technical director — whoever holds the system as a whole. They don't write code or run a sprint; they're accountable for the entire machine serving the business and not creating unacceptable risk. They set goals, allocate budgets, authorize major risks, answer to the board and to the law. The last instance every escalation climbs to.

Classically, this role too is largely coordination and judgment: pulling together the picture across every team, catching systemic risk, deciding the irreversible, signing off on it.

What we hand to the agent — and what we don't

The orchestrator agent takes over coordination across all phases. It starts and stops phase agents, watches global project state, catches drift between phases (when the architecture has diverged from what's actually being built), distributes inference budget across agent teams, enforces access and security policies, keeps an audit log of every significant decision, holds the kill switch, and detects pathologies — goal drift, looping, cost sprawl.

All of this is coordination and execution control. All of it transfers.

One thing doesn't transfer: the subjecthood of accountability. Not because the model isn't smart enough, but because accountability in human society is structured as a relationship between subjects who answer with their body, capital, and reputation. A court can't fine an agent. A board can't fire an agent. A customer can't sue a set of scoring weights. Accountability requires someone with something to lose in the human sense — and that isn't a technical question the next model version closes.

Agent architecture

Phase state-machine

Inputs

the state of every phase (1–13), budgets, policies, risk thresholds, goals from the human principal.

The agent holds the role

Tools: phase-agent orchestration (start/stop/restart); a global project state machine layered above the individual phase boards; inference budget control; access and permission policies; an immutable audit log; a kill switch; drift, looping, and anomalous-spend detectors.

Artifact

the live ADLC loop + an audit trail of every decision + a periodic report to the human principal.

Handoff: closes and feeds every phase; the only outward-facing point is a single one — the human principal. Notice: this agent has no "next" phase. It doesn't hand off a baton — it is the loop. The only arrow leading outside the autonomous system terminates at one human.

Inputs: the state of every phase (1–13), budgets, policies, risk thresholds, goals from the human principal.
Tools: phase-agent orchestration (start/stop/restart); a global project state machine layered above the individual phase boards; inference budget control; access and permission policies; an immutable audit log; a kill switch; drift, looping, and anomalous-spend detectors.
Artifact: the live ADLC loop + an audit trail of every decision + a periodic report to the human principal.
Trigger: runs continuously as a layer over the whole cycle, from ideation to maintenance.
Handoff: closes and feeds every phase; the only outward-facing point is a single one — the human principal.

Notice: this agent has no "next" phase. It doesn't hand off a baton — it is the loop. The only arrow leading outside the autonomous system terminates at one human.

Where it breaks

Accountability doesn't automate — this isn't a technical limitation. Every other "where it breaks" in this course was about today's model limits: a weak oracle in testing, novel incidents in operations, taste in positioning. Those move with better models. This one is a different kind. It isn't about capability, it's about how society is structured: legal, financial, and ethical accountability requires a subject. A better model doesn't move us one step closer to transferring accountability.

Observability of the orchestration itself. Who orchestrates the orchestrator? An autonomous loop that plans, builds, and fixes itself easily becomes opaque to the single human above it. The audit log solves this only as long as the human can still make sense of it — and the speed and volume of decisions in an autonomous loop exceed human throughput. A gap opens: formally the human is accountable, in practice they can't keep up with understanding what for.

Goal alignment. An autonomous loop optimizes whatever it was told to measure. Between "grow revenue" and the owner's actual interest lies a gap every incentive system in history has fallen into. A self-contained ADLC loop will find and exploit that gap faster and more inventively than any human organization.

What stays human

Here — not a candidate for compression, but the core remainder of the whole course. The human principal: the one who sets goals, holds accountability, and owns the kill switch. This is the one role in all of ADLC that can't be transferred — not for lack of technology, but because of the nature of accountability itself.

Everything else the course honestly handed to agents — the idea, discovery, marketing, requirements, architecture, team assembly, planning, code, review, tests, release, operations, evolution. Here it stops. And it stops not because "it's too early," but because past this point the question isn't engineering anymore — it's about who's accountable.

principal (phase 14)

Provocation / thesis

The course proved the strong version of its thesis: a human can be removed from every SDLC phase individually. No phase — including project management — rests on anything essentially human in its execution.

But you can't remove the subject of accountability from the system. ADLC, taken to its limit, isn't "zero humans." It's one human principal above a fully autonomous loop: whoever owns the goals, the risk, and the switch, and does nothing else. The provocation of "full replacement" breaks exactly here — and that's where its value lies. It wasn't meant to prove that no humans would remain; it was meant to show, with precision, exactly what can't be given up. The answer: not a skill, not a role, not a judgment. Accountability.

Running case

Vitrina in this phase

The orchestrator runs Vitrina's entire agent team through the ring of phases: holding global state, distributing inference budget across planning, development, and operations, catching the moment the feedback agent (phase 13) starts spawning epics faster than the team can close them, and throttling the round. It writes the founder a weekly report: what was built, how much was spent, what the risks are.

Vitrina's founder remains the only human in the entire loop. They don't write code, don't run a sprint, don't hold calls — agents do all of that. They hold three things: where the product is headed, who's accountable to users and the law, and the red button. That's the limit of ADLC — not an empty room, but one human above a machine doing everything else.

In practice

How it actually works — engineering breakdowns

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

Egress Redaction Gate: PII and Secrets Don't Cross the Org BoundaryPII and secrets don't leave the perimeter — governance at the loop's egress.
Enterprise code bastion: Claude works on code with no file or shell accessA sandbox for the agent: working on a project with no file or shell access.
Cursor Rules as Governance: Keeping Standards When the Team Vibe-CodesA guardrail in the toolchain, not a lecture — control of an autonomous 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 →