The End to End Lifecycle

The End-to-End Lifecycle

Status: Complete · The canonical SAE operating loop — how a single operator takes an idea from intent to production and keeps it healthy.

Modules 1–5 define the principles. This page is the operating model: the repeatable cycle you run for every unit of work, the persona that owns each phase, the artifact it produces, and the gate it must pass.

---

The loop at a glance

Text version of the loop

   ┌──────────────────────────────────────────────────────────────────────┐
   │                                                                        │
   ▼                                                                        │
0 FRAME ─▶ 1 SPEC ─▶ 2 PRIME ─▶ 3 GENERATE ─▶ 4 REVIEW ─▶ 5 GUARD ─▶ 6 RECONCILE ─▶ 7 SHIP
   │          ▲                                    │           │            │
   │          │                                    └──fail─────┘            │
   │          └──────────────── spec amendment ◀─── 9 MAINTAIN ◀── 8 OBSERVE ◀───────┘
   │                                                                        ▲
   └────────────────────────── telemetry / incidents ──────────────────────┘

The loop is spec‑centric: every change — feature, fix, or refactor — re‑enters at Spec, never at the code. That single discipline keeps the source of truth authoritative (see SDD in Module 2).

---

The ten phases

#	Phase	Owner	Input	Output	Exit gate
0	Frame	Conductor	Idea / business rule	Intent + entropy rating + blast radius	Scope and risk are explicit
1	Spec	Conductor	Intent	Bounded‑context spec (incl. edge cases)	Every behaviour & edge case written
2	Prime	Conductor	Spec + repo state	Loaded context window, .cursorrules	Agent has only what it needs
3	Generate	Engineer / Visualizer	Spec + context	Vertical slice (schema→API→state→UI)	Slice compiles & maps end‑to‑end
4	Review	Conductor	Generated slice	Approved or flagged diff	No structural drift; matches spec
5	Guard	Guardian	Slice + spec	Tests + adversarial findings	All edge cases covered & passing
6	Reconcile	Conductor	Findings / hot‑fixes	Updated spec	Spec ⇄ code back in sync
7	Ship	Zero‑Ops pipeline	Approved slice	Deployed change	Push‑to‑deploy succeeds
8	Observe	Telemetry	Production	Traces, errors, metrics	Signal flows back to operator
9	Maintain	Conductor + Engineer	Incident / change request	Spec amendment → re‑enter at 1	Fix flows through the spec

---

Phase notes

0 · Frame. Before any spec, name three things out loud: the business rule this serves, the blast radius (what breaks if it's wrong), and the Context Entropy (how much prep it needs). Frame is 60 seconds that prevents an afternoon of confident, wrong output.

1 · Spec. The highest‑leverage phase. The SDD Spec Template is your form. The edge‑cases section is where defects are prevented — a spec without edge cases is a wish.

2 · Prime. Give the agent the spec, the relevant slice, and .cursorrules — and nothing else. Context discipline is what keeps generation precise; see Operator Techniques.

3 · Generate. Build the whole vertical slice in one cycle so layers align by construction. UI‑heavy work routes through the Visualizer.

4 · Review. You are auditing for structural drift — does the API shape match the UI's expectations, do types match the schema, did the agent invent scope the spec didn't ask for?

5 · Guard. Open a fresh context and task it to break the slice, not bless it. This independence is the framework's only built‑in check against hallucinated correctness.

6 · Reconcile. If Guard or a hot‑fix changed behaviour, update the spec before moving on. Skipping this is the #1 way the framework decays (see stale‑spec failure mode).

7 · Ship. Git‑push deploy on a Zero‑Ops stack. Anything touching auth, payments, or data deletion gets an explicit human gate — never auto.

8–9 · Observe & Maintain. The self‑healing circle: telemetry feeds an agent that drafts a spec amendment, you approve, the loop re‑runs. Maintenance is just the loop re‑entering at Spec.

---

Scaling the loop by entropy

Not every change runs all ten phases at full weight. Match ceremony to risk:

Entropy	Frame	Spec	Guard	Typical example
Low (1–3)	1 line	Update existing spec	Smoke + edge tests	Add a field to an existing slice
Medium (5–8)	Explicit	New/expanded spec, reviewed	Full adversarial pass	New feature spanning schemas + webhook
High (13)	Written, with rollback plan	Re‑draft boundaries first	Multi‑lens adversarial + staged rollout	Framework migration, major integration

Reality check. The loop is a default, not a cage. A one‑character typo fix doesn't need a frame meeting with yourself. The discipline that never relaxes regardless of entropy: reconcile the spec and keep the human gate on high‑blast‑radius changes. Everything else scales down for trivial work.

---

See also: Scenario Playbooks (the loop applied to real situations) · Operator Techniques (the tactical how) · KPIs & Metrics (measuring the loop).